option

func MakeFunctor ¶

func MakeFunctor[A, B any]() Functor[A, B]

Functor implements the functoric operations for Option. A functor is a type that can be mapped over, transforming the contained value while preserving the structure.

Example:

f := Functor[int, string]()
mapper := f.Map(strconv.Itoa)
result := mapper(Some(42)) // Some("42")

func FromNonZero ¶

func FromNonZero[A comparable]() Kleisli[A, A]

FromNonZero returns a function that creates an Option based on whether a value is non-zero. Returns Some if the value is non-zero, None otherwise.

Example:

checkNonZero := FromNonZero[int]()
result := checkNonZero(5)  // Some(5)
result := checkNonZero(0)  // None

func FromPredicate ¶

func FromPredicate[A any](pred func(A) bool) Kleisli[A, A]

FromPredicate returns a function that creates an Option based on a predicate. The returned function will wrap a value in Some if the predicate is satisfied, otherwise None.

Parameters:

• pred: A predicate function that determines if a value should be wrapped in Some

Example:

isPositive := FromPredicate(N.MoreThan(0))
result := isPositive(5)  // Some(5)
result := isPositive(-1) // None

func FromZero ¶

func FromZero[A comparable]() Kleisli[A, A]

FromZero returns a function that creates an Option based on whether a value is the zero value. Returns Some if the value is the zero value, None otherwise.

Example:

checkZero := FromZero[int]()
result := checkZero(0)  // Some(0)
result := checkZero(5)  // None

func TraverseArray ¶

func TraverseArray[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B]

TraverseArray transforms an array by applying a function that returns an Option to each element. Returns Some containing the array of results if all operations succeed, None if any fails.

Example:

validate := func(x int) Option[int] {
    if x > 0 { return Some(x * 2) }
    return None[int]()
}
result := TraverseArray(validate)([]int{1, 2, 3}) // Some([2, 4, 6])
result := TraverseArray(validate)([]int{1, -1, 3}) // None

func TraverseArrayG ¶

func TraverseArrayG[GA ~[]A, GB ~[]B, A, B any](f Kleisli[A, B]) Kleisli[GA, GB]

TraverseArrayG transforms an array by applying a function that returns an Option to each element. Returns Some containing the array of results if all operations succeed, None if any fails. This is the generic version that works with custom slice types.

Example:

parse := func(s string) Option[int] {
    n, err := strconv.Atoi(s)
    if err != nil { return None[int]() }
    return Some(n)
}
result := TraverseArrayG[[]string, []int](parse)([]string{"1", "2", "3"}) // Some([1, 2, 3])
result := TraverseArrayG[[]string, []int](parse)([]string{"1", "x", "3"}) // None

func TraverseArrayWithIndex ¶

func TraverseArrayWithIndex[A, B any](f func(int, A) (B, bool)) Kleisli[[]A, []B]

TraverseArrayWithIndex transforms an array by applying an indexed function that returns an Option. The function receives both the index and the element.

Example:

f := func(i int, x int) Option[int] {
    if x > i { return Some(x) }
    return None[int]()
}
result := TraverseArrayWithIndex(f)([]int{1, 2, 3}) // Some([1, 2, 3])

func TraverseArrayWithIndexG ¶

func TraverseArrayWithIndexG[GA ~[]A, GB ~[]B, A, B any](f func(int, A) (B, bool)) Kleisli[GA, GB]

TraverseArrayWithIndexG transforms an array by applying an indexed function that returns an Option. The function receives both the index and the element. This is the generic version that works with custom slice types.

Example:

f := func(i int, s string) Option[string] {
    return Some(fmt.Sprintf("%d:%s", i, s))
}
result := TraverseArrayWithIndexG[[]string, []string](f)([]string{"a", "b"}) // Some(["0:a", "1:b"])

func TraverseIter ¶

func TraverseIter[A, B any](f Kleisli[A, B]) Kleisli[Seq[A], Seq[B]]

TraverseIter transforms a sequence by applying a function that returns an Option to each element. Returns Some containing a sequence of results if all operations succeed, None if any fails. This function is useful for processing sequences where each element may fail validation or transformation.

The traversal short-circuits on the first None encountered, making it efficient for validation pipelines. The resulting sequence is lazy and will only be evaluated when iterated.

Example:

// Parse a sequence of strings to integers
parse := func(s string) Option[int] {
    n, err := strconv.Atoi(s)
    if err != nil { return None[int]() }
    return Some(n)
}

// Create a sequence of strings
strings := func(yield func(string) bool) {
    for _, s := range []string{"1", "2", "3"} {
        if !yield(s) { return }
    }
}

result := TraverseIter(parse)(strings)
// result is Some(sequence of [1, 2, 3])

// With invalid input
invalidStrings := func(yield func(string) bool) {
    for _, s := range []string{"1", "invalid", "3"} {
        if !yield(s) { return }
    }
}

result := TraverseIter(parse)(invalidStrings)
// result is None because "invalid" cannot be parsed

// Parse a sequence of strings to integers
parse := func(s string) (int, bool) {
	n, err := strconv.Atoi(s)
	if err != nil {
		return None[int]()
	}
	return Some(n)
}

// Create a sequence of valid strings
validStrings := seqFromSlice([]string{"1", "2", "3"})
result, resultok := TraverseIter(parse)(validStrings)

if IsSome(result, resultok) {
	numbers := collectSeq(result)
	fmt.Println(numbers)
}

// Create a sequence with invalid string
invalidStrings := seqFromSlice([]string{"1", "invalid", "3"})
result2, result2ok := TraverseIter(parse)(invalidStrings)

if IsNone(result2, result2ok) {
	fmt.Println("Parsing failed")
}

Output:

[1 2 3]
Parsing failed

func TraverseRecord ¶

func TraverseRecord[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A, map[K]B]

TraverseRecord transforms a record (map) by applying a function that returns an Option to each value. Returns Some containing the map of results if all operations succeed, None if any fails.

Example:

validate := func(x int) Option[string] {
    if x > 0 { return Some(fmt.Sprintf("%d", x)) }
    return None[string]()
}
input := map[string]int{"a": 1, "b": 2}
result := TraverseRecord(validate)(input) // Some(map[a:"1" b:"2"])

func TraverseRecordG ¶

func TraverseRecordG[GA ~map[K]A, GB ~map[K]B, K comparable, A, B any](f Kleisli[A, B]) Kleisli[GA, GB]

TraverseRecordG transforms a record (map) by applying a function that returns an Option to each value. Returns Some containing the map of results if all operations succeed, None if any fails. This is the generic version that works with custom map types.

Example:

validate := func(x int) Option[int] {
    if x > 0 { return Some(x * 2) }
    return None[int]()
}
input := map[string]int{"a": 1, "b": 2}
result := TraverseRecordG[map[string]int, map[string]int](validate)(input) // Some(map[a:2 b:4])

func TraverseRecordWithIndex ¶

func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) (B, bool)) Kleisli[map[K]A, map[K]B]

TraverseRecordWithIndex transforms a record by applying a function that receives both key and value. Returns Some containing the map of results if all operations succeed, None if any fails.

Example:

f := func(k string, v int) Option[int] {
    if v > 0 { return Some(v) }
    return None[int]()
}
input := map[string]int{"a": 1, "b": 2}
result := TraverseRecordWithIndex(f)(input) // Some(map[a:1 b:2])

func TraverseRecordWithIndexG ¶

func TraverseRecordWithIndexG[GA ~map[K]A, GB ~map[K]B, K comparable, A, B any](f func(K, A) (B, bool)) Kleisli[GA, GB]

TraverseRecordWithIndexG transforms a record by applying a function that receives both key and value. Returns Some containing the map of results if all operations succeed, None if any fails. This is the generic version that works with custom map types.

Example:

f := func(k string, v int) Option[string] {
    return Some(fmt.Sprintf("%s:%d", k, v))
}
input := map[string]int{"a": 1, "b": 2}
result := TraverseRecordWithIndexG[map[string]int, map[string]string](f)(input) // Some(map[a:"a:1" b:"b:2"])

func Alt ¶

func Alt[A any](that func() (A, bool)) Operator[A, A]

Alt returns a function that provides an alternative Option if the input is None.

Parameters:

• that: A function that provides an alternative Option

Example:

withDefault := Alt(func() (int, bool) { return 0, true })
result := withDefault(Some(5)) // Some(5)
result := withDefault(None[int]()) // Some(0)

func Ap ¶

func Ap[B, A any](fa A, faok bool) Operator[func(A) B, B]

Ap is the curried applicative functor for Option. Returns a function that applies an Option-wrapped function to the given Option value.

Parameters:

• fa: The value of the Option
• faok: Whether the Option contains a value (true for Some, false for None)

Example:

fa := Some(5)
applyTo5 := Ap[int](fa)
fab := Some(N.Mul(2))
result := applyTo5(fab) // Some(10)

func Bind ¶

func Bind[S1, S2, A any](
	setter func(A) func(S1) S2,
	f Kleisli[S1, A],
) Operator[S1, S2]

Bind attaches the result of a computation to a context S1 to produce a context S2. This is used in do-notation style to sequentially build up a context.

Parameters:

• setter: A function that takes a value and returns a function to update the context
• f: A function that computes an Option value from the current context

Example:

type State struct { x int; y int }
result := F.Pipe2(
    Do(State{}),
    Bind(func(x int) func(State) State {
        return func(s State) State { s.x = x; return s }
    }, func(s State) (int, bool) { return 42, true }),
)

func BindL ¶

func BindL[S, T any](
	lens L.Lens[S, T],
	f Kleisli[T, T],
) Operator[S, S]

BindL attaches the result of a computation to a context using a lens-based setter. This is a convenience function that combines Bind with a lens, allowing you to use optics to update nested structures based on their current values.

The lens parameter provides both the getter and setter for a field within the structure S. The computation function f receives the current value of the focused field and returns an Option that produces the new value.

Unlike ApSL, BindL uses monadic sequencing, meaning the computation f can depend on the current value of the focused field.

Example:

type Counter struct {
    Value int
}

valueLens := lens.MakeLens(
    func(c Counter) int { return c.Value },
    func(c Counter, v int) Counter { c.Value = v; return c },
)

// Increment the counter, but return None if it would exceed 100
increment := func(v int) option.Option[int] {
    if v >= 100 {
        return option.None[int]()
    }
    return option.Some(v + 1)
}

result := F.Pipe1(
    option.Some(Counter{Value: 42}),
    option.BindL(valueLens, increment),
) // Some(Counter{Value: 43})

Parameters:

• lens: A lens that focuses on a field within the structure S
• f: A function that computes an Option value from the current field value

func BindTo ¶

func BindTo[S1, T any](
	setter func(T) S1,
) Operator[T, S1]

BindTo initializes a new state S1 from a value T. This is typically used as the first operation after creating an Option value.

Parameters:

• setter: A function that creates the initial context from a value

Example:

type State struct { value int }
result := F.Pipe1(
    Some(42),
    BindTo(func(x int) State { return State{value: x} }),
)

func Chain ¶

func Chain[A, B any](f Kleisli[A, B]) Operator[A, B]

Chain returns a function that applies an Option-returning function to an Option value. This is the curried form of the monadic bind operation.

Parameters:

• f: A function that takes a value and returns an Option

Example:

validate := Chain(func(x int) (int, bool) {
    if x > 0 { return x * 2, true }
    return 0, false
})
result := validate(Some(5)) // Some(10)

func ChainFirst ¶

func ChainFirst[A, B any](f Kleisli[A, B]) Operator[A, A]

ChainFirst returns a function that applies an Option-returning function but keeps the original value.

Parameters:

• f: A function that takes a value and returns an Option (result is used only for success/failure)

Example:

logAndKeep := ChainFirst(func(x int) (string, bool) {
    fmt.Println(x)
    return "logged", true
})
result := logAndKeep(Some(5)) // Some(5)

func ChainTo ¶

func ChainTo[A, B any](b B, bok bool) Operator[A, B]

ChainTo returns a function that ignores its input Option and returns a fixed Option.

Parameters:

• b: The value of the replacement Option
• bok: Whether the replacement Option contains a value

Example:

replaceWith := ChainTo(Some("hello"))
result := replaceWith(Some(42)) // Some("hello")

func Filter ¶

func Filter[A any](pred func(A) bool) Operator[A, A]

Filter keeps the Option if it's Some and the predicate is satisfied, otherwise returns None.

Parameters:

• pred: A predicate function to test the Option value

Example:

isPositive := Filter(N.MoreThan(0))
result := isPositive(Some(5)) // Some(5)
result := isPositive(Some(-1)) // None
result := isPositive(None[int]()) // None

func Flap ¶

func Flap[B, A any](a A) Operator[func(A) B, B]

Flap returns a function that applies a value to an Option-wrapped function.

Parameters:

• a: The value to apply to the function

Example:

applyFive := Flap[int](5)
fab := Some(N.Mul(2))
result := applyFive(fab) // Some(10)

func Let ¶

func Let[S1, S2, B any](
	key func(B) func(S1) S2,
	f func(S1) B,
) Operator[S1, S2]

Let attaches the result of a pure computation to a context S1 to produce a context S2. Unlike Bind, the computation function returns a plain value, not an Option.

Parameters:

• key: A function that takes a value and returns a function to update the context
• f: A pure function that computes a value from the current context

Example:

type State struct { x int; computed int }
result := F.Pipe2(
    Do(State{x: 5}),
    Let(func(c int) func(State) State {
        return func(s State) State { s.computed = c; return s }
    }, func(s State) int { return s.x * 2 }),
)

func LetL ¶

func LetL[S, T any](
	lens L.Lens[S, T],
	f Endomorphism[T],
) Operator[S, S]

LetL attaches the result of a pure computation to a context using a lens-based setter. This is a convenience function that combines Let with a lens, allowing you to use optics to update nested structures with pure transformations.

The lens parameter provides both the getter and setter for a field within the structure S. The transformation function f receives the current value of the focused field and returns the new value directly (not wrapped in Option).

This is useful for pure transformations that cannot fail, such as mathematical operations, string manipulations, or other deterministic updates.

Example:

type Counter struct {
    Value int
}

valueLens := lens.MakeLens(
    func(c Counter) int { return c.Value },
    func(c Counter, v int) Counter { c.Value = v; return c },
)

// Double the counter value
double := func(v int) int { return v * 2 }

result := F.Pipe1(
    option.Some(Counter{Value: 21}),
    option.LetL(valueLens, double),
) // Some(Counter{Value: 42})

Parameters:

• lens: A lens that focuses on a field within the structure S
• f: A pure transformation function for the field value

func LetTo ¶

func LetTo[S1, S2, B any](
	key func(B) func(S1) S2,
	b B,
) Operator[S1, S2]

LetTo attaches a constant value to a context S1 to produce a context S2.

Parameters:

• key: A function that takes a value and returns a function to update the context
• b: The constant value to attach to the context

Example:

type State struct { x int; name string }
result := F.Pipe2(
    Do(State{x: 5}),
    LetTo(func(n string) func(State) State {
        return func(s State) State { s.name = n; return s }
    }, "example"),
)

func LetToL ¶

func LetToL[S, T any](
	lens L.Lens[S, T],
	b T,
) Operator[S, S]

LetToL attaches a constant value to a context using a lens-based setter. This is a convenience function that combines LetTo with a lens, allowing you to use optics to set nested fields to specific values.

The lens parameter provides the setter for a field within the structure S. Unlike LetL which transforms the current value, LetToL simply replaces it with the provided constant value b.

This is useful for resetting fields, initializing values, or setting fields to predetermined constants.

Example:

type Config struct {
    Debug   bool
    Timeout int
}

debugLens := lens.MakeLens(
    func(c Config) bool { return c.Debug },
    func(c Config, d bool) Config { c.Debug = d; return c },
)

result := F.Pipe1(
    option.Some(Config{Debug: true, Timeout: 30}),
    option.LetToL(debugLens, false),
) // Some(Config{Debug: false, Timeout: 30})

Parameters:

• lens: A lens that focuses on a field within the structure S
• b: The constant value to set the field to

func Map ¶

func Map[A, B any](f func(a A) B) Operator[A, B]

Map returns a function that applies a transformation to the value inside an Option. If the Option is None, returns None.

Parameters:

• f: A transformation function to apply to the Option value

Example:

double := Map(N.Mul(2))
result := double(Some(5)) // Some(10)
result := double(None[int]()) // None

func MapTo ¶

func MapTo[A, B any](b B) Operator[A, B]

MapTo returns a function that replaces the value inside an Option with a constant.

Parameters:

• b: The constant value to replace with

Example:

replaceWith42 := MapTo[string, int](42)
result := replaceWith42(Some("hello")) // Some(42)

func MakePointed ¶

func MakePointed[A any]() Pointed[A]

Pointed implements the Pointed operations for Option. A pointed functor is a functor with an Of operation that wraps a value.

Example:

p := Pointed[int]()
result := p.Of(42) // Some(42)