Zafu/Control/PartialResult

source code:

• src/Zafu/Control/PartialResult.bosatsu

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

Index

• Types: PartialResult
• Values: and_then, combine_map2, combine_product, combine_product_l, combine_product_r, eq, err, flat_map, fold, from_Option, from_Result, has_err, has_ok, hash, is_partial_err, is_total_err, is_total_ok, map, map_err, monad_PartialResult, ok, or_else, ord, to_Option, to_Result_fail_fast, traverse_PartialResult, unwrap, unwrap_or, unwrap_or_else

Types

PartialResult[e, a]

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

Constructors

• PartialErr(err: e, partial: a)
• TotalErr(err: e)
• TotalOk(ok: a)

Values

and_then

references: PartialResult, Zafu/Abstract/Semigroup::Semigroup

def and_then[a, b, c](
    result: PartialResult[a, b],
    semi: Zafu/Abstract/Semigroup::Semigroup[a],
    fn: b -> PartialResult[a, c]
) -> PartialResult[a, c]

combine_map2

references: PartialResult, Zafu/Abstract/Semigroup::Semigroup

def combine_map2[a, b, c, d](
    semi: Zafu/Abstract/Semigroup::Semigroup[a],
    left: PartialResult[a, b],
    right: PartialResult[a, c],
    fn: (b, c) -> d
) -> PartialResult[a, d]

combine_product

references: PartialResult, Tuple2, Zafu/Abstract/Semigroup::Semigroup

def combine_product[a,
    b,
    c
](semi: Zafu/Abstract/Semigroup::Semigroup[a], left: PartialResult[a, b], right: PartialResult[a, c]) -> PartialResult[a, (b, c)]

combine_product_l

references: PartialResult, Zafu/Abstract/Semigroup::Semigroup

def combine_product_l[a,
    b,
    c
](semi: Zafu/Abstract/Semigroup::Semigroup[a], left: PartialResult[a, b], right: PartialResult[a, c]) -> PartialResult[a, b]

combine_product_r

references: PartialResult, Zafu/Abstract/Semigroup::Semigroup

def combine_product_r[a,
    b,
    c
](semi: Zafu/Abstract/Semigroup::Semigroup[a], left: PartialResult[a, b], right: PartialResult[a, c]) -> PartialResult[a, c]

eq

references: PartialResult, 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[PartialResult[a, b]]

err

references: Option, PartialResult

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

flat_map

references: PartialResult, Zafu/Abstract/Semigroup::Semigroup

def flat_map[a, b, c](
    result: PartialResult[a, b],
    semi: Zafu/Abstract/Semigroup::Semigroup[a],
    fn: b -> PartialResult[a, c]
) -> PartialResult[a, c]

fold

references: PartialResult

def fold[a, b, c](
    result: PartialResult[a, b],
    on_total_err: a -> c,
    on_partial_err: (a, b) -> c,
    on_total_ok: b -> c
) -> c

from_Option

references: Option, PartialResult, Unit

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

from_Result

references: PartialResult, Zafu/Control/Result::Result

def from_Result[a, b](value: Zafu/Control/Result::Result[a, b]) -> PartialResult[a, b]

has_err

references: Bool, PartialResult

def has_err[a, b](result: PartialResult[a, b]) -> Bool

has_ok

references: Bool, PartialResult

def has_ok[a, b](result: PartialResult[a, b]) -> Bool

hash

references: PartialResult, 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[PartialResult[a, b]]

is_partial_err

references: Bool, PartialResult

def is_partial_err[a, b](result: PartialResult[a, b]) -> Bool

is_total_err

references: Bool, PartialResult

def is_total_err[a, b](result: PartialResult[a, b]) -> Bool

is_total_ok

references: Bool, PartialResult

def is_total_ok[a, b](result: PartialResult[a, b]) -> Bool

map

references: PartialResult

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

map_err

references: PartialResult

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

monad_PartialResult

references: PartialResult, Zafu/Abstract/Monad::Monad, Zafu/Abstract/Semigroup::Semigroup

def monad_PartialResult[a
](semi: Zafu/Abstract/Semigroup::Semigroup[a]) -> Zafu/Abstract/Monad::Monad[PartialResult[a]]

ok

references: Option, PartialResult

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

or_else

references: PartialResult

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

ord

references: PartialResult, 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[PartialResult[a, b]]

to_Option

references: Option, PartialResult

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

to_Result_fail_fast

references: PartialResult, Zafu/Control/Result::Result

def to_Result_fail_fast[a, b](value: PartialResult[a, b]) -> Zafu/Control/Result::Result[a, b]

traverse_PartialResult

references: PartialResult, Zafu/Abstract/Traverse::Traverse

traverse_PartialResult: forall a: *. Zafu/Abstract/Traverse::Traverse[PartialResult[a]]

unwrap

references: PartialResult

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

unwrap_or

references: PartialResult

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

unwrap_or_else

references: PartialResult

def unwrap_or_else[a, b](result: PartialResult[a, b], on_total_err: a -> b) -> b