tree

type Gindex interface {
	// Subtree returns the same gindex, but with the anchor moved one bit to the right, to represent the subtree position.
	Subtree() Gindex
	// Anchor of the gindex: same depth, but with position zeroed out.
	Anchor() Gindex
	// Left child gindex
	Left() Gindex
	// Right child gindex
	Right() Gindex
	// Parent gindex
	Parent() Gindex
	// If the gindex points into the left subtree (2nd bit is 0)
	IsLeft() bool
	// If the gindex is the root (= 1)
	IsRoot() bool
	// If gindex is 2 or 3
	IsClose() bool
	// Get the depth of the gindex
	Depth() uint32
	// Iterate over the bits of the gindex
	// The depth is excl. the "root" bit
	BitIter() (iter GindexBitIter, depth uint32)
}

type Gindex64 uint64

type Gindex64BitIter struct {
	Marker uint64
	Gindex uint64
}

type GindexBitIter interface {
	// Next: move forward through gindex.
	// It returns bools for each bit after the "root" bit.
	// If "ok" is false, the bit cannot be read, none are remaining.
	// Subsequent calls are invalid.
	// For these extra calls, "ok" will be false, and "right" is undefined.
	Next() (right bool, ok bool)
}

type HashFn func(a Root, b Root) Root

type Link func(v Node) (Node, error)

type NewHashFn func() HashFn

type Node interface {
	Left() (Node, error)
	Right() (Node, error)
	IsLeaf() bool
	RebindLeft(v Node) (Node, error)
	RebindRight(v Node) (Node, error)
	Getter(target Gindex) (Node, error)
	Setter(target Gindex, expand bool) (Link, error)
	SummarizeInto(target Gindex, h HashFn) (SummaryLink, error)
	MerkleRoot(h HashFn) Root
}

type PairNode struct {
	Value      Root
	LeftChild  Node
	RightChild Node
}

type Root [32]byte

type SummaryLink func() (Node, error)