File: Mathlib/Control/Bitraversable/Instances.lean

full_name: Prod.bitraverse
code: /-- The bitraverse function for `α × β`. -/
def Prod.bitraverse {α α' β β'} (f : α → F α') (f' : β → F β') : α × β → F (α' × β')
  
goal: α × β → F (α' × β')

full_name: instBitraversableProd
code: instance : Bitraversable Prod 
goal: Bitraversable Prod

full_name: instLawfulBitraversableProd
code: instance : LawfulBitraversable Prod 
goal: LawfulBitraversable Prod

full_name: Sum.bitraverse
code: /-- The bitraverse function for `α ⊕ β`. -/
def Sum.bitraverse {α α' β β'} (f : α → F α') (f' : β → F β') : α ⊕ β → F (α' ⊕ β')
  
goal: α ⊕ β → F (α' ⊕ β')

full_name: instBitraversableSum
code: instance : Bitraversable Sum 
goal: Bitraversable Sum

full_name: instLawfulBitraversableSum
code: instance : LawfulBitraversable Sum 
goal: LawfulBitraversable Sum

full_name: Const.bitraverse
code: /-- The bitraverse function for `Const`. It throws away the second map. -/
@[nolint unusedArguments]
def Const.bitraverse {F : Type u → Type u} [Applicative F] {α α' β β'} (f : α → F α')
    (f' : β → F β') : Const α β → F (Const α' β') 
goal: Functor.Const α β → F (Functor.Const α' β')

full_name: Bitraversable.const
code: instance Bitraversable.const : Bitraversable Const 
goal: Bitraversable Functor.Const

full_name: LawfulBitraversable.const
code: instance LawfulBitraversable.const : LawfulBitraversable Const 
goal: LawfulBitraversable Functor.Const

full_name: flip.bitraverse
code: /-- The bitraverse function for `flip`. -/
nonrec def flip.bitraverse {α α' β β'} (f : α → F α') (f' : β → F β') :
    flip t α β → F (flip t α' β') 
goal: flip t α β → F (flip t α' β')

full_name: Bitraversable.flip
code: instance Bitraversable.flip : Bitraversable (flip t) 
goal: Bitraversable (flip t)

full_name: LawfulBitraversable.flip
code: instance LawfulBitraversable.flip [LawfulBitraversable t] : LawfulBitraversable (flip t) 
goal: LawfulBitraversable (flip t)

full_name: Bitraversable.traversable
code: instance (priority := 10) Bitraversable.traversable {α} : Traversable (t α) 
goal: Traversable (t α)

full_name: Bitraversable.isLawfulTraversable
code: instance (priority := 10) Bitraversable.isLawfulTraversable [LawfulBitraversable t] {α} :
    LawfulTraversable (t α) 
goal: LawfulTraversable (t α)

full_name: Bicompl.bitraverse
code: /-- The bitraverse function for `bicompl`. -/
nonrec def Bicompl.bitraverse {m} [Applicative m] {α β α' β'} (f : α → m β) (f' : α' → m β') :
    bicompl t F G α α' → m (bicompl t F G β β') 
goal: Function.bicompl t F G α α' → m (Function.bicompl t F G β β')

full_name: instBitraversableBicompl
code: instance : Bitraversable (bicompl t F G) 
goal: Bitraversable (Function.bicompl t F G)

full_name: instLawfulBitraversableBicomplOfLawfulTraversable
code: instance [LawfulTraversable F] [LawfulTraversable G] [LawfulBitraversable t] :
    LawfulBitraversable (bicompl t F G) 
goal: LawfulBitraversable (Function.bicompl t F G)

full_name: Bicompr.bitraverse
code: /-- The bitraverse function for `bicompr`. -/
nonrec def Bicompr.bitraverse {m} [Applicative m] {α β α' β'} (f : α → m β) (f' : α' → m β') :
    bicompr F t α α' → m (bicompr F t β β') 
goal: Function.bicompr F t α α' → m (Function.bicompr F t β β')

full_name: instBitraversableBicompr
code: instance : Bitraversable (bicompr F t) 
goal: Bitraversable (Function.bicompr F t)

full_name: instLawfulBitraversableBicomprOfLawfulTraversable
code: instance [LawfulTraversable F] [LawfulBitraversable t] : LawfulBitraversable (bicompr F t) 
goal: LawfulBitraversable (Function.bicompr F t)