From Tealeaves Require Export
  Classes.Categorical.Applicative
  Classes.Kleisli.DecoratedTraversableCommIdemFunctor
  Functors.List_Telescoping_General
  Functors.Writer.

Import Applicative.Notations.
Import Product.Notations.
Import Monad.Notations.
Import Comonad.Notations.
Import DecoratedTraversableCommIdemFunctor.Notations.

#[local] Generalizable Variables ϕ G T.

Class MapdtPoly (T: Type → Type → Type) :=
    mapdtp:
      ∀ (B1 B2 A1 A2: Type)
        (G : Type → Type)
        `{Gmap: Map G} `{Gpure: Pure G} `{Gmult: Mult G},
        (list B1 × B1 → G B2) →
        (list B1 × A1 → G A2) →
        T B1 A1 →
        G (T B2 A2).

Arguments mapdtp {T}%function_scope {MapdtPoly} {B1 B2 A1 A2}%type_scope
  {G}%function_scope {Gmap Gpure Gmult} (_ _)%function_scope _.

Definition kc_dtfp {T}
  `{MapdtPoly T}
  {G1 : Type → Type}
  `{map_G1: Map G1} `{pure_G1: Pure G1} `{mult_G1: Mult G1}
  {G2 : Type → Type}
  `{map_G2: Map G2} `{pure_G2: Pure G2} `{mult_G2: Mult G2}
  {B1 A1 B2 A2 A3: Type}
  (σ2: list B2 × A2 → G2 A3) (* second op to rename variables *)
  (ρ1: list B1 × B1 → G1 B2) (* first op to rename binders *)
  (σ1: list B1 × A1 → G1 A2) (* first op to rename variables *)
  : list B1 × A1 → (G1 ∘ G2) A3 :=
  fun '(ctx, a) ⇒
    map (F := G1) σ2 (pure pair
                        <⋆> mapdt_ci (W := Z) ρ1 ctx
                        <⋆> σ1 (ctx, a)).

Class DecoratedTraversableFunctorPoly
    (T: Type → Type → Type)
    `{MapdtPoly T} :=
  { kdtfp_mapdtp1:
    ∀ (B A: Type),
      mapdtp (G := fun A ⇒ A)
        (extract (W := (list B ×)))
        (extract (W := (list B ×)))
      = @id (T B A);
    kdtfp_mapdtp2:
    ∀ {B1 B2 B3: Type}
      {A1 A2 A3: Type}
      `{Applicative G1}
      `{Applicative G2}
      (ρ1: list B1 × B1 → G1 B2)
      (ρ2: list B2 × B2 → G2 B3)
      (σ1: list B1 × A1 → G1 A2)
      (σ2: list B2 × A2 → G2 A3),
      (∀ p: list B1 × B1, IdempotentCenter G1 B2 (ρ1 p)) →
      map (F := G1) (mapdtp (G := G2) ρ2 σ2) ∘
        mapdtp (G := G1) (T := T) ρ1 σ1 =
        mapdtp (T := T) (G := G1 ∘ G2)
          (ρ2 ⋆3_ci ρ1) (kc_dtfp σ2 ρ1 σ1);
    kdtfp_morphism:
    ∀ {B1 A1 B2 A2: Type} {G1 G2: Type → Type}
      `{morph: ApplicativeMorphism G1 G2 ϕ}
      (ρ: list B1 × B1 → G1 B2)
      (σ: list B1 × A1 → G1 A2),
      ϕ (T B2 A2) ∘ mapdtp ρ σ =
        mapdtp (ϕ B2 ∘ ρ) (ϕ A2 ∘ σ);
  }.