monad

type Monad ¶

type Monad[A, B, HKTA, HKTB, HKTFAB any] interface {
	applicative.Applicative[A, B, HKTA, HKTB, HKTFAB]
	chain.Chainable[A, B, HKTA, HKTB, HKTFAB]
}

Monad represents the full monadic interface, combining Applicative and Chainable.

A Monad provides the complete set of operations for working with computational contexts: - Map (from Functor): transform values within a context - Of (from Pointed): lift pure values into a context - Ap (from Apply): apply wrapped functions to wrapped values - Chain (from Chainable): sequence dependent computations

Monads must satisfy the monad laws:

Left Identity:

Chain(f)(Of(a)) == f(a)

Right Identity:

Chain(Of)(m) == m

Associativity:

Chain(g)(Chain(f)(m)) == Chain(x => Chain(g)(f(x)))(m)

Type Parameters:

• A: The input value type
• B: The output value type
• HKTA: The higher-kinded type containing A
• HKTB: The higher-kinded type containing B
• HKTFAB: The higher-kinded type containing a function from A to B

Example:

// Given a Monad for Option
var m Monad[int, string, Option[int], Option[string], Option[func(int) string]]

// Use Of to create a value
value := m.Of(42) // Some(42)

// Use Chain for dependent operations
chainFn := m.Chain(func(x int) Option[string] {
  if x > 0 {
    return Some(strconv.Itoa(x))
  }
  return None[string]()
})
result := chainFn(value) // Some("42")