types

type Comparable ¶

type Comparable = comparable

Comparable is an interface that is implemented by all comparable types (booleans, numbers, strings, pointers, channels, arrays of comparable types, structs whose fields are all comparable types). The comparable interface may only be used as a type parameter constraint, not as the type of a variable.

type Complex ¶

type Complex interface {
	~complex64 | ~complex128
}

Complex is a constraint that permits any complex numeric type. If future releases of Go add new predeclared complex numeric types, this constraint will be modified to include them.

type Float ¶

type Float interface {
	~float32 | ~float64
}

Float is a constraint that permits any floating-point type. If future releases of Go add new predeclared floating-point types, this constraint will be modified to include them.

type Integer ¶

type Integer interface {
	Signed | Unsigned
}

Integer is a constraint that permits any integer type. If future releases of Go add new predeclared integer types, this constraint will be modified to include them.

type Number ¶

type Number interface {
	Integer | Float
}

Number is a constraint that permits any numeric type. If future releases of Go add new predeclared numeric types, this constraint will be modified to include them.

type Ordered ¶

type Ordered = cmp.Ordered

Ordered is a constraint that permits any ordered type: any type that supports the operators < <= >= >. If future releases of Go add new ordered types, this constraint will be modified to include them.

Note that floating-point types may contain NaN ("not-a-number") values. An operator such as == or < will always report false when comparing a NaN value with any other value, NaN or not. See the [Compare] function for a consistent way to compare NaN values.

type Pair ¶

type Pair[L, R any] struct {
	Left  L
	Right R
}

Pair is a generic type that represents a pair of values.

func NewPair[L, R any](left L, right R) *Pair[L, R]

func (p *Pair[L, R]) GetLeft() L

func (p *Pair[L, R]) GetRight() R

func (p *Pair[L, R]) Seq() iter.Seq[Pair[L, R]]

func (p *Pair[L, R]) Seq2() iter.Seq2[L, R]

func (p *Pair[L, R]) ToTuple() Tuple2[L, R]

func (p *Pair[L, R]) Unpack() (L, R)

type PairLike ¶

type PairLike[L, R any] interface {
	GetLeft() L
	GetRight() R
}

PairLike represents any type that is pair-like, it is used for creating a Result instance.

type Result ¶ added in v0.24.0

type Result[V any] struct {
	// contains filtered or unexported fields
}

Result is a type representing a result that could be either a value or an error.

func FailureResult[V any](err error) *Result[V]

func ResultFrom[V any](provider func() (V, error)) *Result[V]

func ResultFromPair[V any](pair PairLike[V, error]) *Result[V]

func ResultOf[V any](value V, err error) *Result[V]

func SuccessResult[V any](value V) *Result[V]

func (m *Result[V]) Get() (V, error)

func (m *Result[V]) GetError() error

func (m *Result[V]) IsError() bool

func (m *Result[V]) IsNotError() bool

func (m *Result[V]) MustGetError() error

func (m *Result[V]) MustGetValue() V

func (m *Result[V]) Or(alternative *Result[V]) *Result[V]

func (m *Result[V]) OrElse(defaultValue V) V

func (m *Result[V]) OrElseGet(defaultValue func() V) V

func (m *Result[V]) Seq() iter.Seq[Result[V]]

func (m *Result[V]) Seq2() iter.Seq2[V, error]

type Signed ¶

type Signed interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64
}

Signed is a constraint that permits any signed integer type. If future releases of Go add new predeclared signed integer types, this constraint will be modified to include them.

type SignedNumber ¶

type SignedNumber interface {
	Signed | Float
}

SignedNumber is a constraint that permits any signed numeric type. If future releases of Go add new predeclared signed numeric types, this constraint will be modified to include them.

type Tuple ¶

type Tuple[A, B any] = Tuple2[A, B]

Tuple is a group of 2 elements

func NewTuple[A, B any](a A, b B) Tuple[A, B]

type Tuple2 ¶

type Tuple2[A, B any] struct {
	A A
	B B
}

Tuple2 is a group of 2 elements.

func NewTuple2[A, B any](a A, b B) Tuple2[A, B]

func (t Tuple2[A, B]) GetLeft() A

func (t Tuple2[A, B]) GetRight() B

type Tuple3 ¶

type Tuple3[A, B, C any] struct {
	A A
	B B
	C C
}

Tuple3 is a group of 3 elements.

func NewTuple3[A, B, C any](a A, b B, c C) Tuple3[A, B, C]

type Tuple4 ¶

type Tuple4[A, B, C, D any] struct {
	A A
	B B
	C C
	D D
}

Tuple4 is a group of 4 elements.

func NewTuple4[A, B, C, D any](a A, b B, c C, d D) Tuple4[A, B, C, D]

type Tuple5 ¶

type Tuple5[A, B, C, D, E any] struct {
	A A
	B B
	C C
	D D
	E E
}

Tuple5 is a group of 5 elements.

func NewTuple5[A, B, C, D, E any](a A, b B, c C, d D, e E) Tuple5[A, B, C, D, E]

type Tuple6 ¶

type Tuple6[A, B, C, D, E, F any] struct {
	A A
	B B
	C C
	D D
	E E
	F F
}

Tuple6 is a group of 6 elements.

func NewTuple6[A, B, C, D, E, F any](a A, b B, c C, d D, e E, f F) Tuple6[A, B, C, D, E, F]

type Tuple7 ¶

type Tuple7[A, B, C, D, E, F, G any] struct {
	A A
	B B
	C C
	D D
	E E
	F F
	G G
}

Tuple7 is a group of 7 elements.

func NewTuple7[A, B, C, D, E, F, G any](a A, b B, c C, d D, e E, f F, g G) Tuple7[A, B, C, D, E, F, G]

type Tuple8 ¶

type Tuple8[A, B, C, D, E, F, G, H any] struct {
	A A
	B B
	C C
	D D
	E E
	F F
	G G
	H H
}

Tuple8 is a group of 8 elements.

func NewTuple8[A, B, C, D, E, F, G, H any](a A, b B, c C, d D, e E, f F, g G, h H) Tuple8[A, B, C, D, E, F, G, H]

type Tuple9 ¶

type Tuple9[A, B, C, D, E, F, G, H, I any] struct {
	A A
	B B
	C C
	D D
	E E
	F F
	G G
	H H
	I I
}

Tuple9 is a group of 9 elements.

func NewTuple9[A, B, C, D, E, F, G, H, I any](a A, b B, c C, d D, e E, f F, g G, h H, i I) Tuple9[A, B, C, D, E, F, G, H, I]

type Unsigned ¶

type Unsigned interface {
	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}

Unsigned is a constraint that permits any unsigned integer type. If future releases of Go add new predeclared unsigned integer types, this constraint will be modified to include them.