File: Mathlib/Control/ULift.lean

full_name: PLift.map
code: /-- Functorial action. -/
protected def map (f : α → β) (a : PLift α) : PLift β 
goal: PLift β

full_name: PLift.map_up
code: @[simp]
theorem map_up (f : α → β) (a : α) : (PLift.up a).map f = PLift.up (f a) 
goal: PLift.map f { down := a } = { down := f a }

full_name: PLift.pure
code: /-- Embedding of pure values. -/
@[simp]
protected def pure : α → PLift α 
goal: α → PLift α

full_name: PLift.seq
code: /-- Applicative sequencing. -/
protected def seq (f : PLift (α → β)) (x : Unit → PLift α) : PLift β 
goal: PLift β

full_name: PLift.seq_up
code: @[simp]
theorem seq_up (f : α → β) (x : α) : (PLift.up f).seq (fun _ => PLift.up x) = PLift.up (f x) 
goal: ({ down := f }.seq fun x_1 => { down := x }) = { down := f x }

full_name: PLift.bind
code: /-- Monadic bind. -/
protected def bind (a : PLift α) (f : α → PLift β) : PLift β 
goal: PLift β

full_name: PLift.bind_up
code: @[simp]
theorem bind_up (a : α) (f : α → PLift β) : (PLift.up a).bind f = f a 
goal: { down := a }.bind f = f a

full_name: PLift.instMonad_mathlib
code: instance : Monad PLift 
goal: Monad PLift

full_name: PLift.instLawfulFunctor_mathlib
code: instance : LawfulFunctor PLift 
goal: LawfulFunctor PLift

full_name: PLift.instLawfulApplicative_mathlib
code: instance : LawfulApplicative PLift 
goal: LawfulApplicative PLift

full_name: PLift.instLawfulMonad_mathlib
code: instance : LawfulMonad PLift 
goal: LawfulMonad PLift

full_name: PLift.rec.constant
code: @[simp]
theorem rec.constant {α : Sort u} {β : Type v} (b : β) :
    (@PLift.rec α (fun _ => β) fun _ => b) = fun _ => b 
goal: (PLift.rec fun x => b) = fun x => b

full_name: ULift.map
code: /-- Functorial action. -/
protected def map (f : α → β) (a : ULift.{u'} α) : ULift.{v'} β 
goal: ULift β

full_name: ULift.map_up
code: @[simp]
theorem map_up (f : α → β) (a : α) : (ULift.up.{u'} a).map f = ULift.up.{v'} (f a) 
goal: ULift.map f { down := a } = { down := f a }

full_name: ULift.pure
code: /-- Embedding of pure values. -/
@[simp]
protected def pure : α → ULift α 
goal: α → ULift α

full_name: ULift.seq
code: /-- Applicative sequencing. -/
protected def seq {α β} (f : ULift (α → β)) (x : Unit → ULift α) : ULift β 
goal: ULift β

full_name: ULift.seq_up
code: @[simp]
theorem seq_up (f : α → β) (x : α) : (ULift.up f).seq (fun _ => ULift.up x) = ULift.up (f x) 
goal: ({ down := f }.seq fun x_1 => { down := x }) = { down := f x }

full_name: ULift.bind
code: /-- Monadic bind. -/
protected def bind (a : ULift α) (f : α → ULift β) : ULift β 
goal: ULift β

full_name: ULift.bind_up
code: @[simp]
theorem bind_up (a : α) (f : α → ULift β) : (ULift.up a).bind f = f a 
goal: { down := a }.bind f = f a

full_name: ULift.instMonad_mathlib
code: instance : Monad ULift 
goal: Monad ULift

full_name: ULift.instLawfulFunctor_mathlib
code: instance : LawfulFunctor ULift 
goal: LawfulFunctor ULift

full_name: ULift.instLawfulApplicative_mathlib
code: instance : LawfulApplicative ULift 
goal: LawfulApplicative ULift

full_name: ULift.instLawfulMonad_mathlib
code: instance : LawfulMonad ULift 
goal: LawfulMonad ULift

full_name: ULift.rec.constant
code: @[simp]
theorem rec.constant {α : Type u} {β : Sort v} (b : β) :
    (@ULift.rec α (fun _ => β) fun _ => b) = fun _ => b 
goal: (ULift.rec fun x => b) = fun x => b