Module `Relude_Result.WithError`

Because Result is a bi-functor, we need to capture the error type in order to implement many of the single-type-parameter typeclasses. Doing it like this allows us to unlock a bunch of stuff at once using a single module functor.

Parameters

E: BsBastet.Interface.TYPE

Signature

type nonrec t('a) = t('a, E.t);

module Functor: BsBastet.Interface.FUNCTOR with type Functor.t('a) = t('a);

let map: ('a => 'b) => Functor.t('a) => Functor.t('b);

include { ... };

module BsFunctorExtensions: { ... };

let flipMap: Functor.t('a) => ('a => 'b) => Functor.t('b);
let void: Functor.t('a) => Functor.t(unit);
let voidRight: 'a => Functor.t('b) => Functor.t('a);
let voidLeft: Functor.t('a) => 'b => Functor.t('b);
let flap: Functor.t(('a => 'b)) => 'a => Functor.t('b);

module Alt: BsBastet.Interface.ALT with type Alt.t('a) = t('a);

let alt: Alt.t('a) => Alt.t('a) => Alt.t('a);

include { ... };

let orElse: fallback:Alt.t('a) => Alt.t('a) => Alt.t('a);

module Apply: BsBastet.Interface.APPLY with type Apply.t('a) = t('a);

let apply: Apply.t(('a => 'b)) => Apply.t('a) => Apply.t('b);

include { ... };

module BsApplyExtensions: { ... };

let applyFirst: Apply.t('a) => Apply.t('b) => Apply.t('a);
let applySecond: Apply.t('a) => Apply.t('b) => Apply.t('b);
let map2: ('a => 'b => 'c) => Apply.t('a) => Apply.t('b) => Apply.t('c);
let map3: ('a => 'b => 'c => 'd) => Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t('d);
let map4: ('a => 'b => 'c => 'd => 'e) => Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t('d) => Apply.t('e);
let map5: ('a => 'b => 'c => 'd => 'e => 'f) => Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t('d) => Apply.t('e) => Apply.t('f);
let tuple2: Apply.t('a) => Apply.t('b) => Apply.t(('a, 'b));
let tuple3: Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t(('a, 'b, 'c));
let tuple4: Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t('d) => Apply.t(('a, 'b, 'c, 'd));
let tuple5: Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t('d) => Apply.t('e) => Apply.t(('a, 'b, 'c, 'd, 'e));
let mapTuple2: ('a => 'b => 'c) => (Apply.t('a), Apply.t('b)) => Apply.t('c);
let mapTuple3: ('a => 'b => 'c => 'd) => (Apply.t('a), Apply.t('b), Apply.t('c)) => Apply.t('d);
let mapTuple4: ('a => 'b => 'c => 'd => 'e) => (Apply.t('a), Apply.t('b), Apply.t('c), Apply.t('d)) => Apply.t('e);
let mapTuple5: ('a => 'b => 'c => 'd => 'e => 'f) => (Apply.t('a), Apply.t('b), Apply.t('c), Apply.t('d), Apply.t('e)) => Apply.t('f);

module Applicative: BsBastet.Interface.APPLICATIVE with type Applicative.t('a) = t('a);

let pure: 'a => Applicative.t('a);

include { ... };

module BsApplicativeExtensions: { ... };

let liftA1: ('a => 'b) => Applicative.t('a) => Applicative.t('b);
let when_: bool => Applicative.t(unit) => Applicative.t(unit);
let unless: bool => Applicative.t(unit) => Applicative.t(unit);
let all: list(Applicative.t('a)) => Applicative.t(list('a));

module Semialign: Relude_Interface.SEMIALIGN with type Semialign.t('a) = t('a);

include { ... };

module Monad: BsBastet.Interface.MONAD with type Monad.t('a) = t('a);

let bind: Monad.t('a) => ('a => Monad.t('b)) => Monad.t('b);

include { ... };

module BsMonadExtensions: { ... };

let flatMap: ('a => Monad.t('b)) => Monad.t('a) => Monad.t('b);
let flatten: Monad.t(Monad.t('a)) => Monad.t('a);
let composeKleisli: ('a => Monad.t('b)) => ('b => Monad.t('c)) => 'a => Monad.t('c);
let flipComposeKleisli: ('b => Monad.t('c)) => ('a => Monad.t('b)) => 'a => Monad.t('c);
let liftM1: ('a => 'b) => Monad.t('a) => Monad.t('b);
let when_: Monad.t(bool) => Monad.t(unit) => Monad.t(unit);
let unless: Monad.t(bool) => Monad.t(unit) => Monad.t(unit);

module MonadThrow: Relude_Interface.MONAD_THROW with type MonadThrow.t('a) = t('a) and type MonadThrow.e = E.t;

let throwError: MonadThrow.e => MonadThrow.t('a);

include { ... };

module MonadError: Relude_Interface.MONAD_ERROR with type MonadError.t('a) = t('a) and type MonadError.e = E.t;

let catchError: (MonadError.e => MonadError.t('a)) => MonadError.t('a) => MonadError.t('a);

include { ... };

module Semigroupoid: BsBastet.Interface.SEMIGROUPOID with type Semigroupoid.t('a, 'b) = t(('a => 'b));

let compose: t('a => 'b, 'c) => t('d => 'a, 'c) => t('d => 'b, 'c);

include { ... };

let andThen: Semigroupoid.t('a, 'b) => Semigroupoid.t('b, 'c) => Semigroupoid.t('a, 'c);

module Foldable: BsBastet.Interface.FOLDABLE with type Foldable.t('a) = t('a);

let foldLeft: ('a => 'b => 'a) => 'a => Foldable.t('b) => 'a;
let foldRight: ('a => 'b => 'b) => 'b => Foldable.t('a) => 'b;

include { ... };

module BsFoldableExtensions: { ... };

let any: ('a => bool) => Foldable.t('a) => bool;
let all: ('a => bool) => Foldable.t('a) => bool;
let containsBy: ('a => 'a => bool) => 'a => Foldable.t('a) => bool;
let contains: (module BsBastet.Interface.EQ with type t = 'a) => 'a => Foldable.t('a) => bool;
let indexOfBy: ('a => 'a => bool) => 'a => Foldable.t('a) => option(int);
let indexOf: (module BsBastet.Interface.EQ with type t = 'a) => 'a => Foldable.t('a) => option(int);
let minBy: ('a => 'a => BsBastet.Interface.ordering) => Foldable.t('a) => option('a);
let min: (module BsBastet.Interface.ORD with type t = 'a) => Foldable.t('a) => option('a);
let maxBy: ('a => 'a => BsBastet.Interface.ordering) => Foldable.t('a) => option('a);
let max: (module BsBastet.Interface.ORD with type t = 'a) => Foldable.t('a) => option('a);
let countBy: ('a => bool) => Foldable.t('a) => int;
let length: Foldable.t('a) => int;
let size: Foldable.t('a) => int;
let count: Foldable.t('a) => int;
let forEach: ('a => unit) => Foldable.t('a) => unit;
let forEachWithIndex: ('a => int => unit) => Foldable.t('a) => unit;
let find: ('a => bool) => Foldable.t('a) => option('a);
let findWithIndex: ('a => int => bool) => Foldable.t('a) => option('a);
let toList: Foldable.t('a) => list('a);
let toArray: Foldable.t('a) => array('a);

module FoldableSemigroupExtensions: (S: BsBastet.Interface.SEMIGROUP) => { ... };

module FoldableMonoidExtensions: (M: BsBastet.Interface.MONOID) => { ... };

let foldMap: (module BsBastet.Interface.MONOID with type t = 'a) => ('b => 'a) => Foldable.t('b) => 'a;
let foldWithMonoid: (module BsBastet.Interface.MONOID with type t = 'a) => Foldable.t('a) => 'a;
let intercalate: (module BsBastet.Interface.MONOID with type t = 'a) => 'a => Foldable.t('a) => 'a;

module FoldableApplicativeExtensions: (A: BsBastet.Interface.APPLICATIVE) => { ... };

module FoldableMonadExtensions: (M: BsBastet.Interface.MONAD) => { ... };

module FoldableEqExtensions: (E: BsBastet.Interface.EQ) => { ... };

module FoldableOrdExtensions: (O: BsBastet.Interface.ORD) => { ... };

module WithApplicative: (A: BsBastet.Interface.APPLICATIVE) => { ... };

module Eq = BsBastet.Result.Eq;

module Ord = BsBastet.Result.Ord;

module Show = BsBastet.Result.Show;

module Infix: { ... };