container

package
v0.0.0-...-27647ab Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 17, 2023 License: BSD-3-Clause Imports: 21 Imported by: 3

Documentation

Overview

https://www.boost.org/doc/libs/1_79_0/libs/multi_index/doc/tutorial/basics.html

type specifier key-based ordered ordered_unique 

           ordered_non_unique
           ranked_unique
           ranked_non_unique
hashed     hashed_unique
           hashed_non_unique

non key-based sequenced 

random_access

See also maps/builder.go

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func GetOrMake 

func GetOrMake[K, V any](m MutMap[K, V], k K, fn func() V) V

func Keys 

func Keys[K, V any](m Map[K, V]) bt.Iterable[K]

func MapFormat 

func MapFormat[K, V any](f fmt.State, m Map[K, V])

func MapMarshalJson 

func MapMarshalJson[K, V any](m Map[K, V]) ([]byte, error)

func MapString 

func MapString[K, V any](sb *strings.Builder, m Map[K, V])

func SetPop 

func SetPop[T comparable](s MutSet[T]) (T, bool)

func Values 

func Values[K, V any](m Map[K, V]) bt.Iterable[V]

Types

type BiMap 

type BiMap[K, V comparable] interface {
	Map[K, V]

	Invert() BiMap[V, K]
}

type CowList 

type CowList[T any] struct {
	// contains filtered or unexported fields
}

func NewCowList 

func NewCowList[T any](it bt.Iterable[T]) *CowList[T]

func NewCowListOf 

func NewCowListOf[T any](vs ...T) *CowList[T]

func (*CowList[T]) Append 

func (m *CowList[T]) Append(v T)

func (*CowList[T]) Clone 

func (m *CowList[T]) Clone() *CowList[T]

func (*CowList[T]) Delete 

func (m *CowList[T]) Delete(i int)

func (*CowList[T]) ForEach 

func (m *CowList[T]) ForEach(fn func(v T) bool) bool

func (*CowList[T]) Get 

func (m *CowList[T]) Get(i int) T

func (*CowList[T]) Iterate 

func (m *CowList[T]) Iterate() bt.Iterator[T]

func (*CowList[T]) Len 

func (m *CowList[T]) Len() int

func (*CowList[T]) Put 

func (m *CowList[T]) Put(i int, v T)

type CowMap 

type CowMap[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func NewCowMap 

func NewCowMap[K comparable, V any](it bt.Iterable[bt.Kv[K, V]]) *CowMap[K, V]

func (*CowMap[K, V]) Clone 

func (m *CowMap[K, V]) Clone() *CowMap[K, V]

func (*CowMap[K, V]) Contains 

func (m *CowMap[K, V]) Contains(k K) bool

func (*CowMap[K, V]) Default 

func (m *CowMap[K, V]) Default(k K, v V) bool

func (*CowMap[K, V]) Delete 

func (m *CowMap[K, V]) Delete(k K)

func (*CowMap[K, V]) ForEach 

func (m *CowMap[K, V]) ForEach(fn func(bt.Kv[K, V]) bool) bool

func (*CowMap[K, V]) Get 

func (m *CowMap[K, V]) Get(k K) V

func (*CowMap[K, V]) Iterate 

func (m *CowMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (*CowMap[K, V]) Len 

func (m *CowMap[K, V]) Len() int

func (*CowMap[K, V]) Put 

func (m *CowMap[K, V]) Put(k K, v V)

func (*CowMap[K, V]) TryGet 

func (m *CowMap[K, V]) TryGet(k K) (V, bool)

type Decay 

type Decay[T any] interface {
	Mut

	Decay() T
}

type DenseList8 

type DenseList8[T any] struct {
	// contains filtered or unexported fields
}

func (DenseList8[T]) ForEach 

func (l DenseList8[T]) ForEach(fn func(v T) bool) bool

func (DenseList8[T]) Get 

func (l DenseList8[T]) Get(i int) T

func (DenseList8[T]) Iterate 

func (l DenseList8[T]) Iterate() bt.Iterator[T]

func (DenseList8[T]) Len 

func (l DenseList8[T]) Len() int

type HashEqMap 

type HashEqMap[K, V any] struct {
	// contains filtered or unexported fields
}

func NewHashEqMap 

func NewHashEqMap[K, V any](he bt.HashEqImpl[K], it bt.Iterable[bt.Kv[K, V]]) HashEqMap[K, V]

func (HashEqMap[K, V]) Contains 

func (m HashEqMap[K, V]) Contains(k K) bool

func (HashEqMap[K, V]) ForEach 

func (m HashEqMap[K, V]) ForEach(fn func(v bt.Kv[K, V]) bool) bool

func (HashEqMap[K, V]) Get 

func (m HashEqMap[K, V]) Get(k K) V

func (HashEqMap[K, V]) Iterate 

func (m HashEqMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (HashEqMap[K, V]) Len 

func (m HashEqMap[K, V]) Len() int

func (HashEqMap[K, V]) TryGet 

func (m HashEqMap[K, V]) TryGet(k K) (V, bool)

type IndexError 

type IndexError struct {
	Index int
}

func (IndexError) Error 

func (e IndexError) Error() string

func (IndexError) String 

func (e IndexError) String() string

type IntrusiveList 

type IntrusiveList[T any] struct {
	// contains filtered or unexported fields
}

func NewIntrusiveList 

func NewIntrusiveList[T any](ops IntrusiveListOps[T]) *IntrusiveList[T]

func (*IntrusiveList[T]) Append 

func (l *IntrusiveList[T]) Append(v *T)

func (IntrusiveList[T]) Back 

func (l IntrusiveList[T]) Back() *T

func (*IntrusiveList[T]) Delete 

func (l *IntrusiveList[T]) Delete(i int)

func (IntrusiveList[T]) ForEach 

func (l IntrusiveList[T]) ForEach(fn func(v *T) bool) bool

func (IntrusiveList[T]) Front 

func (l IntrusiveList[T]) Front() *T

func (IntrusiveList[T]) Get 

func (l IntrusiveList[T]) Get(i int) *T

func (*IntrusiveList[T]) InsertAfter 

func (l *IntrusiveList[T]) InsertAfter(v, mark *T) *T

func (*IntrusiveList[T]) InsertBefore 

func (l *IntrusiveList[T]) InsertBefore(v, mark *T) *T

func (IntrusiveList[T]) Iterate 

func (l IntrusiveList[T]) Iterate() bt.Iterator[*T]

func (IntrusiveList[T]) IterateFrom 

func (l IntrusiveList[T]) IterateFrom(e *T) bt.Iterator[*T]

func (IntrusiveList[T]) Len 

func (l IntrusiveList[T]) Len() int

func (*IntrusiveList[T]) MoveAfter 

func (l *IntrusiveList[T]) MoveAfter(e, mark *T) *T

func (*IntrusiveList[T]) MoveBefore 

func (l *IntrusiveList[T]) MoveBefore(e, mark *T) *T

func (*IntrusiveList[T]) MoveToBack 

func (l *IntrusiveList[T]) MoveToBack(e *T) *T

func (*IntrusiveList[T]) MoveToFront 

func (l *IntrusiveList[T]) MoveToFront(e *T) *T

func (*IntrusiveList[T]) PushBack 

func (l *IntrusiveList[T]) PushBack(v *T) *T

func (*IntrusiveList[T]) PushFront 

func (l *IntrusiveList[T]) PushFront(v *T) *T

func (*IntrusiveList[T]) Put 

func (l *IntrusiveList[T]) Put(i int, v *T)

func (*IntrusiveList[T]) Remove 

func (l *IntrusiveList[T]) Remove(e *T) *T

func (*IntrusiveList[T]) ReverseIterate 

func (l *IntrusiveList[T]) ReverseIterate() bt.Iterator[*T]

func (*IntrusiveList[T]) ReverseIterateFrom 

func (l *IntrusiveList[T]) ReverseIterateFrom(e *T) bt.Iterator[*T]

type IntrusiveListNode 

type IntrusiveListNode[T any] struct {
	// contains filtered or unexported fields
}

func (IntrusiveListNode[T]) Next 

func (n IntrusiveListNode[T]) Next() *T

func (IntrusiveListNode[T]) Prev 

func (n IntrusiveListNode[T]) Prev() *T

func (IntrusiveListNode[T]) String 

func (n IntrusiveListNode[T]) String() string

type IntrusiveListOps 

type IntrusiveListOps[T any] struct {
	// contains filtered or unexported fields
}

func NewIntrusiveListOps 

func NewIntrusiveListOps[T any](getNode func(*T) *IntrusiveListNode[T]) IntrusiveListOps[T]

func (IntrusiveListOps[T]) GetNode 

func (o IntrusiveListOps[T]) GetNode(e *T) *IntrusiveListNode[T]

type KeyError 

type KeyError[K any] struct {
	Key K
}

func (KeyError[K]) Error 

func (e KeyError[K]) Error() string

func (KeyError[K]) String 

func (e KeyError[K]) String() string

type LinkedList 

type LinkedList[T any] struct {
	list.List
}

func NewLinkedList 

func NewLinkedList[T any](it bt.Iterable[T]) *LinkedList[T]

func (*LinkedList[T]) Append 

func (l *LinkedList[T]) Append(v T)

func (*LinkedList[T]) Delete 

func (l *LinkedList[T]) Delete(i int)

func (*LinkedList[T]) ForEach 

func (l *LinkedList[T]) ForEach(fn func(v T) bool) bool

func (*LinkedList[T]) Get 

func (l *LinkedList[T]) Get(i int) T

func (*LinkedList[T]) GetElement 

func (l *LinkedList[T]) GetElement(i int) *list.Element

func (*LinkedList[T]) Iterate 

func (l *LinkedList[T]) Iterate() bt.Iterator[T]

func (*LinkedList[T]) Len 

func (l *LinkedList[T]) Len() int

func (*LinkedList[T]) Put 

func (l *LinkedList[T]) Put(i int, v T)

type LinkedMap 

type LinkedMap[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func NewLinkedMap 

func NewLinkedMap[K comparable, V any](it bt.Iterable[bt.Kv[K, V]]) LinkedMap[K, V]

func (LinkedMap[K, V]) AnyIterate 

func (m LinkedMap[K, V]) AnyIterate() bt.Iterator[any]

func (LinkedMap[K, V]) Contains 

func (m LinkedMap[K, V]) Contains(k K) bool

func (LinkedMap[K, V]) ForEach 

func (m LinkedMap[K, V]) ForEach(fn func(bt.Kv[K, V]) bool) bool

func (LinkedMap[K, V]) Get 

func (m LinkedMap[K, V]) Get(k K) V

func (LinkedMap[K, V]) Iterate 

func (m LinkedMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (LinkedMap[K, V]) IterateFrom 

func (m LinkedMap[K, V]) IterateFrom(k K) bt.Iterator[bt.Kv[K, V]]

func (LinkedMap[K, V]) Len 

func (m LinkedMap[K, V]) Len() int

func (LinkedMap[K, V]) ReverseIterate 

func (m LinkedMap[K, V]) ReverseIterate() bt.Iterator[bt.Kv[K, V]]

func (LinkedMap[K, V]) ReverseIterateFrom 

func (m LinkedMap[K, V]) ReverseIterateFrom(k K) bt.Iterator[bt.Kv[K, V]]

func (LinkedMap[K, V]) TryGet 

func (m LinkedMap[K, V]) TryGet(k K) (V, bool)

type List 

type List[T any] interface {
	Len() int
	Get(i int) T

	bt.Iterable[T]
	bt.Traversable[T]
}

func DecayList 

func DecayList[T any](l MutList[T]) List[T]

type ListView 

type ListView[F, T any] struct {
	// contains filtered or unexported fields
}

func NewListView 

func NewListView[F, T any](l List[F], fn func(F) T) ListView[F, T]

func (ListView[F, T]) ForEach 

func (l ListView[F, T]) ForEach(fn func(v T) bool) bool

func (ListView[F, T]) Get 

func (l ListView[F, T]) Get(i int) T

func (ListView[F, T]) Iterate 

func (l ListView[F, T]) Iterate() bt.Iterator[T]

func (ListView[F, T]) Len 

func (l ListView[F, T]) Len() int

type LockedMap 

type LockedMap[K, V any] struct {
	// contains filtered or unexported fields
}

func NewLockedMap 

func NewLockedMap[K, V any](m Map[K, V]) *LockedMap[K, V]

func (*LockedMap[K, V]) Contains 

func (m *LockedMap[K, V]) Contains(k K) bool

func (*LockedMap[K, V]) ForEach 

func (m *LockedMap[K, V]) ForEach(fn func(v bt.Kv[K, V]) bool) bool

func (*LockedMap[K, V]) Get 

func (m *LockedMap[K, V]) Get(k K) V

func (*LockedMap[K, V]) Iterate 

func (m *LockedMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (*LockedMap[K, V]) Len 

func (m *LockedMap[K, V]) Len() int

func (*LockedMap[K, V]) MarshalJSON 

func (m *LockedMap[K, V]) MarshalJSON() ([]byte, error)

func (*LockedMap[K, V]) TryGet 

func (m *LockedMap[K, V]) TryGet(k K) (V, bool)

func (*LockedMap[K, V]) UnmarshalJSON 

func (m *LockedMap[K, V]) UnmarshalJSON(b []byte) error

type LockedMutMap 

type LockedMutMap[K, V any] struct {
	LockedMap[K, V]
	// contains filtered or unexported fields
}

func NewLockedMutMap 

func NewLockedMutMap[K, V any](m MutMap[K, V]) *LockedMutMap[K, V]

func (*LockedMutMap[K, V]) Default 

func (m *LockedMutMap[K, V]) Default(k K, v V) bool

func (*LockedMutMap[K, V]) Delete 

func (m *LockedMutMap[K, V]) Delete(k K)

func (*LockedMutMap[K, V]) MarshalJSON 

func (m *LockedMutMap[K, V]) MarshalJSON() ([]byte, error)

func (*LockedMutMap[K, V]) Put 

func (m *LockedMutMap[K, V]) Put(k K, v V)

func (*LockedMutMap[K, V]) UnmarshalJSON 

func (m *LockedMutMap[K, V]) UnmarshalJSON(b []byte) error

type Map 

type Map[K, V any] interface {
	Len() int
	Contains(k K) bool
	Get(k K) V
	TryGet(k K) (V, bool)

	bt.Iterable[bt.Kv[K, V]]
	bt.Traversable[bt.Kv[K, V]]
}

func DecayMap 

func DecayMap[K comparable, V any](l MutMap[K, V]) Map[K, V]

func MapKeys 

func MapKeys[KF, KT comparable, V any](fn func(k KF) KT, m Map[KF, V]) Map[KT, V]

func MapValues 

func MapValues[K comparable, VF, VT any](fn func(v VF) VT, m Map[K, VF]) Map[K, VT]

func NewSetMap 

func NewSetMap[K, V any](s Set[K]) Map[K, V]

type MapBuilder 

type MapBuilder[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func NewMapBuilder 

func NewMapBuilder[K comparable, V any]() *MapBuilder[K, V]

func (*MapBuilder[K, V]) Build 

func (b *MapBuilder[K, V]) Build() OrderedMap[K, V]

func (*MapBuilder[K, V]) Default 

func (b *MapBuilder[K, V]) Default(k K, v V) *MapBuilder[K, V]

func (*MapBuilder[K, V]) Delete 

func (b *MapBuilder[K, V]) Delete(k K) *MapBuilder[K, V]

func (*MapBuilder[K, V]) Filter 

func (b *MapBuilder[K, V]) Filter(fn func(kv bt.Kv[K, V]) bool) *MapBuilder[K, V]

func (*MapBuilder[K, V]) FilterKeys 

func (b *MapBuilder[K, V]) FilterKeys(fn func(k K) bool) *MapBuilder[K, V]

func (*MapBuilder[K, V]) FilterValues 

func (b *MapBuilder[K, V]) FilterValues(fn func(v V) bool) *MapBuilder[K, V]

func (*MapBuilder[K, V]) Put 

func (b *MapBuilder[K, V]) Put(k K, v V) *MapBuilder[K, V]

func (*MapBuilder[K, V]) Update 

func (b *MapBuilder[K, V]) Update(it bt.Iterable[bt.Kv[K, V]]) *MapBuilder[K, V]

type MapFormatter 

type MapFormatter struct {
	// contains filtered or unexported fields
}

func (MapFormatter) WriteBegin 

func (mf MapFormatter) WriteBegin()

func (MapFormatter) WriteEnd 

func (mf MapFormatter) WriteEnd()

func (MapFormatter) WriteEntry 

func (mf MapFormatter) WriteEntry(i int, k, v any)

func (MapFormatter) WriteString 

func (mf MapFormatter) WriteString(s string)

type MapShape 

type MapShape[K comparable] struct {
	// contains filtered or unexported fields
}

func NewMapShape 

func NewMapShape[K comparable](ks bt.Iterable[K]) MapShape[K]

func (MapShape[K]) Contains 

func (s MapShape[K]) Contains(k K) bool

func (MapShape[K]) ForEach 

func (s MapShape[K]) ForEach(fn func(v K) bool) bool

func (MapShape[K]) Iterate 

func (s MapShape[K]) Iterate() bt.Iterator[K]

func (MapShape[K]) Len 

func (s MapShape[K]) Len() int

type MapStringer 

type MapStringer struct {
	// contains filtered or unexported fields
}

func (MapStringer) WriteBegin 

func (ms MapStringer) WriteBegin()

func (MapStringer) WriteEnd 

func (ms MapStringer) WriteEnd()

func (MapStringer) WriteEntry 

func (ms MapStringer) WriteEntry(i int, k, v any)

type MapView 

type MapView[K comparable, VF, VT any] struct {
	// contains filtered or unexported fields
}

func NewMapView 

func NewMapView[K comparable, VF, VT any](m Map[K, VF], fn func(VF) VT) MapView[K, VF, VT]

func (MapView[K, VF, VT]) Contains 

func (m MapView[K, VF, VT]) Contains(k K) bool

func (MapView[K, VF, VT]) ForEach 

func (m MapView[K, VF, VT]) ForEach(fn func(v bt.Kv[K, VT]) bool) bool

func (MapView[K, VF, VT]) Get 

func (m MapView[K, VF, VT]) Get(k K) VT

func (MapView[K, VF, VT]) Iterate 

func (m MapView[K, VF, VT]) Iterate() bt.Iterator[bt.Kv[K, VT]]

func (MapView[K, VF, VT]) Len 

func (m MapView[K, VF, VT]) Len() int

func (MapView[K, VF, VT]) TryGet 

func (m MapView[K, VF, VT]) TryGet(k K) (VT, bool)

type Mut 

type Mut interface {
	// contains filtered or unexported methods
}

type MutBiMap 

type MutBiMap[K, V comparable] interface {
	MutMap[K, V]
	BiMap[K, V]

	MutInvert() MutBiMap[V, K]
}

type MutDenseList8 

type MutDenseList8[T any] struct {
	// contains filtered or unexported fields
}

func (*MutDenseList8[T]) Append 

func (l *MutDenseList8[T]) Append(v T)

func (*MutDenseList8[T]) Delete 

func (l *MutDenseList8[T]) Delete(i int)

func (*MutDenseList8[T]) ForEach 

func (l *MutDenseList8[T]) ForEach(fn func(v T) bool) bool

func (*MutDenseList8[T]) Get 

func (l *MutDenseList8[T]) Get(i int) T

func (*MutDenseList8[T]) Iterate 

func (l *MutDenseList8[T]) Iterate() bt.Iterator[T]

func (*MutDenseList8[T]) Len 

func (l *MutDenseList8[T]) Len() int

func (*MutDenseList8[T]) Put 

func (l *MutDenseList8[T]) Put(i int, v T)

type MutHashEqMap 

type MutHashEqMap[K, V any] struct {
	// contains filtered or unexported fields
}

func NewMutHashEqMap 

func NewMutHashEqMap[K, V any](he bt.HashEqImpl[K], it bt.Iterable[bt.Kv[K, V]]) *MutHashEqMap[K, V]

func (*MutHashEqMap[K, V]) Contains 

func (m *MutHashEqMap[K, V]) Contains(k K) bool

func (*MutHashEqMap[K, V]) Decay 

func (m *MutHashEqMap[K, V]) Decay() Map[K, V]

func (*MutHashEqMap[K, V]) Default 

func (m *MutHashEqMap[K, V]) Default(k K, v V) bool

func (*MutHashEqMap[K, V]) Delete 

func (m *MutHashEqMap[K, V]) Delete(k K)

func (*MutHashEqMap[K, V]) ForEach 

func (m *MutHashEqMap[K, V]) ForEach(fn func(v bt.Kv[K, V]) bool) bool

func (*MutHashEqMap[K, V]) Get 

func (m *MutHashEqMap[K, V]) Get(k K) V

func (*MutHashEqMap[K, V]) Iterate 

func (m *MutHashEqMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (*MutHashEqMap[K, V]) Len 

func (m *MutHashEqMap[K, V]) Len() int

func (*MutHashEqMap[K, V]) Put 

func (m *MutHashEqMap[K, V]) Put(k K, v V)

func (*MutHashEqMap[K, V]) TryGet 

func (m *MutHashEqMap[K, V]) TryGet(k K) (V, bool)

type MutLinkedMap 

type MutLinkedMap[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func NewMutLinkedMap 

func NewMutLinkedMap[K comparable, V any](it bt.Iterable[bt.Kv[K, V]]) *MutLinkedMap[K, V]

func (*MutLinkedMap[K, V]) Contains 

func (m *MutLinkedMap[K, V]) Contains(k K) bool

func (*MutLinkedMap[K, V]) Decay 

func (m *MutLinkedMap[K, V]) Decay() Map[K, V]

func (*MutLinkedMap[K, V]) Default 

func (m *MutLinkedMap[K, V]) Default(k K, v V) bool

func (*MutLinkedMap[K, V]) Delete 

func (m *MutLinkedMap[K, V]) Delete(k K)

func (*MutLinkedMap[K, V]) ForEach 

func (m *MutLinkedMap[K, V]) ForEach(fn func(v bt.Kv[K, V]) bool) bool

func (*MutLinkedMap[K, V]) Get 

func (m *MutLinkedMap[K, V]) Get(k K) V

func (*MutLinkedMap[K, V]) Iterate 

func (m *MutLinkedMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (*MutLinkedMap[K, V]) IterateFrom 

func (m *MutLinkedMap[K, V]) IterateFrom(k K) bt.Iterator[bt.Kv[K, V]]

func (*MutLinkedMap[K, V]) Len 

func (m *MutLinkedMap[K, V]) Len() int

func (*MutLinkedMap[K, V]) Put 

func (m *MutLinkedMap[K, V]) Put(k K, v V)

func (*MutLinkedMap[K, V]) ReverseIterate 

func (m *MutLinkedMap[K, V]) ReverseIterate() bt.Iterator[bt.Kv[K, V]]

func (*MutLinkedMap[K, V]) ReverseIterateFrom 

func (m *MutLinkedMap[K, V]) ReverseIterateFrom(k K) bt.Iterator[bt.Kv[K, V]]

func (*MutLinkedMap[K, V]) TryGet 

func (m *MutLinkedMap[K, V]) TryGet(k K) (V, bool)

type MutList 

type MutList[T any] interface {
	List[T]
	Mut

	Put(i int, v T)
	Append(v T)
	Delete(i int)
}

func WrapSlice 

func WrapSlice[T any](s []T) MutList[T]

type MutMap 

type MutMap[K, V any] interface {
	Map[K, V]
	Mut

	Put(k K, v V)
	Delete(k K)
	Default(k K, v V) bool
}

func NewMutSetMap 

func NewMutSetMap[K, V any](s MutSet[K]) MutMap[K, V]

type MutOrderedMap 

type MutOrderedMap[K, V any] interface {
	OrderedMap[K, V]
	MutMap[K, V]
}

type MutRbTreeMap 

type MutRbTreeMap[K, V any] struct {
	// contains filtered or unexported fields
}

func NewMutRbTreeMap 

func NewMutRbTreeMap[K, V any](less bt.LessImpl[K], it bt.Iterable[bt.Kv[K, V]]) *MutRbTreeMap[K, V]

func (*MutRbTreeMap[K, V]) Contains 

func (m *MutRbTreeMap[K, V]) Contains(k K) bool

func (*MutRbTreeMap[K, V]) Decay 

func (m *MutRbTreeMap[K, V]) Decay() Map[K, V]

func (*MutRbTreeMap[K, V]) Default 

func (m *MutRbTreeMap[K, V]) Default(k K, v V) bool

func (*MutRbTreeMap[K, V]) Delete 

func (m *MutRbTreeMap[K, V]) Delete(k K)

func (*MutRbTreeMap[K, V]) ForEach 

func (m *MutRbTreeMap[K, V]) ForEach(fn func(v bt.Kv[K, V]) bool) bool

func (*MutRbTreeMap[K, V]) Get 

func (m *MutRbTreeMap[K, V]) Get(k K) V

func (*MutRbTreeMap[K, V]) Iterate 

func (m *MutRbTreeMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (*MutRbTreeMap[K, V]) Len 

func (m *MutRbTreeMap[K, V]) Len() int

func (MutRbTreeMap[K, V]) MarshalJSON 

func (m MutRbTreeMap[K, V]) MarshalJSON() ([]byte, error)

func (*MutRbTreeMap[K, V]) Put 

func (m *MutRbTreeMap[K, V]) Put(k K, v V)

func (*MutRbTreeMap[K, V]) TryGet 

func (m *MutRbTreeMap[K, V]) TryGet(k K) (V, bool)

func (*MutRbTreeMap[K, V]) UnmarshalJSON 

func (m *MutRbTreeMap[K, V]) UnmarshalJSON(b []byte) error

type MutSet 

type MutSet[T any] interface {
	Set[T]
	Mut

	Add(v T)
	TryAdd(v T) bool
	Remove(v T)
	TryRemove(v T) bool
}

func NewMutHashEqSet 

func NewMutHashEqSet[K any](he bt.HashEqImpl[K], it bt.Iterable[K]) MutSet[K]

func NewMutMapSet 

func NewMutMapSet[K, V any](m MutMap[K, V]) MutSet[K]

type MutShapeMap 

type MutShapeMap[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func NewMutShapeMap 

func NewMutShapeMap[K comparable, V any](shape MapShape[K], vs bt.Iterable[V]) MutShapeMap[K, V]

func (MutShapeMap[K, V]) Contains 

func (m MutShapeMap[K, V]) Contains(k K) bool

func (MutShapeMap[K, V]) Default 

func (m MutShapeMap[K, V]) Default(k K, v V) bool

func (MutShapeMap[K, V]) Delete 

func (m MutShapeMap[K, V]) Delete(k K)

func (MutShapeMap[K, V]) ForEach 

func (m MutShapeMap[K, V]) ForEach(fn func(kv bt.Kv[K, V]) bool) bool

func (MutShapeMap[K, V]) Format 

func (m MutShapeMap[K, V]) Format(f fmt.State, c rune)

func (MutShapeMap[K, V]) Get 

func (m MutShapeMap[K, V]) Get(k K) V

func (MutShapeMap[K, V]) Iterate 

func (m MutShapeMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (MutShapeMap[K, V]) Len 

func (m MutShapeMap[K, V]) Len() int

func (MutShapeMap[K, V]) MarshalJSON 

func (m MutShapeMap[K, V]) MarshalJSON() ([]byte, error)

func (MutShapeMap[K, V]) Put 

func (m MutShapeMap[K, V]) Put(k K, v V)

func (MutShapeMap[K, V]) Shape 

func (m MutShapeMap[K, V]) Shape() MapShape[K]

func (MutShapeMap[K, V]) String 

func (m MutShapeMap[K, V]) String() string

func (MutShapeMap[K, V]) TryGet 

func (m MutShapeMap[K, V]) TryGet(k K) (V, bool)

func (MutShapeMap[K, V]) Value 

func (m MutShapeMap[K, V]) Value(i int) *V

func (MutShapeMap[K, V]) Values 

func (m MutShapeMap[K, V]) Values() []V

type MutSimpleBiMap 

type MutSimpleBiMap[K, V comparable] struct {
	// contains filtered or unexported fields
}

func NewMutSimpleBiMap 

func NewMutSimpleBiMap[K, V comparable](it bt.Iterable[bt.Kv[K, V]]) MutSimpleBiMap[K, V]

func (MutSimpleBiMap[K, V]) Contains 

func (m MutSimpleBiMap[K, V]) Contains(k K) bool

func (MutSimpleBiMap[K, V]) Default 

func (m MutSimpleBiMap[K, V]) Default(k K, v V) bool

func (MutSimpleBiMap[K, V]) Delete 

func (m MutSimpleBiMap[K, V]) Delete(k K)

func (MutSimpleBiMap[K, V]) ForEach 

func (m MutSimpleBiMap[K, V]) ForEach(fn func(kv bt.Kv[K, V]) bool) bool

func (MutSimpleBiMap[K, V]) Get 

func (m MutSimpleBiMap[K, V]) Get(k K) V

func (MutSimpleBiMap[K, V]) Invert 

func (m MutSimpleBiMap[K, V]) Invert() BiMap[V, K]

func (MutSimpleBiMap[K, V]) Iterate 

func (m MutSimpleBiMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (MutSimpleBiMap[K, V]) Len 

func (m MutSimpleBiMap[K, V]) Len() int

func (MutSimpleBiMap[K, V]) MarshalJSON 

func (m MutSimpleBiMap[K, V]) MarshalJSON() ([]byte, error)

func (MutSimpleBiMap[K, V]) MutInvert 

func (m MutSimpleBiMap[K, V]) MutInvert() MutBiMap[V, K]

func (MutSimpleBiMap[K, V]) Put 

func (m MutSimpleBiMap[K, V]) Put(k K, v V)

func (MutSimpleBiMap[K, V]) TryGet 

func (m MutSimpleBiMap[K, V]) TryGet(k K) (V, bool)

func (*MutSimpleBiMap[K, V]) UnmarshalJSON 

func (m *MutSimpleBiMap[K, V]) UnmarshalJSON(b []byte) error

type MutSliceList 

type MutSliceList[T any] struct {
	// contains filtered or unexported fields
}

func NewMutSliceList 

func NewMutSliceList[T any](it bt.Iterable[T]) *MutSliceList[T]

func NewMutSliceListOf 

func NewMutSliceListOf[T any](vs ...T) *MutSliceList[T]

func (*MutSliceList[T]) Append 

func (l *MutSliceList[T]) Append(v T)

func (*MutSliceList[T]) Decay 

func (l *MutSliceList[T]) Decay() List[T]

func (*MutSliceList[T]) Delete 

func (l *MutSliceList[T]) Delete(i int)

func (*MutSliceList[T]) ForEach 

func (l *MutSliceList[T]) ForEach(fn func(v T) bool) bool

func (*MutSliceList[T]) Get 

func (l *MutSliceList[T]) Get(i int) T

func (*MutSliceList[T]) Iterate 

func (l *MutSliceList[T]) Iterate() bt.Iterator[T]

func (*MutSliceList[T]) Len 

func (l *MutSliceList[T]) Len() int

func (MutSliceList[T]) MarshalJSON 

func (l MutSliceList[T]) MarshalJSON() ([]byte, error)

func (*MutSliceList[T]) Put 

func (l *MutSliceList[T]) Put(i int, v T)

func (*MutSliceList[T]) UnmarshalJSON 

func (l *MutSliceList[T]) UnmarshalJSON(b []byte) error

type MutSliceMap 

type MutSliceMap[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func NewMutSliceMap 

func NewMutSliceMap[K comparable, V any](it bt.Iterable[bt.Kv[K, V]]) *MutSliceMap[K, V]

func (*MutSliceMap[K, V]) All 

func (m *MutSliceMap[K, V]) All() []bt.Kv[K, V]

func (*MutSliceMap[K, V]) Contains 

func (m *MutSliceMap[K, V]) Contains(k K) bool

func (*MutSliceMap[K, V]) Decay 

func (m *MutSliceMap[K, V]) Decay() Map[K, V]

func (*MutSliceMap[K, V]) Default 

func (m *MutSliceMap[K, V]) Default(k K, v V) bool

func (*MutSliceMap[K, V]) Delete 

func (m *MutSliceMap[K, V]) Delete(k K)

func (*MutSliceMap[K, V]) ForEach 

func (m *MutSliceMap[K, V]) ForEach(fn func(v bt.Kv[K, V]) bool) bool

func (MutSliceMap[K, V]) Format 

func (m MutSliceMap[K, V]) Format(f fmt.State, c rune)

func (*MutSliceMap[K, V]) Get 

func (m *MutSliceMap[K, V]) Get(k K) V

func (*MutSliceMap[K, V]) Iterate 

func (m *MutSliceMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (*MutSliceMap[K, V]) IterateFrom 

func (m *MutSliceMap[K, V]) IterateFrom(k K) bt.Iterator[bt.Kv[K, V]]

func (*MutSliceMap[K, V]) Len 

func (m *MutSliceMap[K, V]) Len() int

func (MutSliceMap[K, V]) MarshalJSON 

func (m MutSliceMap[K, V]) MarshalJSON() ([]byte, error)

func (*MutSliceMap[K, V]) Put 

func (m *MutSliceMap[K, V]) Put(k K, v V)

func (*MutSliceMap[K, V]) ReverseIterate 

func (m *MutSliceMap[K, V]) ReverseIterate() bt.Iterator[bt.Kv[K, V]]

func (*MutSliceMap[K, V]) ReverseIterateFrom 

func (m *MutSliceMap[K, V]) ReverseIterateFrom(k K) bt.Iterator[bt.Kv[K, V]]

func (MutSliceMap[K, V]) String 

func (m MutSliceMap[K, V]) String() string

func (*MutSliceMap[K, V]) TryGet 

func (m *MutSliceMap[K, V]) TryGet(k K) (V, bool)

func (*MutSliceMap[K, V]) UnmarshalJSON 

func (m *MutSliceMap[K, V]) UnmarshalJSON(b []byte) error

type MutStdMap 

type MutStdMap[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func NewMutStdMap 

func NewMutStdMap[K comparable, V any](it bt.Iterable[bt.Kv[K, V]]) *MutStdMap[K, V]

func WrapMap 

func WrapMap[K comparable, V any](m map[K]V) *MutStdMap[K, V]

func (*MutStdMap[K, V]) Contains 

func (m *MutStdMap[K, V]) Contains(k K) bool

func (*MutStdMap[K, V]) Decay 

func (m *MutStdMap[K, V]) Decay() Map[K, V]

func (*MutStdMap[K, V]) Default 

func (m *MutStdMap[K, V]) Default(k K, v V) bool

func (*MutStdMap[K, V]) Delete 

func (m *MutStdMap[K, V]) Delete(k K)

func (*MutStdMap[K, V]) ForEach 

func (m *MutStdMap[K, V]) ForEach(fn func(bt.Kv[K, V]) bool) bool

func (*MutStdMap[K, V]) Get 

func (m *MutStdMap[K, V]) Get(k K) V

func (*MutStdMap[K, V]) Iterate 

func (m *MutStdMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (*MutStdMap[K, V]) Len 

func (m *MutStdMap[K, V]) Len() int

func (MutStdMap[K, V]) MarshalJSON 

func (m MutStdMap[K, V]) MarshalJSON() ([]byte, error)

func (*MutStdMap[K, V]) Put 

func (m *MutStdMap[K, V]) Put(k K, v V)

func (*MutStdMap[K, V]) TryGet 

func (m *MutStdMap[K, V]) TryGet(k K) (V, bool)

func (*MutStdMap[K, V]) UnmarshalJSON 

func (m *MutStdMap[K, V]) UnmarshalJSON(b []byte) error

type MutStdSet 

type MutStdSet[T comparable] struct {
	// contains filtered or unexported fields
}

func NewMutStdSet 

func NewMutStdSet[T comparable](it bt.Iterable[T]) *MutStdSet[T]

func NewMutStdSetOf 

func NewMutStdSetOf[T comparable](vs ...T) *MutStdSet[T]

func WrapSet 

func WrapSet[T comparable](s map[T]struct{}) *MutStdSet[T]

func (*MutStdSet[T]) Add 

func (s *MutStdSet[T]) Add(value T)

func (*MutStdSet[T]) Contains 

func (s *MutStdSet[T]) Contains(v T) bool

func (*MutStdSet[T]) Decay 

func (s *MutStdSet[T]) Decay() Set[T]

func (*MutStdSet[T]) ForEach 

func (s *MutStdSet[T]) ForEach(fn func(v T) bool) bool

func (*MutStdSet[T]) Iterate 

func (s *MutStdSet[T]) Iterate() bt.Iterator[T]

func (*MutStdSet[T]) Len 

func (s *MutStdSet[T]) Len() int

func (MutStdSet[T]) MarshalJSON 

func (s MutStdSet[T]) MarshalJSON() ([]byte, error)

func (*MutStdSet[T]) Remove 

func (s *MutStdSet[T]) Remove(value T)

func (*MutStdSet[T]) TryAdd 

func (s *MutStdSet[T]) TryAdd(value T) bool

func (*MutStdSet[T]) TryRemove 

func (s *MutStdSet[T]) TryRemove(value T) bool

func (*MutStdSet[T]) UnmarshalJSON 

func (s *MutStdSet[T]) UnmarshalJSON(b []byte) error

type Ordered 

type Ordered[T any] interface {
	bt.Iterable[T]
	// contains filtered or unexported methods
}

type OrderedMap 

type OrderedMap[K, V any] interface {
	Map[K, V]
	Ordered[bt.Kv[K, V]]
}

type Persistent 

type Persistent[T any] interface {
	bt.Iterable[T]
	// contains filtered or unexported methods
}

type PersistentMap 

type PersistentMap[K, V any] interface {
	Map[K, V]
	Persistent[bt.Kv[K, V]]

	With(k K, v V) PersistentMap[K, V]
	Without(k K) PersistentMap[K, V]
	Default(k K, v V) PersistentMap[K, V]
}

type PrimitiveMutRbTreeMap 

type PrimitiveMutRbTreeMap[K constraints.Ordered, V any] struct {
	// contains filtered or unexported fields
}

func NewPrimitiveMutRbTreeMap 

func NewPrimitiveMutRbTreeMap[K constraints.Ordered, V any](it bt.Iterable[bt.Kv[K, V]]) *PrimitiveMutRbTreeMap[K, V]

func (*PrimitiveMutRbTreeMap[K, V]) Contains 

func (m *PrimitiveMutRbTreeMap[K, V]) Contains(k K) bool

func (*PrimitiveMutRbTreeMap[K, V]) Decay 

func (m *PrimitiveMutRbTreeMap[K, V]) Decay() Map[K, V]

func (*PrimitiveMutRbTreeMap[K, V]) Default 

func (m *PrimitiveMutRbTreeMap[K, V]) Default(k K, v V) bool

func (*PrimitiveMutRbTreeMap[K, V]) Delete 

func (m *PrimitiveMutRbTreeMap[K, V]) Delete(k K)

func (*PrimitiveMutRbTreeMap[K, V]) ForEach 

func (m *PrimitiveMutRbTreeMap[K, V]) ForEach(fn func(v bt.Kv[K, V]) bool) bool

func (*PrimitiveMutRbTreeMap[K, V]) Get 

func (m *PrimitiveMutRbTreeMap[K, V]) Get(k K) V

func (*PrimitiveMutRbTreeMap[K, V]) Iterate 

func (m *PrimitiveMutRbTreeMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (*PrimitiveMutRbTreeMap[K, V]) Len 

func (m *PrimitiveMutRbTreeMap[K, V]) Len() int

func (*PrimitiveMutRbTreeMap[K, V]) Put 

func (m *PrimitiveMutRbTreeMap[K, V]) Put(k K, v V)

func (*PrimitiveMutRbTreeMap[K, V]) TryGet 

func (m *PrimitiveMutRbTreeMap[K, V]) TryGet(k K) (V, bool)

type PrimitiveRbTreeMap 

type PrimitiveRbTreeMap[K constraints.Ordered, V any] struct {
	// contains filtered or unexported fields
}

func NewPrimitiveRbTreeMap 

func NewPrimitiveRbTreeMap[K constraints.Ordered, V any](it bt.Iterable[bt.Kv[K, V]]) PrimitiveRbTreeMap[K, V]

func (PrimitiveRbTreeMap[K, V]) Contains 

func (m PrimitiveRbTreeMap[K, V]) Contains(k K) bool

func (PrimitiveRbTreeMap[K, V]) ForEach 

func (m PrimitiveRbTreeMap[K, V]) ForEach(fn func(v bt.Kv[K, V]) bool) bool

func (PrimitiveRbTreeMap[K, V]) Get 

func (m PrimitiveRbTreeMap[K, V]) Get(k K) V

func (PrimitiveRbTreeMap[K, V]) Iterate 

func (m PrimitiveRbTreeMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (PrimitiveRbTreeMap[K, V]) Len 

func (m PrimitiveRbTreeMap[K, V]) Len() int

func (PrimitiveRbTreeMap[K, V]) TryGet 

func (m PrimitiveRbTreeMap[K, V]) TryGet(k K) (V, bool)

type RbTreeMap 

type RbTreeMap[K, V any] struct {
	// contains filtered or unexported fields
}

func NewRbTreeMap 

func NewRbTreeMap[K, V any](less bt.LessImpl[K], it bt.Iterable[bt.Kv[K, V]]) RbTreeMap[K, V]

func (RbTreeMap[K, V]) Contains 

func (m RbTreeMap[K, V]) Contains(k K) bool

func (RbTreeMap[K, V]) ForEach 

func (m RbTreeMap[K, V]) ForEach(fn func(v bt.Kv[K, V]) bool) bool

func (RbTreeMap[K, V]) Get 

func (m RbTreeMap[K, V]) Get(k K) V

func (RbTreeMap[K, V]) Iterate 

func (m RbTreeMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (RbTreeMap[K, V]) Len 

func (m RbTreeMap[K, V]) Len() int

func (RbTreeMap[K, V]) MarshalJSON 

func (m RbTreeMap[K, V]) MarshalJSON() ([]byte, error)

func (RbTreeMap[K, V]) TryGet 

func (m RbTreeMap[K, V]) TryGet(k K) (V, bool)

func (*RbTreeMap[K, V]) UnmarshalJSON 

func (m *RbTreeMap[K, V]) UnmarshalJSON(b []byte) error

type Set 

type Set[T any] interface {
	Len() int
	Contains(v T) bool

	bt.Iterable[T]
	bt.Traversable[T]
}

func DecaySet 

func DecaySet[T comparable](l MutSet[T]) Set[T]

func Difference 

func Difference[T comparable](ss ...Set[T]) Set[T]

func Intersection 

func Intersection[T comparable](ss ...Set[T]) Set[T]

func NewHashEqSet 

func NewHashEqSet[K any](he bt.HashEqImpl[K], it bt.Iterable[K]) Set[K]

func NewMapSet 

func NewMapSet[K, V any](m Map[K, V]) Set[K]

func Union 

func Union[T comparable](ss ...Set[T]) Set[T]

type SetView 

type SetView[F, T any] struct {
	// contains filtered or unexported fields
}

func NewSetView 

func NewSetView[F, T any](s Set[F], bfn bt.BiFunc[F, T]) SetView[F, T]

func (SetView[F, T]) Contains 

func (s SetView[F, T]) Contains(v T) bool

func (SetView[F, T]) ForEach 

func (s SetView[F, T]) ForEach(fn func(v T) bool) bool

func (SetView[F, T]) Iterate 

func (s SetView[F, T]) Iterate() bt.Iterator[T]

func (SetView[F, T]) Len 

func (s SetView[F, T]) Len() int

type ShapeMap 

type ShapeMap[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func NewShapeMap 

func NewShapeMap[K comparable, V any](shape MapShape[K], vs bt.Iterable[V]) ShapeMap[K, V]

func NewShapeMapFromSlice 

func NewShapeMapFromSlice[K comparable, V any](shape MapShape[K], s []V) ShapeMap[K, V]

func (ShapeMap[K, V]) Clone 

func (m ShapeMap[K, V]) Clone() ShapeMap[K, V]

func (ShapeMap[K, V]) Contains 

func (m ShapeMap[K, V]) Contains(k K) bool

func (ShapeMap[K, V]) ForEach 

func (m ShapeMap[K, V]) ForEach(fn func(kv bt.Kv[K, V]) bool) bool

func (ShapeMap[K, V]) Format 

func (m ShapeMap[K, V]) Format(f fmt.State, c rune)

func (ShapeMap[K, V]) Get 

func (m ShapeMap[K, V]) Get(k K) V

func (ShapeMap[K, V]) Iterate 

func (m ShapeMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (ShapeMap[K, V]) Len 

func (m ShapeMap[K, V]) Len() int

func (ShapeMap[K, V]) MarshalJSON 

func (m ShapeMap[K, V]) MarshalJSON() ([]byte, error)

func (ShapeMap[K, V]) Shape 

func (m ShapeMap[K, V]) Shape() MapShape[K]

func (ShapeMap[K, V]) String 

func (m ShapeMap[K, V]) String() string

func (ShapeMap[K, V]) TryGet 

func (m ShapeMap[K, V]) TryGet(k K) (V, bool)

func (ShapeMap[K, V]) Value 

func (m ShapeMap[K, V]) Value(i int) V

func (ShapeMap[K, V]) Values 

func (m ShapeMap[K, V]) Values() []V

type SimpleBiMap 

type SimpleBiMap[K, V comparable] struct {
	Map[K, V]
	// contains filtered or unexported fields
}

func NewSimpleBiMap 

func NewSimpleBiMap[K, V comparable](it bt.Iterable[bt.Kv[K, V]]) SimpleBiMap[K, V]

func (SimpleBiMap[K, V]) Invert 

func (m SimpleBiMap[K, V]) Invert() BiMap[V, K]

func (SimpleBiMap[K, V]) MarshalJSON 

func (m SimpleBiMap[K, V]) MarshalJSON() ([]byte, error)

func (*SimpleBiMap[K, V]) UnmarshalJSON 

func (m *SimpleBiMap[K, V]) UnmarshalJSON(b []byte) error

type SliceList 

type SliceList[T any] struct {
	// contains filtered or unexported fields
}

func NewSliceList 

func NewSliceList[T any](it bt.Iterable[T]) SliceList[T]

func NewSliceListOf 

func NewSliceListOf[T any](vs ...T) SliceList[T]

func (SliceList[T]) ForEach 

func (l SliceList[T]) ForEach(fn func(v T) bool) bool

func (SliceList[T]) Get 

func (l SliceList[T]) Get(i int) T

func (SliceList[T]) Iterate 

func (l SliceList[T]) Iterate() bt.Iterator[T]

func (SliceList[T]) Len 

func (l SliceList[T]) Len() int

func (SliceList[T]) MarshalJSON 

func (l SliceList[T]) MarshalJSON() ([]byte, error)

func (*SliceList[T]) UnmarshalJSON 

func (l *SliceList[T]) UnmarshalJSON(b []byte) error

type SliceMap 

type SliceMap[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func NewSliceMap 

func NewSliceMap[K comparable, V any](it bt.Iterable[bt.Kv[K, V]]) SliceMap[K, V]

func (SliceMap[K, V]) AnyIterate 

func (m SliceMap[K, V]) AnyIterate() bt.Iterator[any]

func (SliceMap[K, V]) Contains 

func (m SliceMap[K, V]) Contains(k K) bool

func (SliceMap[K, V]) ForEach 

func (m SliceMap[K, V]) ForEach(fn func(bt.Kv[K, V]) bool) bool

func (SliceMap[K, V]) Format 

func (m SliceMap[K, V]) Format(f fmt.State, c rune)

func (SliceMap[K, V]) Get 

func (m SliceMap[K, V]) Get(k K) V

func (SliceMap[K, V]) Iterate 

func (m SliceMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (SliceMap[K, V]) IterateFrom 

func (m SliceMap[K, V]) IterateFrom(k K) bt.Iterator[bt.Kv[K, V]]

func (SliceMap[K, V]) Len 

func (m SliceMap[K, V]) Len() int

func (SliceMap[K, V]) MarshalJSON 

func (m SliceMap[K, V]) MarshalJSON() ([]byte, error)

func (SliceMap[K, V]) ReverseIterate 

func (m SliceMap[K, V]) ReverseIterate() bt.Iterator[bt.Kv[K, V]]

func (SliceMap[K, V]) ReverseIterateFrom 

func (m SliceMap[K, V]) ReverseIterateFrom(k K) bt.Iterator[bt.Kv[K, V]]

func (SliceMap[K, V]) String 

func (m SliceMap[K, V]) String() string

func (SliceMap[K, V]) TryGet 

func (m SliceMap[K, V]) TryGet(k K) (V, bool)

func (*SliceMap[K, V]) UnmarshalJSON 

func (m *SliceMap[K, V]) UnmarshalJSON(b []byte) error

type Sorted 

type Sorted[A, I any] interface {
	bt.Iterable[I]
	ReverseIterate() bt.Iterator[I]

	IterateFrom(a A) bt.Iterator[I]
	ReverseIterateFrom(a A) bt.Iterator[I]
	// contains filtered or unexported methods
}

type StdMap 

type StdMap[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func NewStdMap 

func NewStdMap[K comparable, V any](it bt.Iterable[bt.Kv[K, V]]) StdMap[K, V]

func (StdMap[K, V]) Contains 

func (m StdMap[K, V]) Contains(k K) bool

func (StdMap[K, V]) ForEach 

func (m StdMap[K, V]) ForEach(fn func(bt.Kv[K, V]) bool) bool

func (StdMap[K, V]) Get 

func (m StdMap[K, V]) Get(k K) V

func (StdMap[K, V]) Iterate 

func (m StdMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (StdMap[K, V]) Len 

func (m StdMap[K, V]) Len() int

func (StdMap[K, V]) MarshalJSON 

func (m StdMap[K, V]) MarshalJSON() ([]byte, error)

func (StdMap[K, V]) TryGet 

func (m StdMap[K, V]) TryGet(k K) (V, bool)

func (*StdMap[K, V]) UnmarshalJSON 

func (m *StdMap[K, V]) UnmarshalJSON(b []byte) error

type StdSet 

type StdSet[T comparable] struct {
	// contains filtered or unexported fields
}

func NewStdSet 

func NewStdSet[T comparable](it bt.Iterable[T]) StdSet[T]

func NewStdSetOf 

func NewStdSetOf[T comparable](vs ...T) StdSet[T]

func (StdSet[T]) Contains 

func (s StdSet[T]) Contains(t T) bool

func (StdSet[T]) ForEach 

func (s StdSet[T]) ForEach(fn func(T) bool) bool

func (StdSet[T]) Iterate 

func (s StdSet[T]) Iterate() bt.Iterator[T]

func (StdSet[T]) Len 

func (s StdSet[T]) Len() int

func (StdSet[T]) MarshalJSON 

func (s StdSet[T]) MarshalJSON() ([]byte, error)

func (*StdSet[T]) UnmarshalJSON 

func (s *StdSet[T]) UnmarshalJSON(b []byte) error

type Sync 

type Sync interface {
	// contains filtered or unexported methods
}

type SyncList 

type SyncList[T any] interface {
	List[T]
	Sync
}

type SyncMap 

type SyncMap[K, V any] interface {
	Map[K, V]
	Sync
}

type SyncMutList 

type SyncMutList[T any] interface {
	MutList[T]
	Sync
}

type SyncMutMap 

type SyncMutMap[K, V any] interface {
	MutMap[K, V]
	Sync
}

type TreapMap 

type TreapMap[K, V any] struct {
	// contains filtered or unexported fields
}

func NewTreapMap 

func NewTreapMap[K, V any](cmp treap.Comparer[K]) TreapMap[K, V]

func (TreapMap[K, V]) Contains 

func (m TreapMap[K, V]) Contains(k K) bool

func (TreapMap[K, V]) Default 

func (m TreapMap[K, V]) Default(k K, v V) PersistentMap[K, V]

func (TreapMap[K, V]) ForEach 

func (m TreapMap[K, V]) ForEach(fn func(kv bt.Kv[K, V]) bool) bool

func (TreapMap[K, V]) Get 

func (m TreapMap[K, V]) Get(k K) V

func (TreapMap[K, V]) Iterate 

func (m TreapMap[K, V]) Iterate() bt.Iterator[bt.Kv[K, V]]

func (TreapMap[K, V]) Len 

func (m TreapMap[K, V]) Len() int

func (TreapMap[K, V]) TryGet 

func (m TreapMap[K, V]) TryGet(k K) (V, bool)

func (TreapMap[K, V]) With 

func (m TreapMap[K, V]) With(k K, v V) PersistentMap[K, V]

func (TreapMap[K, V]) Without 

func (m TreapMap[K, V]) Without(k K) PersistentMap[K, V]

Source Files

View all Source files

Directories

Path Synopsis
The MIT License (MIT)
 The MIT License (MIT)
MIT License
 MIT License

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.