Too many error messages

Code:

prim I
prim left
prim right
struct Path (A : I -> Type) (a : A left) (b : A right) : Type
  | at (i : I) : A i {
    | left => a
    | right => b
  }
def path {A : I -> Type} (p : Pi (i : I) -> A i)
  => new Path A (p left) (p right) { | at i => p i }
def `=` Eq {A : Type} (a b : A) : Type => Path (\ i => A) a b
bind = looser application

def psqueeze {A : Type} {a a' : A} (p : a = a') (i : I) : a = p.at i => path (\j => p.at (I.squeeze i j))

Error:

In file test.aya:14:90 ->

  12 | bind = looser application
  13 | 
  14 | def psqueeze {A : Type} {a a' : A} (p : a = a') (i : I) : a = p.at i => path (\j => p.at (I.squeeze i j))
                                                                                                 ^^

Error: Expected type: Type
       Normalized: Type
       Want: struct type
       Because we want to type a term such as: I
In file test.aya:14:90 ->

  12 | bind = looser application
  13 | 
  14 | def psqueeze {A : Type} {a a' : A} (p : a = a') (i : I) : a = p.at i => path (\j => p.at (I.squeeze i j))
                                                                                                 ^---------^

Error: Expected type: Type
       Normalized: Type
       Want: pi type
       Because we want to type a term such as: I.squeeze i
In file test.aya:14:90 ->

  12 | bind = looser application
  13 | 
  14 | def psqueeze {A : Type} {a a' : A} (p : a = a') (i : I) : a = p.at i => path (\j => p.at (I.squeeze i j))
                                                                                                 ^-----------^

Error: Expected type: Type
       Normalized: Type
       Want: pi type
       Because we want to type a term such as: I.squeeze i j
In file test.aya:14:72 ->

  12 | bind = looser application
  13 | 
  14 | def psqueeze {A : Type} {a a' : A} (p : a = a') (i : I) : a = p.at i => path (\j => p.at (I.squeeze i j))
                                                                               ^------------------------------^

Error: Expected type: Eq {A} a (p.at i)
       Normalized: Path (λ i ⇒ A) a (p.at i)
       Actual type: Path (λ _9 ⇒ A _9) (p.at <I.squeeze i j>) (p.at <I.squeeze i
       j>)
       Normalized: Path (λ _9 ⇒ A) (p.at <I.squeeze i j>) (p.at <I.squeeze i j>)
       They don't match, sorry
🔨

Probably we only want the first error to appear.

[re-xyr]

Here are my ideas for what error messages can be like:

Cannot check the expression 
  p left
of type
  P true
  (Normalized: Top)
against type
  P false
  (Normalized: Bottom)

Cannot apply this expression as a function
  tt
because its type is not a Pi type, but instead:
  Top

Cannot access field `squeeze` of the expression
  I
because its type is not a struct type, but instead:
  Type

[re-xyr]

Imo only the “I is not a struct type” error makes sense

I think she is referring to the error messages I gave