From cb7a3a66b25d796f05d162700845ee4fa182efc7 Mon Sep 17 00:00:00 2001
From: teivah <tharsanyi@utilitywarehouse.co.uk>
Date: Tue, 16 Jul 2019 01:25:13 +0100
Subject: [PATCH] Type

---
 README.md           | 28 ++++++++--------------
 bitvector.go        | 24 -------------------
 bitvector16.go      | 57 ++++++++++++++++++---------------------------
 bitvector16_test.go | 53 +++++++++++++++++------------------------
 bitvector32.go      | 57 ++++++++++++++++++---------------------------
 bitvector32_test.go | 53 +++++++++++++++++------------------------
 bitvector64.go      | 57 ++++++++++++++++++---------------------------
 bitvector64_test.go | 53 +++++++++++++++++------------------------
 bitvector8.go       | 57 ++++++++++++++++++---------------------------
 bitvector8_test.go  | 52 +++++++++++++++++------------------------
 10 files changed, 189 insertions(+), 302 deletions(-)
 delete mode 100644 bitvector.go

diff --git a/README.md b/README.md
index 3bf8511..133513d 100644
--- a/README.md
+++ b/README.md
@@ -6,12 +6,16 @@
 
 A bit vector is an array data structure that compactly stores bits.
 
-This library is based on 4 different data structures:
+This library is statically based on 4 different data structures:
 * 8-bit vector: relies on an internal `uint8`
 * 16-bit vector: relies on an internal `uint16`
 * 32-bit vector: relies on an internal `uint32`
 * 64-bit vector: relies on an internal `uint64`
 
+The rationale compared to being based on a `[]byte` is to save memory if you need a static bit vector structure. Hence, you might be interested in this library for memory-bound computation.
+
+Moreover,    
+
 ## Installation
 
 ```
@@ -51,8 +55,8 @@ bv := bitvector.New64()
 * Set ith bit:
 
 ```go
-bv.Set(i, true)
-bv.Set(i, false)
+bv = bv.Set(i, true)
+bv = bv.Set(i, false)
 ```
 
 * Get ith bit:
@@ -64,13 +68,13 @@ b := bv.Get(i) // bool
 * Toggle (flip) ith bit:
 
 ```go
-bv.Toggle(i)
+bv = bv.Toggle(i)
 ```
 
 * Clear bits from index i (included) to index j (excluded):
 
 ```go
-bv.Clear(i, j)
+bv = bv.Clear(i, j)
 ```
 
 * Count the number of bits set to 1:
@@ -79,20 +83,8 @@ bv.Clear(i, j)
 i := bv.Count() // uint8
 ```
 
-* Reset the internal bit vector:
-
-```go
-bv.Reset()
-```
-
-* Copy the current bit vector to another data structure:
-
-```go
-bv2 := bv.Copy() // bitvector.Handler
-```
-
 * Convert the internal bit vector structure to a string:
 
 ```go
-s := bv.String()
+s := bv.String() // string
 ```
\ No newline at end of file
diff --git a/bitvector.go b/bitvector.go
deleted file mode 100644
index 4060385..0000000
--- a/bitvector.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package bitvector
-
-import (
-	"fmt"
-)
-
-// Handler represents an 8, 16, 32 or 64 bit vector
-type Handler interface {
-	fmt.Stringer
-	// Clear bits from index i (included) to index j (excluded)
-	Clear(i, j uint8)
-	// Copy creates another bit vector structure based on the same length
-	Copy() Handler
-	// Count the number of bits set to 1
-	Count() uint8
-	// Get ith bit
-	Get(i uint8) bool
-	// Reset the bit vector to 0
-	Reset()
-	// Set ith bit
-	Set(i uint8, b bool)
-	// Toggle ith bit
-	Toggle(i uint8)
-}
diff --git a/bitvector16.go b/bitvector16.go
index 29de864..aa7318d 100644
--- a/bitvector16.go
+++ b/bitvector16.go
@@ -5,33 +5,28 @@ import (
 	"math"
 )
 
-type bitVector16 struct {
-	n uint16
-}
+// Len16 is a 16-bit vector
+type Len16 uint16
 
-func (bv *bitVector16) String() string {
-	return fmt.Sprintf("%b", bv.n)
+func (bv Len16) String() string {
+	return fmt.Sprintf("%b", bv)
 }
 
-func (bv *bitVector16) Clear(i, j uint8) {
+// Clear bits from index i (included) to index j (excluded)
+func (bv Len16) Clear(i, j uint8) Len16 {
 	if i > j {
-		return
-	}
-	bv.n = math.MaxUint16<<j | ((1<<i)-1)&bv.n
-}
-
-func (bv *bitVector16) Copy() Handler {
-	return &bitVector16{
-		n: bv.n,
+		return bv
 	}
+	return math.MaxUint16<<j | ((1<<i)-1)&bv
 }
 
-func (bv *bitVector16) Count() uint8 {
+// Count the number of bits set to 1
+func (bv Len16) Count() uint8 {
 	var count uint8
-	var index uint16 = 1
+	var index Len16 = 1
 	var i uint8
 	for {
-		if bv.n&index != 0 {
+		if bv&index != 0 {
 			count++
 		}
 		index <<= 1
@@ -43,28 +38,22 @@ func (bv *bitVector16) Count() uint8 {
 	return count
 }
 
-func (bv *bitVector16) Toggle(i uint8) {
-	bv.n ^= 1 << i
+// Toggle ith bit
+func (bv Len16) Toggle(i uint8) Len16 {
+	return bv ^ 1<<i
 }
 
-func (bv *bitVector16) Get(i uint8) bool {
-	return (bv.n & (1 << i)) != 0
+// Get ith bit
+func (bv Len16) Get(i uint8) bool {
+	return (bv & (1 << i)) != 0
 }
 
-func (bv *bitVector16) Reset() {
-	bv.n = 0
-}
-
-func (bv *bitVector16) Set(i uint8, b bool) {
-	var value uint16
+// Set ith bit
+func (bv Len16) Set(i uint8, b bool) Len16 {
+	var value Len16
 	if b {
 		value = 1
 	}
-	var mask uint16 = ^(1 << i)
-	bv.n = (bv.n & mask) | (value << i)
-}
-
-// New16 creates a new 16-bit vector
-func New16() Handler {
-	return &bitVector16{}
+	var mask Len16 = ^(1 << i)
+	return (bv & mask) | (value << i)
 }
diff --git a/bitvector16_test.go b/bitvector16_test.go
index 6cfd1ec..42d6924 100644
--- a/bitvector16_test.go
+++ b/bitvector16_test.go
@@ -7,21 +7,21 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestBV16(t *testing.T) {
-	bv := &bitVector16{}
+func Test_Len16(t *testing.T) {
+	var bv Len16
 
 	// Set
-	assert.Equal(t, uint16(0), bv.n)
-	bv.Set(0, true)
-	assert.Equal(t, uint16(1), bv.n)
-	bv.Set(15, true)
-	assert.Equal(t, uint16(32769), bv.n)
-	bv.Set(16, true)
-	assert.Equal(t, uint16(32769), bv.n)
-	bv.Set(14, true)
-	assert.Equal(t, uint16(49153), bv.n)
-	bv.Set(14, false)
-	assert.Equal(t, uint16(32769), bv.n)
+	assert.Equal(t, Len16(0), bv)
+	bv = bv.Set(0, true)
+	assert.Equal(t, Len16(1), bv)
+	bv = bv.Set(15, true)
+	assert.Equal(t, Len16(32769), bv)
+	bv = bv.Set(16, true)
+	assert.Equal(t, Len16(32769), bv)
+	bv = bv.Set(14, true)
+	assert.Equal(t, Len16(49153), bv)
+	bv = bv.Set(14, false)
+	assert.Equal(t, Len16(32769), bv)
 
 	// Count
 	assert.Equal(t, uint8(2), bv.Count())
@@ -31,31 +31,22 @@ func TestBV16(t *testing.T) {
 	assert.True(t, bv.Get(15))
 	assert.False(t, bv.Get(14))
 
-	// Reset
-	bv.Reset()
-	assert.Equal(t, uint16(0), bv.n)
-
 	// Toggle
-	bv.Toggle(15)
-	assert.Equal(t, uint16(32768), bv.n)
+	bv = 0
+	bv = bv.Toggle(15)
+	assert.Equal(t, Len16(32768), bv)
 
 	// Clear
-	bv.Reset()
+	bv = 0
 	var i uint8
 	for ; i < 16; i++ {
-		bv.Set(i, true)
+		bv = bv.Set(i, true)
 	}
-	bv.Clear(6, 2)
-	assert.Equal(t, uint16(math.MaxUint16), bv.n)
-	bv.Clear(2, 6)
-	assert.Equal(t, uint16(65475), bv.n)
-
-	// Copy
-	assert.Equal(t, uint8(12), bv.Copy().Count())
+	bv = bv.Clear(6, 2)
+	assert.Equal(t, Len16(math.MaxUint16), bv)
+	bv = bv.Clear(2, 6)
+	assert.Equal(t, Len16(65475), bv)
 
 	// String
 	assert.Equal(t, "1111111111000011", bv.String())
-
-	// New
-	assert.Equal(t, uint8(0), New16().Count())
 }
diff --git a/bitvector32.go b/bitvector32.go
index a0d9273..f933a2c 100644
--- a/bitvector32.go
+++ b/bitvector32.go
@@ -5,33 +5,28 @@ import (
 	"math"
 )
 
-type bitVector32 struct {
-	n uint32
-}
+// Len32 is a 32-bit vector
+type Len32 uint32
 
-func (bv *bitVector32) String() string {
-	return fmt.Sprintf("%b", bv.n)
+func (bv Len32) String() string {
+	return fmt.Sprintf("%b", bv)
 }
 
-func (bv *bitVector32) Clear(i, j uint8) {
+// Clear bits from index i (included) to index j (excluded)
+func (bv Len32) Clear(i, j uint8) Len32 {
 	if i > j {
-		return
-	}
-	bv.n = math.MaxUint32<<j | ((1<<i)-1)&bv.n
-}
-
-func (bv *bitVector32) Copy() Handler {
-	return &bitVector32{
-		n: bv.n,
+		return bv
 	}
+	return math.MaxUint32<<j | ((1<<i)-1)&bv
 }
 
-func (bv *bitVector32) Count() uint8 {
+// Count the number of bits set to 1
+func (bv Len32) Count() uint8 {
 	var count uint8
-	var index uint32 = 1
+	var index Len32 = 1
 	var i uint8
 	for {
-		if bv.n&index != 0 {
+		if bv&index != 0 {
 			count++
 		}
 		index <<= 1
@@ -43,28 +38,22 @@ func (bv *bitVector32) Count() uint8 {
 	return count
 }
 
-func (bv *bitVector32) Toggle(i uint8) {
-	bv.n ^= 1 << i
+// Toggle ith bit
+func (bv Len32) Toggle(i uint8) Len32 {
+	return bv ^ 1<<i
 }
 
-func (bv *bitVector32) Get(i uint8) bool {
-	return (bv.n & (1 << i)) != 0
+// Get ith bit
+func (bv Len32) Get(i uint8) bool {
+	return (bv & (1 << i)) != 0
 }
 
-func (bv *bitVector32) Reset() {
-	bv.n = 0
-}
-
-func (bv *bitVector32) Set(i uint8, b bool) {
-	var value uint32
+// Set ith bit
+func (bv Len32) Set(i uint8, b bool) Len32 {
+	var value Len32
 	if b {
 		value = 1
 	}
-	var mask uint32 = ^(1 << i)
-	bv.n = (bv.n & mask) | (value << i)
-}
-
-// New32 creates a new 32-bit vector
-func New32() Handler {
-	return &bitVector32{}
+	var mask Len32 = ^(1 << i)
+	return (bv & mask) | (value << i)
 }
diff --git a/bitvector32_test.go b/bitvector32_test.go
index d53d973..e1b1464 100644
--- a/bitvector32_test.go
+++ b/bitvector32_test.go
@@ -7,21 +7,21 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestBV32(t *testing.T) {
-	bv := &bitVector32{}
+func Test_Len32(t *testing.T) {
+	var bv Len32
 
 	// Set
-	assert.Equal(t, uint32(0), bv.n)
-	bv.Set(0, true)
-	assert.Equal(t, uint32(1), bv.n)
-	bv.Set(31, true)
-	assert.Equal(t, uint32(2147483649), bv.n)
-	bv.Set(32, true)
-	assert.Equal(t, uint32(2147483649), bv.n)
-	bv.Set(30, true)
-	assert.Equal(t, uint32(3221225473), bv.n)
-	bv.Set(30, false)
-	assert.Equal(t, uint32(2147483649), bv.n)
+	assert.Equal(t, Len32(0), bv)
+	bv = bv.Set(0, true)
+	assert.Equal(t, Len32(1), bv)
+	bv = bv.Set(31, true)
+	assert.Equal(t, Len32(2147483649), bv)
+	bv = bv.Set(32, true)
+	assert.Equal(t, Len32(2147483649), bv)
+	bv = bv.Set(30, true)
+	assert.Equal(t, Len32(3221225473), bv)
+	bv = bv.Set(30, false)
+	assert.Equal(t, Len32(2147483649), bv)
 
 	// Count
 	assert.Equal(t, uint8(2), bv.Count())
@@ -31,31 +31,22 @@ func TestBV32(t *testing.T) {
 	assert.True(t, bv.Get(31))
 	assert.False(t, bv.Get(30))
 
-	// Reset
-	bv.Reset()
-	assert.Equal(t, uint32(0), bv.n)
-
 	// Toggle
-	bv.Toggle(31)
-	assert.Equal(t, uint32(2147483648), bv.n)
+	bv = 0
+	bv = bv.Toggle(15)
+	assert.Equal(t, Len32(32768), bv)
 
 	// Clear
-	bv.Reset()
+	bv = 0
 	var i uint8
 	for ; i < 32; i++ {
-		bv.Set(i, true)
+		bv = bv.Set(i, true)
 	}
-	bv.Clear(6, 2)
-	assert.Equal(t, uint32(math.MaxUint32), bv.n)
-	bv.Clear(2, 6)
-	assert.Equal(t, uint32(4294967235), bv.n)
-
-	// Copy
-	assert.Equal(t, uint8(28), bv.Copy().Count())
+	bv = bv.Clear(6, 2)
+	assert.Equal(t, Len32(math.MaxUint32), bv)
+	bv = bv.Clear(2, 6)
+	assert.Equal(t, Len32(4294967235), bv)
 
 	// String
 	assert.Equal(t, "11111111111111111111111111000011", bv.String())
-
-	// New
-	assert.Equal(t, uint8(0), New32().Count())
 }
diff --git a/bitvector64.go b/bitvector64.go
index 3a34d94..4e1a857 100644
--- a/bitvector64.go
+++ b/bitvector64.go
@@ -5,33 +5,28 @@ import (
 	"math"
 )
 
-type bitVector64 struct {
-	n uint64
-}
+// Len64 is a 64-bit vector
+type Len64 uint64
 
-func (bv *bitVector64) String() string {
-	return fmt.Sprintf("%b", bv.n)
+func (bv Len64) String() string {
+	return fmt.Sprintf("%b", bv)
 }
 
-func (bv *bitVector64) Clear(i, j uint8) {
+// Clear bits from index i (included) to index j (excluded)
+func (bv Len64) Clear(i, j uint8) Len64 {
 	if i > j {
-		return
-	}
-	bv.n = math.MaxUint64<<j | ((1<<i)-1)&bv.n
-}
-
-func (bv *bitVector64) Copy() Handler {
-	return &bitVector64{
-		n: bv.n,
+		return bv
 	}
+	return math.MaxUint64<<j | ((1<<i)-1)&bv
 }
 
-func (bv *bitVector64) Count() uint8 {
+// Count the number of bits set to 1
+func (bv Len64) Count() uint8 {
 	var count uint8
-	var index uint64 = 1
+	var index Len64 = 1
 	var i uint8
 	for {
-		if bv.n&index != 0 {
+		if bv&index != 0 {
 			count++
 		}
 		index <<= 1
@@ -43,28 +38,22 @@ func (bv *bitVector64) Count() uint8 {
 	return count
 }
 
-func (bv *bitVector64) Toggle(i uint8) {
-	bv.n ^= 1 << i
+// Toggle ith bit
+func (bv Len64) Toggle(i uint8) Len64 {
+	return bv ^ 1<<i
 }
 
-func (bv *bitVector64) Get(i uint8) bool {
-	return (bv.n & (1 << i)) != 0
+// Get ith bit
+func (bv Len64) Get(i uint8) bool {
+	return (bv & (1 << i)) != 0
 }
 
-func (bv *bitVector64) Reset() {
-	bv.n = 0
-}
-
-func (bv *bitVector64) Set(i uint8, b bool) {
-	var value uint64
+// Set ith bit
+func (bv Len64) Set(i uint8, b bool) Len64 {
+	var value Len64
 	if b {
 		value = 1
 	}
-	var mask uint64 = ^(1 << i)
-	bv.n = (bv.n & mask) | (value << i)
-}
-
-// New64 creates a new 64-bit vector
-func New64() Handler {
-	return &bitVector64{}
+	var mask Len64 = ^(1 << i)
+	return (bv & mask) | (value << i)
 }
diff --git a/bitvector64_test.go b/bitvector64_test.go
index 0fa3a10..cfe3b55 100644
--- a/bitvector64_test.go
+++ b/bitvector64_test.go
@@ -7,21 +7,21 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestBV64(t *testing.T) {
-	bv := &bitVector64{}
+func Test_Len64(t *testing.T) {
+	var bv Len64
 
 	// Set
-	assert.Equal(t, uint64(0), bv.n)
-	bv.Set(0, true)
-	assert.Equal(t, uint64(1), bv.n)
-	bv.Set(63, true)
-	assert.Equal(t, uint64(9223372036854775809), bv.n)
-	bv.Set(64, true)
-	assert.Equal(t, uint64(9223372036854775809), bv.n)
-	bv.Set(62, true)
-	assert.Equal(t, uint64(13835058055282163713), bv.n)
-	bv.Set(62, false)
-	assert.Equal(t, uint64(9223372036854775809), bv.n)
+	assert.Equal(t, Len64(0), bv)
+	bv = bv.Set(0, true)
+	assert.Equal(t, Len64(1), bv)
+	bv = bv.Set(63, true)
+	assert.Equal(t, Len64(9223372036854775809), bv)
+	bv = bv.Set(64, true)
+	assert.Equal(t, Len64(9223372036854775809), bv)
+	bv = bv.Set(62, true)
+	assert.Equal(t, Len64(13835058055282163713), bv)
+	bv = bv.Set(62, false)
+	assert.Equal(t, Len64(9223372036854775809), bv)
 
 	// Count
 	assert.Equal(t, uint8(2), bv.Count())
@@ -31,31 +31,22 @@ func TestBV64(t *testing.T) {
 	assert.True(t, bv.Get(63))
 	assert.False(t, bv.Get(62))
 
-	// Reset
-	bv.Reset()
-	assert.Equal(t, uint64(0), bv.n)
-
 	// Toggle
-	bv.Toggle(63)
-	assert.Equal(t, uint64(9223372036854775808), bv.n)
+	bv = 0
+	bv = bv.Toggle(63)
+	assert.Equal(t, Len64(9223372036854775808), bv)
 
 	// Clear
-	bv.Reset()
+	bv = 0
 	var i uint8
 	for ; i < 64; i++ {
-		bv.Set(i, true)
+		bv = bv.Set(i, true)
 	}
-	bv.Clear(6, 2)
-	assert.Equal(t, uint64(math.MaxUint64), bv.n)
-	bv.Clear(2, 6)
-	assert.Equal(t, uint64(18446744073709551555), bv.n)
-
-	// Copy
-	assert.Equal(t, uint8(60), bv.Copy().Count())
+	bv = bv.Clear(6, 2)
+	assert.Equal(t, Len64(math.MaxUint64), bv)
+	bv = bv.Clear(2, 6)
+	assert.Equal(t, Len64(18446744073709551555), bv)
 
 	// String
 	assert.Equal(t, "1111111111111111111111111111111111111111111111111111111111000011", bv.String())
-
-	// New
-	assert.Equal(t, uint8(0), New64().Count())
 }
diff --git a/bitvector8.go b/bitvector8.go
index 9d73c7e..c1b99af 100644
--- a/bitvector8.go
+++ b/bitvector8.go
@@ -5,33 +5,28 @@ import (
 	"math"
 )
 
-type bitVector8 struct {
-	n uint8
-}
+// Len8 is a 8-bit vector
+type Len8 uint8
 
-func (bv *bitVector8) String() string {
-	return fmt.Sprintf("%b", bv.n)
+func (bv Len8) String() string {
+	return fmt.Sprintf("%b", bv)
 }
 
-func (bv *bitVector8) Clear(i, j uint8) {
+// Clear bits from index i (included) to index j (excluded)
+func (bv Len8) Clear(i, j uint8) Len8 {
 	if i > j {
-		return
-	}
-	bv.n = math.MaxUint8<<j | ((1<<i)-1)&bv.n
-}
-
-func (bv *bitVector8) Copy() Handler {
-	return &bitVector8{
-		n: bv.n,
+		return bv
 	}
+	return math.MaxUint8<<j | ((1<<i)-1)&bv
 }
 
-func (bv *bitVector8) Count() uint8 {
+// Count the number of bits set to 1
+func (bv Len8) Count() uint8 {
 	var count uint8
-	var index uint8 = 1
+	var index Len8 = 1
 	var i uint8
 	for {
-		if bv.n&index != 0 {
+		if bv&index != 0 {
 			count++
 		}
 		index <<= 1
@@ -43,28 +38,22 @@ func (bv *bitVector8) Count() uint8 {
 	return count
 }
 
-func (bv *bitVector8) Toggle(i uint8) {
-	bv.n ^= 1 << i
+// Toggle ith bit
+func (bv Len8) Toggle(i uint8) Len8 {
+	return bv ^ 1<<i
 }
 
-func (bv *bitVector8) Get(i uint8) bool {
-	return (bv.n & (1 << i)) != 0
+// Get ith bit
+func (bv Len8) Get(i uint8) bool {
+	return (bv & (1 << i)) != 0
 }
 
-func (bv *bitVector8) Reset() {
-	bv.n = 0
-}
-
-func (bv *bitVector8) Set(i uint8, b bool) {
-	var value uint8
+// Set ith bit
+func (bv Len8) Set(i uint8, b bool) Len8 {
+	var value Len8
 	if b {
 		value = 1
 	}
-	var mask uint8 = ^(1 << i)
-	bv.n = (bv.n & mask) | (value << i)
-}
-
-// New8 creates a new 8-bit vector
-func New8() Handler {
-	return &bitVector8{}
+	var mask Len8 = ^(1 << i)
+	return (bv & mask) | (value << i)
 }
diff --git a/bitvector8_test.go b/bitvector8_test.go
index 4f560fe..2efff39 100644
--- a/bitvector8_test.go
+++ b/bitvector8_test.go
@@ -7,21 +7,21 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestBV8(t *testing.T) {
-	bv := &bitVector8{}
+func Test_Len8(t *testing.T) {
+	var bv Len8
 
 	// Set
-	assert.Equal(t, uint8(0), bv.n)
-	bv.Set(0, true)
-	assert.Equal(t, uint8(1), bv.n)
-	bv.Set(7, true)
-	assert.Equal(t, uint8(129), bv.n)
-	bv.Set(8, true)
-	assert.Equal(t, uint8(129), bv.n)
-	bv.Set(6, true)
-	assert.Equal(t, uint8(193), bv.n)
-	bv.Set(6, false)
-	assert.Equal(t, uint8(129), bv.n)
+	assert.Equal(t, Len8(0), bv)
+	bv = bv.Set(0, true)
+	assert.Equal(t, Len8(1), bv)
+	bv = bv.Set(7, true)
+	assert.Equal(t, Len8(129), bv)
+	bv = bv.Set(8, true)
+	assert.Equal(t, Len8(129), bv)
+	bv = bv.Set(6, true)
+	assert.Equal(t, Len8(193), bv)
+	bv = bv.Set(6, false)
+	assert.Equal(t, Len8(129), bv)
 
 	// Count
 	assert.Equal(t, uint8(2), bv.Count())
@@ -31,31 +31,21 @@ func TestBV8(t *testing.T) {
 	assert.True(t, bv.Get(7))
 	assert.False(t, bv.Get(6))
 
-	// Reset
-	bv.Reset()
-	assert.Equal(t, uint8(0), bv.n)
-
 	// Toggle
-	bv.Toggle(7)
-	assert.Equal(t, uint8(128), bv.n)
+	bv = bv.Toggle(7)
+	assert.Equal(t, Len8(1), bv)
 
 	// Clear
-	bv.Reset()
+	bv = 0
 	var i uint8
 	for ; i < 8; i++ {
-		bv.Set(i, true)
+		bv = bv.Set(i, true)
 	}
-	bv.Clear(6, 2)
-	assert.Equal(t, uint8(math.MaxUint8), bv.n)
-	bv.Clear(2, 6)
-	assert.Equal(t, uint8(195), bv.n)
-
-	// Copy
-	assert.Equal(t, uint8(4), bv.Copy().Count())
+	bv = bv.Clear(6, 2)
+	assert.Equal(t, Len8(math.MaxUint8), bv)
+	bv = bv.Clear(2, 6)
+	assert.Equal(t, Len8(195), bv)
 
 	// String
 	assert.Equal(t, "11000011", bv.String())
-
-	// New
-	assert.Equal(t, uint8(0), New8().Count())
 }