source

@[simp]

theorem monadLift_self {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] (x : m α) :

monadLift x = x

source

class LawfulFunctor (f : Type u → Type v) [Functor f] :

Prop

map_const : ∀ {α β : Type u}, Functor.mapConst = Functor.map ∘ Function.const β
id_map : ∀ {α : Type u} (x : f α), id <$> x = x
comp_map : ∀ {α β γ : Type u} (g : α → β) (h : β → γ) (x : f α), (h ∘ g) <$> x = h <$> g <$> x

Instances

source

@[simp]

theorem id_map' {m : Type u_1 → Type u_2} {α : Type u_1} [Functor m] [LawfulFunctor m] (x : m α) :

(fun (a : α) => a) <$> x = x

source

class LawfulApplicative (f : Type u → Type v) [Applicative f] extends LawfulFunctor :

Prop

map_const : ∀ {α β : Type u}, Functor.mapConst = Functor.map ∘ Function.const β
id_map : ∀ {α : Type u} (x : f α), id <$> x = x
comp_map : ∀ {α β γ : Type u} (g : α → β) (h : β → γ) (x : f α), (h ∘ g) <$> x = h <$> g <$> x
seqLeft_eq : ∀ {α β : Type u} (x : f α) (y : f β), (SeqLeft.seqLeft x fun (x : Unit) => y) = Seq.seq (Function.const β <$> x) fun (x : Unit) => y
seqRight_eq : ∀ {α β : Type u} (x : f α) (y : f β), (SeqRight.seqRight x fun (x : Unit) => y) = Seq.seq (Function.const α id <$> x) fun (x : Unit) => y
pure_seq : ∀ {α β : Type u} (g : α → β) (x : f α), (Seq.seq (pure g) fun (x_1 : Unit) => x) = g <$> x
map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x)
seq_pure : ∀ {α β : Type u} (g : f (α → β)) (x : α), (Seq.seq g fun (x_1 : Unit) => pure x) = (fun (h : α → β) => h x) <$> g
seq_assoc : ∀ {α β γ : Type u} (x : f α) (g : f (α → β)) (h : f (β → γ)), (Seq.seq h fun (x_1 : Unit) => Seq.seq g fun (x_2 : Unit) => x) = Seq.seq (Seq.seq (Function.comp <$> h) fun (x : Unit) => g) fun (x_1 : Unit) => x

Instances

source

@[simp]

theorem pure_id_seq {f : Type u_1 → Type u_2} {α : Type u_1} [Applicative f] [LawfulApplicative f] (x : f α) :

(Seq.seq (pure id) fun (x_1 : Unit) => x) = x

source

class LawfulMonad (m : Type u → Type v) [Monad m] extends LawfulApplicative :

Prop

map_const : ∀ {α β : Type u}, Functor.mapConst = Functor.map ∘ Function.const β
id_map : ∀ {α : Type u} (x : m α), id <$> x = x
comp_map : ∀ {α β γ : Type u} (g : α → β) (h : β → γ) (x : m α), (h ∘ g) <$> x = h <$> g <$> x
seqLeft_eq : ∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun (x : Unit) => y) = Seq.seq (Function.const β <$> x) fun (x : Unit) => y
seqRight_eq : ∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun (x : Unit) => y) = Seq.seq (Function.const α id <$> x) fun (x : Unit) => y
pure_seq : ∀ {α β : Type u} (g : α → β) (x : m α), (Seq.seq (pure g) fun (x_1 : Unit) => x) = g <$> x
map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x)
seq_pure : ∀ {α β : Type u} (g : m (α → β)) (x : α), (Seq.seq g fun (x_1 : Unit) => pure x) = (fun (h : α → β) => h x) <$> g
seq_assoc : ∀ {α β γ : Type u} (x : m α) (g : m (α → β)) (h : m (β → γ)), (Seq.seq h fun (x_1 : Unit) => Seq.seq g fun (x_2 : Unit) => x) = Seq.seq (Seq.seq (Function.comp <$> h) fun (x : Unit) => g) fun (x_1 : Unit) => x
bind_pure_comp : ∀ {α β : Type u} (f : α → β) (x : m α), (do let a ← x pure (f a)) = f <$> x
bind_map : ∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun (x_1 : Unit) => x
pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x
bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun (x : α) => f x >>= g

Instances

source

@[simp]

theorem bind_pure {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] [LawfulMonad m] (x : m α) :

x >>= pure = x

source

theorem map_eq_pure_bind {m : Type u_1 → Type u_2} {α : Type u_1} {β : Type u_1} [Monad m] [LawfulMonad m] (f : α → β) (x : m α) :

f <$> x = do let a ← x pure (f a)

source

theorem seq_eq_bind_map {m : Type u → Type u_1} {α : Type u} {β : Type u} [Monad m] [LawfulMonad m] (f : m (α → β)) (x : m α) :

(Seq.seq f fun (x_1 : Unit) => x) = do let x_1 ← f x_1 <$> x

source

theorem bind_congr {m : Type u_1 → Type u_2} {α : Type u_1} {β : Type u_1} [Bind m] {x : m α} {f : α → m β} {g : α → m β} (h : ∀ (a : α), f a = g a) :

x >>= f = x >>= g

source

@[simp]

theorem bind_pure_unit {m : Type u_1 → Type u_2} [Monad m] [LawfulMonad m] {x : m PUnit} :

(do x pure PUnit.unit) = x

source

theorem map_congr {m : Type u_1 → Type u_2} {α : Type u_1} {β : Type u_1} [Functor m] {x : m α} {f : α → β} {g : α → β} (h : ∀ (a : α), f a = g a) :

f <$> x = g <$> x

source

theorem seq_eq_bind {m : Type u → Type u_1} {α : Type u} {β : Type u} [Monad m] [LawfulMonad m] (mf : m (α → β)) (x : m α) :

(Seq.seq mf fun (x_1 : Unit) => x) = do let f ← mf f <$> x

source

theorem seqRight_eq_bind {m : Type u_1 → Type u_2} {α : Type u_1} {β : Type u_1} [Monad m] [LawfulMonad m] (x : m α) (y : m β) :

(SeqRight.seqRight x fun (x : Unit) => y) = do let _ ← x y

source

theorem seqLeft_eq_bind {m : Type u_1 → Type u_2} {α : Type u_1} {β : Type u_1} [Monad m] [LawfulMonad m] (x : m α) (y : m β) :

(SeqLeft.seqLeft x fun (x : Unit) => y) = do let a ← x let _ ← y pure a

Id #

source

@[simp]

theorem Id.map_eq {α : Type u_1} {β : Type u_1} (x : Id α) (f : α → β) :

f <$> x = f x

source

@[simp]

theorem Id.bind_eq {α : Type u_1} {β : Type u_1} (x : Id α) (f : α → id β) :

x >>= f = f x

source

@[simp]

theorem Id.pure_eq {α : Type u_1} (a : α) :

pure a = a

source

instance Id.instLawfulMonadIdInstMonadId :

LawfulMonad Id

Equations

Id.instLawfulMonadIdInstMonadId = (_ : LawfulMonad Id)

ExceptT #

source

theorem ExceptT.ext {m : Type u_1 → Type u_2} {ε : Type u_1} {α : Type u_1} [Monad m] {x : ExceptT ε m α} {y : ExceptT ε m α} (h : ExceptT.run x = ExceptT.run y) :

x = y

source

@[simp]

theorem ExceptT.run_pure {m : Type u_1 → Type u_2} {α : Type u_1} {ε : Type u_1} [Monad m] (x : α) :

ExceptT.run (pure x) = pure (Except.ok x)

source

@[simp]

theorem ExceptT.run_lift {m : Type u → Type v} {α : Type u} {ε : Type u} [Monad m] (x : m α) :

ExceptT.run (ExceptT.lift x) = Except.ok <$> x

source

@[simp]

theorem ExceptT.run_throw {m : Type u_1 → Type u_2} {ε : Type u_1} {β : Type u_1} {e : ε} [Monad m] :

ExceptT.run (throw e) = pure (Except.error e)

source

@[simp]

theorem ExceptT.run_bind_lift {m : Type u_1 → Type u_2} {α : Type u_1} {ε : Type u_1} {β : Type u_1} [Monad m] [LawfulMonad m] (x : m α) (f : α → ExceptT ε m β) :

ExceptT.run (ExceptT.lift x >>= f) = do let a ← x ExceptT.run (f a)

source

@[simp]

theorem ExceptT.bind_throw {m : Type u_1 → Type u_2} {α : Type u_1} {ε : Type u_1} {β : Type u_1} {e : ε} [Monad m] [LawfulMonad m] (f : α → ExceptT ε m β) :

throw e >>= f = throw e

source

theorem ExceptT.run_bind {m : Type u_1 → Type u_2} {ε : Type u_1} {α : Type u_1} {β : Type u_1} {f : α → ExceptT ε m β} [Monad m] (x : ExceptT ε m α) :

ExceptT.run (x >>= f) = do let x ← ExceptT.run x match x with | Except.ok x => ExceptT.run (f x) | Except.error e => pure (Except.error e)

source

@[simp]

theorem ExceptT.lift_pure {m : Type u_1 → Type u_2} {α : Type u_1} {ε : Type u_1} [Monad m] [LawfulMonad m] (a : α) :

ExceptT.lift (pure a) = pure a

source

@[simp]

theorem ExceptT.run_map {m : Type u_1 → Type u_2} {α : Type u_1} {β : Type u_1} {ε : Type u_1} [Monad m] [LawfulMonad m] (f : α → β) (x : ExceptT ε m α) :

ExceptT.run (f <$> x) = Except.map f <$> ExceptT.run x

source

theorem ExceptT.seq_eq {m : Type u → Type u_1} {α : Type u} {β : Type u} {ε : Type u} [Monad m] (mf : ExceptT ε m (α → β)) (x : ExceptT ε m α) :

(Seq.seq mf fun (x_1 : Unit) => x) = do let f ← mf f <$> x

source

theorem ExceptT.bind_pure_comp {m : Type u_1 → Type u_2} {α : Type u_1} {β : Type u_1} {ε : Type u_1} [Monad m] [LawfulMonad m] (f : α → β) (x : ExceptT ε m α) :

x >>= pure ∘ f = f <$> x

source

theorem ExceptT.seqLeft_eq {α : Type u} {β : Type u} {ε : Type u} {m : Type u → Type v} [Monad m] [LawfulMonad m] (x : ExceptT ε m α) (y : ExceptT ε m β) :

(SeqLeft.seqLeft x fun (x : Unit) => y) = Seq.seq (Function.const β <$> x) fun (x : Unit) => y

source

theorem ExceptT.seqRight_eq {m : Type u_1 → Type u_2} {ε : Type u_1} {α : Type u_1} {β : Type u_1} [Monad m] [LawfulMonad m] (x : ExceptT ε m α) (y : ExceptT ε m β) :

(SeqRight.seqRight x fun (x : Unit) => y) = Seq.seq (Function.const α id <$> x) fun (x : Unit) => y

source

instance ExceptT.instLawfulMonadExceptTInstMonadExceptT {m : Type u_1 → Type u_2} {ε : Type u_1} [Monad m] [LawfulMonad m] :

LawfulMonad (ExceptT ε m)

Equations

(_ : LawfulMonad (ExceptT ε m)) = (_ : LawfulMonad (ExceptT ε m))

ReaderT #

source

theorem ReaderT.ext {ρ : Type u_1} {m : Type u_1 → Type u_2} {α : Type u_1} {x : ReaderT ρ m α} {y : ReaderT ρ m α} (h : ∀ (ctx : ρ), ReaderT.run x ctx = ReaderT.run y ctx) :

x = y

source

@[simp]

theorem ReaderT.run_pure {m : Type u_1 → Type u_2} {α : Type u_1} {ρ : Type u_1} [Monad m] (a : α) (ctx : ρ) :

ReaderT.run (pure a) ctx = pure a

source

@[simp]

theorem ReaderT.run_bind {m : Type u_1 → Type u_2} {ρ : Type u_1} {α : Type u_1} {β : Type u_1} [Monad m] (x : ReaderT ρ m α) (f : α → ReaderT ρ m β) (ctx : ρ) :

ReaderT.run (x >>= f) ctx = do let a ← ReaderT.run x ctx ReaderT.run (f a) ctx

source

@[simp]

theorem ReaderT.run_mapConst {m : Type u_1 → Type u_2} {α : Type u_1} {ρ : Type u_1} {β : Type u_1} [Monad m] (a : α) (x : ReaderT ρ m β) (ctx : ρ) :

ReaderT.run (Functor.mapConst a x) ctx = Functor.mapConst a (ReaderT.run x ctx)

source

@[simp]

theorem ReaderT.run_map {m : Type u_1 → Type u_2} {α : Type u_1} {β : Type u_1} {ρ : Type u_1} [Monad m] (f : α → β) (x : ReaderT ρ m α) (ctx : ρ) :

ReaderT.run (f <$> x) ctx = f <$> ReaderT.run x ctx

source

@[simp]

theorem ReaderT.run_monadLift {n : Type u_1 → Type u_2} {m : Type u_1 → Type u_3} {α : Type u_1} {ρ : Type u_1} [MonadLiftT n m] (x : n α) (ctx : ρ) :

ReaderT.run (monadLift x) ctx = monadLift x

source

@[simp]

theorem ReaderT.run_monadMap {n : Type u → Type u_1} {m : Type u → Type u_2} {ρ : Type u} {α : Type u} [MonadFunctor n m] (f : {β : Type u} → n β → n β) (x : ReaderT ρ m α) (ctx : ρ) :

ReaderT.run (monadMap f x) ctx = monadMap f (ReaderT.run x ctx)

source

@[simp]

theorem ReaderT.run_read {m : Type u_1 → Type u_2} {ρ : Type u_1} [Monad m] (ctx : ρ) :

ReaderT.run ReaderT.read ctx = pure ctx

source

@[simp]

theorem ReaderT.run_seq {m : Type u → Type u_1} {ρ : Type u} {α : Type u} {β : Type u} [Monad m] (f : ReaderT ρ m (α → β)) (x : ReaderT ρ m α) (ctx : ρ) :

ReaderT.run (Seq.seq f fun (x_1 : Unit) => x) ctx = Seq.seq (ReaderT.run f ctx) fun (x_1 : Unit) => ReaderT.run x ctx

source

@[simp]

theorem ReaderT.run_seqRight {m : Type u_1 → Type u_2} {ρ : Type u_1} {α : Type u_1} {β : Type u_1} [Monad m] (x : ReaderT ρ m α) (y : ReaderT ρ m β) (ctx : ρ) :

ReaderT.run (SeqRight.seqRight x fun (x : Unit) => y) ctx = SeqRight.seqRight (ReaderT.run x ctx) fun (x : Unit) => ReaderT.run y ctx

source

@[simp]

theorem ReaderT.run_seqLeft {m : Type u_1 → Type u_2} {ρ : Type u_1} {α : Type u_1} {β : Type u_1} [Monad m] (x : ReaderT ρ m α) (y : ReaderT ρ m β) (ctx : ρ) :

ReaderT.run (SeqLeft.seqLeft x fun (x : Unit) => y) ctx = SeqLeft.seqLeft (ReaderT.run x ctx) fun (x : Unit) => ReaderT.run y ctx

source

instance ReaderT.instLawfulFunctorReaderTInstFunctorReaderT {m : Type u_1 → Type u_2} {ρ : Type u_1} [Monad m] [LawfulFunctor m] :

LawfulFunctor (ReaderT ρ m)

Equations

(_ : LawfulFunctor (ReaderT ρ m)) = (_ : LawfulFunctor (ReaderT ρ m))

source

instance ReaderT.instLawfulApplicativeReaderTInstApplicativeReaderT {m : Type u_1 → Type u_2} {ρ : Type u_1} [Monad m] [LawfulApplicative m] :

LawfulApplicative (ReaderT ρ m)

Equations

(_ : LawfulApplicative (ReaderT ρ m)) = (_ : LawfulApplicative (ReaderT ρ m))

source

instance ReaderT.instLawfulMonadReaderTInstMonadReaderT {m : Type u_1 → Type u_2} {ρ : Type u_1} [Monad m] [LawfulMonad m] :

LawfulMonad (ReaderT ρ m)

Equations

(_ : LawfulMonad (ReaderT ρ m)) = (_ : LawfulMonad (ReaderT ρ m))

StateRefT #

source

instance instLawfulMonadStateRefT'InstMonadStateRefT' {m : Type → Type} {ω : Type} {σ : Type} [Monad m] [LawfulMonad m] :

LawfulMonad (StateRefT' ω σ m)

Equations

(_ : LawfulMonad (StateRefT' ω σ m)) = (_ : LawfulMonad (ReaderT (ST.Ref ω σ) m))

StateT #

source

theorem StateT.ext {σ : Type u_1} {m : Type u_1 → Type u_2} {α : Type u_1} {x : StateT σ m α} {y : StateT σ m α} (h : ∀ (s : σ), StateT.run x s = StateT.run y s) :

x = y

source

@[simp]

theorem StateT.run'_eq {m : Type u_1 → Type u_2} {σ : Type u_1} {α : Type u_1} [Monad m] (x : StateT σ m α) (s : σ) :

StateT.run' x s = (fun (x : α × σ) => x.fst) <$> StateT.run x s

source

@[simp]

theorem StateT.run_pure {m : Type u_1 → Type u_2} {α : Type u_1} {σ : Type u_1} [Monad m] (a : α) (s : σ) :

StateT.run (pure a) s = pure (a, s)

source

@[simp]

theorem StateT.run_bind {m : Type u_1 → Type u_2} {σ : Type u_1} {α : Type u_1} {β : Type u_1} [Monad m] (x : StateT σ m α) (f : α → StateT σ m β) (s : σ) :

StateT.run (x >>= f) s = do let p ← StateT.run x s StateT.run (f p.fst) p.snd

source

@[simp]

theorem StateT.run_map {m : Type u → Type u_1} {α : Type u} {β : Type u} {σ : Type u} [Monad m] [LawfulMonad m] (f : α → β) (x : StateT σ m α) (s : σ) :

StateT.run (f <$> x) s = (fun (p : α × σ) => (f p.fst, p.snd)) <$> StateT.run x s

source

@[simp]

theorem StateT.run_get {m : Type u_1 → Type u_2} {σ : Type u_1} [Monad m] (s : σ) :

StateT.run get s = pure (s, s)

source

@[simp]

theorem StateT.run_set {m : Type u_1 → Type u_2} {σ : Type u_1} [Monad m] (s : σ) (s' : σ) :

StateT.run (set s') s = pure (PUnit.unit, s')

source

@[simp]

theorem StateT.run_modify {m : Type u_1 → Type u_2} {σ : Type u_1} [Monad m] (f : σ → σ) (s : σ) :

StateT.run (modify f) s = pure (PUnit.unit, f s)

source

@[simp]

theorem StateT.run_modifyGet {m : Type u_1 → Type u_2} {σ : Type u_1} {α : Type u_1} [Monad m] (f : σ → α × σ) (s : σ) :

StateT.run (modifyGet f) s = pure ((f s).fst, (f s).snd)

source

@[simp]

theorem StateT.run_lift {m : Type u → Type u_1} {α : Type u} {σ : Type u} [Monad m] (x : m α) (s : σ) :

StateT.run (StateT.lift x) s = do let a ← x pure (a, s)

source

@[simp]

theorem StateT.run_bind_lift {m : Type u → Type u_1} {β : Type u} {α : Type u} {σ : Type u} [Monad m] [LawfulMonad m] (x : m α) (f : α → StateT σ m β) (s : σ) :

StateT.run (StateT.lift x >>= f) s = do let a ← x StateT.run (f a) s

source

@[simp]

theorem StateT.run_monadLift {m : Type u → Type u_1} {n : Type u → Type u_2} {α : Type u} {σ : Type u} [Monad m] [MonadLiftT n m] (x : n α) (s : σ) :

StateT.run (monadLift x) s = do let a ← monadLift x pure (a, s)

source

@[simp]

theorem StateT.run_monadMap {m : Type u → Type u_1} {n : Type u → Type u_2} {σ : Type u} {α : Type u} [Monad m] [MonadFunctor n m] (f : {β : Type u} → n β → n β) (x : StateT σ m α) (s : σ) :

StateT.run (monadMap f x) s = monadMap f (StateT.run x s)

source

@[simp]

theorem StateT.run_seq {m : Type u → Type u_1} {α : Type u} {β : Type u} {σ : Type u} [Monad m] [LawfulMonad m] (f : StateT σ m (α → β)) (x : StateT σ m α) (s : σ) :

StateT.run (Seq.seq f fun (x_1 : Unit) => x) s = do let fs ← StateT.run f s (fun (p : α × σ) => (fs.fst p.fst, p.snd)) <$> StateT.run x fs.snd

source

@[simp]

theorem StateT.run_seqRight {m : Type u_1 → Type u_2} {σ : Type u_1} {α : Type u_1} {β : Type u_1} [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) (s : σ) :

StateT.run (SeqRight.seqRight x fun (x : Unit) => y) s = do let p ← StateT.run x s StateT.run y p.snd

source

@[simp]

theorem StateT.run_seqLeft {m : Type u → Type u_1} {α : Type u} {β : Type u} {σ : Type u} [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) (s : σ) :

StateT.run (SeqLeft.seqLeft x fun (x : Unit) => y) s = do let p ← StateT.run x s let p' ← StateT.run y p.snd pure (p.fst, p'.snd)

source

theorem StateT.seqRight_eq {m : Type u_1 → Type u_2} {σ : Type u_1} {α : Type u_1} {β : Type u_1} [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) :

(SeqRight.seqRight x fun (x : Unit) => y) = Seq.seq (Function.const α id <$> x) fun (x : Unit) => y

source

theorem StateT.seqLeft_eq {m : Type u_1 → Type u_2} {σ : Type u_1} {α : Type u_1} {β : Type u_1} [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) :

(SeqLeft.seqLeft x fun (x : Unit) => y) = Seq.seq (Function.const β <$> x) fun (x : Unit) => y

source

instance StateT.instLawfulMonadStateTInstMonadStateT {m : Type u_1 → Type u_2} {σ : Type u_1} [Monad m] [LawfulMonad m] :

LawfulMonad (StateT σ m)

Equations

(_ : LawfulMonad (StateT σ m)) = (_ : LawfulMonad (StateT σ m))

Documentation

Init.Control.Lawful

Id #

ExceptT #

ReaderT #

StateRefT #

StateT #