pkg/

Jul 18, 2022

Changes in this version

type Set

+ Projection func(A) K

+ func NewSetBy(projection func(A) K, elems []A) *Set[A, K]

+ func NewSetComparable(elems []A) *Set[A, A]

Jul 14, 2022

Changes in this version

+ func SortOnBy(xs []A, projection F1[A, B], compare F2[B, B, Ordering]) []A

+ type PairOrd Pair[A, B]

+ func (p1 PairOrd[A, B]) Compare(p2 PairOrd[A, B]) Ordering

+ func (p1 PairOrd[A, B]) Equal(p2 PairOrd[A, B]) bool

Jul 14, 2022

Changes in this version

+ func Equal(a T, b T) bool

+ func EqualPair(p1 *Pair[A, B], p2 *Pair[A, B]) bool

+ func UnwrapBool(a Bool) bool

+ func UnwrapComplex128(a Complex128) complex128

+ func UnwrapComplex64(a Complex64) complex64

+ func UnwrapFloat32(a Float32) float32

+ func UnwrapFloat64(a Float64) float64

+ func UnwrapInt(a Int) int

+ func UnwrapInt16(a Int16) int16

+ func UnwrapInt32(a Int32) int32

+ func UnwrapInt64(a Int64) int64

+ func UnwrapInt8(a Int8) int8

+ func UnwrapString(a String) string

+ func UnwrapUint(a Uint) uint

+ func UnwrapUint16(a Uint16) uint16

+ func UnwrapUint32(a Uint32) uint32

+ func UnwrapUint64(a Uint64) uint64

+ func UnwrapUint8(a Uint8) uint8

+ func UnwrapUintptr(a Uintptr) uintptr

type Bool

+ func WrapBool(a bool) Bool

type Complex128

+ func WrapComplex128(a complex128) Complex128

type Complex64

+ func WrapComplex64(a complex64) Complex64

type Float32

+ func WrapFloat32(a float32) Float32

type Float64

+ func WrapFloat64(a float64) Float64

type Int

+ func WrapInt(a int) Int

type Int16

+ func WrapInt16(a int16) Int16

type Int32

+ func WrapInt32(a int32) Int32

type Int64

+ func WrapInt64(a int64) Int64

type Int8

+ func WrapInt8(a int8) Int8

+ type PairEq Pair[A, B]

+ func (p1 *PairEq[A, B]) Equal(p2 *PairEq[A, B]) bool

type String

+ func WrapString(a string) String

type Uint

+ func WrapUint(a uint) Uint

type Uint16

+ func WrapUint16(a uint16) Uint16

type Uint32

+ func WrapUint32(a uint32) Uint32

type Uint64

+ func WrapUint64(a uint64) Uint64

type Uint8

+ func WrapUint8(a uint8) Uint8

type Uintptr

+ func WrapUintptr(a uintptr) Uintptr

Jul 13, 2022

Changes in this version

type SliceOrd

+ func (xs SliceOrd[A]) Equal(ys SliceOrd[A]) bool

Jul 13, 2022

Changes in this version

+ func Sort(xs []A) []A

+ func SortBy(xs []A, f F2[A, A, Ordering]) []A

+ func SortOn(xs []A, f F1[A, B]) []A

type F2

+ func ComparingP(f F1[B, A]) F2[B, B, Ordering]

type Ordering

+ func Compare(y A, z A) Ordering

+ func Comparing(f F1[B, A], x B, y B) Ordering

+ func OrderedCompare(a A, b A) Ordering

Jul 12, 2022

Changes in this version

+ func AllSlice(f F1[A, bool], xs []A) bool

+ func And(a bool, b bool) bool

+ func AnySlice(f F1[A, bool], xs []A) bool

+ func ConcatSlice(xs []A, ys []A) []A

+ func ConcatSlices(xss [][]A) []A

+ func Divide(a T, b T) T

+ func GroupSlice(xs []A) map[A][]A

+ func Intercalate(sep []A, xss [][]A) []A

+ func Intersperse(sep A, xs []A) []A

+ func IsEmptySlice(xs []A) bool

+ func MapMap(f F1[B, C], kvs map[A]B) map[A]C

+ func Minus(a T, b T) T

+ func NotEqual(a T, b T) bool

+ func Or(a bool, b bool) bool

+ func PartitionSlice(predicate F1[A, bool], xs []A) ([]A, []A)

+ func Plus(a T, b T) T

+ func ProductSlice(xs []A) A

+ func ReverseSlice(xs []A) []A

+ func SumSlice(xs []A) A

+ func Times(a T, b T) T

+ func UnfoldrSlice(f F1[B, *Maybe[*Pair[A, B]]], b B) []A

+ type Either struct

+ Error *E

+ Success *A

+ func App2(f func(A, B) C, m1 *Either[E, A], m2 *Either[E, B]) *Either[E, C]

+ func Bind(m *Either[E, A], f func(A) *Either[E, B]) *Either[E, B]

+ func Fmap(m *Either[E, A], f func(a A) B) *Either[E, B]

+ func MapError(m *Either[E1, A], f func(E1) E2) *Either[E2, A]

+ func NewError(error E) *Either[E, A]

+ func NewSuccess(value A) *Either[E, A]

+ func (e *Either[E, A]) IsValid() bool

+ func (e *Either[E, A]) Plus(other *Either[E, A]) *Either[E, A]

type F1

+ func Partial3(f F3[A, B, C, Z]) F1[A, F1[B, F1[C, Z]]]

+ func Partial4(f F4[A, B, C, D, Z]) F1[A, F1[B, F1[C, F1[D, Z]]]]

type Maybe

+ func (m *Maybe[A]) Default(defaultValue A) A

+ type Number interface

type Pair

+ Fst A

+ Snd B

+ func Zip(xs []A, ys []B) []*Pair[A, B]

+ type Set struct

+ Elems map[T]bool

+ func NewSet() *Set[T]

+ func (s *Set[T]) Add(a T)

+ func (s *Set[T]) Contains(a T) bool

+ func (s *Set[T]) Delete(a T)

+ func (s *Set[T]) Len() int

+ func (s *Set[T]) ToSlice() []T

+ type Uintptr uintptr

+ func (a Uintptr) Compare(b Uintptr) Ordering

+ func (a Uintptr) Equal(b Uintptr) bool

Jul 11, 2022

Changes in this version

+ const OrderingEqual

+ const OrderingGreaterThan

+ const OrderingLessThan

+ var UnitC = &Unit

+ func Apply(f F1[A, B], x A) B

+ func EqExample()

+ func Example()

+ func FilterSlice(f F1[A, bool], xs []A) []A

+ func First(p *Pair[A, B]) A

+ func GreaterThan(a T, b T) bool

+ func GreaterThanOrEqual(a T, b T) bool

+ func Id(x A) A

+ func Index(s []T, e T) int

+ func LessThan(a T, b T) bool

+ func LessThanOrEqual(a T, b T) bool

+ func MapSlice(f F1[A, B], xs []A) []B

+ func Max(a T, b T) T

+ func Merge(xs []A, ys []A, f func(A, A) Ordering) []A

+ func MergeSort(xs []A) []A

+ func MergeSortWithComparator(xs []A, f func(A, A) Ordering) []A

+ func Min(a T, b T) T

+ func ReduceMaybe(m *Maybe[A], b B, f F2[B, A, B]) B

+ func ReduceSlice(f F2[B, A, B], b B, xs []A) B

+ func Replicate(count int, item A) []A

+ func Second(p *Pair[A, B]) B

+ type Bool bool

+ func (a Bool) Compare(b Bool) Ordering

+ func (a Bool) Equal(b Bool) bool

+ type Complex128 complex128

+ func (a Complex128) Equal(b Complex128) bool

+ type Complex64 complex64

+ func (a Complex64) Equal(b Complex64) bool

+ type Eq interface

+ Equal func(T) bool

+ type EqOrComparable interface

+ type F1 func(A) Z

+ func Compose(f F1[B, C], g F1[A, B]) F1[A, C]

+ func Const(x A) F1[B, A]

+ func Partial2(f F2[A, B, C]) F1[A, F1[B, C]]

+ type F2 func(A, B) Z

+ func Flip(f F2[A, B, C]) F2[B, A, C]

+ type F3 func(A, B, C) Z

+ type F4 func(A, B, C, D) Z

+ type F5 func(A, B, C, D, E) Z

+ type Float32 float32

+ func (a Float32) Compare(b Float32) Ordering

+ func (a Float32) Equal(b Float32) bool

+ type Float64 float64

+ func (a Float64) Compare(b Float64) Ordering

+ func (a Float64) Equal(b Float64) bool

+ type Int int

+ func (a Int) Compare(b Int) Ordering

+ func (a Int) Equal(b Int) bool

+ type Int16 int16

+ func (a Int16) Compare(b Int16) Ordering

+ func (a Int16) Equal(b Int16) bool

+ type Int32 int32

+ func (a Int32) Compare(b Int32) Ordering

+ func (a Int32) Equal(b Int32) bool

+ type Int64 int64

+ func (a Int64) Compare(b Int64) Ordering

+ func (a Int64) Equal(b Int64) bool

+ type Int8 int8

+ func (a Int8) Compare(b Int8) Ordering

+ func (a Int8) Equal(b Int8) bool

+ type List struct

+ Head A

+ Tail *List[A]

+ func NewList(xs []A) *List[A]

+ type MapEq map[A]B

+ func (xs MapEq[A, B]) Equal(ys MapEq[A, B]) bool

+ type Maybe struct

+ Value *A

+ func BindMaybe(m *Maybe[A], f F1[A, *Maybe[B]]) *Maybe[B]

+ func FilterMaybe(m *Maybe[A], f F1[A, bool]) *Maybe[A]

+ func Just(a A) *Maybe[A]

+ func MapMaybe(f F1[A, B], m *Maybe[A]) *Maybe[B]

+ func Nothing() *Maybe[A]

+ type Ord interface

+ Compare func(T) Ordering

+ type Ordering string

+ type Pair struct

+ A A

+ B B

+ func NewPair(a A, b B) *Pair[A, B]

+ type SliceEq []A

+ func (xs SliceEq[A]) Equal(ys SliceEq[A]) bool

+ type SliceOrd []A

+ func (xs SliceOrd[A]) Compare(ys SliceOrd[A]) Ordering

+ func (xs SliceOrd[A]) Sort() SliceOrd[A]

+ type String string

+ func (a String) Compare(b String) Ordering

+ func (a String) Equal(b String) bool

+ type Uint uint

+ func (a Uint) Compare(b Uint) Ordering

+ func (a Uint) Equal(b Uint) bool

+ type Uint16 uint16

+ func (a Uint16) Compare(b Uint16) Ordering

+ func (a Uint16) Equal(b Uint16) bool

+ type Uint32 uint32

+ func (a Uint32) Compare(b Uint32) Ordering

+ func (a Uint32) Equal(b Uint32) bool

+ type Uint64 uint64

+ func (a Uint64) Compare(b Uint64) Ordering

+ func (a Uint64) Equal(b Uint64) bool

+ type Uint8 uint8

+ func (a Uint8) Compare(b Uint8) Ordering

+ func (a Uint8) Equal(b Uint8) bool

+ type Unit struct