Std.Result

24 public declarations

• all&Array[Result[T, E]] -> Result[Array[T], E]

  Every success, or the first failure.

  fn
• andThenResult[T, E] -> fn(T) -> Result[U, E] -> Result[U, E]

  The success transformed into another result, flattened.

  fn
• errResult[T, E] -> Option[E]

  The failure if there was one.

  fn
• errOrResult[T, E] -> E -> E

  The failure, or a fallback when the operation succeeded.

  fn
• failures&Array[Result[T, E]] -> Array[E]

  Every failure, with the successes dropped.

  fn
• flattenResult[Result[T, E], E] -> Result[T, E]

  A nested result flattened by one level.

  fn
• foldResult[T, E] -> fn(T) -> A -> fn(E) -> A -> A

  One of two transformations, whichever side the result holds.

  fn
• holds&Result[T, E] -> fn(T) -> Bool -> Bool

  Whether the operation succeeded and the predicate accepts the value.

  fn
• isErr&Result[T, E] -> Bool

  Whether the operation failed.

  fn
• isOk&Result[T, E] -> Bool

  Whether the operation succeeded.

  fn
• mapResult[T, E] -> fn(T) -> U -> Result[U, E]

  The success transformed, if there was one.

  fn
• map2Result[T, E] -> Result[U, E] -> fn(T, U) -> V -> Result[V, E]

  Both successes combined, or the first failure.

  fn
• mapErrResult[T, E] -> fn(E) -> F -> Result[T, F]

  The failure transformed, if there was one.

  fn
• okResult[T, E] -> Option[T]

  The value if there is one, forgetting why there was not.

  fn
• orElseResult[T, E] -> Result[T, E] -> Result[T, E]

  The first result if it succeeded, otherwise the second.

  fn
• partition&Array[Result[T, E]] -> (Array[T], Array[E])

  The two sides separated: every success, and every failure.

  fn
• requireBool -> E -> Result[(), E]

  A success when a condition holds, and a named failure otherwise.

  fn
• successes&Array[Result[T, E]] -> Array[T]

  Every success, with the failures dropped.

  fn
• swapResult[T, E] -> Result[E, T]

  The sides exchanged, so a failure becomes a success and back.

  fn
• toArrayResult[T, E] -> Array[T]

  The value as an array of nought or one element.

  fn
• toOptionResult[T, E] -> Option[T]

  The success, or `None` when there was a failure, keeping neither.

  fn
• traverse&Array[A] -> fn(A) -> Result[B, E] -> Result[Array[B], E]

  Every result transformed and collected, stopping at the first failure.

  fn
• unwrapOrResult[T, E] -> T -> T

  The value, or a fallback when the operation failed.

  fn
• unwrapOrElseResult[T, E] -> fn(E) -> T -> T

  The success, or a fallback computed from the failure.

  fn