mo

package module

Go to main page

Versions in this module

v1

v1.11.0

Sep 28, 2023

Changes in this version

type Result

+ func (o *Result[T]) UnmarshalJSON(data []byte) error

+ func (o Result[T]) MarshalJSON() ([]byte, error)

v1.10.0

Sep 25, 2023

Changes in this version

type Option

+ func (o Option[T]) ToPointer() *T

type Result

+ func Errf(format string, a ...any) Result[T]

v1.9.0

Sep 25, 2023

Changes in this version

type Option

+ func (o Option[T]) PointerOrNil() *T

v1.8.0

Jan 31, 2023

Changes in this version

type Option

+ func PointerToOption(value *T) Option[T]

v1.7.0

Dec 15, 2022

v1.6.0

Dec 9, 2022

Changes in this version

type Either

+ func (e Either[L, R]) Unpack() (L, R)

type Either3

+ func (e Either3[T1, T2, T3]) Unpack() (T1, T2, T3)

type Either4

+ func (e Either4[T1, T2, T3, T4]) Unpack() (T1, T2, T3, T4)

type Either5

+ func (e Either5[T1, T2, T3, T4, T5]) Unpack() (T1, T2, T3, T4, T5)

v1.5.2

Nov 28, 2022

v1.5.1

Oct 7, 2022

v1.5.0

Sep 21, 2022

Changes in this version

type Option

+ func EmptyableToOption(value T) Option[T]

v1.4.0

Sep 20, 2022

Changes in this version

type Option

+ func (o *Option[T]) GobDecode(data []byte) error

+ func (o *Option[T]) Scan(src any) error

+ func (o *Option[T]) UnmarshalBinary(data []byte) error

+ func (o *Option[T]) UnmarshalText(data []byte) error

+ func (o Option[T]) GobEncode() ([]byte, error)

+ func (o Option[T]) MarshalBinary() ([]byte, error)

+ func (o Option[T]) MarshalText() ([]byte, error)

+ func (o Option[T]) Value() (driver.Value, error)

v1.3.0

Sep 11, 2022

Changes in this version

type Option

+ func (o *Option[T]) UnmarshalJSON(b []byte) error

+ func (o Option[T]) MarshalJSON() ([]byte, error)

v1.2.0

Sep 4, 2022

Changes in this version

+ type Either3 struct

+ func NewEither3Arg1(value T1) Either3[T1, T2, T3]

+ func NewEither3Arg2(value T2) Either3[T1, T2, T3]

+ func NewEither3Arg3(value T3) Either3[T1, T2, T3]

+ func (e Either3[T1, T2, T3]) Arg1() (T1, bool)

+ func (e Either3[T1, T2, T3]) Arg1OrElse(fallback T1) T1

+ func (e Either3[T1, T2, T3]) Arg1OrEmpty() T1

+ func (e Either3[T1, T2, T3]) Arg2() (T2, bool)

+ func (e Either3[T1, T2, T3]) Arg2OrElse(fallback T2) T2

+ func (e Either3[T1, T2, T3]) Arg2OrEmpty() T2

+ func (e Either3[T1, T2, T3]) Arg3() (T3, bool)

+ func (e Either3[T1, T2, T3]) Arg3OrElse(fallback T3) T3

+ func (e Either3[T1, T2, T3]) Arg3OrEmpty() T3

+ func (e Either3[T1, T2, T3]) ForEach(arg1Cb func(T1), arg2Cb func(T2), arg3Cb func(T3))

+ func (e Either3[T1, T2, T3]) IsArg1() bool

+ func (e Either3[T1, T2, T3]) IsArg2() bool

+ func (e Either3[T1, T2, T3]) IsArg3() bool

+ func (e Either3[T1, T2, T3]) MapArg1(mapper func(T1) Either3[T1, T2, T3]) Either3[T1, T2, T3]

+ func (e Either3[T1, T2, T3]) MapArg2(mapper func(T2) Either3[T1, T2, T3]) Either3[T1, T2, T3]

+ func (e Either3[T1, T2, T3]) MapArg3(mapper func(T3) Either3[T1, T2, T3]) Either3[T1, T2, T3]

+ func (e Either3[T1, T2, T3]) Match(onArg1 func(T1) Either3[T1, T2, T3], onArg2 func(T2) Either3[T1, T2, T3], ...) Either3[T1, T2, T3]

+ func (e Either3[T1, T2, T3]) MustArg1() T1

+ func (e Either3[T1, T2, T3]) MustArg2() T2

+ func (e Either3[T1, T2, T3]) MustArg3() T3

+ type Either4 struct

+ func NewEither4Arg1(value T1) Either4[T1, T2, T3, T4]

+ func NewEither4Arg2(value T2) Either4[T1, T2, T3, T4]

+ func NewEither4Arg3(value T3) Either4[T1, T2, T3, T4]

+ func NewEither4Arg4(value T4) Either4[T1, T2, T3, T4]

+ func (e Either4[T1, T2, T3, T4]) Arg1() (T1, bool)

+ func (e Either4[T1, T2, T3, T4]) Arg1OrElse(fallback T1) T1

+ func (e Either4[T1, T2, T3, T4]) Arg1OrEmpty() T1

+ func (e Either4[T1, T2, T3, T4]) Arg2() (T2, bool)

+ func (e Either4[T1, T2, T3, T4]) Arg2OrElse(fallback T2) T2

+ func (e Either4[T1, T2, T3, T4]) Arg2OrEmpty() T2

+ func (e Either4[T1, T2, T3, T4]) Arg3() (T3, bool)

+ func (e Either4[T1, T2, T3, T4]) Arg3OrElse(fallback T3) T3

+ func (e Either4[T1, T2, T3, T4]) Arg3OrEmpty() T3

+ func (e Either4[T1, T2, T3, T4]) Arg4() (T4, bool)

+ func (e Either4[T1, T2, T3, T4]) Arg4OrElse(fallback T4) T4

+ func (e Either4[T1, T2, T3, T4]) Arg4OrEmpty() T4

+ func (e Either4[T1, T2, T3, T4]) ForEach(arg1Cb func(T1), arg2Cb func(T2), arg3Cb func(T3), arg4Cb func(T4))

+ func (e Either4[T1, T2, T3, T4]) IsArg1() bool

+ func (e Either4[T1, T2, T3, T4]) IsArg2() bool

+ func (e Either4[T1, T2, T3, T4]) IsArg3() bool

+ func (e Either4[T1, T2, T3, T4]) IsArg4() bool

+ func (e Either4[T1, T2, T3, T4]) MapArg1(mapper func(T1) Either4[T1, T2, T3, T4]) Either4[T1, T2, T3, T4]

+ func (e Either4[T1, T2, T3, T4]) MapArg2(mapper func(T2) Either4[T1, T2, T3, T4]) Either4[T1, T2, T3, T4]

+ func (e Either4[T1, T2, T3, T4]) MapArg3(mapper func(T3) Either4[T1, T2, T3, T4]) Either4[T1, T2, T3, T4]

+ func (e Either4[T1, T2, T3, T4]) MapArg4(mapper func(T4) Either4[T1, T2, T3, T4]) Either4[T1, T2, T3, T4]

+ func (e Either4[T1, T2, T3, T4]) Match(onArg1 func(T1) Either4[T1, T2, T3, T4], ...) Either4[T1, T2, T3, T4]

+ func (e Either4[T1, T2, T3, T4]) MustArg1() T1

+ func (e Either4[T1, T2, T3, T4]) MustArg2() T2

+ func (e Either4[T1, T2, T3, T4]) MustArg3() T3

+ func (e Either4[T1, T2, T3, T4]) MustArg4() T4

+ type Either5 struct

+ func NewEither5Arg1(value T1) Either5[T1, T2, T3, T4, T5]

+ func NewEither5Arg2(value T2) Either5[T1, T2, T3, T4, T5]

+ func NewEither5Arg3(value T3) Either5[T1, T2, T3, T4, T5]

+ func NewEither5Arg4(value T4) Either5[T1, T2, T3, T4, T5]

+ func NewEither5Arg5(value T5) Either5[T1, T2, T3, T4, T5]

+ func (e Either5[T1, T2, T3, T4, T5]) Arg1() (T1, bool)

+ func (e Either5[T1, T2, T3, T4, T5]) Arg1OrElse(fallback T1) T1

+ func (e Either5[T1, T2, T3, T4, T5]) Arg1OrEmpty() T1

+ func (e Either5[T1, T2, T3, T4, T5]) Arg2() (T2, bool)

+ func (e Either5[T1, T2, T3, T4, T5]) Arg2OrElse(fallback T2) T2

+ func (e Either5[T1, T2, T3, T4, T5]) Arg2OrEmpty() T2

+ func (e Either5[T1, T2, T3, T4, T5]) Arg3() (T3, bool)

+ func (e Either5[T1, T2, T3, T4, T5]) Arg3OrElse(fallback T3) T3

+ func (e Either5[T1, T2, T3, T4, T5]) Arg3OrEmpty() T3

+ func (e Either5[T1, T2, T3, T4, T5]) Arg4() (T4, bool)

+ func (e Either5[T1, T2, T3, T4, T5]) Arg4OrElse(fallback T4) T4

+ func (e Either5[T1, T2, T3, T4, T5]) Arg4OrEmpty() T4

+ func (e Either5[T1, T2, T3, T4, T5]) Arg5() (T5, bool)

+ func (e Either5[T1, T2, T3, T4, T5]) Arg5OrElse(fallback T5) T5

+ func (e Either5[T1, T2, T3, T4, T5]) Arg5OrEmpty() T5

+ func (e Either5[T1, T2, T3, T4, T5]) ForEach(arg1Cb func(T1), arg2Cb func(T2), arg3Cb func(T3), arg4Cb func(T4), ...)

+ func (e Either5[T1, T2, T3, T4, T5]) IsArg1() bool

+ func (e Either5[T1, T2, T3, T4, T5]) IsArg2() bool

+ func (e Either5[T1, T2, T3, T4, T5]) IsArg3() bool

+ func (e Either5[T1, T2, T3, T4, T5]) IsArg4() bool

+ func (e Either5[T1, T2, T3, T4, T5]) IsArg5() bool

+ func (e Either5[T1, T2, T3, T4, T5]) MapArg1(mapper func(T1) Either5[T1, T2, T3, T4, T5]) Either5[T1, T2, T3, T4, T5]

+ func (e Either5[T1, T2, T3, T4, T5]) MapArg2(mapper func(T2) Either5[T1, T2, T3, T4, T5]) Either5[T1, T2, T3, T4, T5]

+ func (e Either5[T1, T2, T3, T4, T5]) MapArg3(mapper func(T3) Either5[T1, T2, T3, T4, T5]) Either5[T1, T2, T3, T4, T5]

+ func (e Either5[T1, T2, T3, T4, T5]) MapArg4(mapper func(T4) Either5[T1, T2, T3, T4, T5]) Either5[T1, T2, T3, T4, T5]

+ func (e Either5[T1, T2, T3, T4, T5]) MapArg5(mapper func(T5) Either5[T1, T2, T3, T4, T5]) Either5[T1, T2, T3, T4, T5]

+ func (e Either5[T1, T2, T3, T4, T5]) Match(onArg1 func(T1) Either5[T1, T2, T3, T4, T5], ...) Either5[T1, T2, T3, T4, T5]

+ func (e Either5[T1, T2, T3, T4, T5]) MustArg1() T1

+ func (e Either5[T1, T2, T3, T4, T5]) MustArg2() T2

+ func (e Either5[T1, T2, T3, T4, T5]) MustArg3() T3

+ func (e Either5[T1, T2, T3, T4, T5]) MustArg4() T4

+ func (e Either5[T1, T2, T3, T4, T5]) MustArg5() T5

v1.1.0

Aug 28, 2022

Changes in this version

type Result

+ func Try(f func() (T, error)) Result[T]

v1.0.1

Jul 25, 2022

v1.0.0

May 18, 2022

Changes in this version

+ type CatchCb func(error) (T, error)

+ type Either struct

+ func Left(value L) Either[L, R]

+ func Right(value R) Either[L, R]

+ func (e Either[L, R]) ForEach(a func(L), b func(R))

+ func (e Either[L, R]) IsLeft() bool

+ func (e Either[L, R]) IsRight() bool

+ func (e Either[L, R]) Left() (L, bool)

+ func (e Either[L, R]) LeftOrElse(fallback L) L

+ func (e Either[L, R]) LeftOrEmpty() L

+ func (e Either[L, R]) MapLeft(mapper func(L) Either[L, R]) Either[L, R]

+ func (e Either[L, R]) MapRight(mapper func(R) Either[L, R]) Either[L, R]

+ func (e Either[L, R]) Match(onLeft func(L) Either[L, R], onRight func(R) Either[L, R]) Either[L, R]

+ func (e Either[L, R]) MustLeft() L

+ func (e Either[L, R]) MustRight() R

+ func (e Either[L, R]) Right() (R, bool)

+ func (e Either[L, R]) RightOrElse(fallback R) R

+ func (e Either[L, R]) RightOrEmpty() R

+ func (e Either[L, R]) Swap() Either[R, L]

+ type FinalCb func(T, error) (T, error)

+ type Future struct

+ func NewFuture(cb func(resolve Resolver[T], reject Rejection)) *Future[T]

+ func (f *Future[T]) Cancel()

+ func (f *Future[T]) Catch(cb CatchCb[T]) *Future[T]

+ func (f *Future[T]) Collect() (T, error)

+ func (f *Future[T]) Either() Either[error, T]

+ func (f *Future[T]) Finally(cb FinalCb[T]) *Future[T]

+ func (f *Future[T]) Result() Result[T]

+ func (f *Future[T]) Then(cb ThenCb[T]) *Future[T]

+ type IO struct

+ func NewIO(f f0[R]) IO[R]

+ func (io IO[R]) Run() R

+ type IO1 struct

+ func NewIO1(f f1[R, A]) IO1[R, A]

+ func (io IO1[R, A]) Run(a A) R

+ type IO2 struct

+ func NewIO2(f f2[R, A, B]) IO2[R, A, B]

+ func (io IO2[R, A, B]) Run(a A, b B) R

+ type IO3 struct

+ func NewIO3(f f3[R, A, B, C]) IO3[R, A, B, C]

+ func (io IO3[R, A, B, C]) Run(a A, b B, c C) R

+ type IO4 struct

+ func NewIO4(f f4[R, A, B, C, D]) IO4[R, A, B, C, D]

+ func (io IO4[R, A, B, C, D]) Run(a A, b B, c C, d D) R

+ type IO5 struct

+ func NewIO5(f f5[R, A, B, C, D, E]) IO5[R, A, B, C, D, E]

+ func (io IO5[R, A, B, C, D, E]) Run(a A, b B, c C, d D, e E) R

+ type IOEither struct

+ func NewIOEither(f fe0[R]) IOEither[R]

+ func (io IOEither[R]) Run() Either[error, R]

+ type IOEither1 struct

+ func NewIOEither1(f fe1[R, A]) IOEither1[R, A]

+ func (io IOEither1[R, A]) Run(a A) Either[error, R]

+ type IOEither2 struct

+ func NewIOEither2(f fe2[R, A, B]) IOEither2[R, A, B]

+ func (io IOEither2[R, A, B]) Run(a A, b B) Either[error, R]

+ type IOEither3 struct

+ func NewIOEither3(f fe3[R, A, B, C]) IOEither3[R, A, B, C]

+ func (io IOEither3[R, A, B, C]) Run(a A, b B, c C) Either[error, R]

+ type IOEither4 struct

+ func NewIOEither4(f fe4[R, A, B, C, D]) IOEither4[R, A, B, C, D]

+ func (io IOEither4[R, A, B, C, D]) Run(a A, b B, c C, d D) Either[error, R]

+ type IOEither5 struct

+ func NewIOEither5(f fe5[R, A, B, C, D, E]) IOEither5[R, A, B, C, D, E]

+ func (io IOEither5[R, A, B, C, D, E]) Run(a A, b B, c C, d D, e E) Either[error, R]

+ type Option struct

+ func None() Option[T]

+ func Some(value T) Option[T]

+ func TupleToOption(v T, ok bool) Option[T]

+ func (o Option[T]) FlatMap(mapper func(T) Option[T]) Option[T]

+ func (o Option[T]) ForEach(f func(T))

+ func (o Option[T]) Get() (T, bool)

+ func (o Option[T]) IsAbsent() bool

+ func (o Option[T]) IsPresent() bool

+ func (o Option[T]) Map(mapper func(T) (T, bool)) Option[T]

+ func (o Option[T]) MapNone(mapper func() (T, bool)) Option[T]

+ func (o Option[T]) Match(onValue func(T) (T, bool), onNone func() (T, bool)) Option[T]

+ func (o Option[T]) MustGet() T

+ func (o Option[T]) OrElse(fallback T) T

+ func (o Option[T]) OrEmpty() T

+ func (o Option[T]) Size() int

+ type Rejection func(error)

+ type Resolver func(T)

+ type Result struct

+ func Err(err error) Result[T]

+ func Ok(value T) Result[T]

+ func TupleToResult(v T, err error) Result[T]

+ func (r Result[T]) Error() error

+ func (r Result[T]) FlatMap(mapper func(T) Result[T]) Result[T]

+ func (r Result[T]) ForEach(f func(T))

+ func (r Result[T]) Get() (T, error)

+ func (r Result[T]) IsError() bool

+ func (r Result[T]) IsOk() bool

+ func (r Result[T]) Map(mapper func(T) (T, error)) Result[T]

+ func (r Result[T]) MapErr(mapper func(error) (T, error)) Result[T]

+ func (r Result[T]) Match(onSuccess func(T) (T, error), onError func(error) (T, error)) Result[T]

+ func (r Result[T]) MustGet() T

+ func (r Result[T]) OrElse(fallback T) T

+ func (r Result[T]) OrEmpty() T

+ func (r Result[T]) ToEither() Either[error, T]

+ type State struct

+ func NewState(f func(state S) (A, S)) State[S, A]

+ func ReturnState(x A) State[S, A]

+ func (s State[S, A]) Get() State[S, S]

+ func (s State[S, A]) Modify(f func(state S) S) State[S, A]

+ func (s State[S, A]) Put(state S) State[S, A]

+ func (s State[S, A]) Run(state S) (A, S)

+ type Task struct

+ func NewTask(f ff0[R]) Task[R]

+ func NewTaskFromIO(io IO[R]) Task[R]

+ func (t Task[R]) Run() *Future[R]

+ type Task1 struct

+ func NewTask1(f ff1[R, A]) Task1[R, A]

+ func NewTaskFromIO1(io IO1[R, A]) Task1[R, A]

+ func (t Task1[R, A]) Run(a A) *Future[R]

+ type Task2 struct

+ func NewTask2(f ff2[R, A, B]) Task2[R, A, B]

+ func NewTaskFromIO2(io IO2[R, A, B]) Task2[R, A, B]

+ func (t Task2[R, A, B]) Run(a A, b B) *Future[R]

+ type Task3 struct

+ func NewTask3(f ff3[R, A, B, C]) Task3[R, A, B, C]

+ func NewTaskFromIO3(io IO3[R, A, B, C]) Task3[R, A, B, C]

+ func (t Task3[R, A, B, C]) Run(a A, b B, c C) *Future[R]

+ type Task4 struct

+ func NewTask4(f ff4[R, A, B, C, D]) Task4[R, A, B, C, D]

+ func NewTaskFromIO4(io IO4[R, A, B, C, D]) Task4[R, A, B, C, D]

+ func (t Task4[R, A, B, C, D]) Run(a A, b B, c C, d D) *Future[R]

+ type Task5 struct

+ func NewTask5(f ff5[R, A, B, C, D, E]) Task5[R, A, B, C, D, E]

+ func NewTaskFromIO5(io IO5[R, A, B, C, D, E]) Task5[R, A, B, C, D, E]

+ func (t Task5[R, A, B, C, D, E]) Run(a A, b B, c C, d D, e E) *Future[R]

+ type TaskEither struct

+ func NewTaskEither(f ff0[R]) TaskEither[R]

+ func NewTaskEitherFromIO(io IO[R]) TaskEither[R]

+ func (t TaskEither[R]) Match(onLeft func(error) Either[error, R], onRight func(R) Either[error, R]) Either[error, R]

+ func (t TaskEither[R]) OrElse(fallback R) R

+ func (t TaskEither[R]) ToEither() Either[error, R]

+ func (t TaskEither[R]) ToTask(fallback R) Task[R]

+ func (t TaskEither[R]) TryCatch(onLeft func(error) Either[error, R], onRight func(R) Either[error, R]) Either[error, R]

+ type ThenCb func(T) (T, error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL