Zafu/Control/Result

source code:

• src/Zafu/Control/Result.bosatsu

public dependencies: Zafu/Abstract/Applicative, Zafu/Abstract/Eq, Zafu/Abstract/Hash, Zafu/Abstract/Monad, Zafu/Abstract/Ord, Zafu/Abstract/Semigroup, Zafu/Abstract/Traverse

Index

• Types: Result
• Values: and_then, applicative, applicative_Result, applicative_combine_Err, eq, err, flat_map, fold, from_Option, hash, is_err, is_ok, map, map_err, monad_Result, ok, or_else, ord, to_Option, traverse_Result, unwrap, unwrap_or, unwrap_or_else

Types

Result[e, a]

type Result[e: +*, a: +*]

Constructors

• Err(err: e)
• Ok(ok: a)

Values

and_then

references: Result

def and_then[a, b, c](result: Result[a, b], fn: b -> Result[a, c]) -> Result[a, c]

applicative

references: Result, Zafu/Abstract/Applicative::Applicative

applicative: forall a: *. Zafu/Abstract/Applicative::Applicative[Result[a]]

applicative_Result

references: Result, Zafu/Abstract/Applicative::Applicative

applicative_Result: forall a: *. Zafu/Abstract/Applicative::Applicative[Result[a]]

applicative_combine_Err

references: Result, Zafu/Abstract/Applicative::Applicative, Zafu/Abstract/Semigroup::Semigroup

def applicative_combine_Err[a
](semigroup_err: Zafu/Abstract/Semigroup::Semigroup[a]) -> Zafu/Abstract/Applicative::Applicative[Result[a]]

eq

references: Result, Zafu/Abstract/Eq::Eq

def eq[a,
    b
](eq_err: Zafu/Abstract/Eq::Eq[a], eq_ok: Zafu/Abstract/Eq::Eq[b]) -> Zafu/Abstract/Eq::Eq[Result[a, b]]

err

references: Option, Result

def err[a, b](result: Result[a, b]) -> Option[a]

flat_map

references: Result

def flat_map[a, b, c](result: Result[a, b], fn: b -> Result[a, c]) -> Result[a, c]

fold

references: Result

def fold[a, b, c](result: Result[a, b], on_err: a -> c, on_ok: b -> c) -> c

from_Option

references: Option, Result, Unit

def from_Option[a, b](value: Option[a], on_none: () -> b) -> Result[b, a]

hash

references: Result, Zafu/Abstract/Hash::Hash

def hash[a,
    b
](hash_err: Zafu/Abstract/Hash::Hash[a], hash_ok: Zafu/Abstract/Hash::Hash[b]) -> Zafu/Abstract/Hash::Hash[Result[a, b]]

is_err

references: Bool, Result

def is_err[a, b](result: Result[a, b]) -> Bool

is_ok

references: Bool, Result

def is_ok[a, b](result: Result[a, b]) -> Bool

map

references: Result

def map[a, b, c](result: Result[a, b], fn: b -> c) -> Result[a, c]

map_err

references: Result

def map_err[a, b, c](result: Result[a, b], fn: a -> c) -> Result[c, b]

monad_Result

references: Result, Zafu/Abstract/Monad::Monad

monad_Result: forall a: *. Zafu/Abstract/Monad::Monad[Result[a]]

ok

references: Option, Result

def ok[a, b](result: Result[a, b]) -> Option[b]

or_else

references: Result

def or_else[a, b, c](result: Result[a, b], fn: a -> Result[c, b]) -> Result[c, b]

ord

references: Result, Zafu/Abstract/Ord::Ord

def ord[a,
    b
](ord_err: Zafu/Abstract/Ord::Ord[a], ord_ok: Zafu/Abstract/Ord::Ord[b]) -> Zafu/Abstract/Ord::Ord[Result[a, b]]

to_Option

references: Option, Result

def to_Option[a, b](result: Result[a, b]) -> Option[b]

traverse_Result

references: Result, Zafu/Abstract/Traverse::Traverse

traverse_Result: forall a: *. Zafu/Abstract/Traverse::Traverse[Result[a]]

unwrap

references: Result

def unwrap[a](ok: forall b: *. Result[b, a]) -> a

unwrap_or

references: Result

def unwrap_or[a, b](result: Result[a, b], fallback: b) -> b

unwrap_or_else

references: Result

def unwrap_or_else[a, b](result: Result[a, b], on_err: a -> b) -> b