Refactor.

key.go → key/key.go

-package xor
+package key
 
 import "bytes"
 
-// TrieKey is a vector of bits backed by a Go byte slice in big endian byte order and big-endian bit order.
-type TrieKey []byte
+// Key is a vector of bits backed by a Go byte slice in big endian byte order and big-endian bit order.
+type Key []byte
 
-func (bs TrieKey) BitAt(offset int) byte {
+func (bs Key) BitAt(offset int) byte {
 	if bs[offset/8]&(1<<(offset%8)) == 0 {
 		return 0
 	} else {
@@ -13,10 +13,10 @@ func (bs TrieKey) BitAt(offset int) byte {
 	}
 }
 
-func (bs TrieKey) BitLen() int {
+func (bs Key) BitLen() int {
 	return 8 * len(bs)
 }
 
-func TrieKeyEqual(x, y TrieKey) bool {
+func Equal(x, y Key) bool {
 	return bytes.Equal(x, y)
 }

add.go → trie/add.go

-package xor
+package trie
+
+import (
+	"github.com/libp2p/go-libp2p-xor/key"
+)
 
 // Add adds the key q to trie, returning a new trie.
 // Add is immutable/non-destructive: The original trie remains unchanged.
-func Add(trie *XorTrie, q TrieKey) *XorTrie {
+func Add(trie *XorTrie, q key.Key) *XorTrie {
 	return add(0, trie, q)
 }
 
-func add(depth int, trie *XorTrie, q TrieKey) *XorTrie {
+func add(depth int, trie *XorTrie, q key.Key) *XorTrie {
 	dir := q.BitAt(depth)
 	if !trie.isLeaf() {
 		s := &XorTrie{}
@@ -17,7 +21,7 @@ func add(depth int, trie *XorTrie, q TrieKey) *XorTrie {
 		if trie.key == nil {
 			return &XorTrie{key: q}
 		} else {
-			if TrieKeyEqual(trie.key, q) {
+			if key.Equal(trie.key, q) {
 				return trie
 			} else {
 				s := &XorTrie{}

add_test.go → trie/add_test.go

-package xor
+package trie
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/libp2p/go-libp2p-xor/key"
+)
 
 // Verify mutable and immutable add do the same thing.
 func TestMutableAndImmutableAddSame(t *testing.T) {
 	for _, s := range testAddSameSamples {
-		mut := NewXorTrie()
-		immut := NewXorTrie()
+		mut := New()
+		immut := New()
 		for _, k := range s.Keys {
 			mut.Add(k)
 			immut = Add(immut, k)
 		}
-		if !XorTrieEqual(mut, immut) {
+		if !Equal(mut, immut) {
 			t.Errorf("mutable trie %v differs from immutable trie %v", mut, immut)
 		}
 	}
 }
 
 type testAddSameSample struct {
-	Keys []TrieKey
+	Keys []key.Key
 }
 
 var testAddSameSamples = []*testAddSameSample{
-	{Keys: []TrieKey{{1, 3, 5, 7, 11, 13}}},
+	{Keys: []key.Key{{1, 3, 5, 7, 11, 13}}},
 }

equal.go → trie/equal.go

-package xor
+package trie
 
-func XorTrieEqual(p, q *XorTrie) bool {
+import (
+	"github.com/libp2p/go-libp2p-xor/key"
+)
+
+func Equal(p, q *XorTrie) bool {
 	switch {
 	case p.isLeaf() && q.isLeaf():
-		return TrieKeyEqual(p.key, q.key)
+		return key.Equal(p.key, q.key)
 	case !p.isLeaf() && !q.isLeaf():
-		return XorTrieEqual(p.branch[0], q.branch[0]) && XorTrieEqual(p.branch[1], q.branch[1])
+		return Equal(p.branch[0], q.branch[0]) && Equal(p.branch[1], q.branch[1])
 	}
 	return false
 }

intersect.go → trie/intersect.go

-package xor
+package trie
+
+import (
+	"github.com/libp2p/go-libp2p-xor/key"
+)
 
 // Intersect computes the intersection of the keys in p and q.
 // p and q must be non-nil. The returned trie is never nil.
@@ -12,7 +16,7 @@ func intersect(depth int, p, q *XorTrie) *XorTrie {
 		if p.isEmpty() || q.isEmpty() {
 			return &XorTrie{} // empty set
 		} else {
-			if TrieKeyEqual(p.key, q.key) {
+			if key.Equal(p.key, q.key) {
 				return &XorTrie{key: p.key} // singleton
 			} else {
 				return &XorTrie{} // empty set

intersect_test.go → trie/intersect_test.go

-package xor
+package trie
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/libp2p/go-libp2p-xor/key"
+)
 
 func TestIntersectRandom(t *testing.T) {
 	for _, s := range testIntersectSamples {
@@ -9,7 +13,7 @@ func TestIntersectRandom(t *testing.T) {
 }
 
 func testIntersect(t *testing.T, sample *testIntersectSample) {
-	left, right, expected := NewXorTrie(), NewXorTrie(), NewXorTrie()
+	left, right, expected := New(), New(), New()
 	for _, l := range sample.LeftKeys {
 		left.Add(l)
 	}
@@ -20,17 +24,17 @@ func testIntersect(t *testing.T, sample *testIntersectSample) {
 		expected.Add(s)
 	}
 	got := Intersect(left, right)
-	if !XorTrieEqual(expected, got) {
+	if !Equal(expected, got) {
 		t.Errorf("intersection of %v and %v: expected %v, got %v",
 			sample.LeftKeys, sample.RightKeys, expected, got)
 	}
 }
 
-func setIntersect(left, right []TrieKey) []TrieKey {
-	intersection := []TrieKey{}
+func setIntersect(left, right []key.Key) []key.Key {
+	intersection := []key.Key{}
 	for _, l := range left {
 		for _, r := range right {
-			if TrieKeyEqual(l, r) {
+			if key.Equal(l, r) {
 				intersection = append(intersection, r)
 			}
 		}
@@ -39,21 +43,21 @@ func setIntersect(left, right []TrieKey) []TrieKey {
 }
 
 type testIntersectSample struct {
-	LeftKeys  []TrieKey
-	RightKeys []TrieKey
+	LeftKeys  []key.Key
+	RightKeys []key.Key
 }
 
 var testIntersectSamples = []*testIntersectSample{
 	{
-		LeftKeys:  []TrieKey{{1, 2, 3}},
-		RightKeys: []TrieKey{{1, 3, 5}},
+		LeftKeys:  []key.Key{{1, 2, 3}},
+		RightKeys: []key.Key{{1, 3, 5}},
 	},
 	{
-		LeftKeys:  []TrieKey{{1, 2, 3, 4, 5, 6}},
-		RightKeys: []TrieKey{{3, 5, 7}},
+		LeftKeys:  []key.Key{{1, 2, 3, 4, 5, 6}},
+		RightKeys: []key.Key{{3, 5, 7}},
 	},
 	{
-		LeftKeys:  []TrieKey{{23, 3, 7, 13, 17}},
-		RightKeys: []TrieKey{{2, 11, 17, 19, 23}},
+		LeftKeys:  []key.Key{{23, 3, 7, 13, 17}},
+		RightKeys: []key.Key{{2, 11, 17, 19, 23}},
 	},
 }

xortrie.go → trie/xortrie.go

-package xor
+package trie
+
+import (
+	"github.com/libp2p/go-libp2p-xor/key"
+)
 
 // XorTrie is a trie for equal-length bit vectors, which stores values only in the leaves.
 // XorTrie node invariants:
@@ -6,10 +10,10 @@ package xor
 // (2) If both branches are leaves, then they are both non-empty (have keys).
 type XorTrie struct {
 	branch [2]*XorTrie
-	key    TrieKey
+	key    key.Key
 }
 
-func NewXorTrie() *XorTrie {
+func New() *XorTrie {
 	return &XorTrie{}
 }
 
@@ -32,29 +36,29 @@ func max(x, y int) int {
 	return y
 }
 
-func (trie *XorTrie) Find(q TrieKey) (reachedDepth int, found bool) {
+func (trie *XorTrie) Find(q key.Key) (reachedDepth int, found bool) {
 	return trie.find(0, q)
 }
 
-func (trie *XorTrie) find(depth int, q TrieKey) (reachedDepth int, found bool) {
+func (trie *XorTrie) find(depth int, q key.Key) (reachedDepth int, found bool) {
 	if qb := trie.branch[q.BitAt(depth)]; qb != nil {
 		return qb.find(depth+1, q)
 	} else {
 		if trie.key == nil {
 			return depth, false
 		} else {
-			return depth, TrieKeyEqual(trie.key, q)
+			return depth, key.Equal(trie.key, q)
 		}
 	}
 }
 
 // Add adds the key q to the trie. Add mutates the trie.
 // TODO: Also implement an immutable version of Add.
-func (trie *XorTrie) Add(q TrieKey) (insertedDepth int, insertedOK bool) {
+func (trie *XorTrie) Add(q key.Key) (insertedDepth int, insertedOK bool) {
 	return trie.add(0, q)
 }
 
-func (trie *XorTrie) add(depth int, q TrieKey) (insertedDepth int, insertedOK bool) {
+func (trie *XorTrie) add(depth int, q key.Key) (insertedDepth int, insertedOK bool) {
 	if qb := trie.branch[q.BitAt(depth)]; qb != nil {
 		return qb.add(depth+1, q)
 	} else {
@@ -62,7 +66,7 @@ func (trie *XorTrie) add(depth int, q TrieKey) (insertedDepth int, insertedOK bo
 			trie.key = q
 			return depth, true
 		} else {
-			if TrieKeyEqual(trie.key, q) {
+			if key.Equal(trie.key, q) {
 				return depth, false
 			} else {
 				p := trie.key
@@ -78,11 +82,11 @@ func (trie *XorTrie) add(depth int, q TrieKey) (insertedDepth int, insertedOK bo
 
 // Remove removes the key q from the trie. Remove mutates the trie.
 // TODO: Also implement an immutable version of Add.
-func (trie *XorTrie) Remove(q TrieKey) (removedDepth int, removed bool) {
+func (trie *XorTrie) Remove(q key.Key) (removedDepth int, removed bool) {
 	return trie.remove(0, q)
 }
 
-func (trie *XorTrie) remove(depth int, q TrieKey) (reachedDepth int, removed bool) {
+func (trie *XorTrie) remove(depth int, q key.Key) (reachedDepth int, removed bool) {
 	if qb := trie.branch[q.BitAt(depth)]; qb != nil {
 		if d, ok := qb.remove(depth+1, q); ok {
 			trie.shrink()
@@ -91,7 +95,7 @@ func (trie *XorTrie) remove(depth int, q TrieKey) (reachedDepth int, removed boo
 			return d, false
 		}
 	} else {
-		if trie.key != nil && TrieKeyEqual(q, trie.key) {
+		if trie.key != nil && key.Equal(q, trie.key) {
 			trie.key = nil
 			return depth, true
 		} else {

xortrie_test.go → trie/xortrie_test.go

-package xor
+package trie
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/libp2p/go-libp2p-xor/key"
+)
 
 func TestInsertRemove(t *testing.T) {
-	r := NewXorTrie()
+	r := New()
 	testSeq(r, t)
 	testSeq(r, t)
 }
 
 func testSeq(r *XorTrie, t *testing.T) {
 	for _, s := range testInsertSeq {
-		depth, _ := r.Add(TrieKey(s.key))
+		depth, _ := r.Add(key.Key(s.key))
 		if depth != s.insertedDepth {
 			t.Errorf("inserting expected %d, got %d", s.insertedDepth, depth)
 		}
 	}
 	for _, s := range testRemoveSeq {
-		depth, _ := r.Remove(TrieKey(s.key))
+		depth, _ := r.Remove(key.Key(s.key))
 		if depth != s.reachedDepth {
 			t.Errorf("removing expected %d, got %d", s.reachedDepth, depth)
 		}