Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  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

tl

package module

Go to main page

Versions in this module

v0

v0.2.1

Sep 28, 2022

Changes in this version

+ func DeleteAll(set []T, value T) []T

type Bytes

+ func (b Bytes) IndexByte(c byte) int

v0.2.0

Sep 28, 2022

Changes in this version

+ func Advance(iter Iter[T], count int)

+ func AntiJoin(a, b []T) []T

+ func AntiJoinFn(a, b []T, cmpFn func(a, b T) bool) (r []T)

+ func Avg(a ...T) (r T)

+ func Contains(vs []T, e T) bool

+ func ContainsFn(vs []T, cmpFn CompareFunc[T]) bool

+ func Delete(set []T, value T) []T

+ func Filter(set []T, cmpFn CompareFunc[T]) []T

+ func FilterInPlace(set []T, cmpFn CompareFunc[T]) []T

+ func Join(a, b []T) []T

+ func JoinFn(a, b []T, cmpFn func(a, b T) bool) (r []T)

+ func Map(set []T, fn func(T) E) []E

+ func Max(numbers ...T) (r T)

+ func Merge(a, b []T) (r []T)

+ func MergeFn(cmpFn func(a, b T) bool, a []T, more ...[]T) (r []T)

+ func Min(a, b T) (r T)

+ func SearchFn(vs []T, cmpFn CompareFunc[T]) int

+ func Sum(a ...T) (r T)

+ type Bytes Vec[byte]

+ func BytesFrom(bts []byte) Bytes

+ func NewBytes(size, capacity int) Bytes

+ func (b *Bytes) Append(bts ...byte)

+ func (b *Bytes) CopyFrom(b2 Bytes)

+ func (b *Bytes) LimitReadFrom(r io.Reader, n int) (int64, error)

+ func (b *Bytes) Push(bts ...byte)

+ func (b *Bytes) Reserve(n int)

+ func (b *Bytes) Resize(n int)

+ func (b Bytes) Cap() int

+ func (b Bytes) Contains(c byte) bool

+ func (b Bytes) Index(c byte) int

+ func (b Bytes) Len() int

+ func (b Bytes) LimitWriteTo(w io.Writer, n int) (int64, error)

+ func (b Bytes) ReadFrom(r io.Reader) (int64, error)

+ func (b Bytes) Slice(low, max int) Bytes

+ func (b Bytes) String() string

+ func (b Bytes) UnsafeString() string

+ func (b Bytes) WriteTo(w io.Writer) (int64, error)

+ type CompareFunc func(T) bool

+ type Iter interface

+ Get func() T

+ GetPtr func() *T

+ Next func() bool

+ type IterBidir interface

+ Back func() bool

+ type IterDrop interface

+ Drop func()

+ type IterDropBidir interface

+ type List struct

+ func (list *List[T]) Back() (opt OptionalPtr[T])

+ func (list *List[T]) Front() (opt OptionalPtr[T])

+ func (list *List[T]) Iter() IterDropBidir[T]

+ func (list *List[T]) PopBack() (opt OptionalPtr[T])

+ func (list *List[T]) PopFront() (opt OptionalPtr[T])

+ func (list *List[T]) PushBack(v T) *ListElement[T]

+ func (list *List[T]) PushFront(v T) *ListElement[T]

+ func (list *List[T]) Reset()

+ func (list *List[T]) Size() int

+ type ListElement struct

+ func (e *ListElement[T]) Drop()

+ func (e *ListElement[T]) Get() T

+ func (e *ListElement[T]) GetPtr() *T

+ type Optional struct

+ func MakeOptional(v T) (opt Optional[T])

+ func NewOptional(v *T) (opt Optional[T])

+ func None() (opt Optional[T])

+ func (opt *Optional[T]) Reset()

+ func (opt *Optional[T]) Set(v T)

+ func (opt Optional[T]) From(v T) Optional[T]

+ func (opt Optional[T]) Get() T

+ func (opt Optional[T]) HasValue() bool

+ func (opt Optional[T]) Or(v T) Optional[T]

+ func (opt Optional[T]) Ptr() *T

+ type OptionalPtr struct

+ func MakeOptionalPtr(v *T) (opt OptionalPtr[T])

+ func (opt *OptionalPtr[T]) GetValue() T

+ func (opt *OptionalPtr[T]) Reset()

+ func (opt *OptionalPtr[T]) Set(v *T)

+ func (opt OptionalPtr[T]) Get() *T

+ func (opt OptionalPtr[T]) HasValue() bool

+ func (opt OptionalPtr[T]) Or(v *T) OptionalPtr[T]

+ func (opt OptionalPtr[T]) Ptr() *T

+ type Pair struct

+ func MakePair(t T, u U) Pair[T, U]

+ func (p Pair[T, U]) Both() (T, U)

+ func (p Pair[T, U]) First() T

+ func (p Pair[T, U]) Second() U

+ func (p Pair[T, U]) Swap() Pair[U, T]

+ type Queue struct

+ func (q *Queue[T]) Front() (v Optional[T])

+ func (q *Queue[T]) Pop() (v Optional[T])

+ func (q *Queue[T]) PushBack(data T)

+ func (q *Queue[T]) PushFront(data T)

+ func (q *Queue[T]) Reset()

+ type Ring struct

+ func NewRing(size int) *Ring[T]

+ func (ring *Ring[T]) Pop() (value T, ok bool)

+ func (ring *Ring[T]) Push(fn T) bool

+ type Tree struct

+ func (tree *Tree[Key, Value]) Data() Optional[Value]

+ func (tree *Tree[Key, Value]) Del(path ...Key)

+ func (tree *Tree[Key, Value]) Depth() int

+ func (tree *Tree[Key, Value]) Fetch(path ...Key) (opt Optional[Value])

+ func (tree *Tree[Key, Value]) Get(path ...Key) (depth int, opt Optional[Value])

+ func (tree *Tree[Key, Value]) GetTree(path ...Key) *Tree[Key, Value]

+ func (tree *Tree[Key, Value]) Name() Key

+ func (tree *Tree[Key, Value]) Path() []Key

+ func (tree *Tree[Key, Value]) Range(fn func(*Tree[Key, Value]) bool, path ...Key)

+ func (tree *Tree[Key, Value]) RangeAll(fn func(*Tree[Key, Value]) bool)

+ func (tree *Tree[Key, Value]) RangeLevel(fn func(*Tree[Key, Value]) bool, level int)

+ func (tree *Tree[Key, Value]) RangeLimit(fn func(*Tree[Key, Value]) bool, maxDepth int)

+ func (tree *Tree[Key, Value]) Set(data Value, path ...Key)

+ func (tree *Tree[Key, Value]) SetRange(data Value, lvl int)

+ func (tree *Tree[Key, Value]) Trees() []*Tree[Key, Value]

+ type Vec []T

+ func MakeVec(elmnts ...T) Vec[T]

+ func MakeVecSize(size, capacity int) Vec[T]

+ func (vc *Vec[T]) Append(elmnts ...T)

+ func (vc *Vec[T]) DelByIndex(i int) (val T, erased bool)

+ func (vc *Vec[T]) Filter(cmpFn CompareFunc[T]) (val T, erased bool)

+ func (vc *Vec[T]) PopBack() (opt OptionalPtr[T])

+ func (vc *Vec[T]) PopFront() (opt OptionalPtr[T])

+ func (vc *Vec[T]) Push(elmnts ...T)

+ func (vc *Vec[T]) Reserve(n int)

+ func (vc *Vec[T]) Resize(n int)

+ func (vc Vec[T]) Back() (opt OptionalPtr[T])

+ func (vc Vec[T]) Cap() int

+ func (vc Vec[T]) Contains(cmpFn CompareFunc[T]) bool

+ func (vc Vec[T]) Front() (opt OptionalPtr[T])

+ func (vc Vec[T]) Get(i int) T

+ func (vc Vec[T]) Index(cmpFn CompareFunc[T]) int

+ func (vc Vec[T]) Len() int

+ func (vc Vec[T]) Search(cmpFn CompareFunc[T]) (v T, ok bool)