What are the difference between and consequences of using type parameters and type indexes?
ListP t and ListI t are isomorphic: they have exactly the same constructors.

&lt;prompt&gt;Coq &lt; 12 || 0 &lt; &lt;/prompt&gt;Check (NilP, NilI). 
(NilP, NilI)
     : (forall t : Type, ListP t) *
       (forall t : Type, ListI t)

&lt;prompt&gt;Coq &lt; 13 || 0 &lt; &lt;/prompt&gt;Check (ConsP, ConsI). 
(ConsP, ConsI)
     : (forall t : Type, t -&gt; ListP t -&gt; ListP t) *
       (forall t : Type, t -&gt; ListI t -&gt; ListI t)


However Coq generates different induction principles.    

&lt;prompt&gt;Coq &lt; 14 || 0 &lt; &lt;/prompt&gt;Check (ListP_ind, ListI_ind). 
(ListP_ind, ListI_ind)
     : (forall (t : Type) (P : ListP t -&gt; Prop),
        P (NilP t) -&gt;
        (forall (t0 : t) (l : ListP t), P l -&gt; P (ConsP t t0 l)) -&gt;
        forall l : ListP t, P l) *
       (forall P : forall T : Type, ListI T -&gt; Prop,
        (forall t : Type, P t (NilI t)) -&gt;
        (forall (t : Type) (t0 : t) (l : ListI t),
         P t l -&gt; P t (ConsI t t0 l)) -&gt;
        forall (T : Type) (l : ListI T), P T l)


The induction principle of ListI requires the property to be parameteric in the element type (P : forall T, ListI T -&gt; Prop) whereas the induction principle of ListP can be instantiated at any type t (P : ListP t -&gt; Prop). This is a weakness of Coq's front-end, in that it is not smart about non-uniform recursive types; you can manually define the same induction principle (the typechecker accepts it, which is unsurprising given that it is ListP_ind transformed by the obvious isomorphism between ListP and ListI).

The parametric form ListP is simpler and easier to use out of the box. The ListI form can generalize to non-uniform recursion, where the parameters in the recursive calls are not the original. See Polymorphism and Inductive datatypes for an example.