Run a list of Evals in sequence and then combine their results into a list. If any of the Evals fail, the whole sequence fails.

📝 Note: you might find this called sequence in some other languages like Haskell or PureScript.

✨ Tip: in other languages there might be a more general version of this function called traverse. You can easily create that by combining list.map and all!

[ 1, 2, 3 ]
    |> list.map(eval.succeed)
    |> eval.all
    // => Eval(List(Int), e, ctx)

Intended to be used in combination with the succeed{N} functions. This runs an Eval and then applies it to the result of the second argument.

case expr {
  Add(lhs, rhs) ->
    succeed2(fn (x, y) { x + y })
      |> apply(eval(lhs))
      |> apply(eval(rhs))

  ...
}

📝 Note: you might find this called ap or <*> in some other languages like Haskell or PureScript. In this context, the Eval type would be known as an applicative functor.

Run an Eval and then attempt to recover from an error by applying a function that takes the error value and returns another Eval.

Construct an Eval from a function that takes some context and returns a pair of a new context and some Result value. This is provided as a fallback if none of the functions here or in eval/context are getting you where you need to go: generally you should avoid using this in favour of combining the other functions in this module!

Construct an Eval from an optional value and an error to throw if that value is None. This is useful for situations where you have some function or value that returns an Option but is not dependent on the context.

Construct an Eval from a result. This is useful for situations where you have some function or value that returns a Result but is not dependent on the context.

Transform the value produced by an Eval using the given function.

📝 Note: you might find this called fmap or <$> in some other languages like Haskell or PureScript. In this context, the Eval type would be known as a functor.

📝 Note: you might find this called liftA2 or liftM2 in some other languages like Haskell or PureScript.

Just like map but for error-producing steps instead. Transforms the error produced by some Eval step using the given function.

Run an Eval step but then replace its result with some other fixed value. Often used in tandem with effectful steps that often do something but don’t produce any meaninful value (and so are usually Eval(Nil, e, ctx)).

Just like replace but for error-producing steps instead. Replaces the error thrown by some Eval step with another, fixed, value.

Given an Eval, actuall perform the computation by also providing the context that the computation is running in.

Construct an Eval that always succeeds with the given value, regardless of context.

📝 Note: you might find this called pure or return in some other languages like Haskell or PureScript.

Like succeed, but used specifically with a function that takes two arguments. This is most commonly used with apply to run a series of Evals in a pipeline to build up some more complex value.

📝 Note: when used this way, this is often known as “applicative programming”. In this context, the Eval type would be known as an applicative functor.

❓ Why are these succeedN functions necessary? In other functional programming languages, like Elm or Haskell, functions are curried which means all functions are actually just a series of single-argument functions that return other functions. We can achieve this in Gleam by using the function.curryN functions.

We need the functions passed to succeed to be curried to work properly with apply, and so we provide a handful of these succeedN functions that do the currying for you.

Like succeed, but used specifically with a function that takes three arguments. This is most commonly used with apply to run a series of Evals in a pipeline to build up some more complex value.

Like succeed, but used specifically with a function that takes four arguments. This is most commonly used with apply to run a series of Evals in a pipeline to build up some more complex value.

Like succeed, but used specifically with a function that takes five arguments. This is most commonly used with apply to run a series of Evals in a pipeline to build up some more complex value.

Like succeed, but used specifically with a function that takes six arguments. This is most commonly used with apply to run a series of Evals in a pipeline to build up some more complex value.

Run an Eval and then apply a function that returns another Eval to the result. This can be useful for chaining together multiple Evals.

📝 Note: you might find this called bind, >>=, flatMap, or andThen in some other languages like Haskell, Elm, or PureScript. In this context, the Eval type would be known as a monad.

Construct an Eval that always fails with the given error, regardless of context. Often used in combination with then to run some Eval and then potentially fail based on the result of that computation.

eval(expr) |> then(fn (y) {
  case y == 0.0 {
    True ->
      throw(DivisionByZero)

    False ->
      succeed(y)
  }
})