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

fn

module

Go to main page

Versions in this module

v1

v1.0.0

Jun 2, 2023

v0

v0.9.9

Jun 2, 2023

v0.9.2

Apr 17, 2023

v0.9.1

Mar 21, 2023

v0.9.0

Mar 17, 2023

v0.4.0

Feb 17, 2023

v0.3.1

Feb 1, 2023

v0.3.0

Feb 1, 2023

v0.2.0

Jan 29, 2023

Changes in this version

type Array

+ func (a Array[T]) Error() error

+ type Chan <-chan T

+ func (c Chan[T]) Array() Array[T]

+ func (c Chan[T]) First() (Opt[T], Seq[T])

+ func (c Chan[T]) ForEach(f Func1[T]) Seq[T]

+ func (c Chan[T]) ForEachIndex(f Func2[int, T]) Seq[T]

+ func (c Chan[T]) Len() (int, bool)

+ func (c Chan[T]) Map(shaper FuncMap[T, T]) Seq[T]

+ func (c Chan[T]) Seq() Seq[T]

+ func (c Chan[T]) Skip(n int) Seq[T]

+ func (c Chan[T]) Take(n int) (Array[T], Seq[T])

+ func (c Chan[T]) TakeWhile(pred Predicate[T]) (Array[T], Seq[T])

+ func (c Chan[T]) Where(pred Predicate[T]) Seq[T]

+ func (c Chan[T]) While(pred Predicate[T]) Seq[T]

+ type Fallible interface

+ Error func() error

type Opt

+ func Last(seq Seq[T]) Opt[T]

+ func (o Opt[T]) Error() error

+ func (o Opt[T]) Map(f FuncMap[T, T]) Opt[T]

type Seq

+ func Do(seq Seq[T]) Seq[T]

+ func RangeFrom(n N) Seq[N]

v0.1.0

Dec 20, 2022

Changes in this version

+ const LenInfinite

+ const LenUnknown

+ var ErrEmpty = errors.New("empty")

+ func All(seq Seq[T], pred Predicate[T]) bool

+ func Any(seq Seq[T], pred Predicate[T]) bool

+ func Append(into []T, t T) []T

+ func Count(into int, _ T) int

+ func Error(seq Seq[T]) error

+ func GreaterThanZero(t T) bool

+ func GroupBy(into map[K][]V, tup Tuple[K, V]) map[K][]V

+ func Into(into T, collector FuncCollect[S, T], seq Seq[S]) T

+ func IntoErr(into T, collector FuncCollectErr[S, T], seq Seq[S]) (T, error)

+ func IsNonZero(t T) bool

+ func IsZero(t T) bool

+ func LessThanZero(t T) bool

+ func MakeAssoc(into map[K]V, t Tuple[K, V]) map[K]V

+ func MakeBytes(into *bytes.Buffer, b []byte) *bytes.Buffer

+ func MakeSet(into map[K]struct{}, k K) map[K]struct

+ func MakeString(into *strings.Builder, s string) *strings.Builder

+ func Max(s, t T) T

+ func Min(s, t T) T

+ func OrderAsc(t1, t2 T) bool

+ func OrderDesc(t1, t2 T) bool

+ func OrderTupleAsc(t1, t2 Tuple[K, V]) bool

+ func OrderTupleDesc(t1, t2 Tuple[K, V]) bool

+ func Sum(into, t T) T

+ func TupleKey(t Tuple[X, Y]) X

+ func TupleValue(t Tuple[X, Y]) Y

+ func TupleWithKey(keySelector FuncMap[Y, X]) func(Y) Tuple[X, Y]

+ type Arithmetic interface

+ type Array []T

+ func ArrayAs(tt []T) Array[T]

+ func ArrayAsArgs(tt ...T) Array[T]

+ func (a Array[T]) Array() Array[T]

+ func (a Array[T]) AsSlice() []T

+ func (a Array[T]) First() (Opt[T], Seq[T])

+ func (a Array[T]) ForEach(f Func1[T]) Seq[T]

+ func (a Array[T]) ForEachIndex(f Func2[int, T]) Seq[T]

+ func (a Array[T]) Len() (int, bool)

+ func (a Array[T]) Map(shaper FuncMap[T, T]) Seq[T]

+ func (a Array[T]) Reverse() Seq[T]

+ func (a Array[T]) Seq() Seq[T]

+ func (a Array[T]) Shuffle() Seq[T]

+ func (a Array[T]) Skip(n int) Seq[T]

+ func (a Array[T]) Sort(less FuncLess[T]) Array[T]

+ func (a Array[T]) Take(n int) (Array[T], Seq[T])

+ func (a Array[T]) TakeWhile(pred Predicate[T]) (Array[T], Seq[T])

+ func (a Array[T]) Where(pred Predicate[T]) Seq[T]

+ func (a Array[T]) While(pred Predicate[T]) Seq[T]

+ type Assoc map[K]V

+ func AssocAs(m map[K]V) Assoc[K, V]

+ func (a Assoc[K, V]) Array() Array[Tuple[K, V]]

+ func (a Assoc[K, V]) First() (Opt[Tuple[K, V]], Seq[Tuple[K, V]])

+ func (a Assoc[K, V]) ForEach(f Func1[Tuple[K, V]]) Seq[Tuple[K, V]]

+ func (a Assoc[K, V]) ForEachIndex(f Func2[int, Tuple[K, V]]) Seq[Tuple[K, V]]

+ func (a Assoc[K, V]) Len() (int, bool)

+ func (a Assoc[K, V]) Map(shaper FuncMap[Tuple[K, V], Tuple[K, V]]) Seq[Tuple[K, V]]

+ func (a Assoc[K, V]) Seq() Seq[Tuple[K, V]]

+ func (a Assoc[K, V]) Skip(n int) Seq[Tuple[K, V]]

+ func (a Assoc[K, V]) Take(n int) (Array[Tuple[K, V]], Seq[Tuple[K, V]])

+ func (a Assoc[K, V]) TakeWhile(predicate Predicate[Tuple[K, V]]) (Array[Tuple[K, V]], Seq[Tuple[K, V]])

+ func (a Assoc[K, V]) Where(p Predicate[Tuple[K, V]]) Seq[Tuple[K, V]]

+ func (a Assoc[K, V]) While(pred Predicate[Tuple[K, V]]) Seq[Tuple[K, V]]

+ type Complex interface

+ type ErrPanic struct

+ V any

+ func (p ErrPanic) Error() string

+ func (p ErrPanic) Unwrap() error

+ type Float interface

+ type Func0 func()

+ type Func0Err func() error

+ type Func1 func(T)

+ type Func1Err func(T) error

+ type Func2 func(S, T)

+ type Func2Err func(S, T) error

+ type FuncCollect func(T, S) T

+ func UpdateArray(updater FuncUpdate[V]) FuncCollect[Tuple[I, V], []V]

+ func UpdateAssoc(updater FuncUpdate[V]) FuncCollect[Tuple[K, V], map[K]V]

+ type FuncCollectErr func(T, S) (T, error)

+ type FuncLess func(T, T) bool

+ type FuncMap func(S) T

+ type FuncMapErr func(S) (T, error)

+ type FuncSource func() T

+ type FuncSourceErr func() (T, error)

+ type FuncSplit func(val T) SplitChoice

+ type FuncUpdate func(old, new_ T) T

+ type Integer interface

+ type Opt struct

+ func OptEmpty() Opt[T]

+ func OptErr(err error) Opt[T]

+ func OptMap(opt Opt[S], f FuncMap[S, T]) Opt[T]

+ func OptOf(t T) Opt[T]

+ func Try(f FuncSourceErr[T]) Opt[T]

+ func TryMap(f FuncMapErr[S, T], s S) Opt[T]

+ func TryMapRecover(f FuncMapErr[S, T], s S) (opt Opt[T])

+ func TryOf(t T, err error) Opt[T]

+ func TryRecover(f FuncSourceErr[T]) (opt Opt[T])

+ func (o Opt[T]) Empty() bool

+ func (o Opt[T]) Must() T

+ func (o Opt[T]) Ok() bool

+ func (o Opt[T]) OnErr(errFn func(err error) T) T

+ func (o Opt[T]) Or(altValue T) T

+ func (o Opt[T]) Return() (T, error)

+ func (o Opt[T]) Seq() Seq[T]

+ type Ordered interface

+ type Predicate func(T) bool

+ func GreaterThan(val T) Predicate[T]

+ func Is(val T) Predicate[T]

+ func IsNot(val T) Predicate[T]

+ func LessThan(val T) Predicate[T]

+ func Not(pred Predicate[T]) Predicate[T]

+ type PredicateErr func(T) (bool, error)

+ type Seq interface

+ Array func() Array[T]

+ First func() (Opt[T], Seq[T])

+ ForEach func(f Func1[T]) Seq[T]

+ ForEachIndex func(f Func2[int, T]) Seq[T]

+ Len func() (int, bool)

+ Map func(funcMap FuncMap[T, T]) Seq[T]

+ Skip func(int) Seq[T]

+ Take func(int) (Array[T], Seq[T])

+ TakeWhile func(predicate Predicate[T]) (Array[T], Seq[T])

+ Where func(Predicate[T]) Seq[T]

+ While func(predicate Predicate[T]) Seq[T]

+ func ArrayOf(tt []T) Seq[T]

+ func ArrayOfArgs(tt ...T) Seq[T]

+ func AssocOf(m map[K]V) Seq[Tuple[K, V]]

+ func ChanOf(ch <-chan T) Seq[T]

+ func ConcatOf(seqs ...Seq[T]) Seq[T]

+ func Constant(t T) Seq[T]

+ func ErrorOf(err error) Seq[T]

+ func FlattenOf(seqs Seq[Seq[T]]) Seq[T]

+ func Go(seq Seq[S], numJobs int, task FuncMap[S, T]) Seq[T]

+ func MapOf(seq Seq[S], fm FuncMap[S, T]) Seq[T]

+ func NumbersBelow(n N) Seq[N]

+ func NumbersFrom(n N) Seq[N]

+ func RangeOf(from, to N) Seq[N]

+ func RangeStepOf(from, to, step N) Seq[N]

+ func SeqEmpty() Seq[T]

+ func SetOf(s map[K]struct{}) Seq[K]

+ func SingletOf(t T) Seq[T]

+ func SourceOf(f FuncSource[T]) Seq[T]

+ func SplitOf(seq Seq[T], splitter FuncSplit[T]) Seq[Seq[T]]

+ func StringOf(s string) Seq[byte]

+ func WhereOf(seq Seq[T], pred Predicate[T]) Seq[T]

+ func WhileOf(seq Seq[T], pred Predicate[T]) Seq[T]

+ func ZipOf(sx Seq[X], sy Seq[Y]) Seq[Tuple[X, Y]]

+ type Set map[K]struct

+ func SetAs(s map[K]struct{}) Set[K]

+ func (s Set[K]) Array() Array[K]

+ func (s Set[K]) First() (Opt[K], Seq[K])

+ func (s Set[K]) ForEach(f Func1[K]) Seq[K]

+ func (s Set[K]) ForEachIndex(f Func2[int, K]) Seq[K]

+ func (s Set[K]) Len() (int, bool)

+ func (s Set[K]) Map(shaper FuncMap[K, K]) Seq[K]

+ func (s Set[K]) Seq() Seq[K]

+ func (s Set[K]) Skip(n int) Seq[K]

+ func (s Set[K]) Take(n int) (Array[K], Seq[K])

+ func (s Set[K]) TakeWhile(predicate Predicate[K]) (Array[K], Seq[K])

+ func (s Set[K]) Where(p Predicate[K]) Seq[K]

+ func (s Set[T]) While(pred Predicate[T]) Seq[T]

+ type Signed interface

+ type SplitChoice uint8

+ const SplitKeep

+ const SplitSeparate

+ const SplitSeparateKeep

+ type String string

+ func StringAs(s string) String

+ func (s String) Array() Array[byte]

+ func (s String) First() (Opt[byte], Seq[byte])

+ func (s String) ForEach(f Func1[byte]) Seq[byte]

+ func (s String) ForEachIndex(f Func2[int, byte]) Seq[byte]

+ func (s String) Len() (int, bool)

+ func (s String) Map(shaper FuncMap[byte, byte]) Seq[byte]

+ func (s String) Skip(n int) Seq[byte]

+ func (s String) Take(n int) (Array[byte], Seq[byte])

+ func (s String) TakeWhile(pred Predicate[byte]) (Array[byte], Seq[byte])

+ func (s String) Where(pred Predicate[byte]) Seq[byte]

+ func (s String) While(pred Predicate[byte]) Seq[byte]

+ type Tuple struct

+ func TupleOf(x X, y Y) Tuple[X, Y]

+ func (t Tuple[X, Y]) Key() X

+ func (t Tuple[X, Y]) Value() Y

+ func (t Tuple[X, Y]) X() X

+ func (t Tuple[X, Y]) Y() Y

+ type Unsigned interface