def Lake.EquipT (ρ : Type u) (m : Type v → Type w) (α : Type v) : Type (max u w)

A monad transformer that equips a monad with a value. This is a generalization of ReaderT where the value is not necessarily directly readable through the monad.

Equations

• Lake.EquipT ρ m α = (ρ → m α)

instance Lake.instInhabitedEquipT {ρ : Type u} {m : Type v → Type w} {α : Type v} [Inhabited (m α)] : Inhabited (Lake.EquipT ρ m α)

Equations

• Lake.instInhabitedEquipT = { default := fun (x : ρ) => default }

@[inline]

def Lake.EquipT.run {ρ : Type u} {m : Type v → Type w} {α : Type v} (self : Lake.EquipT ρ m α) (r : ρ) : m α

Equations

• Lake.EquipT.run self r = self r

@[inline]

def Lake.EquipT.map {ρ : Type u} {m : Type v → Type w} [Functor m] {α : Type v} {β : Type v} (f : α → β) (self : Lake.EquipT ρ m α) : Lake.EquipT ρ m β

Equations

• Lake.EquipT.map f self fetch = f <$> self fetch

instance Lake.EquipT.instFunctorEquipT {ρ : Type u} {m : Type v → Type w} [Functor m] : Functor (Lake.EquipT ρ m)

Equations

• Lake.EquipT.instFunctorEquipT = { map := fun {α β : Type v} => Lake.EquipT.map, mapConst := fun {α β : Type v} => Lake.EquipT.map ∘ Function.const β }

@[inline]

def Lake.EquipT.pure {ρ : Type u} {m : Type v → Type w} [Pure m] {α : Type v} (a : α) : Lake.EquipT ρ m α

Equations

• Lake.EquipT.pure a x = pure a

instance Lake.EquipT.instPureEquipT {ρ : Type u} {m : Type v → Type w} [Pure m] : Pure (Lake.EquipT ρ m)

Equations

• Lake.EquipT.instPureEquipT = { pure := fun {α : Type v} => Lake.EquipT.pure }

@[inline]

def Lake.EquipT.compose {ρ : Type u} {m : Type v → Type w} {α₁ : Type v} {α₂ : Type v} {β : Type v} (f : m α₁ → (Unit → m α₂) → m β) (x₁ : Lake.EquipT ρ m α₁) (x₂ : Unit → Lake.EquipT ρ m α₂) : Lake.EquipT ρ m β

Equations

• Lake.EquipT.compose f x₁ x₂ fetch = f (x₁ fetch) fun (x : Unit) => x₂ () fetch

@[inline]

def Lake.EquipT.seq {ρ : Type u} {m : Type v → Type w} [Seq m] {α : Type v} {β : Type v} : Lake.EquipT ρ m (α → β) → (Unit → Lake.EquipT ρ m α) → Lake.EquipT ρ m β

Equations

• Lake.EquipT.seq = Lake.EquipT.compose Seq.seq

instance Lake.EquipT.instSeqEquipT {ρ : Type u} {m : Type v → Type w} [Seq m] : Seq (Lake.EquipT ρ m)

Equations

• Lake.EquipT.instSeqEquipT = { seq := fun {α β : Type v} => Lake.EquipT.seq }

instance Lake.EquipT.instApplicativeEquipT {ρ : Type u} {m : Type v → Type w} [Applicative m] : Applicative (Lake.EquipT ρ m)

Equations

• Lake.EquipT.instApplicativeEquipT = Applicative.mk

@[inline]

def Lake.EquipT.bind {ρ : Type u} {m : Type v → Type w} [Bind m] {α : Type v} {β : Type v} (self : Lake.EquipT ρ m α) (f : α → Lake.EquipT ρ m β) : Lake.EquipT ρ m β

Equations

• Lake.EquipT.bind self f fetch = do let a ← self fetch f a fetch

instance Lake.EquipT.instBindEquipT {ρ : Type u} {m : Type v → Type w} [Bind m] : Bind (Lake.EquipT ρ m)

Equations

• Lake.EquipT.instBindEquipT = { bind := fun {α β : Type v} => Lake.EquipT.bind }

instance Lake.EquipT.instMonadEquipT {ρ : Type u} {m : Type v → Type w} [Monad m] : Monad (Lake.EquipT ρ m)

Equations

• Lake.EquipT.instMonadEquipT = Monad.mk

@[inline]

def Lake.EquipT.lift {ρ : Type u} {m : Type v → Type w} {α : Type v} (t : m α) : Lake.EquipT ρ m α

Equations

• Lake.EquipT.lift t x = t

instance Lake.EquipT.instMonadLiftEquipT {ρ : Type u} {m : Type v → Type w} : MonadLift m (Lake.EquipT ρ m)

Equations

• Lake.EquipT.instMonadLiftEquipT = { monadLift := fun {α : Type v} => Lake.EquipT.lift }

@[inline]

def Lake.EquipT.failure {ρ : Type u} {m : Type v → Type w} [Alternative m] {α : Type v} : Lake.EquipT ρ m α

Equations

• Lake.EquipT.failure x = failure

@[inline]

def Lake.EquipT.orElse {ρ : Type u} {m : Type v → Type w} [Alternative m] {α : Type v} : Lake.EquipT ρ m α → (Unit → Lake.EquipT ρ m α) → Lake.EquipT ρ m α

Equations

• Lake.EquipT.orElse = Lake.EquipT.compose Alternative.orElse

instance Lake.EquipT.instAlternativeEquipT {ρ : Type u} {m : Type v → Type w} [Alternative m] : Alternative (Lake.EquipT ρ m)

Equations

• Lake.EquipT.instAlternativeEquipT = Alternative.mk (fun {α : Type v} => Lake.EquipT.failure) fun {α : Type v} => Lake.EquipT.orElse

@[inline]

def Lake.EquipT.throw {ρ : Type u} {m : Type v → Type w} {ε : Type v} [MonadExceptOf ε m] {α : Type v} (e : ε) : Lake.EquipT ρ m α

Equations

• Lake.EquipT.throw e x = throw e

@[inline]

def Lake.EquipT.tryCatch {ρ : Type u} {m : Type v → Type w} {ε : Type v} [MonadExceptOf ε m] {α : Type v} (self : Lake.EquipT ρ m α) (c : ε → Lake.EquipT ρ m α) : Lake.EquipT ρ m α

Equations

• Lake.EquipT.tryCatch self c f = tryCatchThe ε (self f) fun (e : ε) => c e f

instance Lake.EquipT.instMonadExceptOfEquipT {ρ : Type u} {m : Type v → Type w} (ε : Type v) [MonadExceptOf ε m] : MonadExceptOf ε (Lake.EquipT ρ m)

Equations

• Lake.EquipT.instMonadExceptOfEquipT ε = { throw := fun {α : Type v} => Lake.EquipT.throw, tryCatch := fun {α : Type v} => Lake.EquipT.tryCatch }