Documentation
¶
Overview ¶
Package result provides helper functions for working with Result types.
Result represents a value that can be either Ok(T) or Err(error). It provides a Rust-inspired way to handle errors in Go without using the traditional (T, error) tuple pattern, enabling chainable error handling.
Examples ¶
// Create a Result
success := result.Ok(42)
failure := result.TryErr[int](errors.New("error"))
// Chain operations
value := success.
Map(func(x int) int { return x * 2 }).
UnwrapOr(0) // Output: 84
// Handle errors
err := failure.
MapErr(func(e error) error { return fmt.Errorf("wrapped: %w", e) }).
Err() // Returns the error
Index ¶
- func Contains[T comparable](r Result[T], x T) bool
- func Contains2[T comparable](v T, err error, x T) bool
- func MapOr[T any, U any](r Result[T], defaultOk U, f func(T) U) U
- func MapOr2[T any, U any](v T, err error, defaultOk U, f func(T) U) U
- func MapOrElse[T any, U any](r Result[T], defaultFn func(error) U, f func(T) U) U
- func MapOrElse2[T any, U any](v T, err error, defaultFn func(error) U, f func(T) U) U
- func ToError(r VoidResult) error
- func UnwrapErrOr(r VoidResult, defaultErr error) error
- type Result
- func And[T any, U any](r1 Result[T], r2 Result[U]) Result[U]
- func And2[T any, U any](v1 T, err1 error, v2 U, err2 error) Result[U]
- func AndThen[T any, U any](r Result[T], op func(T) Result[U]) Result[U]
- func AndThen2[T any, U any](r Result[T], op func(T) (U, error)) Result[U]
- func AndThen3[T any, U any](v T, err error, op func(T) (U, error)) Result[U]
- func Assert[T any, U any](o Result[T]) Result[U]
- func Assert2[T any, U any](v T, err error) Result[U]
- func AssertRet[T any](i any) Result[T]
- func Flatten[T any](r Result[Result[T]]) Result[T]
- func Flatten2[T any](r Result[T], err error) Result[T]
- func FmtErr[T any](format string, args ...any) Result[T]
- func Map[T any, U any](r Result[T], f func(T) U) Result[U]
- func Map2[T any, U any](v T, err error, f func(T) U) Result[U]
- func Ok[T any](ok T) Result[T]
- func Ret[T any](v T, err error) Result[T]
- func TryErr[T any](err any) Result[T]
- func XAssert[U any](o Result[any]) Result[U]
- func XAssert2[U any](v any, err error) Result[U]
- type VoidResult
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Contains ¶
func Contains[T comparable](r Result[T], x T) bool
Contains returns true if the result is an Ok value containing the given value.
func Contains2 ¶
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 MapOr ¶
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 ¶
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, core.Ok[int](2), result)
func MapOrElse ¶
MapOrElse maps a 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 ¶
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, core.Ok[int](2), result)
func ToError ¶
func ToError(r VoidResult) error
ToError converts VoidResult to a standard Go error. Returns nil if IsOk() is true, otherwise returns the error.
Example:
```go
var result result.VoidResult = result.RetVoid(err)
if err := result.ToError(result); err != nil {
return err
}
```
func UnwrapErrOr ¶
func UnwrapErrOr(r VoidResult, defaultErr error) error
UnwrapErrOr returns the contained error value or a provided default for VoidResult.
Example:
```go
var result result.VoidResult = result.RetVoid(err)
err := result.UnwrapErrOr(result, errors.New("default error"))
```
Types ¶
type Result ¶
Result is an alias for core.Result[T]. This allows using result.Result[T] instead of core.Result[T].
Result represents a value that can be either Ok(T) or Err(error). It provides a Rust-inspired way to handle errors in Go without using the traditional (T, error) tuple pattern.
func And2 ¶
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, core.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 ¶
AndThen calls op if the result is Ok, otherwise returns the error of self. This function can be used for control flow based on Result values.
func AndThen2 ¶
AndThen2 calls op if the result is Ok, otherwise returns the error of self. This function can be used for control flow based on Result values.
func AndThen3 ¶
AndThen3 calls op if the result is Ok, otherwise returns the error of self. This function can be used for control flow based on Result values.
func Assert2 ¶
Assert2 asserts a value and an error as a Result[U].
Examples ¶
var v = 1 var err = nil var result = Assert2(v, err) assert.Equal(t, core.Ok[int](1), result)
func Flatten ¶
Flatten converts from Result[Result[T]] to Result[T].
Examples ¶
var r1 = core.Ok(core.Ok(1))
var result1 = Flatten(r1)
assert.Equal(t, core.Ok[int](1), result1)
var r2 = core.Ok(core.TryErr[int](errors.New("error")))
var result2 = Flatten(r2)
assert.Equal(t, "error", result2.Err().Error())
var r3 = core.TryErr[Result[int]](errors.New("error"))
var result3 = Flatten(r3)
assert.Equal(t, "error", result3.Err().Error())
func Flatten2 ¶
Flatten2 converts from `(Result[T], error)` to Result[T].
Examples ¶
var r1 = core.Ok(1)
var err1 = nil
var result1 = Flatten2(r1, err1)
assert.Equal(t, core.Ok[int](1), result1)
var r2 = core.Ok(1)
var err2 = errors.New("error")
var result2 = Flatten2(r2, err2)
assert.Equal(t, "error", result2.Err().Error())
var r3 = core.TryErr[int](errors.New("error"))
var err3 = nil
var result3 = Flatten2(r3, err3)
assert.Equal(t, "error", result3.Err().Error())
func Map ¶
Map maps a Result[T] to 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 ¶
Map2 maps a value and an error as a 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, core.Ok[int](2), result)
func TryErr ¶
TryErr wraps a failure result. NOTE: If err is nil, TryErr(nil) returns Ok with zero value. This follows the principle that nil represents "no error", so TryErr(nil) should be Ok.
Example:
```go
result := result.TryErr[string](nil) // This is an ok state
if result.IsOk() {
fmt.Println("This will be printed")
}
```
type VoidResult ¶
type VoidResult = core.VoidResult
VoidResult is an alias for core.VoidResult. VoidResult is a type alias for Result[Void], used for operations that only return success or failure without a value.
func OkVoid ¶
func OkVoid() VoidResult
OkVoid returns Ok[Void](nil).
Example:
```go var result result.VoidResult = result.OkVoid() ```
func RetVoid ¶
func RetVoid(err error) VoidResult
RetVoid wraps an error as VoidResult (Result[Void]). Returns Ok[Void](nil) if maybeError is nil, otherwise returns Err[Void](maybeError).
Example:
```go var result result.VoidResult = result.RetVoid(maybeError) ```
func TryErrVoid ¶
func TryErrVoid(err any) VoidResult
TryErrVoid wraps a failure result as VoidResult. NOTE: If err is nil, TryErrVoid(nil) returns OkVoid().
Source Files