Puis-je avoir un «type de coproduit dépendant»?

Je lis le livre HoTT et j'ai une question (probablement très naïve) sur les trucs du premier chapitre.

Le chapitre présente le type de fonction puis le généralise en faisant dépendre B de x : A B : A → U

$$f:A\to B$$ $B$$x:A$ et que l'on appelle letype de fonction dépendante. $$B:A\to\mathcal{U},\qquad g:\prod_{x:A}B(x)$$

En poursuivant, le chapitre présente ensuite le type de produit

$$f:A\times B$$ puis le généralise en faisant dépendre de x : A B : A → U$B$$x:A$ et que l'on appelle letype de paire dépendante. $$B:A\to\mathcal{U},\qquad g:\sum_{x:A}B(x)$$

Je peux certainement voir un modèle ici.

En poursuivant , le chapitre présente ensuite le type de coproduit et ... combobreaker ... il n'y a pas de discussion sur la version dépendante de ce type.

$$f:A+B$$

Y a-t-il une restriction fondamentale à cela ou est-ce simplement hors de propos pour le sujet du livre? Dans tous les cas, quelqu'un peut-il m'aider à comprendre pourquoi les types de fonction et de produit? Qu'est-ce qui rend ces deux si spéciaux qu'ils peuvent être généralisés aux types dépendants, puis utilisés pour construire tout le reste?

La somme dépendante est une généralisation commune du produit cartésien et du coproduit A + $A \times B$ $A + B$$A \times B$

$A$$B$$P : \mathtt{bool} \to \mathcal{U}$$P(\mathtt{false}) = A$$P(\mathtt{true}) = B$$\sum_{b : \mathtt{bool}} P(b)$$A + B$$A \times B$$\prod_{b : \mathtt{bool}} P(b)$

$\sum$$\prod$$\exists$$\forall$$\exists$$\forall$$\sum$$\prod$

Je vais en parler plus en génie logiciel.

Parlez-vous d'un type de coproduit dont les derniers constructeurs peuvent se référer aux précédents (qui, ressemble assez à un produit dont ce dernier champs peuvent se référer aux précédents)? Cela est possible dans Agda après l'introduction de HIT (dans la version 2.6.0):

-- Auxiliary definition: Nat
data Nat : Set where
  zero : Nat
  succ : Nat -> Nat

-- The HIT I was talking about
data Int : Set where
  positive : Nat -> Int
  negative : Nat -> Int
  -- Note this constructor uses `positive` and `negative`.
  zeroPath : positive zero ≡ negative zero

En suivant cet article , si votre vérificateur de type vérifie les définitions définies à l'aide de la syntaxe présentée dans la figure "(26)", je pense qu'il est assez simple de prendre en charge les "coproduits dépendants".