join.go

package incremental

import "github.com/PrositAS/go-incremental/internal/core"

// Join creates a node whose value tracks input's current value, unwrapping one level of
// dynamism - the Go counterpart of Incremental's join. Where Bind rebuilds its right-hand
// side by running a function whenever the left-hand side changes, Join's right-hand side
// is simply whatever node input currently points to: input.Value() is itself a node, and
// Join's result mirrors that node's value, updating whenever input points somewhere new.
func Join[T any](input core.ValueNode[core.ValueNode[T]]) core.ValueNode[T] {
	j := &joinState[T]{lhs: input}

	main := &joinMain[T]{Node: core.New[T](nil, nil), j: j}
	main.SetKind(int(KindJoinMain))

	lhsChange := &joinLHSChange[T]{Node: core.New[struct{}](nil, nil), j: j}
	lhsChange.SetKind(int(KindJoinLHSChange))
	core.AddEdge(lhsChange, input)

	j.lhsChange = lhsChange
	j.main = main

	core.AddEdge(main, lhsChange)
	return main
}

// joinState holds the state shared by a join's two nodes: the lhs-change watcher, which
// re-reads input, and the main result node, which copies the pointed-to node's value.
type joinState[T any] struct {
	lhs       core.ValueNode[core.ValueNode[T]]
	lhsChange *joinLHSChange[T]
	main      *joinMain[T]

	// rhs is written only by lhsChange.Recompute and read only by main.Recompute; see
	// bindState.rhs for why that's race-free without its own lock.
	rhs core.ValueNode[T]
}

type joinLHSChange[T any] struct {
	*core.Node[struct{}]
	j *joinState[T]
}

func (n *joinLHSChange[T]) Recompute(now core.StabilizationNum, round core.RoundCtx) {
	rhs, _ := n.j.lhs.Value()
	oldRHS := n.j.rhs
	n.j.rhs = rhs
	changeChild(round, n.j.main, oldRHS, rhs)
	n.SetValue(struct{}{}, now)
}

type joinMain[T any] struct {
	*core.Node[T]
	j *joinState[T]
}

func (n *joinMain[T]) Recompute(now core.StabilizationNum, _ core.RoundCtx) {
	if !n.j.rhs.IsValid() {
		n.Invalidate()
		return
	}
	v, _ := n.j.rhs.Value()
	n.SetValue(v, now)
}