chore(bst): 100% coverage with cancelable walks, IndexOf.

Author: fgm

binarysearchtree/intrinsic.go

@@ -2,6 +2,7 @@ package binarysearchtree
 
 import (
 	"cmp"
+	"errors"
 
 	"github.com/fgm/container"
 )
@@ -68,43 +69,64 @@ func (n *node[E]) upsert(m *node[E]) *E {
 	}
 }
 
-func (n *node[E]) walkInOrder(cb container.WalkCB[E]) {
+func (n *node[E]) walkInOrder(cb container.WalkCB[E]) error {
+	var err error
 	if n == nil {
-		return
+		return nil
 	}
 	if n.left != nil {
-		n.left.walkInOrder(cb)
+		if err = n.left.walkInOrder(cb); err != nil {
+			return err
+		}
+	}
+	if err := cb(n.data); err != nil {
+		return err
 	}
-	cb(n.data)
 	if n.right != nil {
-		n.right.walkInOrder(cb)
+		if err = n.right.walkInOrder(cb); err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
-func (n *node[E]) walkPostOrder(cb container.WalkCB[E]) {
+func (n *node[E]) walkPostOrder(cb container.WalkCB[E]) error {
+	var err error
 	if n == nil {
-		return
+		return nil
 	}
 	if n.left != nil {
-		n.left.walkPostOrder(cb)
+		if err = n.left.walkPostOrder(cb); err != nil {
+			return err
+		}
 	}
 	if n.right != nil {
-		n.right.walkPostOrder(cb)
+		if err = n.right.walkPostOrder(cb); err != nil {
+			return err
+		}
 	}
-	cb(n.data)
+	return cb(n.data)
 }
 
-func (n *node[E]) walkPreOrder(cb container.WalkCB[E]) {
+func (n *node[E]) walkPreOrder(cb container.WalkCB[E]) error {
+	var err error
 	if n == nil {
-		return
+		return nil
+	}
+	if err := cb(n.data); err != nil {
+		return err
 	}
-	cb(n.data)
 	if n.left != nil {
-		n.left.walkPreOrder(cb)
+		if err = n.left.walkPreOrder(cb); err != nil {
+			return err
+		}
 	}
 	if n.right != nil {
-		n.right.walkPreOrder(cb)
+		if err = n.right.walkPreOrder(cb); err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
 // Intrinsic holds nodes which are their own ordering key.
@@ -116,13 +138,13 @@ type Intrinsic[E cmp.Ordered] struct {
 // Complexity is O(n).
 func (t *Intrinsic[E]) Len() int {
 	l := 0
-	t.WalkPostOrder(func(_ *E) { l++ })
+	t.WalkPostOrder(func(_ *E) error { l++; return nil })
 	return l
 }
 
 func (t *Intrinsic[E]) Elements() []E {
 	var sl []E
-	t.WalkPreOrder(func(e *E) { sl = append(sl, *e) })
+	t.WalkPreOrder(func(e *E) error { sl = append(sl, *e); return nil })
 	return sl
 }
 
@@ -159,49 +181,50 @@ func (t *Intrinsic[E]) Delete(e *E) {
 // If the value cannot be found, it will return 0, false, otherwise the position
 // starting at 0, and true.
 func (t *Intrinsic[E]) IndexOf(e *E) (int, bool) {
-	index, found := 0, false
-	t.WalkInOrder(func(x *E) {
+	errFound := errors.New("found")
+	index := 0
+	err := t.WalkInOrder(func(x *E) error {
 		if *x == *e {
-			found = true
-		}
-		if !found {
-			index++
+			return errFound
 		}
+		index++
+		return nil
 	})
-	if !found {
-		index = 0
+	if err != errFound {
+		return 0, false
 	}
-	return index, found
+	return index, true
 }
 
 // WalkInOrder is useful for search and listing nodes in order.
-func (t *Intrinsic[E]) WalkInOrder(cb container.WalkCB[E]) {
+func (t *Intrinsic[E]) WalkInOrder(cb container.WalkCB[E]) error {
 	if t == nil {
-		return
+		return nil
 	}
-	t.root.walkInOrder(cb)
+	return t.root.walkInOrder(cb)
 }
 
 // WalkPostOrder in useful for deleting subtrees.
-func (t *Intrinsic[E]) WalkPostOrder(cb container.WalkCB[E]) {
+func (t *Intrinsic[E]) WalkPostOrder(cb container.WalkCB[E]) error {
 	if t == nil {
-		return
+		return nil
 	}
-	t.root.walkPostOrder(cb)
+	return t.root.walkPostOrder(cb)
 }
 
 // WalkPreOrder is useful to clone the tree.
-func (t *Intrinsic[E]) WalkPreOrder(cb container.WalkCB[E]) {
+func (t *Intrinsic[E]) WalkPreOrder(cb container.WalkCB[E]) error {
 	if t == nil {
-		return
+		return nil
 	}
-	t.root.walkPreOrder(cb)
+	return t.root.walkPreOrder(cb)
 }
 
 func (t *Intrinsic[E]) Clone() container.BinarySearchTree[E] {
 	clone := &Intrinsic[E]{}
-	t.WalkPreOrder(func(e *E) {
+	t.WalkPreOrder(func(e *E) error {
 		clone.Upsert(e)
+		return nil
 	})
 	return clone
 }

binarysearchtree/intrinsic_opaque_test.go

@@ -1,6 +1,8 @@
 package binarysearchtree_test
 
 import (
+	"fmt"
+	"log"
 	"strconv"
 	"testing"
 
@@ -108,3 +110,47 @@ func TestIntrinsic_Len(t *testing.T) {
 		})
 	}
 }
+
+func TestIntrinsic_Walk_canceling(t *testing.T) {
+	tree := bst.Simple()
+	checks := [...]struct {
+		name                   string
+		walker                 func(cb container.WalkCB[int]) error
+		calls1, calls3, calls5 int
+	}{
+		{"in order", tree.WalkInOrder, 1, 3, 5},
+		{"post order", tree.WalkPostOrder, 1, 5, 3},
+		{"pre order", tree.WalkPreOrder, 3, 1, 5},
+	}
+	tree.WalkInOrder(func(e *int) error { log.Println(*e); return nil })
+	stopper := func(at int) container.WalkCB[int] {
+		called := 0
+		return container.WalkCB[int](func(e *int) error {
+			called++
+			if *e == at {
+				return fmt.Errorf("%d", called)
+			}
+			return nil
+		})
+	}
+	for _, check := range checks {
+		t.Run(check.name, func(t *testing.T) {
+			for _, val := range []struct {
+				input, expected int
+			}{
+				{1, check.calls1},
+				{3, check.calls3},
+				{5, check.calls5},
+			} {
+				err := check.walker(stopper(val.input))
+				actual, err := strconv.Atoi(err.Error())
+				if err != nil {
+					t.Fatalf("unexpected non-int error: %v", err)
+				}
+				if actual != val.expected {
+					t.Fatalf("got %d but expected %d", actual, val.expected)
+				}
+			}
+		})
+	}
+}

binarysearchtree/intrinsic_transparent_test.go

@@ -12,34 +12,37 @@ var (
 )
 
 // Simple builds this tree:
-//       3
-//      / \
-//     2   4
-//    /     \
-//   1       5
+//
+//	    3
+//	   / \
+//	  2   4
+//	 /     \
+//	1       5
 func Simple() container.BinarySearchTree[int] {
 	simple := Intrinsic[int]{}
 	simple.Upsert(&Three, &Two, &Four, &One, &Five)
 	return &simple
 }
 
 // HalfFull builds this tree, which contains all deletion cases
-//       3
-//      / \
-//     2   5
-//    /   / \
-//   1   4   6
+//
+//	    3
+//	   / \
+//	  2   5
+//	 /   / \
+//	1   4   6
 func HalfFull() container.BinarySearchTree[int] {
 	hf := Intrinsic[int]{}
 	hf.Upsert(&Three, &Two, &Five, &One, &Four, &Six)
 	return &hf
 }
 
-func P(e *int) {
-	_, _ = fmt.Println(*e)
+func P(e *int) error {
+	_, err := fmt.Println(*e)
+	return err
 }
 
-func ExampleBST_WalkInOrder() {
+func ExampleIntrinsic_WalkInOrder() {
 	bst := Simple()
 	bst.WalkInOrder(P)
 	// Output:
@@ -50,7 +53,7 @@ func ExampleBST_WalkInOrder() {
 	// 5
 }
 
-func ExampleBST_WalkPostOrder() {
+func ExampleIntrinsic_WalkPostOrder() {
 	bst := Simple()
 	bst.WalkPostOrder(P)
 	// Output:
@@ -61,7 +64,7 @@ func ExampleBST_WalkPostOrder() {
 	// 3
 }
 
-func ExampleBST_WalkPreOrder() {
+func ExampleIntrinsic_WalkPreOrder() {
 	bst := Simple()
 	bst.WalkPreOrder(P)
 	// Output:
@@ -72,7 +75,7 @@ func ExampleBST_WalkPreOrder() {
 	// 5
 }
 
-func TestBST_Clone(t *testing.T) {
+func TestIntrinsic_Clone(t *testing.T) {
 	bst := Simple().(*Intrinsic[int])
 	clone := bst.Clone().(*Intrinsic[int])
 	input := bst.root

types.go

@@ -63,9 +63,9 @@ type BinarySearchTree[E cmp.Ordered] interface {
 	Delete(*E)
 	IndexOf(*E) (int, bool)
 	Upsert(...*E) []*E
-	WalkInOrder(cb WalkCB[E])
-	WalkPostOrder(cb WalkCB[E])
-	WalkPreOrder(cb WalkCB[E])
+	WalkInOrder(cb WalkCB[E]) error
+	WalkPostOrder(cb WalkCB[E]) error
+	WalkPreOrder(cb WalkCB[E]) error
 }
 
-type WalkCB[E any] func(*E)
+type WalkCB[E any] func(*E) error