state

type DerivedState ¶ added in v0.1.61

type DerivedState[T any] struct {
	// contains filtered or unexported fields
}

DerivedState computes a value from other state objects and caches the result. It uses push-based invalidation: when dependencies change, the derived state is marked invalid but not recalculated until Get() is called.

func DerivedStateOf[T any](calculation func() T) *DerivedState[T]

func DerivedStateOfCustom[T any](calculation func() T, compare func(T, T) bool) *DerivedState[T]

func DerivedStateWithPolicy[T any](calculation func() T, policy EqualityPolicy[T]) *DerivedState[T]

func (ds *DerivedState[T]) Get() T

func (ds *DerivedState[T]) IsInvalid() bool

func (ds *DerivedState[T]) Subscribe(callback func()) Subscription

func (ds *DerivedState[T]) SubscribeForInvalidation(callback func()) Subscription

type EqualityPolicy ¶ added in v0.1.67

type EqualityPolicy[T any] interface {
	Equivalent(a, b T) bool
}

EqualityPolicy determines if two values should be considered equivalent. Used by DerivedState to skip unnecessary updates when the computed value hasn't meaningfully changed.

type InvalidationNotifier ¶ added in v0.1.67

type InvalidationNotifier interface {
	// SubscribeForInvalidation registers a callback to be invoked when this
	// state is invalidated (not when its value changes).
	SubscribeForInvalidation(callback func()) Subscription
}

InvalidationNotifier is an optional interface for derived states that support a separate subscription for invalidation events. This allows derived states to subscribe to invalidation events (for chain propagation) rather than value-change events (for user callbacks).

type Memo ¶

type Memo = immap.ImmutableMap[any]

type MemoTyped ¶

type MemoTyped[T any] = immap.ImmutableMap[T]

func EmptyMemo[T any]() MemoTyped[T]

type MutableValue ¶

type MutableValue interface {
	Value
	Set(value any)
}

func NewMutableValue(initial any, changeNotifier func(any), compare func(any, any) bool) MutableValue

type ObserverManager ¶ added in v0.1.67

type ObserverManager interface {
	WithReadObserver(ReadObserver, func())
	NotifyRead(source StateChangeNotifier)
}

type PersistentState ¶

type PersistentState interface {
	GetState(key string, initial func() any, options ...StateOption) MutableValue
	SetOnStateChange(callback func())
}

type ReadObserver ¶ added in v0.1.61

type ReadObserver func(source StateChangeNotifier)

type StateChangeNotifier ¶ added in v0.1.67

type StateChangeNotifier interface {
	// Subscribe registers a callback to be invoked when the state changes.
	// Returns a Subscription that can be used to stop receiving notifications.
	// The callback may be invoked from any goroutine - implementations must be thread-safe.
	Subscribe(callback func()) Subscription
}

StateChangeNotifier is implemented by state objects that can notify subscribers when their value changes. This enables push-based invalidation for derived states.

type StateOption ¶ added in v0.1.67

type StateOption func(*StateOptions)

func WithCompare(compare func(any, any) bool) StateOption

type StateOptions ¶ added in v0.1.67

type StateOptions struct {
	Compare func(any, any) bool
}

type Subscription ¶ added in v0.1.67

type Subscription interface {
	Unsubscribe()
}

Subscription represents an active change observation that can be cancelled. When no longer needed, call Unsubscribe() to stop receiving notifications.

func NewNoOpSubscription() Subscription

func NewSubscription(unsubscribe func()) Subscription

type SubscriptionManager ¶ added in v0.1.67

type SubscriptionManager struct {
	// contains filtered or unexported fields
}

SubscriptionManager manages a list of subscriber callbacks with thread-safe subscription and notification.

func NewSubscriptionManager() *SubscriptionManager

func (sm *SubscriptionManager) Clear()

func (sm *SubscriptionManager) Count() int

func (sm *SubscriptionManager) NotifyAll()

func (sm *SubscriptionManager) Subscribe(callback func()) Subscription

type SupportState ¶

type SupportState interface {
	Remember(key string, calc func() any) any                                  // transient state
	State(key string, initial func() any, options ...StateOption) MutableValue // persistent state
}

type TypedMutableValue ¶

type TypedMutableValue[T any] interface {
	TypedValue[T]
	Set(value T)

	Unwrap() MutableValue
}

type TypedValue ¶

type TypedValue[T any] interface {
	Get() T
	Subscribe(callback func()) Subscription
}

type Value ¶

type Value interface {
	Get() any
	Subscribe(callback func()) Subscription
}