diff --git a/roaring/roaring.go b/roaring/roaring.go
index ed6667c79..3f048a544 100644
--- a/roaring/roaring.go
+++ b/roaring/roaring.go
@@ -54,8 +54,8 @@ const (
 	//containerArray indicates a container of bit position values
 	containerArray = byte(1)
 
-	//ContainerBitmap indicates a container of bits packed in a uint64 array block
-	ContainerBitmap = byte(2)
+	//containerBitmap indicates a container of bits packed in a uint64 array block
+	containerBitmap = byte(2)
 
 	//ContainerRun  indicates a container of run encoded bits
 	ContainerRun = byte(3)
@@ -668,7 +668,7 @@ func (b *Bitmap) UnmarshalBinary(data []byte) error {
 			c.bitmap = nil
 			c.array = (*[0xFFFFFFF]uint16)(unsafe.Pointer(&data[offset]))[:c.n]
 			opsOffset = int(offset) + len(c.array)*2 // sizeof(uint32)
-		case ContainerBitmap:
+		case containerBitmap:
 			c.array = nil
 			c.runs = nil
 			c.bitmap = (*[0xFFFFFFF]uint64)(unsafe.Pointer(&data[offset]))[:bitmapN]
@@ -1048,7 +1048,7 @@ func (c *Container) isArray() bool {
 
 // isBitmap returns true if the container is a bitmap container.
 func (c *Container) isBitmap() bool {
-	return c.containerType == ContainerBitmap
+	return c.containerType == containerBitmap
 }
 
 // isRun returns true if the container is a run-length-encoded container.
@@ -1070,7 +1070,7 @@ func (c *Container) unmap() {
 		tmp := make([]uint16, len(c.array))
 		copy(tmp, c.array)
 		c.array = tmp
-	case ContainerBitmap:
+	case containerBitmap:
 		tmp := make([]uint64, len(c.bitmap))
 		copy(tmp, c.bitmap)
 		c.bitmap = tmp
@@ -1329,12 +1329,12 @@ func (c *Container) optimize() {
 	} else if c.n < ArrayMaxSize {
 		newType = containerArray
 	} else {
-		newType = ContainerBitmap
+		newType = containerBitmap
 	}
 
 	// Then convert accordingly.
 	if c.isArray() {
-		if newType == ContainerBitmap {
+		if newType == containerBitmap {
 			c.arrayToBitmap()
 		} else if newType == ContainerRun {
 			c.arrayToRun()
@@ -1346,7 +1346,7 @@ func (c *Container) optimize() {
 			c.bitmapToRun()
 		}
 	} else if c.isRun() {
-		if newType == ContainerBitmap {
+		if newType == containerBitmap {
 			c.runToBitmap()
 		} else if newType == containerArray {
 			c.runToArray()
@@ -1510,7 +1510,7 @@ func (c *Container) bitmapToArray() {
 // arrayToBitmap converts from array format to bitmap format.
 func (c *Container) arrayToBitmap() {
 	c.bitmap = make([]uint64, bitmapN)
-	c.containerType = ContainerBitmap
+	c.containerType = containerBitmap
 
 	// return early if empty
 	if c.n == 0 {
@@ -1529,7 +1529,7 @@ func (c *Container) arrayToBitmap() {
 // runToBitmap converts from RLE format to bitmap format.
 func (c *Container) runToBitmap() {
 	c.bitmap = make([]uint64, bitmapN)
-	c.containerType = ContainerBitmap
+	c.containerType = containerBitmap
 
 	// return early if empty
 	if c.n == 0 {
@@ -1661,7 +1661,7 @@ func (c *Container) Clone() *Container {
 	case containerArray:
 		other.array = make([]uint16, len(c.array))
 		copy(other.array, c.array)
-	case ContainerBitmap:
+	case containerBitmap:
 		other.bitmap = make([]uint64, len(c.bitmap))
 		copy(other.bitmap, c.bitmap)
 	case ContainerRun:
@@ -1816,7 +1816,7 @@ func flipArray(b *Container) *Container {
 }
 
 func flipBitmap(b *Container) *Container {
-	other := &Container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
+	other := &Container{bitmap: make([]uint64, bitmapN), containerType: containerBitmap}
 
 	for i, bitmap := range b.bitmap {
 		other.bitmap[i] = ^bitmap
@@ -2078,7 +2078,7 @@ func intersectBitmapRun(a, b *Container) *Container {
 		// the bitmap which are between runs.
 		output = &Container{
 			bitmap:        make([]uint64, bitmapN),
-			containerType: ContainerBitmap,
+			containerType: containerBitmap,
 		}
 		for j := 0; j < len(b.runs); j++ {
 			vb := b.runs[j]
@@ -2134,7 +2134,7 @@ func intersectArrayBitmap(a, b *Container) *Container {
 }
 
 func intersectBitmapBitmap(a, b *Container) *Container {
-	output := &Container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
+	output := &Container{bitmap: make([]uint64, bitmapN), containerType: containerBitmap}
 
 	for i := range a.bitmap {
 		v := a.bitmap[i] & b.bitmap[i]
@@ -2396,7 +2396,7 @@ func (c *Container) equals(c2 *Container) bool {
 				return false
 			}
 		}
-	} else if c.containerType == ContainerBitmap {
+	} else if c.containerType == containerBitmap {
 		if len(c.bitmap) != len(c2.bitmap) {
 			return false
 		}
@@ -2434,7 +2434,7 @@ func unionArrayBitmap(a, b *Container) *Container {
 func unionBitmapBitmap(a, b *Container) *Container {
 	output := &Container{
 		bitmap:        make([]uint64, bitmapN),
-		containerType: ContainerBitmap,
+		containerType: containerBitmap,
 	}
 
 	for i := 0; i < bitmapN; i++ {
@@ -2778,7 +2778,7 @@ func differenceBitmapArray(a, b *Container) *Container {
 }
 
 func differenceBitmapBitmap(a, b *Container) *Container {
-	output := &Container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
+	output := &Container{bitmap: make([]uint64, bitmapN), containerType: containerBitmap}
 
 	for i := range a.bitmap {
 		v := a.bitmap[i] & (^b.bitmap[i])
@@ -2861,7 +2861,7 @@ func xorArrayBitmap(a, b *Container) *Container {
 
 	// It's possible that output was converted from bitmap to array in output.remove()
 	// so we only do this conversion if output is still a bitmap container.
-	if output.containerType == ContainerBitmap && output.count() < ArrayMaxSize {
+	if output.containerType == containerBitmap && output.count() < ArrayMaxSize {
 		output.bitmapToArray()
 	}
 
@@ -2871,7 +2871,7 @@ func xorArrayBitmap(a, b *Container) *Container {
 func xorBitmapBitmap(a, b *Container) *Container {
 	output := &Container{
 		bitmap:        make([]uint64, bitmapN),
-		containerType: ContainerBitmap,
+		containerType: containerBitmap,
 	}
 	for i := 0; i < bitmapN; i++ {
 		v := a.bitmap[i] ^ b.bitmap[i]
diff --git a/roaring/roaring_helpers_test.go b/roaring/roaring_helpers_test.go
index 3ed42d8db..7d0265efa 100644
--- a/roaring/roaring_helpers_test.go
+++ b/roaring/roaring_helpers_test.go
@@ -238,7 +238,7 @@ func doContainer(containerType byte, data interface{}) *Container {
 	switch containerType {
 	case containerArray:
 		c.array = data.([]uint16)
-	case ContainerBitmap:
+	case containerBitmap:
 		c.bitmap = data.([]uint64)
 	case ContainerRun:
 		c.runs = data.([]interval16)
@@ -267,17 +267,17 @@ func setupContainerTests() map[byte]map[string]*Container {
 	}
 
 	// bitmap containers
-	cts[ContainerBitmap] = map[string]*Container{
-		"empty":         doContainer(ContainerBitmap, bitmapEmpty()),
-		"full":          doContainer(ContainerBitmap, bitmapFull()),
-		"firstBitSet":   doContainer(ContainerBitmap, bitmapFirstBitSet()),
-		"lastBitSet":    doContainer(ContainerBitmap, bitmapLastBitSet()),
-		"firstBitUnset": doContainer(ContainerBitmap, bitmapFirstBitUnset()),
-		"lastBitUnset":  doContainer(ContainerBitmap, bitmapLastBitUnset()),
-		"innerBitsSet":  doContainer(ContainerBitmap, bitmapInnerBitsSet()),
-		"outerBitsSet":  doContainer(ContainerBitmap, bitmapOuterBitsSet()),
-		"oddBitsSet":    doContainer(ContainerBitmap, bitmapOddBitsSet()),
-		"evenBitsSet":   doContainer(ContainerBitmap, bitmapEvenBitsSet()),
+	cts[containerBitmap] = map[string]*Container{
+		"empty":         doContainer(containerBitmap, bitmapEmpty()),
+		"full":          doContainer(containerBitmap, bitmapFull()),
+		"firstBitSet":   doContainer(containerBitmap, bitmapFirstBitSet()),
+		"lastBitSet":    doContainer(containerBitmap, bitmapLastBitSet()),
+		"firstBitUnset": doContainer(containerBitmap, bitmapFirstBitUnset()),
+		"lastBitUnset":  doContainer(containerBitmap, bitmapLastBitUnset()),
+		"innerBitsSet":  doContainer(containerBitmap, bitmapInnerBitsSet()),
+		"outerBitsSet":  doContainer(containerBitmap, bitmapOuterBitsSet()),
+		"oddBitsSet":    doContainer(containerBitmap, bitmapOddBitsSet()),
+		"evenBitsSet":   doContainer(containerBitmap, bitmapEvenBitsSet()),
 	}
 
 	// run containers
diff --git a/roaring/roaring_internal_test.go b/roaring/roaring_internal_test.go
index c478c6209..dc2693b85 100644
--- a/roaring/roaring_internal_test.go
+++ b/roaring/roaring_internal_test.go
@@ -203,7 +203,7 @@ func TestRunContains(t *testing.T) {
 }
 
 func TestBitmapCountRange(t *testing.T) {
-	c := Container{containerType: ContainerBitmap}
+	c := Container{containerType: containerBitmap}
 	tests := []struct {
 		start  int
 		end    int
@@ -229,11 +229,11 @@ func TestBitmapCountRange(t *testing.T) {
 
 func TestIntersectionCountArrayBitmap3(t *testing.T) {
 	a, b := &Container{}, &Container{}
-	a.containerType = ContainerBitmap
+	a.containerType = containerBitmap
 	a.bitmap = getFullBitmap()
 	a.n = maxContainerVal + 1
 
-	b.containerType = ContainerBitmap
+	b.containerType = containerBitmap
 	b.bitmap = getFullBitmap()
 	b.n = maxContainerVal + 1
 	res := intersectBitmapBitmap(a, b)
@@ -292,7 +292,7 @@ func TestIntersectionCountArrayBitmap2(t *testing.T) {
 		a.array = test.array
 		a.containerType = containerArray
 		b.bitmap = test.bitmap
-		b.containerType = ContainerBitmap
+		b.containerType = containerBitmap
 		ret := intersectionCountArrayBitmap(a, b)
 		if ret != test.exp {
 			t.Fatalf("test #%v intersectCountArrayBitmap fail received: %v exp: %v", i, ret, test.exp)
@@ -359,7 +359,7 @@ func TestIntersectionCountArrayRun(t *testing.T) {
 }
 
 func TestIntersectionCountBitmapRun(t *testing.T) {
-	a := &Container{containerType: ContainerBitmap, bitmap: []uint64{0x8000000000000000}}
+	a := &Container{containerType: containerBitmap, bitmap: []uint64{0x8000000000000000}}
 	b := &Container{containerType: ContainerRun, runs: []interval16{{start: 63, last: 64}}}
 
 	ret := intersectionCountBitmapRun(a, b)
@@ -367,7 +367,7 @@ func TestIntersectionCountBitmapRun(t *testing.T) {
 		t.Fatalf("count of %v with %v should be 1, but got %v", a.bitmap, b.runs, ret)
 	}
 
-	a = &Container{containerType: ContainerBitmap, bitmap: []uint64{0xF0000001, 0xFF00000000000000, 0xFF000000000000F0, 0x0F0000}}
+	a = &Container{containerType: containerBitmap, bitmap: []uint64{0xF0000001, 0xFF00000000000000, 0xFF000000000000F0, 0x0F0000}}
 	b = &Container{containerType: ContainerRun, runs: []interval16{{start: 29, last: 31}, {start: 125, last: 134}, {start: 191, last: 197}, {start: 200, last: 300}}}
 
 	ret = intersectionCountBitmapRun(a, b)
@@ -581,7 +581,7 @@ func TestIntersectBitmapRunBitmap(t *testing.T) {
 		for i, v := range test.exp {
 			exp[i] = v
 		}
-		a.containerType = ContainerBitmap
+		a.containerType = containerBitmap
 		b.containerType = ContainerRun
 		ret := intersectBitmapRun(a, b)
 		if ret.isArray() {
@@ -642,7 +642,7 @@ func TestIntersectBitmapRunArray(t *testing.T) {
 			a.bitmap[i] = v
 		}
 		b.runs = test.runs
-		a.containerType = ContainerBitmap
+		a.containerType = containerBitmap
 		b.containerType = ContainerRun
 		ret := intersectBitmapRun(a, b)
 		if !reflect.DeepEqual(ret.array, test.exp) {
@@ -667,7 +667,7 @@ func TestUnionMixed(t *testing.T) {
 	b := &Container{bitmap: make([]uint64, bitmapN)}
 	b.bitmap[0] = uint64(0x3)
 	b.n = 2
-	b.containerType = ContainerBitmap
+	b.containerType = containerBitmap
 
 	// run container
 	r := &Container{}
@@ -732,7 +732,7 @@ func TestIntersectMixed(t *testing.T) {
 	}
 	c.bitmap = []uint64{0x60}
 	c.n = 2
-	c.containerType = ContainerBitmap
+	c.containerType = containerBitmap
 
 	res = intersect(c, a)
 	if !reflect.DeepEqual(res.array, []uint16{5, 6}) {
@@ -790,7 +790,7 @@ func TestDifferenceMixed(t *testing.T) {
 
 	c.bitmap = []uint64{0x64}
 	c.n = c.countRange(0, 100)
-	c.containerType = ContainerBitmap
+	c.containerType = containerBitmap
 	res = difference(c, a)
 	if !reflect.DeepEqual(res.bitmap, []uint64{0x4}) {
 		t.Fatalf("test #4 expected %v, but got %v", []uint16{4}, res.bitmap)
@@ -937,7 +937,7 @@ func TestUnionArrayRun(t *testing.T) {
 }
 
 func TestBitmapSetRange(t *testing.T) {
-	c := &Container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	c := &Container{containerType: containerBitmap, bitmap: make([]uint64, bitmapN)}
 	tests := []struct {
 		bitmap []uint64
 		start  uint64
@@ -1008,7 +1008,7 @@ func TestArrayToBitmap(t *testing.T) {
 }
 
 func TestBitmapToArray(t *testing.T) {
-	a := &Container{containerType: ContainerBitmap}
+	a := &Container{containerType: containerBitmap}
 	tests := []struct {
 		bitmap []uint64
 		exp    []uint16
@@ -1093,7 +1093,7 @@ func getFullBitmap() []uint64 {
 }
 
 func TestBitmapToRun(t *testing.T) {
-	a := &Container{containerType: ContainerBitmap}
+	a := &Container{containerType: containerBitmap}
 	tests := []struct {
 		bitmap []uint64
 		exp    []interval16
@@ -1239,7 +1239,7 @@ func TestRunToArray(t *testing.T) {
 }
 
 func TestBitmapZeroRange(t *testing.T) {
-	c := &Container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	c := &Container{containerType: containerBitmap, bitmap: make([]uint64, bitmapN)}
 	tests := []struct {
 		bitmap []uint64
 		start  uint64
@@ -1283,7 +1283,7 @@ func TestBitmapZeroRange(t *testing.T) {
 }
 
 func TestUnionBitmapRun(t *testing.T) {
-	a := &Container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	a := &Container{containerType: containerBitmap, bitmap: make([]uint64, bitmapN)}
 	b := &Container{containerType: ContainerRun}
 	tests := []struct {
 		bitmap []uint64
@@ -1322,7 +1322,7 @@ func TestUnionBitmapRun(t *testing.T) {
 }
 
 func TestBitmapCountRuns(t *testing.T) {
-	c := &Container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	c := &Container{containerType: containerBitmap, bitmap: make([]uint64, bitmapN)}
 	tests := []struct {
 		bitmap []uint64
 		exp    int
@@ -1521,7 +1521,7 @@ func MakeLastBitSet() []uint64 {
 
 func TestDifferenceRunBitmap(t *testing.T) {
 	a := &Container{containerType: ContainerRun}
-	b := &Container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	b := &Container{containerType: containerBitmap, bitmap: make([]uint64, bitmapN)}
 	tests := []struct {
 		runs   []interval16
 		bitmap []uint64
@@ -1583,7 +1583,7 @@ func TestDifferenceRunBitmap(t *testing.T) {
 }
 
 func TestDifferenceBitmapRun(t *testing.T) {
-	a := &Container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	a := &Container{containerType: containerBitmap, bitmap: make([]uint64, bitmapN)}
 	b := &Container{containerType: ContainerRun}
 	tests := []struct {
 		bitmap []uint64
@@ -1666,7 +1666,7 @@ func TestDifferenceBitmapRun(t *testing.T) {
 }
 
 func TestDifferenceBitmapArray(t *testing.T) {
-	b := &Container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	b := &Container{containerType: containerBitmap, bitmap: make([]uint64, bitmapN)}
 	a := &Container{containerType: containerArray}
 	tests := []struct {
 		bitmap []uint64
@@ -1716,8 +1716,8 @@ func TestDifferenceBitmapArray(t *testing.T) {
 }
 
 func TestDifferenceBitmapBitmap(t *testing.T) {
-	a := &Container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
-	b := &Container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
+	a := &Container{bitmap: make([]uint64, bitmapN), containerType: containerBitmap}
+	b := &Container{bitmap: make([]uint64, bitmapN), containerType: containerBitmap}
 	tests := []struct {
 		abitmap []uint64
 		bbitmap []uint64
@@ -1800,7 +1800,7 @@ func TestWriteReadArray(t *testing.T) {
 
 func TestWriteReadBitmap(t *testing.T) {
 	// create bitmap containing > 4096 bits
-	cb := &Container{bitmap: make([]uint64, bitmapN), n: 129 * 32, containerType: ContainerBitmap}
+	cb := &Container{bitmap: make([]uint64, bitmapN), n: 129 * 32, containerType: containerBitmap}
 	for i := 0; i < 129; i++ {
 		cb.bitmap[i] = 0x5555555555555555
 	}
@@ -1823,7 +1823,7 @@ func TestWriteReadBitmap(t *testing.T) {
 
 func TestWriteReadFullBitmap(t *testing.T) {
 	// create bitmap containing > 4096 bits
-	cb := &Container{bitmap: make([]uint64, bitmapN), n: 65536, containerType: ContainerBitmap}
+	cb := &Container{bitmap: make([]uint64, bitmapN), n: 65536, containerType: containerBitmap}
 	for i := 0; i < bitmapN; i++ {
 		cb.bitmap[i] = 0xffffffffffffffff
 	}
@@ -2025,7 +2025,7 @@ func TestXorRunRun(t *testing.T) {
 }
 
 func TestBitmapXorRange(t *testing.T) {
-	c := &Container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
+	c := &Container{bitmap: make([]uint64, bitmapN), containerType: containerBitmap}
 	tests := []struct {
 		bitmap []uint64
 		start  uint64
@@ -2093,7 +2093,7 @@ func TestBitmapXorRange(t *testing.T) {
 }
 
 func TestXorBitmapRun(t *testing.T) {
-	a := &Container{containerType: ContainerBitmap}
+	a := &Container{containerType: containerBitmap}
 	b := &Container{containerType: ContainerRun}
 	tests := []struct {
 		bitmap []uint64
@@ -2547,7 +2547,7 @@ func TestSearch64(t *testing.T) {
 
 func TestIntersectArrayBitmap(t *testing.T) {
 	a, b := &Container{containerType: containerArray}, &Container{
-		containerType: ContainerBitmap,
+		containerType: containerBitmap,
 		bitmap:        make([]uint64, bitmapN),
 	}
 	tests := []struct {
@@ -2598,7 +2598,7 @@ func TestIntersectArrayBitmap(t *testing.T) {
 		for i, bmval := range test.bitmap {
 			b.bitmap[i] = bmval
 		}
-		b.containerType = ContainerBitmap
+		b.containerType = containerBitmap
 		ret := intersectArrayBitmap(a, b).array
 		if len(ret) == 0 && len(test.exp) == 0 {
 			continue
@@ -2722,12 +2722,12 @@ func TestContainerCombinations(t *testing.T) {
 
 	cts := setupContainerTests()
 
-	containerTypes := []byte{containerArray, ContainerBitmap, ContainerRun}
+	containerTypes := []byte{containerArray, containerBitmap, ContainerRun}
 
 	// map used for a more descriptive print
 	cm := map[byte]string{
 		containerArray:  "array",
-		ContainerBitmap: "bitmap",
+		containerBitmap: "bitmap",
 		ContainerRun:    "run",
 	}
 
@@ -3212,7 +3212,7 @@ func TestContainerCombinations(t *testing.T) {
 						if !(len(clone.array) == 0 && len(cts[ct][exp].array) == 0) && !reflect.DeepEqual(clone.array, cts[ct][exp].array) {
 							t.Fatalf("test %s expected array %X, but got %X", desc, cts[ct][exp].array, clone.array)
 						}
-					} else if ct == ContainerBitmap {
+					} else if ct == containerBitmap {
 						if clone.isArray() {
 							clone.arrayToBitmap()
 						} else if clone.isRun() {