chore+feat: refactor triplestore and cardinality types

zinic · zinic · commit 3c2ed1e45a54 · 2026-02-21T21:55:05.000-08:00
diff --git a/algo/reach.go b/algo/reach.go
@@ -278,7 +278,7 @@ func (s *ReachabilityCache) OrReach(node uint64, direction graph.Direction, dupl
 // from the result before the XOR operation.
 func (s *ReachabilityCache) XorReach(node uint64, direction graph.Direction, duplex cardinality.Duplex[uint64]) {
 	// Reach bitmap will contain the member due to resolution of component reach
-	reachBitmap := s.ReachOfComponentContainingMember(node, direction).Clone()
+	reachBitmap := s.ReachOfComponentContainingMember(node, direction).Clone().(cardinality.Duplex[uint64])
 	reachBitmap.Remove(node)
 
 	duplex.Xor(reachBitmap)
diff --git a/cardinality/cardinality.go b/cardinality/cardinality.go
@@ -1,38 +1,30 @@
 package cardinality
 
-type ProviderConstructor[T uint32 | uint64] func() Provider[T]
+type ProviderConstructor[T uint32 | uint64] func() MutableProvider[T]
 type SimplexConstructor[T uint32 | uint64] func() Simplex[T]
 type DuplexConstructor[T uint32 | uint64] func() Duplex[T]
 
-// Provider describes the most basic functionality of a cardinality provider algorithm: adding elements to the provider
-// and producing the cardinality of those elements.
 type Provider[T uint32 | uint64] interface {
-	Add(value ...T)
-	Or(other Provider[T])
-	Clear()
 	Cardinality() uint64
+	Clone() Provider[T]
 }
 
-func CloneProvider[T uint32 | uint64](provider Provider[T]) Provider[T] {
-	switch typedProvider := provider.(type) {
-	case Simplex[T]:
-		return typedProvider.Clone()
-
-	case Duplex[T]:
-		return typedProvider.Clone()
+// MutableProvider describes the most basic functionality of a cardinality provider algorithm: adding elements to the provider
+// and producing the cardinality of those elements.
+type MutableProvider[T uint32 | uint64] interface {
+	Provider[T]
 
-	default:
-		return provider
-	}
+	Add(value ...T)
+	Clear()
 }
 
 // Simplex is a one-way cardinality provider that does not allow a user to retrieve encoded values back out of the
 // provider. This interface is suitable for algorithms such as HyperLogLog which utilizes a hash function to merge
 // identifiers into the cardinality provider.
 type Simplex[T uint32 | uint64] interface {
-	Provider[T]
+	MutableProvider[T]
 
-	Clone() Simplex[T]
+	Or(other Provider[T])
 }
 
 // Iterator allows enumeration of a duplex cardinality provider without requiring the allocation of the provider's set.
@@ -44,15 +36,24 @@ type Iterator[T uint32 | uint64] interface {
 // Duplex is a two-way cardinality provider that allows a user to retrieve encoded values back out of the provider. This
 // interface is suitable for algorithms that behave similar to bitvectors.
 type Duplex[T uint32 | uint64] interface {
-	Provider[T]
+	MutableProvider[T]
 
+	Or(other Provider[T])
 	Xor(other Provider[T])
 	And(other Provider[T])
 	AndNot(other Provider[T])
+
+	CheckedAdd(value T) bool
 	Remove(value T)
+	Contains(value T) bool
+	Slice() []T
+	Each(delegate func(value T) bool)
+}
+
+type ImmutableDuplex[T uint32 | uint64] interface {
+	Provider[T]
+
 	Slice() []T
 	Contains(value T) bool
 	Each(delegate func(value T) bool)
-	CheckedAdd(value T) bool
-	Clone() Duplex[T]
 }
diff --git a/cardinality/hyperloglog32.go b/cardinality/hyperloglog32.go
@@ -26,11 +26,11 @@ func NewHyperLogLog32() Simplex[uint32] {
 	}
 }
 
-func NewHyperLogLog32Provider() Provider[uint32] {
+func NewHyperLogLog32Provider() MutableProvider[uint32] {
 	return NewHyperLogLog32()
 }
 
-func (s *hyperLogLog32) Clone() Simplex[uint32] {
+func (s *hyperLogLog32) Clone() Provider[uint32] {
 	return &hyperLogLog32{
 		sketch: s.sketch.Clone(),
 	}
diff --git a/cardinality/hyperloglog64.go b/cardinality/hyperloglog64.go
@@ -26,11 +26,11 @@ func NewHyperLogLog64() Simplex[uint64] {
 	}
 }
 
-func NewHyperLogLog64Provider() Provider[uint64] {
+func NewHyperLogLog64Provider() MutableProvider[uint64] {
 	return NewHyperLogLog64()
 }
 
-func (s *hyperLogLog64) Clone() Simplex[uint64] {
+func (s *hyperLogLog64) Clone() Provider[uint64] {
 	return &hyperLogLog64{
 		sketch: s.sketch.Clone(),
 	}
diff --git a/cardinality/lock.go b/cardinality/lock.go
@@ -100,11 +100,11 @@ func (s threadSafeDuplex[T]) CheckedAdd(value T) bool {
 	return s.provider.CheckedAdd(value)
 }
 
-func (s threadSafeDuplex[T]) Clone() Duplex[T] {
+func (s threadSafeDuplex[T]) Clone() Provider[T] {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	return ThreadSafeDuplex(s.provider.Clone())
+	return ThreadSafeDuplex(s.provider.Clone().(Duplex[T]))
 }
 
 type threadSafeSimplex[T uint32 | uint64] struct {
@@ -147,9 +147,9 @@ func (s threadSafeSimplex[T]) Cardinality() uint64 {
 	return s.provider.Cardinality()
 }
 
-func (s threadSafeSimplex[T]) Clone() Simplex[T] {
+func (s threadSafeSimplex[T]) Clone() Provider[T] {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	return ThreadSafeSimplex(s.provider.Clone())
+	return ThreadSafeSimplex(s.provider.Clone().(Simplex[T]))
 }
diff --git a/cardinality/roaring32.go b/cardinality/roaring32.go
@@ -26,7 +26,7 @@ func NewBitmap32() Duplex[uint32] {
 	}
 }
 
-func NewBitmap32Provider() Provider[uint32] {
+func NewBitmap32Provider() MutableProvider[uint32] {
 	return NewBitmap32()
 }
 
@@ -125,7 +125,7 @@ func (s bitmap32) Cardinality() uint64 {
 	return s.bitmap.GetCardinality()
 }
 
-func (s bitmap32) Clone() Duplex[uint32] {
+func (s bitmap32) Clone() Provider[uint32] {
 	return bitmap32{
 		bitmap: s.bitmap.Clone(),
 	}
diff --git a/cardinality/roaring64.go b/cardinality/roaring64.go
@@ -26,7 +26,7 @@ func NewBitmap64() Duplex[uint64] {
 	}
 }
 
-func NewBitmap64Provider() Provider[uint64] {
+func NewBitmap64Provider() MutableProvider[uint64] {
 	return NewBitmap64()
 }
 
@@ -68,7 +68,13 @@ func (s bitmap64) CheckedAdd(value uint64) bool {
 }
 
 func (s bitmap64) Add(values ...uint64) {
-	s.bitmap.AddMany(values)
+	switch len(values) {
+	case 0:
+	case 1:
+		s.bitmap.Add(values[0])
+	default:
+		s.bitmap.AddMany(values)
+	}
 }
 
 func (s bitmap64) Remove(value uint64) {
@@ -123,7 +129,7 @@ func (s bitmap64) Cardinality() uint64 {
 	return s.bitmap.GetCardinality()
 }
 
-func (s bitmap64) Clone() Duplex[uint64] {
+func (s bitmap64) Clone() Provider[uint64] {
 	return bitmap64{
 		bitmap: s.bitmap.Clone(),
 	}
diff --git a/container/adjacencymap.go b/container/adjacencymap.go
@@ -119,7 +119,7 @@ func (s *adjacencyMapDigraph) getAdjacent(node uint64, direction graph.Direction
 
 		if hasOutbound {
 			if hasInbound {
-				combinedAdjacent := outboundAdjacent.Clone()
+				combinedAdjacent := outboundAdjacent.Clone().(cardinality.Duplex[uint64])
 				combinedAdjacent.Or(inboundAdjacent)
 
 				return combinedAdjacent
diff --git a/container/triplestore.go b/container/triplestore.go
diff --git a/go.mod b/go.mod
diff --git a/go.sum b/go.sum
diff --git a/graph/types.go b/graph/types.go

Original file line number	Diff line number	Diff line change
`@@ -26,11 +26,11 @@ func NewHyperLogLog32() Simplex[uint32] {`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`29`		`-func NewHyperLogLog32Provider() Provider[uint32] {`
	`29`	`+func NewHyperLogLog32Provider() MutableProvider[uint32] {`
`30`	`30`	`return NewHyperLogLog32()`
`31`	`31`	`}`
`32`	`32`
`33`		`-func (s *hyperLogLog32) Clone() Simplex[uint32] {`
	`33`	`+func (s *hyperLogLog32) Clone() Provider[uint32] {`
`34`	`34`	`return &hyperLogLog32{`
`35`	`35`	`sketch: s.sketch.Clone(),`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,11 +100,11 @@ func (s threadSafeDuplex[T]) CheckedAdd(value T) bool {`
`100`	`100`	`return s.provider.CheckedAdd(value)`
`101`	`101`	`}`
`102`	`102`
`103`		`-func (s threadSafeDuplex[T]) Clone() Duplex[T] {`
	`103`	`+func (s threadSafeDuplex[T]) Clone() Provider[T] {`
`104`	`104`	`s.lock.Lock()`
`105`	`105`	`defer s.lock.Unlock()`
`106`	`106`
`107`		`- return ThreadSafeDuplex(s.provider.Clone())`
	`107`	`+ return ThreadSafeDuplex(s.provider.Clone().(Duplex[T]))`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`type threadSafeSimplex[T uint32 \| uint64] struct {`
`@@ -147,9 +147,9 @@ func (s threadSafeSimplex[T]) Cardinality() uint64 {`
`147`	`147`	`return s.provider.Cardinality()`
`148`	`148`	`}`
`149`	`149`
`150`		`-func (s threadSafeSimplex[T]) Clone() Simplex[T] {`
	`150`	`+func (s threadSafeSimplex[T]) Clone() Provider[T] {`
`151`	`151`	`s.lock.Lock()`
`152`	`152`	`defer s.lock.Unlock()`
`153`	`153`
`154`		`- return ThreadSafeSimplex(s.provider.Clone())`
	`154`	`+ return ThreadSafeSimplex(s.provider.Clone().(Simplex[T]))`
`155`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ func NewBitmap32() Duplex[uint32] {`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`29`		`-func NewBitmap32Provider() Provider[uint32] {`
	`29`	`+func NewBitmap32Provider() MutableProvider[uint32] {`
`30`	`30`	`return NewBitmap32()`
`31`	`31`	`}`
`32`	`32`
`@@ -125,7 +125,7 @@ func (s bitmap32) Cardinality() uint64 {`
`125`	`125`	`return s.bitmap.GetCardinality()`
`126`	`126`	`}`
`127`	`127`
`128`		`-func (s bitmap32) Clone() Duplex[uint32] {`
	`128`	`+func (s bitmap32) Clone() Provider[uint32] {`
`129`	`129`	`return bitmap32{`
`130`	`130`	`bitmap: s.bitmap.Clone(),`
`131`	`131`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ func NewBitmap64() Duplex[uint64] {`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`29`		`-func NewBitmap64Provider() Provider[uint64] {`
	`29`	`+func NewBitmap64Provider() MutableProvider[uint64] {`
`30`	`30`	`return NewBitmap64()`
`31`	`31`	`}`
`32`	`32`
`@@ -68,7 +68,13 @@ func (s bitmap64) CheckedAdd(value uint64) bool {`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`func (s bitmap64) Add(values ...uint64) {`
`71`		`- s.bitmap.AddMany(values)`
	`71`	`+ switch len(values) {`
	`72`	`+ case 0:`
	`73`	`+ case 1:`
	`74`	`+ s.bitmap.Add(values[0])`
	`75`	`+ default:`
	`76`	`+ s.bitmap.AddMany(values)`
	`77`	`+ }`
`72`	`78`	`}`
`73`	`79`
`74`	`80`	`func (s bitmap64) Remove(value uint64) {`
`@@ -123,7 +129,7 @@ func (s bitmap64) Cardinality() uint64 {`
`123`	`129`	`return s.bitmap.GetCardinality()`
`124`	`130`	`}`
`125`	`131`
`126`		`-func (s bitmap64) Clone() Duplex[uint64] {`
	`132`	`+func (s bitmap64) Clone() Provider[uint64] {`
`127`	`133`	`return bitmap64{`
`128`	`134`	`bitmap: s.bitmap.Clone(),`
`129`	`135`	`}`