Versions in this module Expand all Collapse all v0 v0.1.0 Jul 26, 2026 Changes in this version + const Changed + const Invalidated + const Necessary + const Unnecessary + var ErrObserverNotStabilized = errors.New("incremental: observer has no value yet; stabilize first") + var ErrObserverUnlinked = errors.New("incremental: observer use disallowed after Unobserve") + func AddDependency[T, U any](n *ExpertNode[T], dep *Dependency[U]) + func All[T any](inputs []core.ValueNode[T]) core.ValueNode[[]T] + func AppendUserInfo(node core.AnyNode, info *DotUserInfo) + func ArrayFold[A, Acc any](children []core.ValueNode[A], init Acc, f func(Acc, A) Acc, ...) core.ValueNode[Acc] + func AtLeastKOf(inputs []core.ValueNode[bool], k int) core.ValueNode[bool] + func Bind[A, B any](lhs core.ValueNode[A], f func(A) core.ValueNode[B]) core.ValueNode[B] + func Both[A, B any](a core.ValueNode[A], b core.ValueNode[B]) core.ValueNode[Pair[A, B]] + func Const[T any](value T) *core.Node[T] + func Exists(inputs []core.ValueNode[bool]) core.ValueNode[bool] + func ForAll(inputs []core.ValueNode[bool]) core.ValueNode[bool] + func Freeze[T any](child core.ValueNode[T], onlyFreezeWhen func(T) bool) core.ValueNode[T] + func IfThenElse[T any](test core.ValueNode[bool], thenBranch, elseBranch core.ValueNode[T]) core.ValueNode[T] + func IncrementalStepFunction[T any](clock *Clock, child core.ValueNode[StepFunctionValue[T]]) core.ValueNode[T] + func Join[T any](input core.ValueNode[core.ValueNode[T]]) core.ValueNode[T] + func Map10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map2[A1, A2, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], f func(A1, A2) R, ...) core.ValueNode[R] + func Map3[A1, A2, A3, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map4[A1, A2, A3, A4, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map5[A1, A2, A3, A4, A5, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map6[A1, A2, A3, A4, A5, A6, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map7[A1, A2, A3, A4, A5, A6, A7, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map8[A1, A2, A3, A4, A5, A6, A7, A8, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any](in1 core.ValueNode[A1], in2 core.ValueNode[A2], in3 core.ValueNode[A3], ...) core.ValueNode[R] + func Map[T, R any](input core.ValueNode[T], f func(T) R, opts ...NodeOpt[R]) core.ValueNode[R] + func ReduceBalanced[A, Acc any](children []core.ValueNode[A], f func(A) Acc, reduce func(Acc, Acc) Acc, ...) (result core.ValueNode[Acc], ok bool) + func RemoveDependency[T, U any](n *ExpertNode[T], dep *Dependency[U]) + func SaveDot(roots []core.AnyNode, emitBindEdges bool) string + func Snapshot[T any](clock *Clock, valueAt core.ValueNode[T], at time.Time, before T) (core.ValueNode[T], error) + func StepFunction[T any](clock *Clock, init T, steps []Step[T]) core.ValueNode[T] + func Sum[T any](inputs []core.ValueNode[T], zero T, add func(T, T) T, sub func(T, T) T, ...) core.ValueNode[T] + func UnorderedArrayFold[A, Acc any](children []core.ValueNode[A], init Acc, f func(Acc, A) Acc, ...) core.ValueNode[Acc] + type BeforeOrAfter int + const After + const Before + func (b BeforeOrAfter) String() string + type Clock struct + func NewClock(state *engine.State, start time.Time) *Clock + func (c *Clock) AdvanceClock(to time.Time) error + func (c *Clock) AdvanceClockBy(span time.Duration) error + func (c *Clock) After(span time.Duration) core.ValueNode[BeforeOrAfter] + func (c *Clock) At(at time.Time) core.ValueNode[BeforeOrAfter] + func (c *Clock) AtIntervals(interval time.Duration) core.ValueNode[struct{}] + func (c *Clock) Now() time.Time + func (c *Clock) WatchNow() core.ValueNode[time.Time] + type Cutoff struct + func AlwaysCutoff[T any]() Cutoff[T] + func CompareCutoff[T any](compare func(oldValue, newValue T) int) Cutoff[T] + func EqualCutoff[T any](equal func(oldValue, newValue T) bool) Cutoff[T] + func NeverCutoff[T any]() Cutoff[T] + func NewCutoff[T any](f func(oldValue, newValue T) bool) Cutoff[T] + func PhysEqualCutoff[T comparable]() Cutoff[T] + func (c Cutoff[T]) ShouldCutoff(oldValue, newValue T) bool + type Dependency struct + func NewDependency[T any](child core.ValueNode[T], onChange func(T)) *Dependency[T] + func (d *Dependency[T]) Value() T + type DotUserInfo struct + func Append(a, b *DotUserInfo) *DotUserInfo + func NewDotUserInfo(label []string, attributes map[string]string) *DotUserInfo + func (info *DotUserInfo) String(name string) string + type ExpertNode struct + func NewExpertNode[T any](f func() T, onObservabilityChange func(isNowObservable bool)) *ExpertNode[T] + func (n *ExpertNode[T]) MakeStale() + func (n *ExpertNode[T]) OnChildChanged(child core.AnyNode) + func (n *ExpertNode[T]) Recompute(now core.StabilizationNum, _ core.RoundCtx) + func (n *ExpertNode[T]) SetObservable(isNowObservable bool) + func (n *ExpertNode[T]) Watch() core.ValueNode[T] + type Future = engine.Future + type Kind int + const KindArrayFold + const KindAt + const KindAtIntervals + const KindBindLHSChange + const KindBindMain + const KindConst + const KindExpert + const KindFreeze + const KindIfTestChange + const KindIfThenElse + const KindInvalid + const KindJoinLHSChange + const KindJoinMain + const KindMap + const KindMap10 + const KindMap11 + const KindMap12 + const KindMap13 + const KindMap14 + const KindMap15 + const KindMap2 + const KindMap3 + const KindMap4 + const KindMap5 + const KindMap6 + const KindMap7 + const KindMap8 + const KindMap9 + const KindMapFilter + const KindMapGroupAggregate + const KindMapGroupMaxBy + const KindMapGroupMinBy + const KindMapGroupReduce + const KindMapJoin + const KindMapLeftJoin + const KindMapLookupJoin + const KindMapValues + const KindMapVar + const KindSnapshot + const KindStepFunction + const KindUninitialized + const KindUnorderedArrayFold + const KindVar + func (k Kind) String() string + type MapDiff struct + HasNew bool + HasOld bool + Key K + New V + Old V + type MapNode interface + ForEach func(fn func(K, V) bool) + Get func(k K) (V, bool) + Len func() int + func MapFilter[K comparable, V any](src MapNode[K, V], pred func(K, V) bool) MapNode[K, V] + func MapGroupAggregate[K comparable, V any, G comparable, A any](src MapNode[K, V], group func(K, V) G, init A, add func(A, V) A, ...) MapNode[G, A] + func MapGroupMaxBy[K comparable, V any, G comparable, W cmp.Ordered](src MapNode[K, V], group func(K, V) G, by func(K, V) W) MapNode[G, W] + func MapGroupMinBy[K comparable, V any, G comparable, W cmp.Ordered](src MapNode[K, V], group func(K, V) G, by func(K, V) W) MapNode[G, W] + func MapGroupReduce[K comparable, V any, G comparable, A any](src MapNode[K, V], group func(K, V) G, init A, combine func(A, V) A) MapNode[G, A] + func MapJoin[K comparable, L, R, O any](left MapNode[K, L], right MapNode[K, R], combine func(K, L, R) O) MapNode[K, O] + func MapLeftJoin[K comparable, L, R, O any](left MapNode[K, L], right MapNode[K, R], ...) MapNode[K, O] + func MapLookupJoin[K comparable, V any, FK comparable, T, O any](src MapNode[K, V], table MapNode[FK, T], on func(K, V) FK, ...) MapNode[K, O] + func MapValues[K comparable, V, W any](src MapNode[K, V], f func(K, V) W) MapNode[K, W] + type MapObserver struct + func ObserveMap[K comparable, V any](state *State, node MapNode[K, V]) *MapObserver[K, V] + func (o *MapObserver[K, V]) Get(k K) (V, bool) + func (o *MapObserver[K, V]) Len() int + func (o *MapObserver[K, V]) Node() MapNode[K, V] + func (o *MapObserver[K, V]) OnDiffs(fn func([]MapDiff[K, V])) + func (o *MapObserver[K, V]) Snapshot() map[K]V + func (o *MapObserver[K, V]) Unobserve() + type MapVar struct + func NewMapVar[K comparable, V any](state *State) *MapVar[K, V] + func (c MapVar) ForEach(fn func(K, V) bool) + func (c MapVar) Get(k K) (V, bool) + func (c MapVar) Len() int + func (m *MapVar[K, V]) Delete(k K) + func (m *MapVar[K, V]) Set(k K, v V) + func (m *MapVar[K, V]) Watch() MapNode[K, V] + type NodeOpt func(*nodeOptions[T]) + func WithCutoff[T any](c Cutoff[T]) NodeOpt[T] + type NodeUpdate = core.NodeUpdate[T] + type NodeUpdateKind = core.NodeUpdateKind + type Observer struct + func Observe[T any](state *engine.State, node core.ValueNode[T]) *Observer[T] + func (o *Observer[T]) Observing() core.ValueNode[T] + func (o *Observer[T]) OnUpdate(fn func(NodeUpdate[T])) error + func (o *Observer[T]) Unobserve() + func (o *Observer[T]) Value() (T, error) + type Pair struct + First A + Second B + type State = engine.State + func NewState(workers int) *State + type Step struct + At time.Time + Value T + type StepFunctionValue struct + Init T + Steps []Step[T] + func NewStepFunctionValue[T any](init T, steps []Step[T]) StepFunctionValue[T] + func (sf StepFunctionValue[T]) ValueAt(at time.Time) T + type UnorderedArrayFoldUpdate struct + FInverse func(acc Acc, oldValue A) Acc + Update func(acc Acc, oldValue, newValue A) Acc + type ValueNode = core.ValueNode[T] + type Var struct + func NewVar[T any](state *engine.State, initial T) *Var[T] + func (v *Var[T]) Set(value T) + func (v *Var[T]) Value() T + func (v *Var[T]) Watch() *core.Node[T]
Go to main page