result
API
result
packageAPI reference for the result
package.
Imports
(3)
S
struct
Result
Result represents either a success value or an error.
pkg/result/result.go:9-12
type Result struct
Example
r := result.Ok(42)
if r.IsOk() { ... }Fields
| Name | Type | Description |
|---|---|---|
| value | T | |
| err | error |
F
function
Ok
Ok creates a successful Result.
Parameters
value
T
Returns
Result[T]
pkg/result/result.go:15-17
func Ok[T any](value T) Result[T]
{
return Result[T]{value: value}
}
F
function
Err
Err creates an error Result.
Parameters
err
error
Returns
Result[T]
pkg/result/result.go:20-22
func Err[T any](err error) Result[T]
{
return Result[T]{err: err}
}
F
function
Map
Map transforms the value if successful.
Parameters
r
Result[T]
fn
func(T) U
Returns
Result[U]
pkg/result/result.go:78-83
func Map[T, U any](r Result[T], fn func(T) U) Result[U]
{
if r.err != nil {
return Err[U](r.err)
}
return Ok(fn(r.value))
}Example
r := result.Ok(10)
r2 := result.Map(r, func(i int) string { return strconv.Itoa(i) })
F
function
FlatMap
FlatMap transforms the value with a function that returns a Result.
Parameters
r
Result[T]
fn
func(T) Result[U]
Returns
Result[U]
pkg/result/result.go:86-91
func FlatMap[T, U any](r Result[T], fn func(T) Result[U]) Result[U]
{
if r.err != nil {
return Err[U](r.err)
}
return fn(r.value)
}
F
function
From
From wraps a traditional (value, error) tuple into a Result.
Parameters
value
T
err
error
Returns
Result[T]
pkg/result/result.go:94-99
func From[T any](value T, err error) Result[T]
{
if err != nil {
return Err[T](err)
}
return Ok(value)
}
F
function
Try
Try executes fn and wraps the result.
Parameters
fn
func() (T, error)
Returns
Result[T]
pkg/result/result.go:102-105
func Try[T any](fn func() (T, error)) Result[T]
{
v, err := fn()
return From(v, err)
}
F
function
Must
Must panics if the result is an error, otherwise returns the value.
Parameters
r
Result[T]
Returns
T
pkg/result/result.go:108-110
func Must[T any](r Result[T]) T
{
return r.Unwrap()
}
F
function
TestResult_Ok
Parameters
t
pkg/result/result_test.go:9-21
func TestResult_Ok(t *testing.T)
{
r := Ok(42)
if !r.IsOk() {
t.Error("IsOk should be true")
}
if r.IsErr() {
t.Error("IsErr should be false")
}
if r.Unwrap() != 42 {
t.Errorf("Unwrap: got %d, want 42", r.Unwrap())
}
}
F
function
TestResult_Err
Parameters
t
pkg/result/result_test.go:23-35
func TestResult_Err(t *testing.T)
{
r := Err[int](errors.New("failed"))
if r.IsOk() {
t.Error("IsOk should be false")
}
if !r.IsErr() {
t.Error("IsErr should be true")
}
if r.Error() == nil {
t.Error("Error should not be nil")
}
}
F
function
TestResult_Unwrap_Panic
Parameters
t
pkg/result/result_test.go:37-47
func TestResult_Unwrap_Panic(t *testing.T)
{
r := Err[int](errors.New("panic test"))
defer func() {
if recover() == nil {
t.Error("Unwrap should panic on error")
}
}()
r.Unwrap()
}
F
function
TestResult_UnwrapOr
Parameters
t
pkg/result/result_test.go:49-59
func TestResult_UnwrapOr(t *testing.T)
{
ok := Ok(10)
err := Err[int](errors.New("fail"))
if ok.UnwrapOr(0) != 10 {
t.Error("UnwrapOr should return value for Ok")
}
if err.UnwrapOr(99) != 99 {
t.Error("UnwrapOr should return default for Err")
}
}
F
function
TestResult_UnwrapOrElse
Parameters
t
pkg/result/result_test.go:61-71
func TestResult_UnwrapOrElse(t *testing.T)
{
r := Err[int](errors.New("custom"))
val := r.UnwrapOrElse(func(e error) int {
return len(e.Error())
})
if val != 6 {
t.Errorf("UnwrapOrElse: got %d, want 6", val)
}
}
F
function
TestResult_Value
Parameters
t
pkg/result/result_test.go:73-83
func TestResult_Value(t *testing.T)
{
r := Ok("hello")
v, err := r.Value()
if err != nil {
t.Error("err should be nil")
}
if v != "hello" {
t.Errorf("value: got %q, want %q", v, "hello")
}
}
F
function
TestMap
Parameters
t
pkg/result/result_test.go:85-92
func TestMap(t *testing.T)
{
r := Ok(5)
doubled := Map(r, func(n int) int { return n * 2 })
if doubled.Unwrap() != 10 {
t.Errorf("Map: got %d, want 10", doubled.Unwrap())
}
}
F
function
TestMap_PropagatesError
Parameters
t
pkg/result/result_test.go:94-101
func TestMap_PropagatesError(t *testing.T)
{
r := Err[int](errors.New("original"))
mapped := Map(r, func(n int) string { return "never" })
if mapped.IsOk() {
t.Error("Map should propagate error")
}
}
F
function
TestFlatMap
Parameters
t
pkg/result/result_test.go:103-113
func TestFlatMap(t *testing.T)
{
r := Ok("123")
parsed := FlatMap(r, func(s string) Result[int] {
n, err := strconv.Atoi(s)
return From(n, err)
})
if parsed.Unwrap() != 123 {
t.Errorf("FlatMap: got %d, want 123", parsed.Unwrap())
}
}
F
function
TestFrom
Parameters
t
pkg/result/result_test.go:115-125
func TestFrom(t *testing.T)
{
r1 := From(42, nil)
if !r1.IsOk() {
t.Error("From with nil error should be Ok")
}
r2 := From(0, errors.New("fail"))
if !r2.IsErr() {
t.Error("From with error should be Err")
}
}
F
function
TestTry
Parameters
t
pkg/result/result_test.go:127-135
func TestTry(t *testing.T)
{
r := Try(func() (int, error) {
return 100, nil
})
if r.Unwrap() != 100 {
t.Errorf("Try: got %d, want 100", r.Unwrap())
}
}
F
function
TestMust
Parameters
t
pkg/result/result_test.go:137-142
func TestMust(t *testing.T)
{
r := Ok("success")
if Must(r) != "success" {
t.Error("Must should return value")
}
}