Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
- API
  
  Reference documentation for the pkg.go.dev API
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

btype

package module

Go to main page

Versions in this module

v0

v0.3.0

Jun 16, 2026

Changes in this version

type Array

+ func (b *Array[T]) PopBackIf(cond func(item T) bool) (T, bool)

+ func (b *Array[T]) PopFrontIf(cond func(item T) bool) (T, bool)

type Deque

+ func (b *Deque[T]) PopBackIf(cond func(item T) bool) (T, bool)

+ func (b *Deque[T]) PopFrontIf(cond func(item T) bool) (T, bool)

type Map

+ func (b *Map[K, V]) PopBackIf(cond func(key K, value V) bool) (K, V, bool)

+ func (b *Map[K, V]) PopFrontIf(cond func(key K, value V) bool) (K, V, bool)

type Prique

+ func (b *Prique[T]) PopIf(cond func(item T) bool) (T, bool)

type Queue

+ func (b *Queue[T]) PopIf(cond func(item T) bool) (T, bool)

type Set

+ func (b *Set[K]) PopBackIf(cond func(key K) bool) (K, bool)

+ func (b *Set[K]) PopFrontIf(cond func(key K) bool) (K, bool)

type Table

+ func (b *Table[T]) PopBackIf(cond func(item T) bool) (T, bool)

+ func (b *Table[T]) PopFrontIf(cond func(item T) bool) (T, bool)

v0.2.3

May 22, 2026

v0.2.2

May 19, 2026

v0.2.1

May 18, 2026

v0.2.0

May 10, 2026

v0.1.0

May 10, 2026

Changes in this version

+ func CompareFor[T any]() func(T, T) int

+ type Array struct

+ func NewArrayOptions[T any](opts ArrayOptions[T]) *Array[T]

+ func NewList[T any]() *Array[T]

+ func (b *Array[T]) All() iter.Seq[T]

+ func (b *Array[T]) Append(items ...T)

+ func (b *Array[T]) Ascend(index int) iter.Seq[T]

+ func (b *Array[T]) Back() (T, bool)

+ func (b *Array[T]) Backward() iter.Seq[T]

+ func (b *Array[T]) Clear()

+ func (b *Array[T]) Copy() *Array[T]

+ func (b *Array[T]) Delete(index int) (T, bool)

+ func (b *Array[T]) DeleteRange(index, count int) *slice[T]

+ func (b *Array[T]) DeleteRangeOptions(index, count int, opts DeleteRangeOptions) *slice[T]

+ func (b *Array[T]) Descend(index int) iter.Seq[T]

+ func (b *Array[T]) Drain() iter.Seq[T]

+ func (b *Array[T]) DrainBackward() iter.Seq[T]

+ func (b *Array[T]) Front() (T, bool)

+ func (b *Array[T]) Get(index int) (T, bool)

+ func (b *Array[T]) Insert(index int, item T) bool

+ func (b *Array[T]) Len() int

+ func (b *Array[T]) PopBack() (T, bool)

+ func (b *Array[T]) PopFront() (T, bool)

+ func (b *Array[T]) PushBack(item T) bool

+ func (b *Array[T]) PushFront(item T) bool

+ func (b *Array[T]) Release()

+ func (b *Array[T]) Replace(index int, item T) (T, bool)

+ type ArrayOptions struct

+ Copy func(T) T

+ Release func(T)

+ type DeleteRangeOptions struct

+ MaxInclusive bool

+ MinExclusive bool

+ NoReturn bool

+ type Deque struct

+ func NewDequeOptions[T any](opts DequeOptions[T]) *Deque[T]

+ func NewDeque[T any]() *Deque[T]

+ func (b *Deque[T]) All() iter.Seq[T]

+ func (b *Deque[T]) AllMut() iter.Seq[T]

+ func (b *Deque[T]) At(pos int) (T, bool)

+ func (b *Deque[T]) AtMut(pos int) (T, bool)

+ func (b *Deque[T]) Back() (T, bool)

+ func (b *Deque[T]) BackMut() (T, bool)

+ func (b *Deque[T]) Backward() iter.Seq[T]

+ func (b *Deque[T]) BackwardMut() iter.Seq[T]

+ func (b *Deque[T]) Clear()

+ func (b *Deque[T]) Copy() *Deque[T]

+ func (b *Deque[T]) Drain() iter.Seq[T]

+ func (b *Deque[T]) DrainBackward() iter.Seq[T]

+ func (b *Deque[T]) Front() (T, bool)

+ func (b *Deque[T]) FrontMut() (T, bool)

+ func (b *Deque[T]) Len() int

+ func (b *Deque[T]) PopBack() (T, bool)

+ func (b *Deque[T]) PopFront() (T, bool)

+ func (b *Deque[T]) PushBack(item T)

+ func (b *Deque[T]) PushFront(item T)

+ func (b *Deque[T]) Release()

+ type DequeOptions struct

+ Copy func(T) T

+ Release func(T)

+ type Map struct

+ func NewMapOptions[K cmp.Ordered, V any](opts MapOptions[K, V]) *Map[K, V]

+ func NewMap[K cmp.Ordered, V any]() *Map[K, V]

+ func (b *Map[K, V]) All() iter.Seq2[K, V]

+ func (b *Map[K, V]) AllMut() iter.Seq2[K, V]

+ func (b *Map[K, V]) Ascend(key K) iter.Seq2[K, V]

+ func (b *Map[K, V]) AscendAt(index int) iter.Seq2[K, V]

+ func (b *Map[K, V]) AscendAtMut(index int) iter.Seq2[K, V]

+ func (b *Map[K, V]) AscendMut(key K) iter.Seq2[K, V]

+ func (b *Map[K, V]) Back() (K, V, bool)

+ func (b *Map[K, V]) BackMut() (K, V, bool)

+ func (b *Map[K, V]) Backward() iter.Seq2[K, V]

+ func (b *Map[K, V]) BackwardMut() iter.Seq2[K, V]

+ func (b *Map[K, V]) Clear()

+ func (b *Map[K, V]) Contains(key K) bool

+ func (b *Map[K, V]) Copy() *Map[K, V]

+ func (b *Map[K, V]) Delete(key K) (V, bool)

+ func (b *Map[K, V]) DeleteAt(index int) (K, V, bool)

+ func (b *Map[K, V]) DeleteRange(min, max K) *slice2[K, V]

+ func (b *Map[K, V]) DeleteRangeAt(index, count int) *slice2[K, V]

+ func (b *Map[K, V]) DeleteRangeAtOptions(index, count int, opts DeleteRangeOptions) *slice2[K, V]

+ func (b *Map[K, V]) DeleteRangeOptions(min, max K, opts DeleteRangeOptions) *slice2[K, V]

+ func (b *Map[K, V]) Descend(key K) iter.Seq2[K, V]

+ func (b *Map[K, V]) DescendAt(index int) iter.Seq2[K, V]

+ func (b *Map[K, V]) DescendAtMut(index int) iter.Seq2[K, V]

+ func (b *Map[K, V]) DescendMut(key K) iter.Seq2[K, V]

+ func (b *Map[K, V]) Drain() iter.Seq2[K, V]

+ func (b *Map[K, V]) DrainBackward() iter.Seq2[K, V]

+ func (b *Map[K, V]) Front() (K, V, bool)

+ func (b *Map[K, V]) FrontMut() (K, V, bool)

+ func (b *Map[K, V]) Get(key K) (V, bool)

+ func (b *Map[K, V]) GetAt(index int) (K, V, bool)

+ func (b *Map[K, V]) GetAtMut(index int) (K, V, bool)

+ func (b *Map[K, V]) GetMut(key K) (V, bool)

+ func (b *Map[K, V]) IndexOf(key K) (int, bool)

+ func (b *Map[K, V]) Insert(key K, value V) (V, bool)

+ func (b *Map[K, V]) InsertAt(index int, key K, value V) bool

+ func (b *Map[K, V]) Keys() iter.Seq[K]

+ func (b *Map[K, V]) Len() int

+ func (b *Map[K, V]) PopBack() (K, V, bool)

+ func (b *Map[K, V]) PopFront() (K, V, bool)

+ func (b *Map[K, V]) PushBack(key K, value V) bool

+ func (b *Map[K, V]) PushFront(key K, value V) bool

+ func (b *Map[K, V]) Release()

+ func (b *Map[K, V]) Replace(key K, value V) (V, bool)

+ func (b *Map[K, V]) ReplaceAt(index int, key K, value V) (K, V, bool)

+ func (b *Map[K, V]) Seek(key K) (K, V, bool)

+ func (b *Map[K, V]) SeekMut(key K) (K, V, bool)

+ func (b *Map[K, V]) SeekNext(key K) (K, V, bool)

+ func (b *Map[K, V]) SeekNextMut(key K) (K, V, bool)

+ func (b *Map[K, V]) SeekPrev(key K) (K, V, bool)

+ func (b *Map[K, V]) SeekPrevMut(key K) (K, V, bool)

+ func (b *Map[K, V]) Set(key K, value V) (V, bool)

+ func (b *Map[K, V]) Values() iter.Seq[V]

+ func (b *Map[K, V]) ValuesMut() iter.Seq[V]

+ type MapOptions struct

+ Copy func(V) V

+ NoPrefix bool

+ Release func(V)

+ type Prique struct

+ func NewPriqueOptions[T any](opts PriqueOptions[T]) *Prique[T]

+ func NewPrique[T any]() *Prique[T]

+ func (b *Prique[T]) All() iter.Seq[T]

+ func (b *Prique[T]) AllMut() iter.Seq[T]

+ func (b *Prique[T]) At(pos int) (T, bool)

+ func (b *Prique[T]) AtMut(pos int) (T, bool)

+ func (b *Prique[T]) Clear()

+ func (b *Prique[T]) Copy() *Prique[T]

+ func (b *Prique[T]) Delete(key T) (T, bool)

+ func (b *Prique[T]) Drain() iter.Seq[T]

+ func (b *Prique[T]) Front() (T, bool)

+ func (b *Prique[T]) FrontMut() (T, bool)

+ func (b *Prique[T]) Len() int

+ func (b *Prique[T]) Pop() (T, bool)

+ func (b *Prique[T]) Push(item T) bool

+ func (b *Prique[T]) Release()

+ type PriqueOptions struct

+ Compare func(T, T) int

+ Copy func(T) T

+ Less func(T, T) bool

+ Release func(T)

+ type Queue struct

+ func NewQueueOptions[T any](opts QueueOptions[T]) *Queue[T]

+ func NewQueue[T any]() *Queue[T]

+ func (b *Queue[K]) Drain() iter.Seq[K]

+ func (b *Queue[T]) All() iter.Seq[T]

+ func (b *Queue[T]) AllMut() iter.Seq[T]

+ func (b *Queue[T]) At(pos int) (T, bool)

+ func (b *Queue[T]) AtMut(pos int) (T, bool)

+ func (b *Queue[T]) Clear()

+ func (b *Queue[T]) Copy() *Queue[T]

+ func (b *Queue[T]) Front() (T, bool)

+ func (b *Queue[T]) FrontMut() (T, bool)

+ func (b *Queue[T]) Len() int

+ func (b *Queue[T]) Pop() (T, bool)

+ func (b *Queue[T]) Push(item T)

+ func (b *Queue[T]) Release()

+ type QueueOptions struct

+ Copy func(T) T

+ Release func(T)

+ type Set struct

+ func NewSet[K cmp.Ordered]() *Set[K]

+ func (b *Set[K]) All() iter.Seq[K]

+ func (b *Set[K]) Ascend(key K) iter.Seq[K]

+ func (b *Set[K]) AscendAt(index int) iter.Seq[K]

+ func (b *Set[K]) Back() (K, bool)

+ func (b *Set[K]) Backward() iter.Seq[K]

+ func (b *Set[K]) Clear()

+ func (b *Set[K]) Contains(key K) bool

+ func (b *Set[K]) Copy() *Set[K]

+ func (b *Set[K]) Delete(key K) bool

+ func (b *Set[K]) DeleteAt(index int) (K, bool)

+ func (b *Set[K]) DeleteRange(min, max K) *slice[K]

+ func (b *Set[K]) DeleteRangeAt(index, count int) *slice[K]

+ func (b *Set[K]) DeleteRangeAtOptions(index, count int, opts DeleteRangeOptions) *slice[K]

+ func (b *Set[K]) DeleteRangeOptions(min, max K, opts DeleteRangeOptions) *slice[K]

+ func (b *Set[K]) Descend(key K) iter.Seq[K]

+ func (b *Set[K]) DescendAt(index int) iter.Seq[K]

+ func (b *Set[K]) Drain() iter.Seq[K]

+ func (b *Set[K]) DrainBackward() iter.Seq[K]

+ func (b *Set[K]) Front() (K, bool)

+ func (b *Set[K]) GetAt(index int) (K, bool)

+ func (b *Set[K]) IndexOf(key K) (int, bool)

+ func (b *Set[K]) Insert(key K) bool

+ func (b *Set[K]) InsertAt(index int, key K) bool

+ func (b *Set[K]) Len() int

+ func (b *Set[K]) PopBack() (K, bool)

+ func (b *Set[K]) PopFront() (K, bool)

+ func (b *Set[K]) PushBack(key K) bool

+ func (b *Set[K]) PushFront(key K) bool

+ func (b *Set[K]) Release()

+ func (b *Set[K]) ReplaceAt(index int, key K) (K, bool)

+ func (b *Set[K]) Seek(key K) (K, bool)

+ func (b *Set[K]) SeekNext(key K) (K, bool)

+ func (b *Set[K]) SeekPrev(key K) (K, bool)

+ type Slice interface

+ All func() iter.Seq[V]

+ Backward func() iter.Seq[V]

+ Len func() int

+ type Slice2 interface

+ All func() iter.Seq2[K, V]

+ Backward func() iter.Seq2[K, V]

+ Keys func() iter.Seq[K]

+ Len func() int

+ Values func() iter.Seq[K]

+ type Stack struct

+ func NewStackOptions[T any](opts StackOptions[T]) *Stack[T]

+ func NewStack[T any]() *Stack[T]

+ func (b *Stack[K]) Drain() iter.Seq[K]

+ func (b *Stack[T]) All() iter.Seq[T]

+ func (b *Stack[T]) AllMut() iter.Seq[T]

+ func (b *Stack[T]) At(pos int) (T, bool)

+ func (b *Stack[T]) AtMut(pos int) (T, bool)

+ func (b *Stack[T]) Clear()

+ func (b *Stack[T]) Copy() *Stack[T]

+ func (b *Stack[T]) Len() int

+ func (b *Stack[T]) Pop() (T, bool)

+ func (b *Stack[T]) Push(item T)

+ func (b *Stack[T]) Release()

+ func (b *Stack[T]) Top() (T, bool)

+ func (b *Stack[T]) TopMut() (T, bool)

+ type StackOptions struct

+ Copy func(T) T

+ Release func(T)

+ type Table struct

+ func NewTableOptions[T any](opts TableOptions[T]) *Table[T]

+ func NewTable[T any]() *Table[T]

+ func (b *Table[T]) All() iter.Seq[T]

+ func (b *Table[T]) AllMut() iter.Seq[T]

+ func (b *Table[T]) Ascend(pivot T) iter.Seq[T]

+ func (b *Table[T]) AscendAt(index int) iter.Seq[T]

+ func (b *Table[T]) AscendAtMut(index int) iter.Seq[T]

+ func (b *Table[T]) AscendMut(pivot T) iter.Seq[T]

+ func (b *Table[T]) Back() (T, bool)

+ func (b *Table[T]) BackMut() (T, bool)

+ func (b *Table[T]) Backward() iter.Seq[T]

+ func (b *Table[T]) BackwardMut() iter.Seq[T]

+ func (b *Table[T]) Clear()

+ func (b *Table[T]) Contains(key T) bool

+ func (b *Table[T]) Copy() *Table[T]

+ func (b *Table[T]) Delete(key T) (T, bool)

+ func (b *Table[T]) DeleteAt(index int) (T, bool)

+ func (b *Table[T]) DeleteRange(min, max T) *slice[T]

+ func (b *Table[T]) DeleteRangeAt(index, count int) *slice[T]

+ func (b *Table[T]) DeleteRangeAtOptions(index, count int, opts DeleteRangeOptions) *slice[T]

+ func (b *Table[T]) DeleteRangeOptions(min, max T, opts DeleteRangeOptions) *slice[T]

+ func (b *Table[T]) Descend(pivot T) iter.Seq[T]

+ func (b *Table[T]) DescendAt(index int) iter.Seq[T]

+ func (b *Table[T]) DescendAtMut(index int) iter.Seq[T]

+ func (b *Table[T]) DescendMut(pivot T) iter.Seq[T]

+ func (b *Table[T]) Drain() iter.Seq[T]

+ func (b *Table[T]) DrainBackward() iter.Seq[T]

+ func (b *Table[T]) Front() (T, bool)

+ func (b *Table[T]) FrontMut() (T, bool)

+ func (b *Table[T]) Get(key T) (T, bool)

+ func (b *Table[T]) GetAt(index int) (T, bool)

+ func (b *Table[T]) GetAtMut(index int) (T, bool)

+ func (b *Table[T]) GetMut(key T) (T, bool)

+ func (b *Table[T]) IndexOf(key T) (int, bool)

+ func (b *Table[T]) Insert(item T) (T, bool)

+ func (b *Table[T]) InsertAt(index int, item T) bool

+ func (b *Table[T]) Len() int

+ func (b *Table[T]) PopBack() (T, bool)

+ func (b *Table[T]) PopFront() (T, bool)

+ func (b *Table[T]) PushBack(item T) bool

+ func (b *Table[T]) PushFront(item T) bool

+ func (b *Table[T]) Release()

+ func (b *Table[T]) Replace(item T) (T, bool)

+ func (b *Table[T]) ReplaceAt(index int, item T) (T, bool)

+ func (b *Table[T]) Seek(key T) (T, bool)

+ func (b *Table[T]) SeekMut(key T) (T, bool)

+ func (b *Table[T]) SeekNext(key T) (T, bool)

+ func (b *Table[T]) SeekNextMut(key T) (T, bool)

+ func (b *Table[T]) SeekPrev(key T) (T, bool)

+ func (b *Table[T]) SeekPrevMut(key T) (T, bool)

+ func (b *Table[T]) Set(item T) (T, bool)

+ type TableOptions struct

+ Compare func(T, T) int

+ Copy func(T) T

+ Less func(T, T) bool

+ Release func(T)