chore+feat: refactor triplestore and cardinality types

Author: zinic

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)

cardinality/cardinality.go

@@ -7,9 +7,6 @@ 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
 }
 
@@ -26,13 +23,21 @@ func CloneProvider[T uint32 | uint64](provider Provider[T]) Provider[T] {
 	}
 }
 
+type ImmutableSimplex[T uint32 | uint64] interface {
+	Provider[T]
+
+	Clone() Simplex[T]
+}
+
 // 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]
+	ImmutableSimplex[T]
 
-	Clone() Simplex[T]
+	Add(value ...T)
+	Or(other Provider[T])
+	Clear()
 }
 
 // Iterator allows enumeration of a duplex cardinality provider without requiring the allocation of the provider's set.
@@ -41,18 +46,27 @@ type Iterator[T uint32 | uint64] interface {
 	Next() T
 }
 
+type ImmutableDuplex[T uint32 | uint64] interface {
+	Provider[T]
+
+	Slice() []T
+	Contains(value T) bool
+	Each(delegate func(value T) bool)
+
+	Clone() Duplex[T]
+}
+
 // 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]
+	ImmutableDuplex[T]
 
+	Add(value ...T)
+	CheckedAdd(value T) bool
+	Remove(value T)
+	Or(other Provider[T])
 	Xor(other Provider[T])
 	And(other Provider[T])
 	AndNot(other Provider[T])
-	Remove(value T)
-	Slice() []T
-	Contains(value T) bool
-	Each(delegate func(value T) bool)
-	CheckedAdd(value T) bool
-	Clone() Duplex[T]
+	Clear()
 }

cardinality/roaring32.go

@@ -68,7 +68,13 @@ func (s bitmap32) CheckedAdd(value uint32) bool {
 }
 
 func (s bitmap32) Add(values ...uint32) {
-	s.bitmap.AddMany(values)
+	switch len(values) {
+	case 0:
+	case 1:
+		s.bitmap.Add(values[0])
+	default:
+		s.bitmap.AddMany(values)
+	}
 }
 
 func (s bitmap32) Remove(value uint32) {

cardinality/roaring64.go

@@ -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) {