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
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

kit

package module

Go to main page

Versions in this module

v0

v0.9.2

Oct 4, 2025

v0.9.1

Sep 26, 2025

v0.9.0

Sep 25, 2025

Changes in this version

+ type LeakyHeap struct

+ func (this *LeakyHeap[T]) Cap() int

+ func (this *LeakyHeap[T]) Len() int

+ func (this *LeakyHeap[T]) Peek() (T, bool)

+ func (this *LeakyHeap[T]) Push(node T)

+ func (this *LeakyHeap[T]) Remove(node T)

v0.8.1

Sep 24, 2025

v0.8.0

Sep 24, 2025

Changes in this version

+ var ErrLogCorruption = errors.New("matt::kit::log: corruption")

+ var ErrLogNoData = errors.New("matt::kit::log: no data")

+ var ErrLogObsolete = errors.New("matt::kit::log: obsolete")

+ var ErrLogUnsupported = errors.New("matt::kit::log: unsupported")

+ var ErrMapNotFound = errors.New("matt::kit::map: not found")

+ var ErrRegistryNotFound = errors.New("matt::kit::registry: not found")

+ var ErrSetFull = errors.New("matt::kit::set: full")

+ var ErrSetNotFound = errors.New("matt::kit::set: not found")

+ func BoolToInt(true bool) int

+ func Close[T any](ch chan<- T)

+ func InitBiboFreelist10[T any](freelist *BiboFreelist10[T], factory func(uint) T)

+ func InitBiboFreelist11[T any](freelist *BiboFreelist11[T], factory func(uint) T)

+ func InitBiboFreelist12[T any](freelist *BiboFreelist12[T], factory func(uint) T)

+ func InitBiboFreelist13[T any](freelist *BiboFreelist13[T], factory func(uint) T)

+ func InitBiboFreelist14[T any](freelist *BiboFreelist14[T], factory func(uint) T)

+ func InitBiboFreelist15[T any](freelist *BiboFreelist15[T], factory func(uint) T)

+ func InitBiboFreelist16[T any](freelist *BiboFreelist16[T], factory func(uint) T)

+ func InitBiboFreelist17[T any](freelist *BiboFreelist17[T], factory func(uint) T)

+ func InitBiboFreelist18[T any](freelist *BiboFreelist18[T], factory func(uint) T)

+ func InitBiboFreelist19[T any](freelist *BiboFreelist19[T], factory func(uint) T)

+ func InitBiboFreelist20[T any](freelist *BiboFreelist20[T], factory func(uint) T)

+ func InitBiboFreelist21[T any](freelist *BiboFreelist21[T], factory func(uint) T)

+ func InitBiboFreelist22[T any](freelist *BiboFreelist22[T], factory func(uint) T)

+ func InitBiboFreelist23[T any](freelist *BiboFreelist23[T], factory func(uint) T)

+ func InitBiboFreelist24[T any](freelist *BiboFreelist24[T], factory func(uint) T)

+ func InitBiboFreelist25[T any](freelist *BiboFreelist25[T], factory func(uint) T)

+ func InitBiboFreelist26[T any](freelist *BiboFreelist26[T], factory func(uint) T)

+ func InitBiboFreelist27[T any](freelist *BiboFreelist27[T], factory func(uint) T)

+ func InitBiboFreelist28[T any](freelist *BiboFreelist28[T], factory func(uint) T)

+ func InitBiboFreelist29[T any](freelist *BiboFreelist29[T], factory func(uint) T)

+ func InitBiboFreelist30[T any](freelist *BiboFreelist30[T], factory func(uint) T)

+ func InitBiboFreelist31[T any](freelist *BiboFreelist31[T], factory func(uint) T)

+ func InitBiboFreelist32[T any](freelist *BiboFreelist32[T], factory func(uint) T)

+ func InitBiboFreelist33[T any](freelist *BiboFreelist33[T], factory func(uint) T)

+ func InitBiboFreelist34[T any](freelist *BiboFreelist34[T], factory func(uint) T)

+ func InitBiboFreelist7[T any](freelist *BiboFreelist7[T], factory func(uint) T)

+ func InitBiboFreelist8[T any](freelist *BiboFreelist8[T], factory func(uint) T)

+ func InitBiboFreelist9[T any](freelist *BiboFreelist9[T], factory func(uint) T)

+ func InitCoarseMap[K comparable, V any](m *CoarseMap[K, V], capacity int)

+ func InitCoarseRegistry[K comparable, V any](registry *CoarseRegistry[K, V], capacity int)

+ func InitFifoFreelist0[T any](freelist *FifoFreelist0[T], factory func(uint) T)

+ func InitFifoFreelist10[T any](freelist *FifoFreelist10[T], factory func(uint) T)

+ func InitFifoFreelist11[T any](freelist *FifoFreelist11[T], factory func(uint) T)

+ func InitFifoFreelist12[T any](freelist *FifoFreelist12[T], factory func(uint) T)

+ func InitFifoFreelist13[T any](freelist *FifoFreelist13[T], factory func(uint) T)

+ func InitFifoFreelist14[T any](freelist *FifoFreelist14[T], factory func(uint) T)

+ func InitFifoFreelist15[T any](freelist *FifoFreelist15[T], factory func(uint) T)

+ func InitFifoFreelist16[T any](freelist *FifoFreelist16[T], factory func(uint) T)

+ func InitFifoFreelist17[T any](freelist *FifoFreelist17[T], factory func(uint) T)

+ func InitFifoFreelist18[T any](freelist *FifoFreelist18[T], factory func(uint) T)

+ func InitFifoFreelist19[T any](freelist *FifoFreelist19[T], factory func(uint) T)

+ func InitFifoFreelist1[T any](freelist *FifoFreelist1[T], factory func(uint) T)

+ func InitFifoFreelist20[T any](freelist *FifoFreelist20[T], factory func(uint) T)

+ func InitFifoFreelist21[T any](freelist *FifoFreelist21[T], factory func(uint) T)

+ func InitFifoFreelist22[T any](freelist *FifoFreelist22[T], factory func(uint) T)

+ func InitFifoFreelist23[T any](freelist *FifoFreelist23[T], factory func(uint) T)

+ func InitFifoFreelist24[T any](freelist *FifoFreelist24[T], factory func(uint) T)

+ func InitFifoFreelist25[T any](freelist *FifoFreelist25[T], factory func(uint) T)

+ func InitFifoFreelist26[T any](freelist *FifoFreelist26[T], factory func(uint) T)

+ func InitFifoFreelist27[T any](freelist *FifoFreelist27[T], factory func(uint) T)

+ func InitFifoFreelist28[T any](freelist *FifoFreelist28[T], factory func(uint) T)

+ func InitFifoFreelist29[T any](freelist *FifoFreelist29[T], factory func(uint) T)

+ func InitFifoFreelist2[T any](freelist *FifoFreelist2[T], factory func(uint) T)

+ func InitFifoFreelist30[T any](freelist *FifoFreelist30[T], factory func(uint) T)

+ func InitFifoFreelist31[T any](freelist *FifoFreelist31[T], factory func(uint) T)

+ func InitFifoFreelist32[T any](freelist *FifoFreelist32[T], factory func(uint) T)

+ func InitFifoFreelist33[T any](freelist *FifoFreelist33[T], factory func(uint) T)

+ func InitFifoFreelist34[T any](freelist *FifoFreelist34[T], factory func(uint) T)

+ func InitFifoFreelist3[T any](freelist *FifoFreelist3[T], factory func(uint) T)

+ func InitFifoFreelist4[T any](freelist *FifoFreelist4[T], factory func(uint) T)

+ func InitFifoFreelist5[T any](freelist *FifoFreelist5[T], factory func(uint) T)

+ func InitFifoFreelist6[T any](freelist *FifoFreelist6[T], factory func(uint) T)

+ func InitFifoFreelist7[T any](freelist *FifoFreelist7[T], factory func(uint) T)

+ func InitFifoFreelist8[T any](freelist *FifoFreelist8[T], factory func(uint) T)

+ func InitFifoFreelist9[T any](freelist *FifoFreelist9[T], factory func(uint) T)

+ func InitLifoFreelist0[T any](freelist *LifoFreelist0[T], factory func(uint) T)

+ func InitLifoFreelist10[T any](freelist *LifoFreelist10[T], factory func(uint) T)

+ func InitLifoFreelist11[T any](freelist *LifoFreelist11[T], factory func(uint) T)

+ func InitLifoFreelist12[T any](freelist *LifoFreelist12[T], factory func(uint) T)

+ func InitLifoFreelist13[T any](freelist *LifoFreelist13[T], factory func(uint) T)

+ func InitLifoFreelist14[T any](freelist *LifoFreelist14[T], factory func(uint) T)

+ func InitLifoFreelist15[T any](freelist *LifoFreelist15[T], factory func(uint) T)

+ func InitLifoFreelist16[T any](freelist *LifoFreelist16[T], factory func(uint) T)

+ func InitLifoFreelist17[T any](freelist *LifoFreelist17[T], factory func(uint) T)

+ func InitLifoFreelist18[T any](freelist *LifoFreelist18[T], factory func(uint) T)

+ func InitLifoFreelist19[T any](freelist *LifoFreelist19[T], factory func(uint) T)

+ func InitLifoFreelist1[T any](freelist *LifoFreelist1[T], factory func(uint) T)

+ func InitLifoFreelist20[T any](freelist *LifoFreelist20[T], factory func(uint) T)

+ func InitLifoFreelist21[T any](freelist *LifoFreelist21[T], factory func(uint) T)

+ func InitLifoFreelist22[T any](freelist *LifoFreelist22[T], factory func(uint) T)

+ func InitLifoFreelist23[T any](freelist *LifoFreelist23[T], factory func(uint) T)

+ func InitLifoFreelist24[T any](freelist *LifoFreelist24[T], factory func(uint) T)

+ func InitLifoFreelist25[T any](freelist *LifoFreelist25[T], factory func(uint) T)

+ func InitLifoFreelist26[T any](freelist *LifoFreelist26[T], factory func(uint) T)

+ func InitLifoFreelist27[T any](freelist *LifoFreelist27[T], factory func(uint) T)

+ func InitLifoFreelist28[T any](freelist *LifoFreelist28[T], factory func(uint) T)

+ func InitLifoFreelist29[T any](freelist *LifoFreelist29[T], factory func(uint) T)

+ func InitLifoFreelist2[T any](freelist *LifoFreelist2[T], factory func(uint) T)

+ func InitLifoFreelist30[T any](freelist *LifoFreelist30[T], factory func(uint) T)

+ func InitLifoFreelist31[T any](freelist *LifoFreelist31[T], factory func(uint) T)

+ func InitLifoFreelist32[T any](freelist *LifoFreelist32[T], factory func(uint) T)

+ func InitLifoFreelist33[T any](freelist *LifoFreelist33[T], factory func(uint) T)

+ func InitLifoFreelist34[T any](freelist *LifoFreelist34[T], factory func(uint) T)

+ func InitLifoFreelist3[T any](freelist *LifoFreelist3[T], factory func(uint) T)

+ func InitLifoFreelist4[T any](freelist *LifoFreelist4[T], factory func(uint) T)

+ func InitLifoFreelist5[T any](freelist *LifoFreelist5[T], factory func(uint) T)

+ func InitLifoFreelist6[T any](freelist *LifoFreelist6[T], factory func(uint) T)

+ func InitLifoFreelist7[T any](freelist *LifoFreelist7[T], factory func(uint) T)

+ func InitLifoFreelist8[T any](freelist *LifoFreelist8[T], factory func(uint) T)

+ func InitLifoFreelist9[T any](freelist *LifoFreelist9[T], factory func(uint) T)

+ func InitLowfiFreelist0[T any](freelist *LowfiFreelist0[T], factory func(uint) T)

+ func InitLowfiFreelist10[T any](freelist *LowfiFreelist10[T], factory func(uint) T)

+ func InitLowfiFreelist11[T any](freelist *LowfiFreelist11[T], factory func(uint) T)

+ func InitLowfiFreelist12[T any](freelist *LowfiFreelist12[T], factory func(uint) T)

+ func InitLowfiFreelist13[T any](freelist *LowfiFreelist13[T], factory func(uint) T)

+ func InitLowfiFreelist14[T any](freelist *LowfiFreelist14[T], factory func(uint) T)

+ func InitLowfiFreelist15[T any](freelist *LowfiFreelist15[T], factory func(uint) T)

+ func InitLowfiFreelist16[T any](freelist *LowfiFreelist16[T], factory func(uint) T)

+ func InitLowfiFreelist17[T any](freelist *LowfiFreelist17[T], factory func(uint) T)

+ func InitLowfiFreelist18[T any](freelist *LowfiFreelist18[T], factory func(uint) T)

+ func InitLowfiFreelist19[T any](freelist *LowfiFreelist19[T], factory func(uint) T)

+ func InitLowfiFreelist1[T any](freelist *LowfiFreelist1[T], factory func(uint) T)

+ func InitLowfiFreelist20[T any](freelist *LowfiFreelist20[T], factory func(uint) T)

+ func InitLowfiFreelist21[T any](freelist *LowfiFreelist21[T], factory func(uint) T)

+ func InitLowfiFreelist22[T any](freelist *LowfiFreelist22[T], factory func(uint) T)

+ func InitLowfiFreelist23[T any](freelist *LowfiFreelist23[T], factory func(uint) T)

+ func InitLowfiFreelist24[T any](freelist *LowfiFreelist24[T], factory func(uint) T)

+ func InitLowfiFreelist25[T any](freelist *LowfiFreelist25[T], factory func(uint) T)

+ func InitLowfiFreelist26[T any](freelist *LowfiFreelist26[T], factory func(uint) T)

+ func InitLowfiFreelist27[T any](freelist *LowfiFreelist27[T], factory func(uint) T)

+ func InitLowfiFreelist28[T any](freelist *LowfiFreelist28[T], factory func(uint) T)

+ func InitLowfiFreelist29[T any](freelist *LowfiFreelist29[T], factory func(uint) T)

+ func InitLowfiFreelist2[T any](freelist *LowfiFreelist2[T], factory func(uint) T)

+ func InitLowfiFreelist30[T any](freelist *LowfiFreelist30[T], factory func(uint) T)

+ func InitLowfiFreelist31[T any](freelist *LowfiFreelist31[T], factory func(uint) T)

+ func InitLowfiFreelist32[T any](freelist *LowfiFreelist32[T], factory func(uint) T)

+ func InitLowfiFreelist33[T any](freelist *LowfiFreelist33[T], factory func(uint) T)

+ func InitLowfiFreelist34[T any](freelist *LowfiFreelist34[T], factory func(uint) T)

+ func InitLowfiFreelist3[T any](freelist *LowfiFreelist3[T], factory func(uint) T)

+ func InitLowfiFreelist4[T any](freelist *LowfiFreelist4[T], factory func(uint) T)

+ func InitLowfiFreelist5[T any](freelist *LowfiFreelist5[T], factory func(uint) T)

+ func InitLowfiFreelist6[T any](freelist *LowfiFreelist6[T], factory func(uint) T)

+ func InitLowfiFreelist7[T any](freelist *LowfiFreelist7[T], factory func(uint) T)

+ func InitLowfiFreelist8[T any](freelist *LowfiFreelist8[T], factory func(uint) T)

+ func InitLowfiFreelist9[T any](freelist *LowfiFreelist9[T], factory func(uint) T)

+ func NewBiboAs() bool

+ func NewFifoAs() bool

+ func NewHeapAs() bool

+ func NewHeapLowBitSet[T common.Standard[T, uint]](lowBitsUsed uint) common.Queue[T]

+ func NewLifoAs() bool

+ func NewLogAs() bool

+ func NewLog[T common.UnixTimestamped](stepWindow, retention time.Duration, capPerLinkedNode int) common.Log[T]

+ func NewLowfiAs() bool

+ func NewMapAs() bool

+ func NewRegistryAs() bool

+ func NewRingAs() bool

+ func NewSetAs() bool

+ func Pack16(low, high uint64) (array [help.SixteenInt]byte)

+ func UnixNano() int64

+ func Unpack16(array [help.SixteenInt]byte) (low, high uint64)

+ type BiboFreelist10 struct

+ func NewBiboFreelist10[T any](factory func(uint) T) *BiboFreelist10[T]

+ func (this *BiboFreelist10[T]) Cap() int

+ func (this *BiboFreelist10[T]) Get() (*T, bool)

+ func (this *BiboFreelist10[T]) Len() int

+ func (this *BiboFreelist10[T]) Release(id uint) bool

+ type BiboFreelist11 struct

+ func NewBiboFreelist11[T any](factory func(uint) T) *BiboFreelist11[T]

+ func (this *BiboFreelist11[T]) Cap() int

+ func (this *BiboFreelist11[T]) Get() (*T, bool)

+ func (this *BiboFreelist11[T]) Len() int

+ func (this *BiboFreelist11[T]) Release(id uint) bool

+ type BiboFreelist12 struct

+ func NewBiboFreelist12[T any](factory func(uint) T) *BiboFreelist12[T]

+ func (this *BiboFreelist12[T]) Cap() int

+ func (this *BiboFreelist12[T]) Get() (*T, bool)

+ func (this *BiboFreelist12[T]) Len() int

+ func (this *BiboFreelist12[T]) Release(id uint) bool

+ type BiboFreelist13 struct

+ func NewBiboFreelist13[T any](factory func(uint) T) *BiboFreelist13[T]

+ func (this *BiboFreelist13[T]) Cap() int

+ func (this *BiboFreelist13[T]) Get() (*T, bool)

+ func (this *BiboFreelist13[T]) Len() int

+ func (this *BiboFreelist13[T]) Release(id uint) bool

+ type BiboFreelist14 struct

+ func NewBiboFreelist14[T any](factory func(uint) T) *BiboFreelist14[T]

+ func (this *BiboFreelist14[T]) Cap() int

+ func (this *BiboFreelist14[T]) Get() (*T, bool)

+ func (this *BiboFreelist14[T]) Len() int

+ func (this *BiboFreelist14[T]) Release(id uint) bool

+ type BiboFreelist15 struct

+ func NewBiboFreelist15[T any](factory func(uint) T) *BiboFreelist15[T]

+ func (this *BiboFreelist15[T]) Cap() int

+ func (this *BiboFreelist15[T]) Get() (*T, bool)

+ func (this *BiboFreelist15[T]) Len() int

+ func (this *BiboFreelist15[T]) Release(id uint) bool

+ type BiboFreelist16 struct

+ func NewBiboFreelist16[T any](factory func(uint) T) *BiboFreelist16[T]

+ func (this *BiboFreelist16[T]) Cap() int

+ func (this *BiboFreelist16[T]) Get() (*T, bool)

+ func (this *BiboFreelist16[T]) Len() int

+ func (this *BiboFreelist16[T]) Release(id uint) bool

+ type BiboFreelist17 struct

+ func NewBiboFreelist17[T any](factory func(uint) T) *BiboFreelist17[T]

+ func (this *BiboFreelist17[T]) Cap() int

+ func (this *BiboFreelist17[T]) Get() (*T, bool)

+ func (this *BiboFreelist17[T]) Len() int

+ func (this *BiboFreelist17[T]) Release(id uint) bool

+ type BiboFreelist18 struct

+ func NewBiboFreelist18[T any](factory func(uint) T) *BiboFreelist18[T]

+ func (this *BiboFreelist18[T]) Cap() int

+ func (this *BiboFreelist18[T]) Get() (*T, bool)

+ func (this *BiboFreelist18[T]) Len() int

+ func (this *BiboFreelist18[T]) Release(id uint) bool

+ type BiboFreelist19 struct

+ func NewBiboFreelist19[T any](factory func(uint) T) *BiboFreelist19[T]

+ func (this *BiboFreelist19[T]) Cap() int

+ func (this *BiboFreelist19[T]) Get() (*T, bool)

+ func (this *BiboFreelist19[T]) Len() int

+ func (this *BiboFreelist19[T]) Release(id uint) bool

+ type BiboFreelist20 struct

+ func NewBiboFreelist20[T any](factory func(uint) T) *BiboFreelist20[T]

+ func (this *BiboFreelist20[T]) Cap() int

+ func (this *BiboFreelist20[T]) Get() (*T, bool)

+ func (this *BiboFreelist20[T]) Len() int

+ func (this *BiboFreelist20[T]) Release(id uint) bool

+ type BiboFreelist21 struct

+ func NewBiboFreelist21[T any](factory func(uint) T) *BiboFreelist21[T]

+ func (this *BiboFreelist21[T]) Cap() int

+ func (this *BiboFreelist21[T]) Get() (*T, bool)

+ func (this *BiboFreelist21[T]) Len() int

+ func (this *BiboFreelist21[T]) Release(id uint) bool

+ type BiboFreelist22 struct

+ func NewBiboFreelist22[T any](factory func(uint) T) *BiboFreelist22[T]

+ func (this *BiboFreelist22[T]) Cap() int

+ func (this *BiboFreelist22[T]) Get() (*T, bool)

+ func (this *BiboFreelist22[T]) Len() int

+ func (this *BiboFreelist22[T]) Release(id uint) bool

+ type BiboFreelist23 struct

+ func NewBiboFreelist23[T any](factory func(uint) T) *BiboFreelist23[T]

+ func (this *BiboFreelist23[T]) Cap() int

+ func (this *BiboFreelist23[T]) Get() (*T, bool)

+ func (this *BiboFreelist23[T]) Len() int

+ func (this *BiboFreelist23[T]) Release(id uint) bool

+ type BiboFreelist24 struct

+ func NewBiboFreelist24[T any](factory func(uint) T) *BiboFreelist24[T]

+ func (this *BiboFreelist24[T]) Cap() int

+ func (this *BiboFreelist24[T]) Get() (*T, bool)

+ func (this *BiboFreelist24[T]) Len() int

+ func (this *BiboFreelist24[T]) Release(id uint) bool

+ type BiboFreelist25 struct

+ func NewBiboFreelist25[T any](factory func(uint) T) *BiboFreelist25[T]

+ func (this *BiboFreelist25[T]) Cap() int

+ func (this *BiboFreelist25[T]) Get() (*T, bool)

+ func (this *BiboFreelist25[T]) Len() int

+ func (this *BiboFreelist25[T]) Release(id uint) bool

+ type BiboFreelist26 struct

+ func NewBiboFreelist26[T any](factory func(uint) T) *BiboFreelist26[T]

+ func (this *BiboFreelist26[T]) Cap() int

+ func (this *BiboFreelist26[T]) Get() (*T, bool)

+ func (this *BiboFreelist26[T]) Len() int

+ func (this *BiboFreelist26[T]) Release(id uint) bool

+ type BiboFreelist27 struct

+ func NewBiboFreelist27[T any](factory func(uint) T) *BiboFreelist27[T]

+ func (this *BiboFreelist27[T]) Cap() int

+ func (this *BiboFreelist27[T]) Get() (*T, bool)

+ func (this *BiboFreelist27[T]) Len() int

+ func (this *BiboFreelist27[T]) Release(id uint) bool

+ type BiboFreelist28 struct

+ func NewBiboFreelist28[T any](factory func(uint) T) *BiboFreelist28[T]

+ func (this *BiboFreelist28[T]) Cap() int

+ func (this *BiboFreelist28[T]) Get() (*T, bool)

+ func (this *BiboFreelist28[T]) Len() int

+ func (this *BiboFreelist28[T]) Release(id uint) bool

+ type BiboFreelist29 struct

+ func NewBiboFreelist29[T any](factory func(uint) T) *BiboFreelist29[T]

+ func (this *BiboFreelist29[T]) Cap() int

+ func (this *BiboFreelist29[T]) Get() (*T, bool)

+ func (this *BiboFreelist29[T]) Len() int

+ func (this *BiboFreelist29[T]) Release(id uint) bool

+ type BiboFreelist30 struct

+ func NewBiboFreelist30[T any](factory func(uint) T) *BiboFreelist30[T]

+ func (this *BiboFreelist30[T]) Cap() int

+ func (this *BiboFreelist30[T]) Get() (*T, bool)

+ func (this *BiboFreelist30[T]) Len() int

+ func (this *BiboFreelist30[T]) Release(id uint) bool

+ type BiboFreelist31 struct

+ func NewBiboFreelist31[T any](factory func(uint) T) *BiboFreelist31[T]

+ func (this *BiboFreelist31[T]) Cap() int

+ func (this *BiboFreelist31[T]) Get() (*T, bool)

+ func (this *BiboFreelist31[T]) Len() int

+ func (this *BiboFreelist31[T]) Release(id uint) bool

+ type BiboFreelist32 struct

+ func NewBiboFreelist32[T any](factory func(uint) T) *BiboFreelist32[T]

+ func (this *BiboFreelist32[T]) Cap() int

+ func (this *BiboFreelist32[T]) Get() (*T, bool)

+ func (this *BiboFreelist32[T]) Len() int

+ func (this *BiboFreelist32[T]) Release(id uint) bool

+ type BiboFreelist33 struct

+ func NewBiboFreelist33[T any](factory func(uint) T) *BiboFreelist33[T]

+ func (this *BiboFreelist33[T]) Cap() int

+ func (this *BiboFreelist33[T]) Get() (*T, bool)

+ func (this *BiboFreelist33[T]) Len() int

+ func (this *BiboFreelist33[T]) Release(id uint) bool

+ type BiboFreelist34 struct

+ func NewBiboFreelist34[T any](factory func(uint) T) *BiboFreelist34[T]

+ func (this *BiboFreelist34[T]) Cap() int

+ func (this *BiboFreelist34[T]) Get() (*T, bool)

+ func (this *BiboFreelist34[T]) Len() int

+ func (this *BiboFreelist34[T]) Release(id uint) bool

+ type BiboFreelist7 struct

+ func NewBiboFreelist7[T any](factory func(uint) T) *BiboFreelist7[T]

+ func (this *BiboFreelist7[T]) Cap() int

+ func (this *BiboFreelist7[T]) Get() (*T, bool)

+ func (this *BiboFreelist7[T]) Len() int

+ func (this *BiboFreelist7[T]) Release(id uint) bool

+ type BiboFreelist8 struct

+ func NewBiboFreelist8[T any](factory func(uint) T) *BiboFreelist8[T]

+ func (this *BiboFreelist8[T]) Cap() int

+ func (this *BiboFreelist8[T]) Get() (*T, bool)

+ func (this *BiboFreelist8[T]) Len() int

+ func (this *BiboFreelist8[T]) Release(id uint) bool

+ type BiboFreelist9 struct

+ func NewBiboFreelist9[T any](factory func(uint) T) *BiboFreelist9[T]

+ func (this *BiboFreelist9[T]) Cap() int

+ func (this *BiboFreelist9[T]) Get() (*T, bool)

+ func (this *BiboFreelist9[T]) Len() int

+ func (this *BiboFreelist9[T]) Release(id uint) bool

+ type CoarseMap struct

+ func NewCoarseMap[K comparable, V any](capacity int) *CoarseMap[K, V]

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

+ func (this *CoarseMap[K, V]) Delete(key K) error

+ func (this *CoarseMap[K, V]) ForEach(yield func(K, V) bool)

+ func (this *CoarseMap[K, V]) Get(key K) (V, error)

+ func (this *CoarseMap[K, V]) Has(key K) bool

+ func (this *CoarseMap[K, V]) Set(key K, value V) error

+ type CoarseRegistry struct

+ func NewCoarseRegistry[K comparable, V any](capacity int) *CoarseRegistry[K, V]

+ func (this *CoarseRegistry[K, V]) Claim(key K) bool

+ func (this *CoarseRegistry[K, V]) ClaimOrRegister(key K, new func() V) (V, bool)

+ func (this *CoarseRegistry[K, V]) Get(key K) (V, error)

+ func (this *CoarseRegistry[K, V]) Release(key K) bool

+ type CoarseSortedSet10 struct

+ func NewCoarseSortedSet10[T common.Comparable[T]]() *CoarseSortedSet10[T]

+ func (this *CoarseSortedSet10[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet10[T]) Delete(element T) error

+ func (this *CoarseSortedSet10[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet10[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet10[T]) Put(element T) error

+ type CoarseSortedSet11 struct

+ func NewCoarseSortedSet11[T common.Comparable[T]]() *CoarseSortedSet11[T]

+ func (this *CoarseSortedSet11[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet11[T]) Delete(element T) error

+ func (this *CoarseSortedSet11[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet11[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet11[T]) Put(element T) error

+ type CoarseSortedSet12 struct

+ func NewCoarseSortedSet12[T common.Comparable[T]]() *CoarseSortedSet12[T]

+ func (this *CoarseSortedSet12[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet12[T]) Delete(element T) error

+ func (this *CoarseSortedSet12[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet12[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet12[T]) Put(element T) error

+ type CoarseSortedSet13 struct

+ func NewCoarseSortedSet13[T common.Comparable[T]]() *CoarseSortedSet13[T]

+ func (this *CoarseSortedSet13[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet13[T]) Delete(element T) error

+ func (this *CoarseSortedSet13[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet13[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet13[T]) Put(element T) error

+ type CoarseSortedSet14 struct

+ func NewCoarseSortedSet14[T common.Comparable[T]]() *CoarseSortedSet14[T]

+ func (this *CoarseSortedSet14[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet14[T]) Delete(element T) error

+ func (this *CoarseSortedSet14[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet14[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet14[T]) Put(element T) error

+ type CoarseSortedSet15 struct

+ func NewCoarseSortedSet15[T common.Comparable[T]]() *CoarseSortedSet15[T]

+ func (this *CoarseSortedSet15[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet15[T]) Delete(element T) error

+ func (this *CoarseSortedSet15[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet15[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet15[T]) Put(element T) error

+ type CoarseSortedSet16 struct

+ func NewCoarseSortedSet16[T common.Comparable[T]]() *CoarseSortedSet16[T]

+ func (this *CoarseSortedSet16[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet16[T]) Delete(element T) error

+ func (this *CoarseSortedSet16[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet16[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet16[T]) Put(element T) error

+ type CoarseSortedSet17 struct

+ func NewCoarseSortedSet17[T common.Comparable[T]]() *CoarseSortedSet17[T]

+ func (this *CoarseSortedSet17[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet17[T]) Delete(element T) error

+ func (this *CoarseSortedSet17[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet17[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet17[T]) Put(element T) error

+ type CoarseSortedSet18 struct

+ func NewCoarseSortedSet18[T common.Comparable[T]]() *CoarseSortedSet18[T]

+ func (this *CoarseSortedSet18[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet18[T]) Delete(element T) error

+ func (this *CoarseSortedSet18[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet18[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet18[T]) Put(element T) error

+ type CoarseSortedSet19 struct

+ func NewCoarseSortedSet19[T common.Comparable[T]]() *CoarseSortedSet19[T]

+ func (this *CoarseSortedSet19[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet19[T]) Delete(element T) error

+ func (this *CoarseSortedSet19[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet19[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet19[T]) Put(element T) error

+ type CoarseSortedSet20 struct

+ func NewCoarseSortedSet20[T common.Comparable[T]]() *CoarseSortedSet20[T]

+ func (this *CoarseSortedSet20[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet20[T]) Delete(element T) error

+ func (this *CoarseSortedSet20[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet20[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet20[T]) Put(element T) error

+ type CoarseSortedSet21 struct

+ func NewCoarseSortedSet21[T common.Comparable[T]]() *CoarseSortedSet21[T]

+ func (this *CoarseSortedSet21[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet21[T]) Delete(element T) error

+ func (this *CoarseSortedSet21[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet21[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet21[T]) Put(element T) error

+ type CoarseSortedSet22 struct

+ func NewCoarseSortedSet22[T common.Comparable[T]]() *CoarseSortedSet22[T]

+ func (this *CoarseSortedSet22[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet22[T]) Delete(element T) error

+ func (this *CoarseSortedSet22[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet22[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet22[T]) Put(element T) error

+ type CoarseSortedSet23 struct

+ func NewCoarseSortedSet23[T common.Comparable[T]]() *CoarseSortedSet23[T]

+ func (this *CoarseSortedSet23[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet23[T]) Delete(element T) error

+ func (this *CoarseSortedSet23[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet23[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet23[T]) Put(element T) error

+ type CoarseSortedSet24 struct

+ func NewCoarseSortedSet24[T common.Comparable[T]]() *CoarseSortedSet24[T]

+ func (this *CoarseSortedSet24[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet24[T]) Delete(element T) error

+ func (this *CoarseSortedSet24[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet24[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet24[T]) Put(element T) error

+ type CoarseSortedSet25 struct

+ func NewCoarseSortedSet25[T common.Comparable[T]]() *CoarseSortedSet25[T]

+ func (this *CoarseSortedSet25[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet25[T]) Delete(element T) error

+ func (this *CoarseSortedSet25[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet25[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet25[T]) Put(element T) error

+ type CoarseSortedSet26 struct

+ func NewCoarseSortedSet26[T common.Comparable[T]]() *CoarseSortedSet26[T]

+ func (this *CoarseSortedSet26[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet26[T]) Delete(element T) error

+ func (this *CoarseSortedSet26[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet26[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet26[T]) Put(element T) error

+ type CoarseSortedSet27 struct

+ func NewCoarseSortedSet27[T common.Comparable[T]]() *CoarseSortedSet27[T]

+ func (this *CoarseSortedSet27[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet27[T]) Delete(element T) error

+ func (this *CoarseSortedSet27[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet27[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet27[T]) Put(element T) error

+ type CoarseSortedSet28 struct

+ func NewCoarseSortedSet28[T common.Comparable[T]]() *CoarseSortedSet28[T]

+ func (this *CoarseSortedSet28[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet28[T]) Delete(element T) error

+ func (this *CoarseSortedSet28[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet28[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet28[T]) Put(element T) error

+ type CoarseSortedSet29 struct

+ func NewCoarseSortedSet29[T common.Comparable[T]]() *CoarseSortedSet29[T]

+ func (this *CoarseSortedSet29[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet29[T]) Delete(element T) error

+ func (this *CoarseSortedSet29[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet29[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet29[T]) Put(element T) error

+ type CoarseSortedSet30 struct

+ func NewCoarseSortedSet30[T common.Comparable[T]]() *CoarseSortedSet30[T]

+ func (this *CoarseSortedSet30[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet30[T]) Delete(element T) error

+ func (this *CoarseSortedSet30[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet30[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet30[T]) Put(element T) error

+ type CoarseSortedSet31 struct

+ func NewCoarseSortedSet31[T common.Comparable[T]]() *CoarseSortedSet31[T]

+ func (this *CoarseSortedSet31[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet31[T]) Delete(element T) error

+ func (this *CoarseSortedSet31[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet31[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet31[T]) Put(element T) error

+ type CoarseSortedSet32 struct

+ func NewCoarseSortedSet32[T common.Comparable[T]]() *CoarseSortedSet32[T]

+ func (this *CoarseSortedSet32[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet32[T]) Delete(element T) error

+ func (this *CoarseSortedSet32[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet32[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet32[T]) Put(element T) error

+ type CoarseSortedSet33 struct

+ func NewCoarseSortedSet33[T common.Comparable[T]]() *CoarseSortedSet33[T]

+ func (this *CoarseSortedSet33[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet33[T]) Delete(element T) error

+ func (this *CoarseSortedSet33[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet33[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet33[T]) Put(element T) error

+ type CoarseSortedSet34 struct

+ func NewCoarseSortedSet34[T common.Comparable[T]]() *CoarseSortedSet34[T]

+ func (this *CoarseSortedSet34[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet34[T]) Delete(element T) error

+ func (this *CoarseSortedSet34[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet34[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet34[T]) Put(element T) error

+ type CoarseSortedSet7 struct

+ func NewCoarseSortedSet7[T common.Comparable[T]]() *CoarseSortedSet7[T]

+ func (this *CoarseSortedSet7[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet7[T]) Delete(element T) error

+ func (this *CoarseSortedSet7[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet7[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet7[T]) Put(element T) error

+ type CoarseSortedSet8 struct

+ func NewCoarseSortedSet8[T common.Comparable[T]]() *CoarseSortedSet8[T]

+ func (this *CoarseSortedSet8[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet8[T]) Delete(element T) error

+ func (this *CoarseSortedSet8[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet8[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet8[T]) Put(element T) error

+ type CoarseSortedSet9 struct

+ func NewCoarseSortedSet9[T common.Comparable[T]]() *CoarseSortedSet9[T]

+ func (this *CoarseSortedSet9[T]) All() iter.Seq[T]

+ func (this *CoarseSortedSet9[T]) Delete(element T) error

+ func (this *CoarseSortedSet9[T]) ForEach(yield func(T) bool)

+ func (this *CoarseSortedSet9[T]) Get(element T) (T, error)

+ func (this *CoarseSortedSet9[T]) Put(element T) error

+ type FifoFreelist0 struct

+ func NewFifoFreelist0[T any](factory func(uint) T) *FifoFreelist0[T]

+ func (this *FifoFreelist0[T]) Cap() int

+ func (this *FifoFreelist0[T]) Get() (*T, bool)

+ func (this *FifoFreelist0[T]) Len() int

+ func (this *FifoFreelist0[T]) Release(id uint) bool

+ type FifoFreelist1 struct

+ func NewFifoFreelist1[T any](factory func(uint) T) *FifoFreelist1[T]

+ func (this *FifoFreelist1[T]) Cap() int

+ func (this *FifoFreelist1[T]) Get() (*T, bool)

+ func (this *FifoFreelist1[T]) Len() int

+ func (this *FifoFreelist1[T]) Release(id uint) bool

+ type FifoFreelist10 struct

+ func NewFifoFreelist10[T any](factory func(uint) T) *FifoFreelist10[T]

+ func (this *FifoFreelist10[T]) Cap() int

+ func (this *FifoFreelist10[T]) Get() (*T, bool)

+ func (this *FifoFreelist10[T]) Len() int

+ func (this *FifoFreelist10[T]) Release(id uint) bool

+ type FifoFreelist11 struct

+ func NewFifoFreelist11[T any](factory func(uint) T) *FifoFreelist11[T]

+ func (this *FifoFreelist11[T]) Cap() int

+ func (this *FifoFreelist11[T]) Get() (*T, bool)

+ func (this *FifoFreelist11[T]) Len() int

+ func (this *FifoFreelist11[T]) Release(id uint) bool

+ type FifoFreelist12 struct

+ func NewFifoFreelist12[T any](factory func(uint) T) *FifoFreelist12[T]

+ func (this *FifoFreelist12[T]) Cap() int

+ func (this *FifoFreelist12[T]) Get() (*T, bool)

+ func (this *FifoFreelist12[T]) Len() int

+ func (this *FifoFreelist12[T]) Release(id uint) bool

+ type FifoFreelist13 struct

+ func NewFifoFreelist13[T any](factory func(uint) T) *FifoFreelist13[T]

+ func (this *FifoFreelist13[T]) Cap() int

+ func (this *FifoFreelist13[T]) Get() (*T, bool)

+ func (this *FifoFreelist13[T]) Len() int

+ func (this *FifoFreelist13[T]) Release(id uint) bool

+ type FifoFreelist14 struct

+ func NewFifoFreelist14[T any](factory func(uint) T) *FifoFreelist14[T]

+ func (this *FifoFreelist14[T]) Cap() int

+ func (this *FifoFreelist14[T]) Get() (*T, bool)

+ func (this *FifoFreelist14[T]) Len() int

+ func (this *FifoFreelist14[T]) Release(id uint) bool

+ type FifoFreelist15 struct

+ func NewFifoFreelist15[T any](factory func(uint) T) *FifoFreelist15[T]

+ func (this *FifoFreelist15[T]) Cap() int

+ func (this *FifoFreelist15[T]) Get() (*T, bool)

+ func (this *FifoFreelist15[T]) Len() int

+ func (this *FifoFreelist15[T]) Release(id uint) bool

+ type FifoFreelist16 struct

+ func NewFifoFreelist16[T any](factory func(uint) T) *FifoFreelist16[T]

+ func (this *FifoFreelist16[T]) Cap() int

+ func (this *FifoFreelist16[T]) Get() (*T, bool)

+ func (this *FifoFreelist16[T]) Len() int

+ func (this *FifoFreelist16[T]) Release(id uint) bool

+ type FifoFreelist17 struct

+ func NewFifoFreelist17[T any](factory func(uint) T) *FifoFreelist17[T]

+ func (this *FifoFreelist17[T]) Cap() int

+ func (this *FifoFreelist17[T]) Get() (*T, bool)

+ func (this *FifoFreelist17[T]) Len() int

+ func (this *FifoFreelist17[T]) Release(id uint) bool

+ type FifoFreelist18 struct

+ func NewFifoFreelist18[T any](factory func(uint) T) *FifoFreelist18[T]

+ func (this *FifoFreelist18[T]) Cap() int

+ func (this *FifoFreelist18[T]) Get() (*T, bool)

+ func (this *FifoFreelist18[T]) Len() int

+ func (this *FifoFreelist18[T]) Release(id uint) bool

+ type FifoFreelist19 struct

+ func NewFifoFreelist19[T any](factory func(uint) T) *FifoFreelist19[T]

+ func (this *FifoFreelist19[T]) Cap() int

+ func (this *FifoFreelist19[T]) Get() (*T, bool)

+ func (this *FifoFreelist19[T]) Len() int

+ func (this *FifoFreelist19[T]) Release(id uint) bool

+ type FifoFreelist2 struct

+ func NewFifoFreelist2[T any](factory func(uint) T) *FifoFreelist2[T]

+ func (this *FifoFreelist2[T]) Cap() int

+ func (this *FifoFreelist2[T]) Get() (*T, bool)

+ func (this *FifoFreelist2[T]) Len() int

+ func (this *FifoFreelist2[T]) Release(id uint) bool

+ type FifoFreelist20 struct

+ func NewFifoFreelist20[T any](factory func(uint) T) *FifoFreelist20[T]

+ func (this *FifoFreelist20[T]) Cap() int

+ func (this *FifoFreelist20[T]) Get() (*T, bool)

+ func (this *FifoFreelist20[T]) Len() int

+ func (this *FifoFreelist20[T]) Release(id uint) bool

+ type FifoFreelist21 struct

+ func NewFifoFreelist21[T any](factory func(uint) T) *FifoFreelist21[T]

+ func (this *FifoFreelist21[T]) Cap() int

+ func (this *FifoFreelist21[T]) Get() (*T, bool)

+ func (this *FifoFreelist21[T]) Len() int

+ func (this *FifoFreelist21[T]) Release(id uint) bool

+ type FifoFreelist22 struct

+ func NewFifoFreelist22[T any](factory func(uint) T) *FifoFreelist22[T]

+ func (this *FifoFreelist22[T]) Cap() int

+ func (this *FifoFreelist22[T]) Get() (*T, bool)

+ func (this *FifoFreelist22[T]) Len() int

+ func (this *FifoFreelist22[T]) Release(id uint) bool

+ type FifoFreelist23 struct

+ func NewFifoFreelist23[T any](factory func(uint) T) *FifoFreelist23[T]

+ func (this *FifoFreelist23[T]) Cap() int

+ func (this *FifoFreelist23[T]) Get() (*T, bool)

+ func (this *FifoFreelist23[T]) Len() int

+ func (this *FifoFreelist23[T]) Release(id uint) bool

+ type FifoFreelist24 struct

+ func NewFifoFreelist24[T any](factory func(uint) T) *FifoFreelist24[T]

+ func (this *FifoFreelist24[T]) Cap() int

+ func (this *FifoFreelist24[T]) Get() (*T, bool)

+ func (this *FifoFreelist24[T]) Len() int

+ func (this *FifoFreelist24[T]) Release(id uint) bool

+ type FifoFreelist25 struct

+ func NewFifoFreelist25[T any](factory func(uint) T) *FifoFreelist25[T]

+ func (this *FifoFreelist25[T]) Cap() int

+ func (this *FifoFreelist25[T]) Get() (*T, bool)

+ func (this *FifoFreelist25[T]) Len() int

+ func (this *FifoFreelist25[T]) Release(id uint) bool

+ type FifoFreelist26 struct

+ func NewFifoFreelist26[T any](factory func(uint) T) *FifoFreelist26[T]

+ func (this *FifoFreelist26[T]) Cap() int

+ func (this *FifoFreelist26[T]) Get() (*T, bool)

+ func (this *FifoFreelist26[T]) Len() int

+ func (this *FifoFreelist26[T]) Release(id uint) bool

+ type FifoFreelist27 struct

+ func NewFifoFreelist27[T any](factory func(uint) T) *FifoFreelist27[T]

+ func (this *FifoFreelist27[T]) Cap() int

+ func (this *FifoFreelist27[T]) Get() (*T, bool)

+ func (this *FifoFreelist27[T]) Len() int

+ func (this *FifoFreelist27[T]) Release(id uint) bool

+ type FifoFreelist28 struct

+ func NewFifoFreelist28[T any](factory func(uint) T) *FifoFreelist28[T]

+ func (this *FifoFreelist28[T]) Cap() int

+ func (this *FifoFreelist28[T]) Get() (*T, bool)

+ func (this *FifoFreelist28[T]) Len() int

+ func (this *FifoFreelist28[T]) Release(id uint) bool

+ type FifoFreelist29 struct

+ func NewFifoFreelist29[T any](factory func(uint) T) *FifoFreelist29[T]

+ func (this *FifoFreelist29[T]) Cap() int

+ func (this *FifoFreelist29[T]) Get() (*T, bool)

+ func (this *FifoFreelist29[T]) Len() int

+ func (this *FifoFreelist29[T]) Release(id uint) bool

+ type FifoFreelist3 struct

+ func NewFifoFreelist3[T any](factory func(uint) T) *FifoFreelist3[T]

+ func (this *FifoFreelist3[T]) Cap() int

+ func (this *FifoFreelist3[T]) Get() (*T, bool)

+ func (this *FifoFreelist3[T]) Len() int

+ func (this *FifoFreelist3[T]) Release(id uint) bool

+ type FifoFreelist30 struct

+ func NewFifoFreelist30[T any](factory func(uint) T) *FifoFreelist30[T]

+ func (this *FifoFreelist30[T]) Cap() int

+ func (this *FifoFreelist30[T]) Get() (*T, bool)

+ func (this *FifoFreelist30[T]) Len() int

+ func (this *FifoFreelist30[T]) Release(id uint) bool

+ type FifoFreelist31 struct

+ func NewFifoFreelist31[T any](factory func(uint) T) *FifoFreelist31[T]

+ func (this *FifoFreelist31[T]) Cap() int

+ func (this *FifoFreelist31[T]) Get() (*T, bool)

+ func (this *FifoFreelist31[T]) Len() int

+ func (this *FifoFreelist31[T]) Release(id uint) bool

+ type FifoFreelist32 struct

+ func NewFifoFreelist32[T any](factory func(uint) T) *FifoFreelist32[T]

+ func (this *FifoFreelist32[T]) Cap() int

+ func (this *FifoFreelist32[T]) Get() (*T, bool)

+ func (this *FifoFreelist32[T]) Len() int

+ func (this *FifoFreelist32[T]) Release(id uint) bool

+ type FifoFreelist33 struct

+ func NewFifoFreelist33[T any](factory func(uint) T) *FifoFreelist33[T]

+ func (this *FifoFreelist33[T]) Cap() int

+ func (this *FifoFreelist33[T]) Get() (*T, bool)

+ func (this *FifoFreelist33[T]) Len() int

+ func (this *FifoFreelist33[T]) Release(id uint) bool

+ type FifoFreelist34 struct

+ func NewFifoFreelist34[T any](factory func(uint) T) *FifoFreelist34[T]

+ func (this *FifoFreelist34[T]) Cap() int

+ func (this *FifoFreelist34[T]) Get() (*T, bool)

+ func (this *FifoFreelist34[T]) Len() int

+ func (this *FifoFreelist34[T]) Release(id uint) bool

+ type FifoFreelist4 struct

+ func NewFifoFreelist4[T any](factory func(uint) T) *FifoFreelist4[T]

+ func (this *FifoFreelist4[T]) Cap() int

+ func (this *FifoFreelist4[T]) Get() (*T, bool)

+ func (this *FifoFreelist4[T]) Len() int

+ func (this *FifoFreelist4[T]) Release(id uint) bool

+ type FifoFreelist5 struct

+ func NewFifoFreelist5[T any](factory func(uint) T) *FifoFreelist5[T]

+ func (this *FifoFreelist5[T]) Cap() int

+ func (this *FifoFreelist5[T]) Get() (*T, bool)

+ func (this *FifoFreelist5[T]) Len() int

+ func (this *FifoFreelist5[T]) Release(id uint) bool

+ type FifoFreelist6 struct

+ func NewFifoFreelist6[T any](factory func(uint) T) *FifoFreelist6[T]

+ func (this *FifoFreelist6[T]) Cap() int

+ func (this *FifoFreelist6[T]) Get() (*T, bool)

+ func (this *FifoFreelist6[T]) Len() int

+ func (this *FifoFreelist6[T]) Release(id uint) bool

+ type FifoFreelist7 struct

+ func NewFifoFreelist7[T any](factory func(uint) T) *FifoFreelist7[T]

+ func (this *FifoFreelist7[T]) Cap() int

+ func (this *FifoFreelist7[T]) Get() (*T, bool)

+ func (this *FifoFreelist7[T]) Len() int

+ func (this *FifoFreelist7[T]) Release(id uint) bool

+ type FifoFreelist8 struct

+ func NewFifoFreelist8[T any](factory func(uint) T) *FifoFreelist8[T]

+ func (this *FifoFreelist8[T]) Cap() int

+ func (this *FifoFreelist8[T]) Get() (*T, bool)

+ func (this *FifoFreelist8[T]) Len() int

+ func (this *FifoFreelist8[T]) Release(id uint) bool

+ type FifoFreelist9 struct

+ func NewFifoFreelist9[T any](factory func(uint) T) *FifoFreelist9[T]

+ func (this *FifoFreelist9[T]) Cap() int

+ func (this *FifoFreelist9[T]) Get() (*T, bool)

+ func (this *FifoFreelist9[T]) Len() int

+ func (this *FifoFreelist9[T]) Release(id uint) bool

+ type LifoFreelist0 struct

+ func NewLifoFreelist0[T any](factory func(uint) T) *LifoFreelist0[T]

+ func (this *LifoFreelist0[T]) Cap() int

+ func (this *LifoFreelist0[T]) Get() (*T, bool)

+ func (this *LifoFreelist0[T]) Len() int

+ func (this *LifoFreelist0[T]) Release(id uint) bool

+ type LifoFreelist1 struct

+ func NewLifoFreelist1[T any](factory func(uint) T) *LifoFreelist1[T]

+ func (this *LifoFreelist1[T]) Cap() int

+ func (this *LifoFreelist1[T]) Get() (*T, bool)

+ func (this *LifoFreelist1[T]) Len() int

+ func (this *LifoFreelist1[T]) Release(id uint) bool

+ type LifoFreelist10 struct

+ func NewLifoFreelist10[T any](factory func(uint) T) *LifoFreelist10[T]

+ func (this *LifoFreelist10[T]) Cap() int

+ func (this *LifoFreelist10[T]) Get() (*T, bool)

+ func (this *LifoFreelist10[T]) Len() int

+ func (this *LifoFreelist10[T]) Release(id uint) bool

+ type LifoFreelist11 struct

+ func NewLifoFreelist11[T any](factory func(uint) T) *LifoFreelist11[T]

+ func (this *LifoFreelist11[T]) Cap() int

+ func (this *LifoFreelist11[T]) Get() (*T, bool)

+ func (this *LifoFreelist11[T]) Len() int

+ func (this *LifoFreelist11[T]) Release(id uint) bool

+ type LifoFreelist12 struct

+ func NewLifoFreelist12[T any](factory func(uint) T) *LifoFreelist12[T]

+ func (this *LifoFreelist12[T]) Cap() int

+ func (this *LifoFreelist12[T]) Get() (*T, bool)

+ func (this *LifoFreelist12[T]) Len() int

+ func (this *LifoFreelist12[T]) Release(id uint) bool

+ type LifoFreelist13 struct

+ func NewLifoFreelist13[T any](factory func(uint) T) *LifoFreelist13[T]

+ func (this *LifoFreelist13[T]) Cap() int

+ func (this *LifoFreelist13[T]) Get() (*T, bool)

+ func (this *LifoFreelist13[T]) Len() int

+ func (this *LifoFreelist13[T]) Release(id uint) bool

+ type LifoFreelist14 struct

+ func NewLifoFreelist14[T any](factory func(uint) T) *LifoFreelist14[T]

+ func (this *LifoFreelist14[T]) Cap() int

+ func (this *LifoFreelist14[T]) Get() (*T, bool)

+ func (this *LifoFreelist14[T]) Len() int

+ func (this *LifoFreelist14[T]) Release(id uint) bool

+ type LifoFreelist15 struct

+ func NewLifoFreelist15[T any](factory func(uint) T) *LifoFreelist15[T]

+ func (this *LifoFreelist15[T]) Cap() int

+ func (this *LifoFreelist15[T]) Get() (*T, bool)

+ func (this *LifoFreelist15[T]) Len() int

+ func (this *LifoFreelist15[T]) Release(id uint) bool

+ type LifoFreelist16 struct

+ func NewLifoFreelist16[T any](factory func(uint) T) *LifoFreelist16[T]

+ func (this *LifoFreelist16[T]) Cap() int

+ func (this *LifoFreelist16[T]) Get() (*T, bool)

+ func (this *LifoFreelist16[T]) Len() int

+ func (this *LifoFreelist16[T]) Release(id uint) bool

+ type LifoFreelist17 struct

+ func NewLifoFreelist17[T any](factory func(uint) T) *LifoFreelist17[T]

+ func (this *LifoFreelist17[T]) Cap() int

+ func (this *LifoFreelist17[T]) Get() (*T, bool)

+ func (this *LifoFreelist17[T]) Len() int

+ func (this *LifoFreelist17[T]) Release(id uint) bool

+ type LifoFreelist18 struct

+ func NewLifoFreelist18[T any](factory func(uint) T) *LifoFreelist18[T]

+ func (this *LifoFreelist18[T]) Cap() int

+ func (this *LifoFreelist18[T]) Get() (*T, bool)

+ func (this *LifoFreelist18[T]) Len() int

+ func (this *LifoFreelist18[T]) Release(id uint) bool

+ type LifoFreelist19 struct

+ func NewLifoFreelist19[T any](factory func(uint) T) *LifoFreelist19[T]

+ func (this *LifoFreelist19[T]) Cap() int

+ func (this *LifoFreelist19[T]) Get() (*T, bool)

+ func (this *LifoFreelist19[T]) Len() int

+ func (this *LifoFreelist19[T]) Release(id uint) bool

+ type LifoFreelist2 struct

+ func NewLifoFreelist2[T any](factory func(uint) T) *LifoFreelist2[T]

+ func (this *LifoFreelist2[T]) Cap() int

+ func (this *LifoFreelist2[T]) Get() (*T, bool)

+ func (this *LifoFreelist2[T]) Len() int

+ func (this *LifoFreelist2[T]) Release(id uint) bool

+ type LifoFreelist20 struct

+ func NewLifoFreelist20[T any](factory func(uint) T) *LifoFreelist20[T]

+ func (this *LifoFreelist20[T]) Cap() int

+ func (this *LifoFreelist20[T]) Get() (*T, bool)

+ func (this *LifoFreelist20[T]) Len() int

+ func (this *LifoFreelist20[T]) Release(id uint) bool

+ type LifoFreelist21 struct

+ func NewLifoFreelist21[T any](factory func(uint) T) *LifoFreelist21[T]

+ func (this *LifoFreelist21[T]) Cap() int

+ func (this *LifoFreelist21[T]) Get() (*T, bool)

+ func (this *LifoFreelist21[T]) Len() int

+ func (this *LifoFreelist21[T]) Release(id uint) bool

+ type LifoFreelist22 struct

+ func NewLifoFreelist22[T any](factory func(uint) T) *LifoFreelist22[T]

+ func (this *LifoFreelist22[T]) Cap() int

+ func (this *LifoFreelist22[T]) Get() (*T, bool)

+ func (this *LifoFreelist22[T]) Len() int

+ func (this *LifoFreelist22[T]) Release(id uint) bool

+ type LifoFreelist23 struct

+ func NewLifoFreelist23[T any](factory func(uint) T) *LifoFreelist23[T]

+ func (this *LifoFreelist23[T]) Cap() int

+ func (this *LifoFreelist23[T]) Get() (*T, bool)

+ func (this *LifoFreelist23[T]) Len() int

+ func (this *LifoFreelist23[T]) Release(id uint) bool

+ type LifoFreelist24 struct

+ func NewLifoFreelist24[T any](factory func(uint) T) *LifoFreelist24[T]

+ func (this *LifoFreelist24[T]) Cap() int

+ func (this *LifoFreelist24[T]) Get() (*T, bool)

+ func (this *LifoFreelist24[T]) Len() int

+ func (this *LifoFreelist24[T]) Release(id uint) bool

+ type LifoFreelist25 struct

+ func NewLifoFreelist25[T any](factory func(uint) T) *LifoFreelist25[T]

+ func (this *LifoFreelist25[T]) Cap() int

+ func (this *LifoFreelist25[T]) Get() (*T, bool)

+ func (this *LifoFreelist25[T]) Len() int

+ func (this *LifoFreelist25[T]) Release(id uint) bool

+ type LifoFreelist26 struct

+ func NewLifoFreelist26[T any](factory func(uint) T) *LifoFreelist26[T]

+ func (this *LifoFreelist26[T]) Cap() int

+ func (this *LifoFreelist26[T]) Get() (*T, bool)

+ func (this *LifoFreelist26[T]) Len() int

+ func (this *LifoFreelist26[T]) Release(id uint) bool

+ type LifoFreelist27 struct

+ func NewLifoFreelist27[T any](factory func(uint) T) *LifoFreelist27[T]

+ func (this *LifoFreelist27[T]) Cap() int

+ func (this *LifoFreelist27[T]) Get() (*T, bool)

+ func (this *LifoFreelist27[T]) Len() int

+ func (this *LifoFreelist27[T]) Release(id uint) bool

+ type LifoFreelist28 struct

+ func NewLifoFreelist28[T any](factory func(uint) T) *LifoFreelist28[T]

+ func (this *LifoFreelist28[T]) Cap() int

+ func (this *LifoFreelist28[T]) Get() (*T, bool)

+ func (this *LifoFreelist28[T]) Len() int

+ func (this *LifoFreelist28[T]) Release(id uint) bool

+ type LifoFreelist29 struct

+ func NewLifoFreelist29[T any](factory func(uint) T) *LifoFreelist29[T]

+ func (this *LifoFreelist29[T]) Cap() int

+ func (this *LifoFreelist29[T]) Get() (*T, bool)

+ func (this *LifoFreelist29[T]) Len() int

+ func (this *LifoFreelist29[T]) Release(id uint) bool

+ type LifoFreelist3 struct

+ func NewLifoFreelist3[T any](factory func(uint) T) *LifoFreelist3[T]

+ func (this *LifoFreelist3[T]) Cap() int

+ func (this *LifoFreelist3[T]) Get() (*T, bool)

+ func (this *LifoFreelist3[T]) Len() int

+ func (this *LifoFreelist3[T]) Release(id uint) bool

+ type LifoFreelist30 struct

+ func NewLifoFreelist30[T any](factory func(uint) T) *LifoFreelist30[T]

+ func (this *LifoFreelist30[T]) Cap() int

+ func (this *LifoFreelist30[T]) Get() (*T, bool)

+ func (this *LifoFreelist30[T]) Len() int

+ func (this *LifoFreelist30[T]) Release(id uint) bool

+ type LifoFreelist31 struct

+ func NewLifoFreelist31[T any](factory func(uint) T) *LifoFreelist31[T]

+ func (this *LifoFreelist31[T]) Cap() int

+ func (this *LifoFreelist31[T]) Get() (*T, bool)

+ func (this *LifoFreelist31[T]) Len() int

+ func (this *LifoFreelist31[T]) Release(id uint) bool

+ type LifoFreelist32 struct

+ func NewLifoFreelist32[T any](factory func(uint) T) *LifoFreelist32[T]

+ func (this *LifoFreelist32[T]) Cap() int

+ func (this *LifoFreelist32[T]) Get() (*T, bool)

+ func (this *LifoFreelist32[T]) Len() int

+ func (this *LifoFreelist32[T]) Release(id uint) bool

+ type LifoFreelist33 struct

+ func NewLifoFreelist33[T any](factory func(uint) T) *LifoFreelist33[T]

+ func (this *LifoFreelist33[T]) Cap() int

+ func (this *LifoFreelist33[T]) Get() (*T, bool)

+ func (this *LifoFreelist33[T]) Len() int

+ func (this *LifoFreelist33[T]) Release(id uint) bool

+ type LifoFreelist34 struct

+ func NewLifoFreelist34[T any](factory func(uint) T) *LifoFreelist34[T]

+ func (this *LifoFreelist34[T]) Cap() int

+ func (this *LifoFreelist34[T]) Get() (*T, bool)

+ func (this *LifoFreelist34[T]) Len() int

+ func (this *LifoFreelist34[T]) Release(id uint) bool

+ type LifoFreelist4 struct

+ func NewLifoFreelist4[T any](factory func(uint) T) *LifoFreelist4[T]

+ func (this *LifoFreelist4[T]) Cap() int

+ func (this *LifoFreelist4[T]) Get() (*T, bool)

+ func (this *LifoFreelist4[T]) Len() int

+ func (this *LifoFreelist4[T]) Release(id uint) bool

+ type LifoFreelist5 struct

+ func NewLifoFreelist5[T any](factory func(uint) T) *LifoFreelist5[T]

+ func (this *LifoFreelist5[T]) Cap() int

+ func (this *LifoFreelist5[T]) Get() (*T, bool)

+ func (this *LifoFreelist5[T]) Len() int

+ func (this *LifoFreelist5[T]) Release(id uint) bool

+ type LifoFreelist6 struct

+ func NewLifoFreelist6[T any](factory func(uint) T) *LifoFreelist6[T]

+ func (this *LifoFreelist6[T]) Cap() int

+ func (this *LifoFreelist6[T]) Get() (*T, bool)

+ func (this *LifoFreelist6[T]) Len() int

+ func (this *LifoFreelist6[T]) Release(id uint) bool

+ type LifoFreelist7 struct

+ func NewLifoFreelist7[T any](factory func(uint) T) *LifoFreelist7[T]

+ func (this *LifoFreelist7[T]) Cap() int

+ func (this *LifoFreelist7[T]) Get() (*T, bool)

+ func (this *LifoFreelist7[T]) Len() int

+ func (this *LifoFreelist7[T]) Release(id uint) bool

+ type LifoFreelist8 struct

+ func NewLifoFreelist8[T any](factory func(uint) T) *LifoFreelist8[T]

+ func (this *LifoFreelist8[T]) Cap() int

+ func (this *LifoFreelist8[T]) Get() (*T, bool)

+ func (this *LifoFreelist8[T]) Len() int

+ func (this *LifoFreelist8[T]) Release(id uint) bool

+ type LifoFreelist9 struct

+ func NewLifoFreelist9[T any](factory func(uint) T) *LifoFreelist9[T]

+ func (this *LifoFreelist9[T]) Cap() int

+ func (this *LifoFreelist9[T]) Get() (*T, bool)

+ func (this *LifoFreelist9[T]) Len() int

+ func (this *LifoFreelist9[T]) Release(id uint) bool

+ type LowfiFreelist0 struct

+ func NewLowfiFreelist0[T any](factory func(uint) T) *LowfiFreelist0[T]

+ func (this *LowfiFreelist0[T]) Cap() int

+ func (this *LowfiFreelist0[T]) Get() (*T, bool)

+ func (this *LowfiFreelist0[T]) Len() int

+ func (this *LowfiFreelist0[T]) Release(id uint) bool

+ type LowfiFreelist1 struct

+ func NewLowfiFreelist1[T any](factory func(uint) T) *LowfiFreelist1[T]

+ func (this *LowfiFreelist1[T]) Cap() int

+ func (this *LowfiFreelist1[T]) Get() (*T, bool)

+ func (this *LowfiFreelist1[T]) Len() int

+ func (this *LowfiFreelist1[T]) Release(id uint) bool

+ type LowfiFreelist10 struct

+ func NewLowfiFreelist10[T any](factory func(uint) T) *LowfiFreelist10[T]

+ func (this *LowfiFreelist10[T]) Cap() int

+ func (this *LowfiFreelist10[T]) Get() (*T, bool)

+ func (this *LowfiFreelist10[T]) Len() int

+ func (this *LowfiFreelist10[T]) Release(id uint) bool

+ type LowfiFreelist11 struct

+ func NewLowfiFreelist11[T any](factory func(uint) T) *LowfiFreelist11[T]

+ func (this *LowfiFreelist11[T]) Cap() int

+ func (this *LowfiFreelist11[T]) Get() (*T, bool)

+ func (this *LowfiFreelist11[T]) Len() int

+ func (this *LowfiFreelist11[T]) Release(id uint) bool

+ type LowfiFreelist12 struct

+ func NewLowfiFreelist12[T any](factory func(uint) T) *LowfiFreelist12[T]

+ func (this *LowfiFreelist12[T]) Cap() int

+ func (this *LowfiFreelist12[T]) Get() (*T, bool)

+ func (this *LowfiFreelist12[T]) Len() int

+ func (this *LowfiFreelist12[T]) Release(id uint) bool

+ type LowfiFreelist13 struct

+ func NewLowfiFreelist13[T any](factory func(uint) T) *LowfiFreelist13[T]

+ func (this *LowfiFreelist13[T]) Cap() int

+ func (this *LowfiFreelist13[T]) Get() (*T, bool)

+ func (this *LowfiFreelist13[T]) Len() int

+ func (this *LowfiFreelist13[T]) Release(id uint) bool

+ type LowfiFreelist14 struct

+ func NewLowfiFreelist14[T any](factory func(uint) T) *LowfiFreelist14[T]

+ func (this *LowfiFreelist14[T]) Cap() int

+ func (this *LowfiFreelist14[T]) Get() (*T, bool)

+ func (this *LowfiFreelist14[T]) Len() int

+ func (this *LowfiFreelist14[T]) Release(id uint) bool

+ type LowfiFreelist15 struct

+ func NewLowfiFreelist15[T any](factory func(uint) T) *LowfiFreelist15[T]

+ func (this *LowfiFreelist15[T]) Cap() int

+ func (this *LowfiFreelist15[T]) Get() (*T, bool)

+ func (this *LowfiFreelist15[T]) Len() int

+ func (this *LowfiFreelist15[T]) Release(id uint) bool

+ type LowfiFreelist16 struct

+ func NewLowfiFreelist16[T any](factory func(uint) T) *LowfiFreelist16[T]

+ func (this *LowfiFreelist16[T]) Cap() int

+ func (this *LowfiFreelist16[T]) Get() (*T, bool)

+ func (this *LowfiFreelist16[T]) Len() int

+ func (this *LowfiFreelist16[T]) Release(id uint) bool

+ type LowfiFreelist17 struct

+ func NewLowfiFreelist17[T any](factory func(uint) T) *LowfiFreelist17[T]

+ func (this *LowfiFreelist17[T]) Cap() int

+ func (this *LowfiFreelist17[T]) Get() (*T, bool)

+ func (this *LowfiFreelist17[T]) Len() int

+ func (this *LowfiFreelist17[T]) Release(id uint) bool

+ type LowfiFreelist18 struct

+ func NewLowfiFreelist18[T any](factory func(uint) T) *LowfiFreelist18[T]

+ func (this *LowfiFreelist18[T]) Cap() int

+ func (this *LowfiFreelist18[T]) Get() (*T, bool)

+ func (this *LowfiFreelist18[T]) Len() int

+ func (this *LowfiFreelist18[T]) Release(id uint) bool

+ type LowfiFreelist19 struct

+ func NewLowfiFreelist19[T any](factory func(uint) T) *LowfiFreelist19[T]

+ func (this *LowfiFreelist19[T]) Cap() int

+ func (this *LowfiFreelist19[T]) Get() (*T, bool)

+ func (this *LowfiFreelist19[T]) Len() int

+ func (this *LowfiFreelist19[T]) Release(id uint) bool

+ type LowfiFreelist2 struct

+ func NewLowfiFreelist2[T any](factory func(uint) T) *LowfiFreelist2[T]

+ func (this *LowfiFreelist2[T]) Cap() int

+ func (this *LowfiFreelist2[T]) Get() (*T, bool)

+ func (this *LowfiFreelist2[T]) Len() int

+ func (this *LowfiFreelist2[T]) Release(id uint) bool

+ type LowfiFreelist20 struct

+ func NewLowfiFreelist20[T any](factory func(uint) T) *LowfiFreelist20[T]

+ func (this *LowfiFreelist20[T]) Cap() int

+ func (this *LowfiFreelist20[T]) Get() (*T, bool)

+ func (this *LowfiFreelist20[T]) Len() int

+ func (this *LowfiFreelist20[T]) Release(id uint) bool

+ type LowfiFreelist21 struct

+ func NewLowfiFreelist21[T any](factory func(uint) T) *LowfiFreelist21[T]

+ func (this *LowfiFreelist21[T]) Cap() int

+ func (this *LowfiFreelist21[T]) Get() (*T, bool)

+ func (this *LowfiFreelist21[T]) Len() int

+ func (this *LowfiFreelist21[T]) Release(id uint) bool

+ type LowfiFreelist22 struct

+ func NewLowfiFreelist22[T any](factory func(uint) T) *LowfiFreelist22[T]

+ func (this *LowfiFreelist22[T]) Cap() int

+ func (this *LowfiFreelist22[T]) Get() (*T, bool)

+ func (this *LowfiFreelist22[T]) Len() int

+ func (this *LowfiFreelist22[T]) Release(id uint) bool

+ type LowfiFreelist23 struct

+ func NewLowfiFreelist23[T any](factory func(uint) T) *LowfiFreelist23[T]

+ func (this *LowfiFreelist23[T]) Cap() int

+ func (this *LowfiFreelist23[T]) Get() (*T, bool)

+ func (this *LowfiFreelist23[T]) Len() int

+ func (this *LowfiFreelist23[T]) Release(id uint) bool

+ type LowfiFreelist24 struct

+ func NewLowfiFreelist24[T any](factory func(uint) T) *LowfiFreelist24[T]

+ func (this *LowfiFreelist24[T]) Cap() int

+ func (this *LowfiFreelist24[T]) Get() (*T, bool)

+ func (this *LowfiFreelist24[T]) Len() int

+ func (this *LowfiFreelist24[T]) Release(id uint) bool

+ type LowfiFreelist25 struct

+ func NewLowfiFreelist25[T any](factory func(uint) T) *LowfiFreelist25[T]

+ func (this *LowfiFreelist25[T]) Cap() int

+ func (this *LowfiFreelist25[T]) Get() (*T, bool)

+ func (this *LowfiFreelist25[T]) Len() int

+ func (this *LowfiFreelist25[T]) Release(id uint) bool

+ type LowfiFreelist26 struct

+ func NewLowfiFreelist26[T any](factory func(uint) T) *LowfiFreelist26[T]

+ func (this *LowfiFreelist26[T]) Cap() int

+ func (this *LowfiFreelist26[T]) Get() (*T, bool)

+ func (this *LowfiFreelist26[T]) Len() int

+ func (this *LowfiFreelist26[T]) Release(id uint) bool

+ type LowfiFreelist27 struct

+ func NewLowfiFreelist27[T any](factory func(uint) T) *LowfiFreelist27[T]

+ func (this *LowfiFreelist27[T]) Cap() int

+ func (this *LowfiFreelist27[T]) Get() (*T, bool)

+ func (this *LowfiFreelist27[T]) Len() int

+ func (this *LowfiFreelist27[T]) Release(id uint) bool

+ type LowfiFreelist28 struct

+ func NewLowfiFreelist28[T any](factory func(uint) T) *LowfiFreelist28[T]

+ func (this *LowfiFreelist28[T]) Cap() int

+ func (this *LowfiFreelist28[T]) Get() (*T, bool)

+ func (this *LowfiFreelist28[T]) Len() int

+ func (this *LowfiFreelist28[T]) Release(id uint) bool

+ type LowfiFreelist29 struct

+ func NewLowfiFreelist29[T any](factory func(uint) T) *LowfiFreelist29[T]

+ func (this *LowfiFreelist29[T]) Cap() int

+ func (this *LowfiFreelist29[T]) Get() (*T, bool)

+ func (this *LowfiFreelist29[T]) Len() int

+ func (this *LowfiFreelist29[T]) Release(id uint) bool

+ type LowfiFreelist3 struct

+ func NewLowfiFreelist3[T any](factory func(uint) T) *LowfiFreelist3[T]

+ func (this *LowfiFreelist3[T]) Cap() int

+ func (this *LowfiFreelist3[T]) Get() (*T, bool)

+ func (this *LowfiFreelist3[T]) Len() int

+ func (this *LowfiFreelist3[T]) Release(id uint) bool

+ type LowfiFreelist30 struct

+ func NewLowfiFreelist30[T any](factory func(uint) T) *LowfiFreelist30[T]

+ func (this *LowfiFreelist30[T]) Cap() int

+ func (this *LowfiFreelist30[T]) Get() (*T, bool)

+ func (this *LowfiFreelist30[T]) Len() int

+ func (this *LowfiFreelist30[T]) Release(id uint) bool

+ type LowfiFreelist31 struct

+ func NewLowfiFreelist31[T any](factory func(uint) T) *LowfiFreelist31[T]

+ func (this *LowfiFreelist31[T]) Cap() int

+ func (this *LowfiFreelist31[T]) Get() (*T, bool)

+ func (this *LowfiFreelist31[T]) Len() int

+ func (this *LowfiFreelist31[T]) Release(id uint) bool

+ type LowfiFreelist32 struct

+ func NewLowfiFreelist32[T any](factory func(uint) T) *LowfiFreelist32[T]

+ func (this *LowfiFreelist32[T]) Cap() int

+ func (this *LowfiFreelist32[T]) Get() (*T, bool)

+ func (this *LowfiFreelist32[T]) Len() int

+ func (this *LowfiFreelist32[T]) Release(id uint) bool

+ type LowfiFreelist33 struct

+ func NewLowfiFreelist33[T any](factory func(uint) T) *LowfiFreelist33[T]

+ func (this *LowfiFreelist33[T]) Cap() int

+ func (this *LowfiFreelist33[T]) Get() (*T, bool)

+ func (this *LowfiFreelist33[T]) Len() int

+ func (this *LowfiFreelist33[T]) Release(id uint) bool

+ type LowfiFreelist34 struct

+ func NewLowfiFreelist34[T any](factory func(uint) T) *LowfiFreelist34[T]

+ func (this *LowfiFreelist34[T]) Cap() int

+ func (this *LowfiFreelist34[T]) Get() (*T, bool)

+ func (this *LowfiFreelist34[T]) Len() int

+ func (this *LowfiFreelist34[T]) Release(id uint) bool

+ type LowfiFreelist4 struct

+ func NewLowfiFreelist4[T any](factory func(uint) T) *LowfiFreelist4[T]

+ func (this *LowfiFreelist4[T]) Cap() int

+ func (this *LowfiFreelist4[T]) Get() (*T, bool)

+ func (this *LowfiFreelist4[T]) Len() int

+ func (this *LowfiFreelist4[T]) Release(id uint) bool

+ type LowfiFreelist5 struct

+ func NewLowfiFreelist5[T any](factory func(uint) T) *LowfiFreelist5[T]

+ func (this *LowfiFreelist5[T]) Cap() int

+ func (this *LowfiFreelist5[T]) Get() (*T, bool)

+ func (this *LowfiFreelist5[T]) Len() int

+ func (this *LowfiFreelist5[T]) Release(id uint) bool

+ type LowfiFreelist6 struct

+ func NewLowfiFreelist6[T any](factory func(uint) T) *LowfiFreelist6[T]

+ func (this *LowfiFreelist6[T]) Cap() int

+ func (this *LowfiFreelist6[T]) Get() (*T, bool)

+ func (this *LowfiFreelist6[T]) Len() int

+ func (this *LowfiFreelist6[T]) Release(id uint) bool

+ type LowfiFreelist7 struct

+ func NewLowfiFreelist7[T any](factory func(uint) T) *LowfiFreelist7[T]

+ func (this *LowfiFreelist7[T]) Cap() int

+ func (this *LowfiFreelist7[T]) Get() (*T, bool)

+ func (this *LowfiFreelist7[T]) Len() int

+ func (this *LowfiFreelist7[T]) Release(id uint) bool

+ type LowfiFreelist8 struct

+ func NewLowfiFreelist8[T any](factory func(uint) T) *LowfiFreelist8[T]

+ func (this *LowfiFreelist8[T]) Cap() int

+ func (this *LowfiFreelist8[T]) Get() (*T, bool)

+ func (this *LowfiFreelist8[T]) Len() int

+ func (this *LowfiFreelist8[T]) Release(id uint) bool

+ type LowfiFreelist9 struct

+ func NewLowfiFreelist9[T any](factory func(uint) T) *LowfiFreelist9[T]

+ func (this *LowfiFreelist9[T]) Cap() int

+ func (this *LowfiFreelist9[T]) Get() (*T, bool)

+ func (this *LowfiFreelist9[T]) Len() int

+ func (this *LowfiFreelist9[T]) Release(id uint) bool

+ type Ring1 struct

+ func (this *Ring1[T]) Cap() int

+ func (this *Ring1[T]) Len() int

+ func (this *Ring1[T]) Peek() (T, bool)

+ func (this *Ring1[T]) Pop() (T, bool)

+ func (this *Ring1[T]) Push(element T) bool

+ func (this *Ring1[T]) Remove(T) bool

+ type Ring10 struct

+ func (this *Ring10[T]) Cap() int

+ func (this *Ring10[T]) Len() int

+ func (this *Ring10[T]) Peek() (T, bool)

+ func (this *Ring10[T]) Pop() (T, bool)

+ func (this *Ring10[T]) Push(element T) bool

+ func (this *Ring10[T]) Remove(T) bool

+ type Ring11 struct

+ func (this *Ring11[T]) Cap() int

+ func (this *Ring11[T]) Len() int

+ func (this *Ring11[T]) Peek() (T, bool)

+ func (this *Ring11[T]) Pop() (T, bool)

+ func (this *Ring11[T]) Push(element T) bool

+ func (this *Ring11[T]) Remove(T) bool

+ type Ring12 struct

+ func (this *Ring12[T]) Cap() int

+ func (this *Ring12[T]) Len() int

+ func (this *Ring12[T]) Peek() (T, bool)

+ func (this *Ring12[T]) Pop() (T, bool)

+ func (this *Ring12[T]) Push(element T) bool

+ func (this *Ring12[T]) Remove(T) bool

+ type Ring13 struct

+ func (this *Ring13[T]) Cap() int

+ func (this *Ring13[T]) Len() int

+ func (this *Ring13[T]) Peek() (T, bool)

+ func (this *Ring13[T]) Pop() (T, bool)

+ func (this *Ring13[T]) Push(element T) bool

+ func (this *Ring13[T]) Remove(T) bool

+ type Ring14 struct

+ func (this *Ring14[T]) Cap() int

+ func (this *Ring14[T]) Len() int

+ func (this *Ring14[T]) Peek() (T, bool)

+ func (this *Ring14[T]) Pop() (T, bool)

+ func (this *Ring14[T]) Push(element T) bool

+ func (this *Ring14[T]) Remove(T) bool

+ type Ring15 struct

+ func (this *Ring15[T]) Cap() int

+ func (this *Ring15[T]) Len() int

+ func (this *Ring15[T]) Peek() (T, bool)

+ func (this *Ring15[T]) Pop() (T, bool)

+ func (this *Ring15[T]) Push(element T) bool

+ func (this *Ring15[T]) Remove(T) bool

+ type Ring16 struct

+ func (this *Ring16[T]) Cap() int

+ func (this *Ring16[T]) Len() int

+ func (this *Ring16[T]) Peek() (T, bool)

+ func (this *Ring16[T]) Pop() (T, bool)

+ func (this *Ring16[T]) Push(element T) bool

+ func (this *Ring16[T]) Remove(T) bool

+ type Ring17 struct

+ func (this *Ring17[T]) Cap() int

+ func (this *Ring17[T]) Len() int

+ func (this *Ring17[T]) Peek() (T, bool)

+ func (this *Ring17[T]) Pop() (T, bool)

+ func (this *Ring17[T]) Push(element T) bool

+ func (this *Ring17[T]) Remove(T) bool

+ type Ring18 struct

+ func (this *Ring18[T]) Cap() int

+ func (this *Ring18[T]) Len() int

+ func (this *Ring18[T]) Peek() (T, bool)

+ func (this *Ring18[T]) Pop() (T, bool)

+ func (this *Ring18[T]) Push(element T) bool

+ func (this *Ring18[T]) Remove(T) bool

+ type Ring19 struct

+ func (this *Ring19[T]) Cap() int

+ func (this *Ring19[T]) Len() int

+ func (this *Ring19[T]) Peek() (T, bool)

+ func (this *Ring19[T]) Pop() (T, bool)

+ func (this *Ring19[T]) Push(element T) bool

+ func (this *Ring19[T]) Remove(T) bool

+ type Ring2 struct

+ func (this *Ring2[T]) Cap() int

+ func (this *Ring2[T]) Len() int

+ func (this *Ring2[T]) Peek() (T, bool)

+ func (this *Ring2[T]) Pop() (T, bool)

+ func (this *Ring2[T]) Push(element T) bool

+ func (this *Ring2[T]) Remove(T) bool

+ type Ring20 struct

+ func (this *Ring20[T]) Cap() int

+ func (this *Ring20[T]) Len() int

+ func (this *Ring20[T]) Peek() (T, bool)

+ func (this *Ring20[T]) Pop() (T, bool)

+ func (this *Ring20[T]) Push(element T) bool

+ func (this *Ring20[T]) Remove(T) bool

+ type Ring21 struct

+ func (this *Ring21[T]) Cap() int

+ func (this *Ring21[T]) Len() int

+ func (this *Ring21[T]) Peek() (T, bool)

+ func (this *Ring21[T]) Pop() (T, bool)

+ func (this *Ring21[T]) Push(element T) bool

+ func (this *Ring21[T]) Remove(T) bool

+ type Ring22 struct

+ func (this *Ring22[T]) Cap() int

+ func (this *Ring22[T]) Len() int

+ func (this *Ring22[T]) Peek() (T, bool)

+ func (this *Ring22[T]) Pop() (T, bool)

+ func (this *Ring22[T]) Push(element T) bool

+ func (this *Ring22[T]) Remove(T) bool

+ type Ring23 struct

+ func (this *Ring23[T]) Cap() int

+ func (this *Ring23[T]) Len() int

+ func (this *Ring23[T]) Peek() (T, bool)

+ func (this *Ring23[T]) Pop() (T, bool)

+ func (this *Ring23[T]) Push(element T) bool

+ func (this *Ring23[T]) Remove(T) bool

+ type Ring24 struct

+ func (this *Ring24[T]) Cap() int

+ func (this *Ring24[T]) Len() int

+ func (this *Ring24[T]) Peek() (T, bool)

+ func (this *Ring24[T]) Pop() (T, bool)

+ func (this *Ring24[T]) Push(element T) bool

+ func (this *Ring24[T]) Remove(T) bool

+ type Ring25 struct

+ func (this *Ring25[T]) Cap() int

+ func (this *Ring25[T]) Len() int

+ func (this *Ring25[T]) Peek() (T, bool)

+ func (this *Ring25[T]) Pop() (T, bool)

+ func (this *Ring25[T]) Push(element T) bool

+ func (this *Ring25[T]) Remove(T) bool

+ type Ring26 struct

+ func (this *Ring26[T]) Cap() int

+ func (this *Ring26[T]) Len() int

+ func (this *Ring26[T]) Peek() (T, bool)

+ func (this *Ring26[T]) Pop() (T, bool)

+ func (this *Ring26[T]) Push(element T) bool

+ func (this *Ring26[T]) Remove(T) bool

+ type Ring27 struct

+ func (this *Ring27[T]) Cap() int

+ func (this *Ring27[T]) Len() int

+ func (this *Ring27[T]) Peek() (T, bool)

+ func (this *Ring27[T]) Pop() (T, bool)

+ func (this *Ring27[T]) Push(element T) bool

+ func (this *Ring27[T]) Remove(T) bool

+ type Ring28 struct

+ func (this *Ring28[T]) Cap() int

+ func (this *Ring28[T]) Len() int

+ func (this *Ring28[T]) Peek() (T, bool)

+ func (this *Ring28[T]) Pop() (T, bool)

+ func (this *Ring28[T]) Push(element T) bool

+ func (this *Ring28[T]) Remove(T) bool

+ type Ring29 struct

+ func (this *Ring29[T]) Cap() int

+ func (this *Ring29[T]) Len() int

+ func (this *Ring29[T]) Peek() (T, bool)

+ func (this *Ring29[T]) Pop() (T, bool)

+ func (this *Ring29[T]) Push(element T) bool

+ func (this *Ring29[T]) Remove(T) bool

+ type Ring3 struct

+ func (this *Ring3[T]) Cap() int

+ func (this *Ring3[T]) Len() int

+ func (this *Ring3[T]) Peek() (T, bool)

+ func (this *Ring3[T]) Pop() (T, bool)

+ func (this *Ring3[T]) Push(element T) bool

+ func (this *Ring3[T]) Remove(T) bool

+ type Ring30 struct

+ func (this *Ring30[T]) Cap() int

+ func (this *Ring30[T]) Len() int

+ func (this *Ring30[T]) Peek() (T, bool)

+ func (this *Ring30[T]) Pop() (T, bool)

+ func (this *Ring30[T]) Push(element T) bool

+ func (this *Ring30[T]) Remove(T) bool

+ type Ring31 struct

+ func (this *Ring31[T]) Cap() int

+ func (this *Ring31[T]) Len() int

+ func (this *Ring31[T]) Peek() (T, bool)

+ func (this *Ring31[T]) Pop() (T, bool)

+ func (this *Ring31[T]) Push(element T) bool

+ func (this *Ring31[T]) Remove(T) bool

+ type Ring32 struct

+ func (this *Ring32[T]) Cap() int

+ func (this *Ring32[T]) Len() int

+ func (this *Ring32[T]) Peek() (T, bool)

+ func (this *Ring32[T]) Pop() (T, bool)

+ func (this *Ring32[T]) Push(element T) bool

+ func (this *Ring32[T]) Remove(T) bool

+ type Ring33 struct

+ func (this *Ring33[T]) Cap() int

+ func (this *Ring33[T]) Len() int

+ func (this *Ring33[T]) Peek() (T, bool)

+ func (this *Ring33[T]) Pop() (T, bool)

+ func (this *Ring33[T]) Push(element T) bool

+ func (this *Ring33[T]) Remove(T) bool

+ type Ring34 struct

+ func (this *Ring34[T]) Cap() int

+ func (this *Ring34[T]) Len() int

+ func (this *Ring34[T]) Peek() (T, bool)

+ func (this *Ring34[T]) Pop() (T, bool)

+ func (this *Ring34[T]) Push(element T) bool

+ func (this *Ring34[T]) Remove(T) bool

+ type Ring4 struct

+ func (this *Ring4[T]) Cap() int

+ func (this *Ring4[T]) Len() int

+ func (this *Ring4[T]) Peek() (T, bool)

+ func (this *Ring4[T]) Pop() (T, bool)

+ func (this *Ring4[T]) Push(element T) bool

+ func (this *Ring4[T]) Remove(T) bool

+ type Ring5 struct

+ func (this *Ring5[T]) Cap() int

+ func (this *Ring5[T]) Len() int

+ func (this *Ring5[T]) Peek() (T, bool)

+ func (this *Ring5[T]) Pop() (T, bool)

+ func (this *Ring5[T]) Push(element T) bool

+ func (this *Ring5[T]) Remove(T) bool

+ type Ring6 struct

+ func (this *Ring6[T]) Cap() int

+ func (this *Ring6[T]) Len() int

+ func (this *Ring6[T]) Peek() (T, bool)

+ func (this *Ring6[T]) Pop() (T, bool)

+ func (this *Ring6[T]) Push(element T) bool

+ func (this *Ring6[T]) Remove(T) bool

+ type Ring7 struct

+ func (this *Ring7[T]) Cap() int

+ func (this *Ring7[T]) Len() int

+ func (this *Ring7[T]) Peek() (T, bool)

+ func (this *Ring7[T]) Pop() (T, bool)

+ func (this *Ring7[T]) Push(element T) bool

+ func (this *Ring7[T]) Remove(T) bool

+ type Ring8 struct

+ func (this *Ring8[T]) Cap() int

+ func (this *Ring8[T]) Len() int

+ func (this *Ring8[T]) Peek() (T, bool)

+ func (this *Ring8[T]) Pop() (T, bool)

+ func (this *Ring8[T]) Push(element T) bool

+ func (this *Ring8[T]) Remove(T) bool

+ type Ring9 struct

+ func (this *Ring9[T]) Cap() int

+ func (this *Ring9[T]) Len() int

+ func (this *Ring9[T]) Peek() (T, bool)

+ func (this *Ring9[T]) Pop() (T, bool)

+ func (this *Ring9[T]) Push(element T) bool

+ func (this *Ring9[T]) Remove(T) bool

+ type SortedSet10 struct

+ func NewSortedSet10[T common.Comparable[T]]() *SortedSet10[T]

+ func (this *SortedSet10[T]) All() iter.Seq[T]

+ func (this *SortedSet10[T]) Delete(element T) error

+ func (this *SortedSet10[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet10[T]) Get(element T) (T, error)

+ func (this *SortedSet10[T]) Put(element T) error

+ type SortedSet11 struct

+ func NewSortedSet11[T common.Comparable[T]]() *SortedSet11[T]

+ func (this *SortedSet11[T]) All() iter.Seq[T]

+ func (this *SortedSet11[T]) Delete(element T) error

+ func (this *SortedSet11[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet11[T]) Get(element T) (T, error)

+ func (this *SortedSet11[T]) Put(element T) error

+ type SortedSet12 struct

+ func NewSortedSet12[T common.Comparable[T]]() *SortedSet12[T]

+ func (this *SortedSet12[T]) All() iter.Seq[T]

+ func (this *SortedSet12[T]) Delete(element T) error

+ func (this *SortedSet12[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet12[T]) Get(element T) (T, error)

+ func (this *SortedSet12[T]) Put(element T) error

+ type SortedSet13 struct

+ func NewSortedSet13[T common.Comparable[T]]() *SortedSet13[T]

+ func (this *SortedSet13[T]) All() iter.Seq[T]

+ func (this *SortedSet13[T]) Delete(element T) error

+ func (this *SortedSet13[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet13[T]) Get(element T) (T, error)

+ func (this *SortedSet13[T]) Put(element T) error

+ type SortedSet14 struct

+ func NewSortedSet14[T common.Comparable[T]]() *SortedSet14[T]

+ func (this *SortedSet14[T]) All() iter.Seq[T]

+ func (this *SortedSet14[T]) Delete(element T) error

+ func (this *SortedSet14[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet14[T]) Get(element T) (T, error)

+ func (this *SortedSet14[T]) Put(element T) error

+ type SortedSet15 struct

+ func NewSortedSet15[T common.Comparable[T]]() *SortedSet15[T]

+ func (this *SortedSet15[T]) All() iter.Seq[T]

+ func (this *SortedSet15[T]) Delete(element T) error

+ func (this *SortedSet15[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet15[T]) Get(element T) (T, error)

+ func (this *SortedSet15[T]) Put(element T) error

+ type SortedSet16 struct

+ func NewSortedSet16[T common.Comparable[T]]() *SortedSet16[T]

+ func (this *SortedSet16[T]) All() iter.Seq[T]

+ func (this *SortedSet16[T]) Delete(element T) error

+ func (this *SortedSet16[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet16[T]) Get(element T) (T, error)

+ func (this *SortedSet16[T]) Put(element T) error

+ type SortedSet17 struct

+ func NewSortedSet17[T common.Comparable[T]]() *SortedSet17[T]

+ func (this *SortedSet17[T]) All() iter.Seq[T]

+ func (this *SortedSet17[T]) Delete(element T) error

+ func (this *SortedSet17[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet17[T]) Get(element T) (T, error)

+ func (this *SortedSet17[T]) Put(element T) error

+ type SortedSet18 struct

+ func NewSortedSet18[T common.Comparable[T]]() *SortedSet18[T]

+ func (this *SortedSet18[T]) All() iter.Seq[T]

+ func (this *SortedSet18[T]) Delete(element T) error

+ func (this *SortedSet18[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet18[T]) Get(element T) (T, error)

+ func (this *SortedSet18[T]) Put(element T) error

+ type SortedSet19 struct

+ func NewSortedSet19[T common.Comparable[T]]() *SortedSet19[T]

+ func (this *SortedSet19[T]) All() iter.Seq[T]

+ func (this *SortedSet19[T]) Delete(element T) error

+ func (this *SortedSet19[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet19[T]) Get(element T) (T, error)

+ func (this *SortedSet19[T]) Put(element T) error

+ type SortedSet20 struct

+ func NewSortedSet20[T common.Comparable[T]]() *SortedSet20[T]

+ func (this *SortedSet20[T]) All() iter.Seq[T]

+ func (this *SortedSet20[T]) Delete(element T) error

+ func (this *SortedSet20[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet20[T]) Get(element T) (T, error)

+ func (this *SortedSet20[T]) Put(element T) error

+ type SortedSet21 struct

+ func NewSortedSet21[T common.Comparable[T]]() *SortedSet21[T]

+ func (this *SortedSet21[T]) All() iter.Seq[T]

+ func (this *SortedSet21[T]) Delete(element T) error

+ func (this *SortedSet21[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet21[T]) Get(element T) (T, error)

+ func (this *SortedSet21[T]) Put(element T) error

+ type SortedSet22 struct

+ func NewSortedSet22[T common.Comparable[T]]() *SortedSet22[T]

+ func (this *SortedSet22[T]) All() iter.Seq[T]

+ func (this *SortedSet22[T]) Delete(element T) error

+ func (this *SortedSet22[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet22[T]) Get(element T) (T, error)

+ func (this *SortedSet22[T]) Put(element T) error

+ type SortedSet23 struct

+ func NewSortedSet23[T common.Comparable[T]]() *SortedSet23[T]

+ func (this *SortedSet23[T]) All() iter.Seq[T]

+ func (this *SortedSet23[T]) Delete(element T) error

+ func (this *SortedSet23[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet23[T]) Get(element T) (T, error)

+ func (this *SortedSet23[T]) Put(element T) error

+ type SortedSet24 struct

+ func NewSortedSet24[T common.Comparable[T]]() *SortedSet24[T]

+ func (this *SortedSet24[T]) All() iter.Seq[T]

+ func (this *SortedSet24[T]) Delete(element T) error

+ func (this *SortedSet24[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet24[T]) Get(element T) (T, error)

+ func (this *SortedSet24[T]) Put(element T) error

+ type SortedSet25 struct

+ func NewSortedSet25[T common.Comparable[T]]() *SortedSet25[T]

+ func (this *SortedSet25[T]) All() iter.Seq[T]

+ func (this *SortedSet25[T]) Delete(element T) error

+ func (this *SortedSet25[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet25[T]) Get(element T) (T, error)

+ func (this *SortedSet25[T]) Put(element T) error

+ type SortedSet26 struct

+ func NewSortedSet26[T common.Comparable[T]]() *SortedSet26[T]

+ func (this *SortedSet26[T]) All() iter.Seq[T]

+ func (this *SortedSet26[T]) Delete(element T) error

+ func (this *SortedSet26[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet26[T]) Get(element T) (T, error)

+ func (this *SortedSet26[T]) Put(element T) error

+ type SortedSet27 struct

+ func NewSortedSet27[T common.Comparable[T]]() *SortedSet27[T]

+ func (this *SortedSet27[T]) All() iter.Seq[T]

+ func (this *SortedSet27[T]) Delete(element T) error

+ func (this *SortedSet27[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet27[T]) Get(element T) (T, error)

+ func (this *SortedSet27[T]) Put(element T) error

+ type SortedSet28 struct

+ func NewSortedSet28[T common.Comparable[T]]() *SortedSet28[T]

+ func (this *SortedSet28[T]) All() iter.Seq[T]

+ func (this *SortedSet28[T]) Delete(element T) error

+ func (this *SortedSet28[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet28[T]) Get(element T) (T, error)

+ func (this *SortedSet28[T]) Put(element T) error

+ type SortedSet29 struct

+ func NewSortedSet29[T common.Comparable[T]]() *SortedSet29[T]

+ func (this *SortedSet29[T]) All() iter.Seq[T]

+ func (this *SortedSet29[T]) Delete(element T) error

+ func (this *SortedSet29[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet29[T]) Get(element T) (T, error)

+ func (this *SortedSet29[T]) Put(element T) error

+ type SortedSet30 struct

+ func NewSortedSet30[T common.Comparable[T]]() *SortedSet30[T]

+ func (this *SortedSet30[T]) All() iter.Seq[T]

+ func (this *SortedSet30[T]) Delete(element T) error

+ func (this *SortedSet30[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet30[T]) Get(element T) (T, error)

+ func (this *SortedSet30[T]) Put(element T) error

+ type SortedSet31 struct

+ func NewSortedSet31[T common.Comparable[T]]() *SortedSet31[T]

+ func (this *SortedSet31[T]) All() iter.Seq[T]

+ func (this *SortedSet31[T]) Delete(element T) error

+ func (this *SortedSet31[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet31[T]) Get(element T) (T, error)

+ func (this *SortedSet31[T]) Put(element T) error

+ type SortedSet32 struct

+ func NewSortedSet32[T common.Comparable[T]]() *SortedSet32[T]

+ func (this *SortedSet32[T]) All() iter.Seq[T]

+ func (this *SortedSet32[T]) Delete(element T) error

+ func (this *SortedSet32[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet32[T]) Get(element T) (T, error)

+ func (this *SortedSet32[T]) Put(element T) error

+ type SortedSet33 struct

+ func NewSortedSet33[T common.Comparable[T]]() *SortedSet33[T]

+ func (this *SortedSet33[T]) All() iter.Seq[T]

+ func (this *SortedSet33[T]) Delete(element T) error

+ func (this *SortedSet33[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet33[T]) Get(element T) (T, error)

+ func (this *SortedSet33[T]) Put(element T) error

+ type SortedSet34 struct

+ func NewSortedSet34[T common.Comparable[T]]() *SortedSet34[T]

+ func (this *SortedSet34[T]) All() iter.Seq[T]

+ func (this *SortedSet34[T]) Delete(element T) error

+ func (this *SortedSet34[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet34[T]) Get(element T) (T, error)

+ func (this *SortedSet34[T]) Put(element T) error

+ type SortedSet7 struct

+ func NewSortedSet7[T common.Comparable[T]]() *SortedSet7[T]

+ func (this *SortedSet7[T]) All() iter.Seq[T]

+ func (this *SortedSet7[T]) Delete(element T) error

+ func (this *SortedSet7[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet7[T]) Get(element T) (T, error)

+ func (this *SortedSet7[T]) Put(element T) error

+ type SortedSet8 struct

+ func NewSortedSet8[T common.Comparable[T]]() *SortedSet8[T]

+ func (this *SortedSet8[T]) All() iter.Seq[T]

+ func (this *SortedSet8[T]) Delete(element T) error

+ func (this *SortedSet8[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet8[T]) Get(element T) (T, error)

+ func (this *SortedSet8[T]) Put(element T) error

+ type SortedSet9 struct

+ func NewSortedSet9[T common.Comparable[T]]() *SortedSet9[T]

+ func (this *SortedSet9[T]) All() iter.Seq[T]

+ func (this *SortedSet9[T]) Delete(element T) error

+ func (this *SortedSet9[T]) ForEach(yield func(T) bool)

+ func (this *SortedSet9[T]) Get(element T) (T, error)

+ func (this *SortedSet9[T]) Put(element T) error