Improvements to grammar

tests/black/Tree.newt

@@ -16,8 +16,8 @@ data Void : U where
 infixl 4 _+_
 
 data _+_ : U -> U -> U where
-  inl : {A B : U} -> A -> A + B
-  inr : {A B : U} -> B -> A + B
+  inl : {A B} -> A -> A + B
+  inr : {A B} -> B -> A + B
 
 infix 4 _<=_
 
@@ -47,14 +47,14 @@ _ <<= Top = Unit
 _ <<= _ = Void
 
 data Intv : Bnd -> Bnd -> U where
-  intv : {l u : Bnd} (x : Nat) (lx : l <<= N x) (xu : N x <<= u) -> Intv l u
+  intv : {l u} (x : Nat) (lx : l <<= N x) (xu : N x <<= u) -> Intv l u
 
 data T23 : Bnd -> Bnd -> Nat -> U where
-  leaf : {l u : Bnd} {h : Nat} (lu : l <<= u) -> T23 l u Z
-  node2 : {l u : Bnd} {h : Nat} (x : _)
+  leaf : {l u} (lu : l <<= u) -> T23 l u Z
+  node2 : {l u h} (x : _)
     (tlx : T23 l (N x) h) (txu : T23 (N x) u h) ->
     T23 l u (S h)
-  node3 : {l u : Bnd} {h : Nat} (x y : _)
+  node3 : {l u h} (x y : _)
     (tlx : T23 l (N x) h) (txy : T23 (N x) (N y) h) (tyu : T23 (N y) u h) ->
     T23 l u (S h)
 
@@ -71,10 +71,8 @@ A * B = Sg A (\ _ => B)
 TooBig : Bnd -> Bnd -> Nat -> U
 TooBig l u h = Sg Nat (\ x => T23 l (N x) h * T23 (N x) u h)
 
-insert : {h : Nat} {l u : Bnd} -> Intv l u -> T23 l u h -> TooBig l u h + T23 l u h
--- Agda is yellow here, needs h = x on each leaf
--- The second arg to the second _,_ is unsolved and pi-typed
-insert (intv x lx xu) (leaf lu) = inl (x , (leaf {_} {_} {x} lx , leaf {_} {_} {x} xu))
+insert : {l u h} -> Intv l u -> T23 l u h -> TooBig l u h + T23 l u h
+insert (intv x lx xu) (leaf lu) = inl (x , (leaf lx , leaf xu))
 insert (intv x lx xu) (node2 y tly tyu) = case cmp x y of
   -- u := N y is not solved at this time
   inl xy => case insert (intv {_} {N y} x lx xy) tly of

tests/black/TypeClass.newt

@@ -3,35 +3,35 @@ module TypeClass
 data Monad : (U -> U) -> U where
   MkMonad : { M : U -> U } ->
             (bind : {A B : U} -> (M A) -> (A -> M B) -> M B) ->
-            (pure : {A : U} -> A -> M A) ->
+            (pure : ∀ A. A -> M A) ->
             Monad M
 
 infixl 1 _>>=_ _>>_
-_>>=_ : {a b : U} -> {m : U -> U} -> {{x : Monad m}} -> (m a) -> (a -> m b) -> m b
-_>>=_ {a} {b} {m} {{MkMonad bind' _}}  ma amb = bind' {a} {b} ma amb
+_>>=_ : ∀ m a b. {{Monad m}} -> (m a) -> (a -> m b) -> m b
+_>>=_ {{MkMonad bind' _}}  ma amb = bind' ma amb
 
-_>>_ : {a b : U} -> {m : U -> U} -> {{x : Monad m}} -> m a -> m b -> m b
+_>>_ : ∀ m a b. {{Monad m}} -> m a -> m b -> m b
 ma >> mb = mb
 
-pure : {a : U} {m : U -> U} {{_ : Monad m}} -> a -> m a
-pure {_} {_} {{MkMonad _ pure'}} a = pure' a
+pure : ∀ m a. {{Monad m}} -> a -> m a
+pure {{MkMonad _ pure'}} a = pure' a
 
 data Either : U -> U -> U where
-  Left : {A B : U} -> A -> Either A B
-  Right : {A B : U} -> B -> Either A B
+  Left : ∀ A B. A -> Either A B
+  Right : ∀ A B. B -> Either A B
 
-bindEither : {A B C : U} -> (Either A B) -> (B -> Either A C) -> Either A C
+bindEither : ∀ A B C. (Either A B) -> (B -> Either A C) -> Either A C
 bindEither (Left a) amb = Left a
 bindEither (Right b) amb = amb b
 
-EitherMonad : {A : U} -> Monad (Either A)
+EitherMonad : ∀ A. Monad (Either A)
 EitherMonad = MkMonad {Either A} bindEither Right
 
 data Maybe : U -> U where
-  Just    : {A : U} -> A -> Maybe A
-  Nothing : {A : U} -> Maybe A
+  Just    : ∀ A. A -> Maybe A
+  Nothing : ∀ A. Maybe A
 
-bindMaybe : {A B : U} -> Maybe A -> (A -> Maybe B) -> Maybe B
+bindMaybe : ∀ A B. Maybe A -> (A -> Maybe B) -> Maybe B
 bindMaybe Nothing amb = Nothing
 bindMaybe (Just a) amb = amb a
 
@@ -40,19 +40,19 @@ MaybeMonad = MkMonad bindMaybe Just
 
 infixr 7 _::_
 data List : U -> U where
-  Nil : {A : U} -> List A
-  _::_ : {A : U} -> A -> List A -> List A
+  Nil : ∀ A. List A
+  _::_ : ∀ A. A -> List A -> List A
 
 infixl 7 _++_
-_++_ : {A : U} -> List A -> List A -> List A
+_++_ : ∀ A. List A -> List A -> List A
 Nil ++ ys = ys
 (x :: xs) ++ ys = x :: (xs ++ ys)
 
-bindList : {A B : U} -> List A -> (A -> List B) -> List B
+bindList : ∀ A B. List A -> (A -> List B) -> List B
 bindList Nil f = Nil
 bindList (x :: xs) f = f x ++ bindList xs f
 
-singleton : {A : U} -> A -> List A
+singleton : ∀ A. A -> List A
 singleton a = a :: Nil
 
 -- TODO need better error when the monad is not defined
@@ -61,7 +61,7 @@ ListMonad = MkMonad bindList singleton
 
 infixr 1 _,_
 data Pair : U -> U -> U where
-  _,_ : {A B : U} -> A -> B -> Pair A B
+  _,_ : ∀ A B. A -> B -> Pair A B
 
 ptype Int
 
@@ -69,7 +69,7 @@ test : Maybe Int
 test = pure 10
 
 foo : Int -> Maybe Int
-foo x = Just 42 >> Just x >>= (\ x => pure {_} {Maybe} 10)
+foo x = Just 42 >> Just x >>= (\ x => pure 10)
 
 bar : Int -> Maybe Int
 bar x = do
@@ -77,7 +77,7 @@ bar x = do
   z <- Just x
   pure z
 
-baz : {A B : U} -> List A -> List B -> List (Pair A B)
+baz : ∀ A B. List A -> List B -> List (Pair A B)
 baz xs ys = do
   x <- xs
   y <- ys