helpers

Documentation

Index

• func Chain[T any](fns ...func(T) T) func(T) T
• func ChainWithErr[T any](fns ...func(T) (T, error)) func(T) (T, error)
• func Default[T comparable](value T, defaultValue T) T
• func DefaultWithFunc[T comparable](value T, defaultValue func() T) T
• func ErrorIf(condition bool, format string, a ...any) error
• func If[T any](condition bool, trueVal T, falseVal T) T
• func IfFunc[T any](condition bool, trueFunc func() T, falseFunc func() T) T
• func IsEmpty[T comparable](value T) bool
• func IsType[T any](value any) bool
• func IsZero[T comparable](value T) bool
• func Optional[T any](value *T) *T
• func PanicIf(condition bool, format string, a ...any)
• func Pipe[T any](fns ...func(T) T) func(T) T
• func PipeWithErr[T any](fns ...func(T) (T, error)) func(T) (T, error)
• func Ptr[T any](value T) *T
• func Repeat(fn func() error, times int) error
• func Retry(fn func() error, attempts int, sleeps ...time.Duration) (err error)
• func Scan(src any, dest any) error
• func Tap[T any](value T, callbacks ...func(T)) T
• func Timeout(fn func() error, timeout time.Duration) error
• func Transform[T, R any](value T, callback func(T) R) R
• func Unless[T any](condition bool, falseVal T, trueVal T) T
• func Until(fn func() bool, sleeps ...time.Duration) bool
• func Val[T any](value *T) T
• func When[T any](value T, condition bool, callbacks ...func(T) T) T
• func With[T any](value T, callbacks ...func(T) T) T
• type Proxy
  • func NewProxy[T any](value T) *Proxy[T]
  • func (p *Proxy[T]) Tap(callbacks ...func(T)) *Proxy[T]
  • func (p *Proxy[T]) Transform(callback func(T) T) *Proxy[T]
  • func (p *Proxy[T]) Unless(condition bool, callbacks ...func(T) T) *Proxy[T]
  • func (p *Proxy[T]) Value() T
  • func (p *Proxy[T]) When(condition bool, callbacks ...func(T) T) *Proxy[T]
  • func (p *Proxy[T]) With(callbacks ...func(T) T) *Proxy[T]

Functions

func Chain

func Chain[T any](fns ...func(T) T) func(T) T

Chain is a reverse Pipe

Chain(m1, m2, m3)(value) => m1(m2(m3(value)))

func ChainWithErr

func ChainWithErr[T any](fns ...func(T) (T, error)) func(T) (T, error)

ChainWithErr is a reverse PipeWithErr

ChainWithErr(m1, m2, m3)(value) => m1(m2(m3(value)))

func Default

func Default[T comparable](value T, defaultValue T) T

Default returns defaultValue if value is zero, otherwise value.

Default("", "foo") // "foo"
Default("bar", "foo") // "bar"

func DefaultWithFunc

func DefaultWithFunc[T comparable](value T, defaultValue func() T) T

DefaultWithFunc returns defaultValue if value is zero, otherwise value.

DefaultWithFunc("", func() string { return "foo" }) // "foo"
DefaultWithFunc("bar", func() string { return "foo" }) // "bar"

func ErrorIf

func ErrorIf(condition bool, format string, a ...any) error

ErrorIf returns an error if the condition is true.

ErrorIf(true, "error") => error
ErrorIf(false, "error") => nil
ErrorIf(true, "error %s", "with value") => error with value

func If

func If[T any](condition bool, trueVal T, falseVal T) T

If returns trueVal if condition is true, otherwise falseVal.

If(true, "foo", "bar") // "foo"
If(false, "foo", "bar") // "bar"

Warning: that the trueVal and falseVal in this method will also be executed during runtime, and there may be panics during use. Please be cautious when using it. You can use IfFunc to avoid this situation.

Example:

var nilVal *foo
If(nilVal != nil, nilVal.Name, "") // panic: runtime error: invalid memory address or nil pointer dereference

func IfFunc

func IfFunc[T any](condition bool, trueFunc func() T, falseFunc func() T) T

IfFunc returns trueFunc() if condition is true, otherwise falseFunc().

IfFunc(true, func() string {
	return "foo"
}, func() string {
	return "bar"
}) // "foo"

func IsEmpty

func IsEmpty[T comparable](value T) bool

IsEmpty returns true if the value is zero.

IsEmpty(0) // true
IsEmpty("") // true

func IsType

func IsType[T any](value any) bool

IsType returns true if the value is the type.

IsType[int](1) // true
IsType[int]("foo") // false

func IsZero

func IsZero[T comparable](value T) bool

IsZero returns true if the value is zero.

IsZero(0) // true
IsZero("") // true
IsZero("foo") // false

func Optional

func Optional[T any](value *T) *T

Optional returns the value if it is not nil, otherwise the zero value.

Optional(&foo{Name: "bar"}) // &foo{Name: "bar"}
Optional[foo](nil) // &foo{}
Optional[int](nil) // *int(0)

func PanicIf

func PanicIf(condition bool, format string, a ...any)

PanicIf panics if the condition is true.

PanicIf(true, "error") => panic("error")
PanicIf(false, "error") => nil
PanicIf(true, "error %s", "with value") => panic("error with value")

func Pipe

func Pipe[T any](fns ...func(T) T) func(T) T

Pipe is a function that takes a value and returns a value

Pipe(m1, m2, m3)(value) => m3(m2(m1(value)))

func PipeWithErr

func PipeWithErr[T any](fns ...func(T) (T, error)) func(T) (T, error)

PipeWithErr is a function that takes a value and returns a value and an error

PipeWithErr(m1, m2, m3)(value) => m3(m2(m1(value)))

func Ptr

func Ptr[T any](value T) *T

Ptr returns a pointer to the value.

Ptr("foo") // *string("foo")
Ptr(1) // *int(1)

func Repeat

func Repeat(fn func() error, times int) error

Repeat runs the given function `times` times or until an error is returned.

Repeat(func() error { fmt.Println("hello"); return nil }, 3) => prints hello 3 times and returns nil
Repeat(func() error { return fmt.Errorf("error") }, 3) => returns error

func Retry

func Retry(fn func() error, attempts int, sleeps ...time.Duration) (err error)

Retry retries the given function until it returns nil or the attempts are exhausted. `sleeps` is the time to sleep between each attempt. If `sleeps` is not provided, it will not sleep.

Retry(func() error { return nil }, 3) => nil
Retry(func() error { return nil }, 3, time.Second) => nil
Retry(func() error { return fmt.Errorf("error") }, 3) => error

func Scan

func Scan(src any, dest any) error

Scan sets the value of dest to the value of src.

var foo string
Scan("bar", &foo) // foo == "bar"

var bar struct {A string}
Scan(struct{A string}{"foo"}, &bar) // bar == struct{A string}{"foo"}

func Tap

func Tap[T any](value T, callbacks ...func(T)) T

Tap calls the given callback with the given value then returns the value.

Tap("foo", func(s string) {
	fmt.Println(s) // "foo" and os.Stdout will print "foo"
}, func(s string) {
	// more callbacks
}...)

func Timeout

func Timeout(fn func() error, timeout time.Duration) error

Timeout runs the given function with a timeout. If the function does not return before the timeout, it returns an error.

Timeout(func() error { return nil }, time.Second) => nil
Timeout(func() error { time.Sleep(2 * time.Second); return nil }, time.Second) => error

func Transform

func Transform[T, R any](value T, callback func(T) R) R

Transform calls the given callback with the given value then return the result.

Transform(1, strconv.Itoa) // "1"
Transform("foo", func(s string) *foo {
	return &foo{Name: s}
}) // &foo{Name: "foo"}

func Unless

func Unless[T any](condition bool, falseVal T, trueVal T) T

Unless returns falseVal if condition is true, otherwise trueVal.

Unless(true, "foo", "bar") // "bar"
Unless(false, "foo", "bar") // "foo"

func Until

func Until(fn func() bool, sleeps ...time.Duration) bool

Until retries the given function until it returns true. `sleeps` is the time to sleep between each attempt. If `sleeps` is not provided, it will not sleep.

Until(func() bool { return true }) => true
Until(func() bool { return true }, time.Second) => true

func Val

func Val[T any](value *T) T

Val returns the value of the pointer. If the pointer is nil, return the zero value.

Val((*string)(nil)) // ""
Val(Ptr("foo")) // "foo"

func When

func When[T any](value T, condition bool, callbacks ...func(T) T) T

When calls the given callbacks with the given value if condition is true then return the value.

When("foo", true, func(s string) string {
	return s + "bar"
}, func(s string) string {
	return s + "baz"
}) // "foobarbaz"

func With

func With[T any](value T, callbacks ...func(T) T) T

With calls the given callbacks with the given value then return the value.

With("foo", func(s string) string {
	return s + "bar"
}, func(s string) string {
	return s + "baz"
}) // "foobarbaz"

Types

type Proxy

type Proxy[T any] struct {
	// contains filtered or unexported fields
}

func NewProxy

func NewProxy[T any](value T) *Proxy[T]

func (*Proxy[T]) Tap

func (p *Proxy[T]) Tap(callbacks ...func(T)) *Proxy[T]

func (*Proxy[T]) Transform

func (p *Proxy[T]) Transform(callback func(T) T) *Proxy[T]

func (*Proxy[T]) Unless

func (p *Proxy[T]) Unless(condition bool, callbacks ...func(T) T) *Proxy[T]

func (*Proxy[T]) Value

func (p *Proxy[T]) Value() T

func (*Proxy[T]) When

func (p *Proxy[T]) When(condition bool, callbacks ...func(T) T) *Proxy[T]

func (*Proxy[T]) With

func (p *Proxy[T]) With(callbacks ...func(T) T) *Proxy[T]