ret

func And ¶

func And[T any, U any](r1 gust.Result[T], r2 gust.Result[U]) gust.Result[U]

And returns `r1` if `r1` is Err, otherwise returns `r2`.

func And2 ¶ added in v1.8.0

func And2[T any, U any](v1 T, err1 error, v2 U, err2 error) gust.Result[U]

And2 returns `Ret(v1, err1)` if `r1` is `Err`, otherwise returns `Ret(v2, err2)`.

Examples ¶

var v1 = 1
var err1 = nil
var v2 = 2
var err2 = nil
var result = And2(v1, err1, v2, err2)
assert.Equal(t, gust.Ok[int](2), result)

var v1 = 1
var err1 = errors.New("error1")
var v2 = 2
var err2 = nil
var result = And2(v1, err1, v2, err2)
assert.Equal(t, "error1", result.Err().Error())

var v1 = 1
var err1 = nil
var v2 = 2
var err2 = errors.New("error2")
var result = And2(v1, err1, v2, err2)
assert.Equal(t, "error2", result.Err().Error())

var v1 = 1
var err1 = errors.New("error1")
var v2 = 2
var err2 = errors.New("error2")
var result = And2(v1, err1, v2, err2)
assert.Equal(t, "error1", result.Err().Error())

func AndThen ¶

func AndThen[T any, U any](r gust.Result[T], op func(T) gust.Result[U]) gust.Result[U]

AndThen calls op if the result is Ok, otherwise returns the error of self. This function can be used for control flow based on gust.Result values.

func AndThen2 ¶ added in v1.8.0

func AndThen2[T any, U any](r gust.Result[T], op func(T) (U, error)) gust.Result[U]

AndThen2 calls op if the result is Ok, otherwise returns the error of self. This function can be used for control flow based on gust.Result values.

func AndThen3 ¶ added in v1.8.0

func AndThen3[T any, U any](v T, err error, op func(T) (U, error)) gust.Result[U]

AndThen3 calls op if the result is Ok, otherwise returns the error of self. This function can be used for control flow based on gust.Result values.

func Assert ¶ added in v0.7.0

func Assert[T any, U any](o gust.Result[T]) gust.Result[U]

Assert asserts gust.Result[T] as gust.Result[U].

func Assert2 ¶ added in v1.8.0

func Assert2[T any, U any](v T, err error) gust.Result[U]

Assert2 asserts a value and an error as a gust.Result[U].

Examples ¶

var v = 1
var err = nil
var result = Assert2(v, err)
assert.Equal(t, gust.Ok[int](1), result)

func Contains ¶

func Contains[T comparable](r gust.Result[T], x T) bool

Contains returns true if the result is an Ok value containing the given value.

func Contains2 ¶ added in v1.8.0

func Contains2[T comparable](v T, err error, x T) bool

Contains2 returns true if the result is an Ok value containing the given value.

func Flatten ¶

func Flatten[T any](r gust.Result[gust.Result[T]]) gust.Result[T]

Flatten converts from gust.Result[gust.Result[T]] to gust.Result[T].

Examples ¶

var r1 = gust.Ok(gust.Ok(1))
var result1 = Flatten(r1)
assert.Equal(t, gust.Ok[int](1), result1)
var r2 = gust.Ok(gust.Err(errors.New("error")))
var result2 = Flatten(r2)
assert.Equal(t, "error", result2.Err().Error())
var r3 = gust.Err[gust.Result[int]](errors.New("error"))
var result3 = Flatten(r3)
assert.Equal(t, "error", result3.Err().Error())

func Flatten2 ¶ added in v1.8.0

func Flatten2[T any](r gust.Result[T], err error) gust.Result[T]

Flatten2 converts from `(gust.Result[T], error)` to gust.Result[T].

Examples ¶

var r1 = gust.Ok(1)
var err1 = nil
var result1 = Flatten2(r1, err1)
assert.Equal(t, gust.Ok[int](1), result1)
var r2 = gust.Ok(1)
var err2 = errors.New("error")
var result2 = Flatten2(r2, err2)
assert.Equal(t, "error", result2.Err().Error())
var r3 = gust.Err(errors.New("error"))
var err3 = nil
var result3 = Flatten2(r3, err3)
assert.Equal(t, "error", result3.Err().Error())

func Map ¶

func Map[T any, U any](r gust.Result[T], f func(T) U) gust.Result[U]

Map maps a gust.Result[T] to gust.Result[U] by applying a function to a contained Ok value, leaving an error untouched. This function can be used to compose the results of two functions.

func Map2 ¶ added in v1.8.0

func Map2[T any, U any](v T, err error, f func(T) U) gust.Result[U]

Map2 maps a value and an error as a gust.Result[U] by applying a function to the value.

Examples ¶

var v = 1
var err = nil
var result = Map2(v, err, func(v int) int { return v * 2 })
assert.Equal(t, gust.Ok[int](2), result)

func MapOr ¶

func MapOr[T any, U any](r gust.Result[T], defaultOk U, f func(T) U) U

MapOr returns the provided default (if error), or applies a function to the contained value (if no error), Arguments passed to map_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use MapOrElse, which is lazily evaluated.

func MapOr2 ¶ added in v1.8.0

func MapOr2[T any, U any](v T, err error, defaultOk U, f func(T) U) U

MapOr2 maps a value and an error to U by applying a function to the value, or returns the default if error.

Examples ¶

var v = 1
var err = nil
var result = MapOr2(v, err, func(v int) int { return v * 2 })
assert.Equal(t, gust.Ok[int](2), result)

func MapOrElse ¶

func MapOrElse[T any, U any](r gust.Result[T], defaultFn func(error) U, f func(T) U) U

MapOrElse maps a gust.Result[T] to U by applying fallback function default to a contained error, or function f to a contained Ok value. This function can be used to unpack a successful result while handling an error.

func MapOrElse2 ¶ added in v1.8.0

func MapOrElse2[T any, U any](v T, err error, defaultFn func(error) U, f func(T) U) U

MapOrElse2 maps a value and an error to U by applying a function to the value, or applies the default function if error.

Examples ¶

var v = 1
var err = nil
var result = MapOrElse2(v, err, func(err error) int { return 0 }, func(v int) int { return v * 2 })
assert.Equal(t, gust.Ok[int](2), result)

func XAssert ¶ added in v0.7.0

func XAssert[U any](o gust.Result[any]) gust.Result[U]

XAssert asserts gust.Result[any] as gust.Result[U].

func XAssert2 ¶ added in v1.8.0

func XAssert2[U any](v any, err error) gust.Result[U]

XAssert2 asserts a value and an error as a gust.Result[U].

Examples ¶

var v = 1
var err = nil
var result = XAssert2(v, err)
assert.Equal(t, gust.Ok[int](1), result)