refactor literal parsing

8 files changed, 202 insertions, 223 deletions

diff --git a/src/LambdaCube/Compiler/Lexer.hs b/src/LambdaCube/Compiler/Lexer.hs
index 576cba23..e3ef0333 100644
--- a/src/LambdaCube/Compiler/Lexer.hs
+++ b/src/LambdaCube/Compiler/Lexer.hs
@@ -64,6 +64,22 @@ namespace :: P Namespace
 namespace = asks snd
 
 
+-------------------------------------------------------------------------------- literals
+
+data Lit
+    = LInt Integer
+    | LChar Char
+    | LFloat Double
+    | LString String
+  deriving (Eq)
+
+instance Show Lit where
+    show = \case
+        LFloat x  -> show x
+        LString x -> show x
+        LInt x    -> show x
+        LChar x   -> show x
+
 -------------------------------------------------------------------------------- names
 
 type SName = String
@@ -278,7 +294,8 @@ parseFixityDecl = do
         <|> InfixL <$ reserved "infixl"
         <|> InfixR <$ reserved "infixr"
   localIndentation Gt $ do
-    i <- fromIntegral <$> natural
+    LInt n <- parseLit
+    let i = fromIntegral n
     ns <- commaSep1 (parseSIName rhsOperator)
     return $ (,) <$> ns <*> pure (dir, i)
 
@@ -313,182 +330,162 @@ semiSep p       = sepBy p semi
 commaSep1 p     = sepBy1 p comma
 semiSep1 p      = sepBy1 p semi
 
-
 -----------------------------------------------------------
--- Chars & Strings
------------------------------------------------------------
-charLiteral     = lexeme (between (char '\'')
-                                  (char '\'' <?> "end of character")
-                                  characterChar )
-                <?> "character"
-
-characterChar   = charLetter <|> charEscape
-                <?> "literal character"
-
-charEscape      = do{ char '\\'; escapeCode }
-charLetter      = satisfy (\c -> (c /= '\'') && (c /= '\\') && (c > '\026'))
-
-
-
-stringLiteral   = lexeme (
-                  do{ str <- between (char '"')
-                                     (localTokenMode (const Pa.Any) (char '"' <?> "end of string"))
-                                     (localTokenMode (const Pa.Any) (many stringChar))
-                    ; return (foldr (maybe id (:)) "" str)
-                    }
-                  <?> "literal string")
-
-stringChar      =   do{ c <- stringLetter; return (Just c) }
-                <|> stringEscape
-                <?> "string character"
-
-stringLetter    = satisfy (\c -> (c /= '"') && (c /= '\\') && (c > '\026'))
-
-stringEscape    = do{ char '\\'
-                    ;     do{ escapeGap  ; return Nothing }
-                      <|> do{ escapeEmpty; return Nothing }
-                      <|> do{ esc <- escapeCode; return (Just esc) }
-                    }
-
-escapeEmpty     = char '&'
-escapeGap       = do{ many1 space
-                    ; char '\\' <?> "end of string gap"
-                    }
-
-
-
--- escape codes
-escapeCode      = charEsc <|> charNum <|> charAscii <|> charControl
-                <?> "escape code"
-
-charControl     = do{ char '^'
-                    ; code <- upper
-                    ; return (toEnum (fromEnum code - fromEnum 'A'))
-                    }
-
-charNum         = do{ code <- decimal
-                              <|> do{ char 'o'; number 8 octDigit }
-                              <|> do{ char 'x'; number 16 hexDigit }
-                    ; return (toEnum (fromInteger code))
-                    }
-
-charEsc         = choice (map parseEsc escMap)
-                where
-                  parseEsc (c,code)     = do{ char c; return code }
-
-charAscii       = choice (map parseAscii asciiMap)
-                where
-                  parseAscii (asc,code) = try (do{ string asc; return code })
-
-
--- escape code tables
-escMap          = zip ("abfnrtv\\\"\'") ("\a\b\f\n\r\t\v\\\"\'")
-asciiMap        = zip (ascii3codes ++ ascii2codes) (ascii3 ++ ascii2)
-
-ascii2codes     = ["BS","HT","LF","VT","FF","CR","SO","SI","EM",
-                   "FS","GS","RS","US","SP"]
-ascii3codes     = ["NUL","SOH","STX","ETX","EOT","ENQ","ACK","BEL",
-                   "DLE","DC1","DC2","DC3","DC4","NAK","SYN","ETB",
-                   "CAN","SUB","ESC","DEL"]
-
-ascii2          = ['\BS','\HT','\LF','\VT','\FF','\CR','\SO','\SI',
-                   '\EM','\FS','\GS','\RS','\US','\SP']
-ascii3          = ['\NUL','\SOH','\STX','\ETX','\EOT','\ENQ','\ACK',
-                   '\BEL','\DLE','\DC1','\DC2','\DC3','\DC4','\NAK',
-                   '\SYN','\ETB','\CAN','\SUB','\ESC','\DEL']
 
+parseLit = lexeme $ charLiteral <|> stringLiteral <|> natFloat
+  where
+    -----------------------------------------------------------
+    -- Chars & Strings
+    -----------------------------------------------------------
+    charLiteral     = LChar <$> between (char '\'')
+                                      (char '\'' <?> "end of character")
+                                      characterChar
+                    <?> "character"
+
+    characterChar   = charLetter <|> charEscape
+                    <?> "literal character"
 
------------------------------------------------------------
--- Numbers
------------------------------------------------------------
-naturalOrFloat  = lexeme (natFloat) <?> "number"
-
-float           = lexeme floating   <?> "float"
-integer         = lexeme int        <?> "integer"
-natural         = lexeme nat        <?> "natural"
-
-
--- floats
-floating        = do{ n <- decimal
-                    ; fractExponent n
-                    }
-
-
-natFloat        = do{ char '0'
-                    ; zeroNumFloat
-                    }
-                  <|> decimalFloat
-
-zeroNumFloat    =  do{ n <- hexadecimal <|> octal
-                     ; return (Left n)
-                     }
-                <|> decimalFloat
-                <|> fractFloat 0
-                <|> return (Left 0)
-
-decimalFloat    = do{ n <- decimal
-                    ; option (Left n)
-                             (fractFloat n)
-                    }
-
-fractFloat n    = do{ f <- fractExponent n
-                    ; return (Right f)
-                    }
-
-fractExponent n = do{ fract <- fraction
-                    ; expo  <- option 1.0 exponent'
-                    ; return ((fromInteger n + fract)*expo)
-                    }
-                <|>
-                  do{ expo <- exponent'
-                    ; return ((fromInteger n)*expo)
-                    }
-
-fraction        = do{ char '.'
-                    ; digits <- many1 digit <?> "fraction"
-                    ; return (foldr op 0.0 digits)
-                    }
-                  <?> "fraction"
-                where
-                  op d f    = (f + fromIntegral (digitToInt d))/10.0
-
-exponent'       = do{ oneOf "eE"
-                    ; f <- sign
-                    ; e <- decimal <?> "exponent"
-                    ; return (power (f e))
-                    }
-                  <?> "exponent"
-                where
-                   power e  | e < 0      = 1.0/power(-e)
-                            | otherwise  = fromInteger (10^e)
-
-
--- integers and naturals
-int             = do{ f <- lexeme sign
-                    ; n <- nat
-                    ; return (f n)
-                    }
-
-sign            =   (char '-' >> return negate)
-                <|> (char '+' >> return id)
-                <|> return id
-
-nat             = zeroNumber <|> decimal
-
-zeroNumber      = do{ char '0'
-                    ; hexadecimal <|> octal <|> decimal <|> return 0
-                    }
-                  <?> ""
-
-decimal         = number 10 digit
-hexadecimal     = do{ oneOf "xX"; number 16 hexDigit }
-octal           = do{ oneOf "oO"; number 8 octDigit  }
-
-number base baseDigit
-    = do{ digits <- many1 baseDigit
-        ; let n = foldl' (\x d -> base*x + toInteger (digitToInt d)) 0 digits
-        ; seq n (return n)
-        }
+    charEscape      = do{ char '\\'; escapeCode }
+    charLetter      = satisfy (\c -> (c /= '\'') && (c /= '\\') && (c > '\026'))
+
+
+
+    stringLiteral   = LString <$> 
+                      do{ str <- between (char '"')
+                                         (localTokenMode (const Pa.Any) (char '"' <?> "end of string"))
+                                         (localTokenMode (const Pa.Any) (many stringChar))
+                        ; return (foldr (maybe id (:)) "" str)
+                        }
+                      <?> "literal string"
+
+    stringChar      =   do{ c <- stringLetter; return (Just c) }
+                    <|> stringEscape
+                    <?> "string character"
+
+    stringLetter    = satisfy (\c -> (c /= '"') && (c /= '\\') && (c > '\026'))
+
+    stringEscape    = do{ char '\\'
+                        ;     do{ escapeGap  ; return Nothing }
+                          <|> do{ escapeEmpty; return Nothing }
+                          <|> do{ esc <- escapeCode; return (Just esc) }
+                        }
+
+    escapeEmpty     = char '&'
+    escapeGap       = do{ many1 space
+                        ; char '\\' <?> "end of string gap"
+                        }
+
+
+
+    -- escape codes
+    escapeCode      = charEsc <|> charNum <|> charAscii <|> charControl
+                    <?> "escape code"
+
+    charControl     = do{ char '^'
+                        ; code <- upper
+                        ; return (toEnum (fromEnum code - fromEnum 'A'))
+                        }
+
+    charNum         = do{ code <- decimal
+                                  <|> do{ char 'o'; number 8 octDigit }
+                                  <|> do{ char 'x'; number 16 hexDigit }
+                        ; return (toEnum (fromInteger code))
+                        }
+
+    charEsc         = choice (map parseEsc escMap)
+                    where
+                      parseEsc (c,code)     = do{ char c; return code }
+
+    charAscii       = choice (map parseAscii asciiMap)
+                    where
+                      parseAscii (asc,code) = try (do{ string asc; return code })
+
+
+    -- escape code tables
+    escMap          = zip ("abfnrtv\\\"\'") ("\a\b\f\n\r\t\v\\\"\'")
+    asciiMap        = zip (ascii3codes ++ ascii2codes) (ascii3 ++ ascii2)
+
+    ascii2codes     = ["BS","HT","LF","VT","FF","CR","SO","SI","EM",
+                       "FS","GS","RS","US","SP"]
+    ascii3codes     = ["NUL","SOH","STX","ETX","EOT","ENQ","ACK","BEL",
+                       "DLE","DC1","DC2","DC3","DC4","NAK","SYN","ETB",
+                       "CAN","SUB","ESC","DEL"]
+
+    ascii2          = ['\BS','\HT','\LF','\VT','\FF','\CR','\SO','\SI',
+                       '\EM','\FS','\GS','\RS','\US','\SP']
+    ascii3          = ['\NUL','\SOH','\STX','\ETX','\EOT','\ENQ','\ACK',
+                       '\BEL','\DLE','\DC1','\DC2','\DC3','\DC4','\NAK',
+                       '\SYN','\ETB','\CAN','\SUB','\ESC','\DEL']
+
+
+    -----------------------------------------------------------
+    -- Numbers
+    -----------------------------------------------------------
+
+    -- floats
+    natFloat        = do{ char '0'
+                        ; zeroNumFloat
+                        }
+                      <|> decimalFloat
+
+    zeroNumFloat    =  do{ n <- hexadecimal <|> octal
+                         ; return (LInt n)
+                         }
+                    <|> decimalFloat
+                    <|> fractFloat 0
+                    <|> return (LInt 0)
+
+    decimalFloat    = do{ n <- decimal
+                        ; option (LInt n)
+                                 (fractFloat n)
+                        }
+
+    fractFloat n    = do{ f <- fractExponent n
+                        ; return (LFloat f)
+                        }
+
+    fractExponent n = do{ fract <- fraction
+                        ; expo  <- option 1.0 exponent'
+                        ; return ((fromInteger n + fract)*expo)
+                        }
+                    <|>
+                      do{ expo <- exponent'
+                        ; return ((fromInteger n)*expo)
+                        }
+
+    fraction        = do{ char '.'
+                        ; digits <- many1 digit <?> "fraction"
+                        ; return (foldr op 0.0 digits)
+                        }
+                      <?> "fraction"
+                    where
+                      op d f    = (f + fromIntegral (digitToInt d))/10.0
+
+    exponent'       = do{ oneOf "eE"
+                        ; f <- sign
+                        ; e <- decimal <?> "exponent"
+                        ; return (power (f e))
+                        }
+                      <?> "exponent"
+                    where
+                       power e  | e < 0      = 1.0/power(-e)
+                                | otherwise  = fromInteger (10^e)
+
+
+    -- integers and naturals
+    sign            =   (char '-' >> return negate)
+                    <|> (char '+' >> return id)
+                    <|> return id
+
+    decimal         = number 10 digit
+    hexadecimal     = do{ oneOf "xX"; number 16 hexDigit }
+    octal           = do{ oneOf "oO"; number 8 octDigit  }
+
+    number base baseDigit
+        = do{ digits <- many1 baseDigit
+            ; let n = foldl' (\x d -> base*x + toInteger (digitToInt d)) 0 digits
+            ; seq n (return n)
+            }
 
 -----------------------------------------------------------
 -- Operators & reserved ops
diff --git a/src/LambdaCube/Compiler/Parser.hs b/src/LambdaCube/Compiler/Parser.hs
index 9ed694d9..bcaa4538 100644
--- a/src/LambdaCube/Compiler/Parser.hs
+++ b/src/LambdaCube/Compiler/Parser.hs
@@ -73,22 +73,6 @@ debug = False--True--tr
 
 try = try_
 
--------------------------------------------------------------------------------- literals
-
-data Lit
-    = LInt !Int
-    | LChar Char
-    | LFloat Double
-    | LString String
-  deriving (Eq)
-
-instance Show Lit where
-    show = \case
-        LFloat x  -> show x
-        LString x -> show x
-        LInt x    -> show x
-        LChar x   -> show x
-
 -------------------------------------------------------------------------------- builtin precedences
 
 data Prec
@@ -382,11 +366,7 @@ parseTerm prec = withRange setSI $ case prec of
     PrecSwiz -> level PrecProj $ \t -> try "swizzling" $ mkSwizzling t <$> lexeme (char '%' *> manyNM 1 4 (satisfy (`elem` ("xyzwrgba" :: String))))
     PrecProj -> level PrecAtom $ \t -> try "projection" $ mkProjection t <$ char '.' <*> sepBy1 (sLit . LString <$> lowerCase) (char '.')
     PrecAtom ->
-         sLit . LChar    <$> try "char literal" charLiteral
-     <|> sLit . LString  <$> stringLiteral
-     <|> sLit . LFloat   <$> try "float literal" float
-     <|> sLit . LInt . fromIntegral <$ char '#' <*> natural -- todo:  remove
-     <|> mkNat <$> namespace <*> natural
+         mkLit <$> namespace <*> try "literal" parseLit
      <|> Wildcard (Wildcard SType) <$ reserved "_"
      <|> char '\'' *> switchNS (parseTerm PrecAtom)
      <|> sVar (try "identifier" upperLower)
@@ -449,8 +429,9 @@ parseTerm prec = withRange setSI $ case prec of
     mkList (Namespace (Just ExpLevel)  _) xs = foldr (\x l -> SBuiltin "Cons" `SAppV` x `SAppV` l) (SBuiltin "Nil") xs
     mkList _ xs = error "mkList"
 
-    mkNat (Namespace (Just ExpLevel) _) n = SBuiltin "fromInt" `SAppV` sLit (LInt $ fromIntegral n)
-    mkNat _ n = toNat n
+    mkLit (Namespace (Just ExpLevel) _) n@LInt{} = SBuiltin "fromInt" `SAppV` sLit n
+    mkLit _ (LInt n) = toNat n
+    mkLit _ l = sLit l
 
     toNat 0 = SBuiltin "Zero"
     toNat n | n > 0 = SAppV (SBuiltin "Succ") $ toNat (n-1)
@@ -463,7 +444,7 @@ parseTerm prec = withRange setSI $ case prec of
     calculatePrecs ns dcls = either fail return . f where
         f []                 = error "impossible"
         f (Right t: xs)      = either (\(op, xs) -> RightSection (calcPrec' t xs) op) (calcPrec' t) <$> cont xs
-        f xs@(Left op@(_, "-"): _) = f $ Right (mkNat ns 0): xs
+        f xs@(Left op@(_, "-"): _) = f $ Right (mkLit ns $ LInt 0): xs
         f (Left op: xs)      = g op xs >>= either (const $ Left "TODO: better error message @476")
                                                   (\((op, e): oe) -> return $ LeftSection op $ calcPrec' e oe)
         g op (Right t: xs)   = (second ((op, t):) +++ ((op, t):)) <$> cont xs
@@ -582,10 +563,7 @@ parsePat = \case
          PCon <$> parseSIName upperCase <*> many (ParPat . pure <$> parsePat PrecAtom)
      <|> parsePat PrecAtom
   PrecAtom ->
-         litP "primCompareFloat"  . LFloat  <$> try "float literal" float
-     <|> litP "primCompareString" . LString <$> stringLiteral
-     <|> litP "primCompareChar"   . LChar   <$> try "char literal" charLiteral
-     <|> appRange (mkNatPat <$> namespace <*> natural)
+         mkLit <$> namespace <*> try "literal" parseLit
      <|> flip PCon [] <$> parseSIName upperCase
      <|> char '\'' *> switchNS (parsePat PrecAtom)
      <|> PVar <$> parseSIName patVar
@@ -593,8 +571,14 @@ parsePat = \case
      <|> (\ns -> pConSI . mkTupPat ns) <$> namespace <*> parens patlist
  where
     litP s = flip ViewPat (ParPat [PCon (mempty, "EQ") []]) . SAppV (SBuiltin s) . sLit
-    mkNatPat (Namespace (Just ExpLevel) _) n si = litP "primCompareInt" . LInt $ fromIntegral n
-    mkNatPat _ n si = toNatP si n
+
+    mkLit (Namespace (Just ExpLevel) _) n@LInt{} = litP "primCompareInt" n
+    mkLit _ (LInt n) = toNatP n
+    mkLit _ n = litP (f n) n where
+        f LFloat{}  = "primCompareFloat"
+        f LString{} = "primCompareString"
+        f LChar{}   = "primCompareChar"
+
     pConSI (PCon (_, n) ps) = PCon (sourceInfo ps, n) ps
     pConSI p = p
 
@@ -613,9 +597,9 @@ parsePat = \case
 
     calculatePatPrecs dcls (e, xs) = calcPrec (\op x y -> PCon op $ ParPat . (:[]) <$> [x, y]) (getFixity dcls . snd) e xs
 
-    toNatP si = run where
-      run 0         = PCon (si, "Zero") []
-      run n | n > 0 = PCon (si, "Succ") [ParPat [run $ n-1]]
+    toNatP = run where
+      run 0         = PCon (mempty, "Zero") []
+      run n | n > 0 = PCon (mempty, "Succ") [ParPat [run $ n-1]]
 
 
 longPattern = parsePat PrecAnn <&> (getPVars &&& id)
diff --git a/testdata/Builtins.out b/testdata/Builtins.out
index 6f407c39..7e947fa9 100644
--- a/testdata/Builtins.out
+++ b/testdata/Builtins.out
@@ -73,10 +73,8 @@ testdata/Builtins.lc 31:52-31:53  Type
 testdata/Builtins.lc 31:54-31:55  Nat
 testdata/Builtins.lc 33:29-33:32  Type
 testdata/Builtins.lc 34:5-34:14  Nat -> Type->Type
-testdata/Builtins.lc 34:15-34:16  Nat
-testdata/Builtins.lc 34:15-35:60  Nat -> Type->Type | Type | Type->Type
 testdata/Builtins.lc 34:21-34:22  Type
-testdata/Builtins.lc 34:21-35:60  Nat->Type
+testdata/Builtins.lc 34:21-35:60  Nat -> Type->Type | Nat->Type | Type->Type
 testdata/Builtins.lc 35:37-35:40  Nat -> Type->Type
 testdata/Builtins.lc 35:37-35:58  Type->Type
 testdata/Builtins.lc 35:37-35:60  Nat->Type | Type
@@ -589,7 +587,7 @@ testdata/Builtins.lc 110:20-112:12  ({a : Component V0} -> V1 -> V2 -> V3 -> Vec
 testdata/Builtins.lc 110:20-113:12  ({a : Component V0} -> V1 -> V2 -> V3 -> V4 -> VecS V5 4) -> {g : Component V1} -> V2 -> V3 -> V4 -> V5 -> VecS V6 4
 testdata/Builtins.lc 110:20-114:19  {a : Component V0}->V1 -> {c : Component V1}->V2
 testdata/Builtins.lc 110:20-115:17  {a : Component V0}->V1 -> {c : Component V1}->V2
-testdata/Builtins.lc 110:20-136:33  Type | Type->Type
+testdata/Builtins.lc 110:20-136:31  Type | Type->Type
 testdata/Builtins.lc 110:20-157:12  {a : Component V0} -> V1 -> V2 -> VecS V3 2 | {a} -> {b : Component a} -> a -> a -> VecS a 2
 testdata/Builtins.lc 110:20-158:12  {a : Component V0} -> V1 -> V2 -> V3 -> VecS V4 3 | {a} -> {b : Component a} -> a -> a -> a -> VecS a 3
 testdata/Builtins.lc 110:20-159:12  {a : Component V0} -> V1 -> V2 -> V3 -> V4 -> VecS V5 4 | {a} -> {b : Component a} -> a -> a -> a -> a -> VecS a 4
@@ -606,7 +604,7 @@ testdata/Builtins.lc 116:20-118:12  ({a : Component V0} -> V1 -> V2 -> V3 -> Vec
 testdata/Builtins.lc 116:20-119:12  ({a : Component V0} -> V1 -> V2 -> V3 -> V4 -> VecS V5 4) -> {g : Component V1} -> V2 -> V3 -> V4 -> V5 -> VecS V6 4
 testdata/Builtins.lc 116:20-120:22  {a : Component V0}->V1 -> {c : Component V1}->V2
 testdata/Builtins.lc 116:20-121:21  {a : Component V0}->V1 -> {c : Component V1}->V2
-testdata/Builtins.lc 116:20-136:33  Type
+testdata/Builtins.lc 116:20-136:31  Type
 testdata/Builtins.lc 116:20-157:12  {a : Component V0} -> V1 -> V2 -> VecS V3 2
 testdata/Builtins.lc 116:20-158:12  {a : Component V0} -> V1 -> V2 -> V3 -> VecS V4 3
 testdata/Builtins.lc 116:20-159:12  {a : Component V0} -> V1 -> V2 -> V3 -> V4 -> VecS V5 4
@@ -627,7 +625,7 @@ testdata/Builtins.lc 123:20-125:12  ({a : Component V0} -> V1 -> V2 -> V3 -> Vec
 testdata/Builtins.lc 123:20-126:12  ({a : Component V0} -> V1 -> V2 -> V3 -> V4 -> VecS V5 4) -> {g : Component V1} -> V2 -> V3 -> V4 -> V5 -> VecS V6 4
 testdata/Builtins.lc 123:20-127:23  {a : Component V0}->V1 -> {c : Component V1}->V2
 testdata/Builtins.lc 123:20-128:22  {a : Component V0}->V1 -> {c : Component V1}->V2
-testdata/Builtins.lc 123:20-136:33  Type
+testdata/Builtins.lc 123:20-136:31  Type
 testdata/Builtins.lc 123:20-157:12  {a : Component V0} -> V1 -> V2 -> VecS V3 2
 testdata/Builtins.lc 123:20-158:12  {a : Component V0} -> V1 -> V2 -> V3 -> VecS V4 3
 testdata/Builtins.lc 123:20-159:12  {a : Component V0} -> V1 -> V2 -> V3 -> V4 -> VecS V5 4
@@ -648,7 +646,7 @@ testdata/Builtins.lc 130:20-132:12  ({a : Component V0} -> V1 -> V2 -> V3 -> Vec
 testdata/Builtins.lc 130:20-133:12  ({a : Component V0} -> V1 -> V2 -> V3 -> V4 -> VecS V5 4) -> {g : Component V1} -> V2 -> V3 -> V4 -> V5 -> VecS V6 4
 testdata/Builtins.lc 130:20-134:17  {a : Component V0}->V1 -> {c : Component V1}->V2
 testdata/Builtins.lc 130:20-135:16  {a : Component V0}->V1 -> {c : Component V1}->V2
-testdata/Builtins.lc 130:20-136:33  Type
+testdata/Builtins.lc 130:20-136:31  Type
 testdata/Builtins.lc 130:20-157:12  {a : Component V0} -> V1 -> V2 -> VecS V3 2
 testdata/Builtins.lc 130:20-158:12  {a : Component V0} -> V1 -> V2 -> V3 -> VecS V4 3
 testdata/Builtins.lc 130:20-159:12  {a : Component V0} -> V1 -> V2 -> V3 -> V4 -> VecS V5 4
@@ -659,7 +657,7 @@ testdata/Builtins.lc 132:10-132:12  {a} -> a -> a -> a -> VecS a 3
 testdata/Builtins.lc 133:10-133:12  {a} -> a -> a -> a -> a -> VecS a 4
 testdata/Builtins.lc 134:14-134:17  Float
 testdata/Builtins.lc 135:13-135:16  Float
-testdata/Builtins.lc 136:26-136:33  Type
+testdata/Builtins.lc 136:26-136:31  Type
 testdata/Builtins.lc 136:26-157:12  ({a : Component V0} -> V1 -> V2 -> VecS V3 2) -> {e : Component V1} -> V2 -> V3 -> VecS V4 2
 testdata/Builtins.lc 136:26-158:12  ({a : Component V0} -> V1 -> V2 -> V3 -> VecS V4 3) -> {f : Component V1} -> V2 -> V3 -> V4 -> VecS V5 3
 testdata/Builtins.lc 136:26-159:12  ({a : Component V0} -> V1 -> V2 -> V3 -> V4 -> VecS V5 4) -> {g : Component V1} -> V2 -> V3 -> V4 -> V5 -> VecS V6 4
@@ -759,9 +757,9 @@ testdata/Builtins.lc 166:25-166:29  Type
 testdata/Builtins.lc 168:7-168:15  Type->Type
 testdata/Builtins.lc 170:25-170:30  Type
 testdata/Builtins.lc 170:25-174:39  Type | Type->Type
-testdata/Builtins.lc 171:31-171:38  Type
+testdata/Builtins.lc 171:31-171:36  Type
 testdata/Builtins.lc 171:31-174:39  Type
-testdata/Builtins.lc 174:30-174:39  Type
+testdata/Builtins.lc 174:34-174:39  Type
 testdata/Builtins.lc 184:6-184:20  Type
 testdata/Builtins.lc 184:6-199:23  Type
 testdata/Builtins.lc 185:7-185:12  BlendingFactor
@@ -1593,7 +1591,7 @@ testdata/Builtins.lc 427:29-427:42  {a} -> {b} -> {c : DefaultFragOp b} -> Fragm
 testdata/Builtins.lc 427:46-427:63  Type->Type
 testdata/Builtins.lc 427:46-427:65  Type
 testdata/Builtins.lc 427:64-427:65  Type
-testdata/Builtins.lc 428:37-428:44  Type
+testdata/Builtins.lc 428:37-428:42  Type
 testdata/Builtins.lc 428:37-428:112  ({a : DefaultFragOp V1} -> FragmentOperation V2) -> {c : DefaultFragOp V2} -> FragmentOperation V3
 testdata/Builtins.lc 428:37-429:36  Type | Type->Type
 testdata/Builtins.lc 428:37-429:77  {a : DefaultFragOp V1} -> FragmentOperation V2 | {a} -> {b : DefaultFragOp a} -> FragmentOperation a
diff --git a/testdata/language-features/basic-values/def05.reject.out b/testdata/language-features/basic-values/def05.reject.out
index 616c6884..59c1b1c2 100644
--- a/testdata/language-features/basic-values/def05.reject.out
+++ b/testdata/language-features/basic-values/def05.reject.out
@@ -1,4 +1,4 @@
 "testdata/language-features/basic-values/def05.reject.lc" (line 4, column 1):
 unexpected end of input
-expecting projection, swizzling, "@", char literal, literal string, float literal, "#", natural, "_", "'", identifier, "[", "(", "{", "let", symbols, backquoted ident, "~", expression, lambda, "::", "->", "=>", "where", "data", "class", "instance", type family, type instance, "type", typed ident, "infix", "infixl", "infixr", operator definition, lhs or pattern
+expecting projection, swizzling, "@", literal, "_", "'", identifier, "[", "(", "{", "let", symbols, backquoted ident, "~", expression, lambda, "::", "->", "=>", "where", "data", "class", "instance", type family, type instance, "type", typed ident, "infix", "infixl", "infixr", operator definition, lhs or pattern
 different number of arguments of fun at testdata/language-features/basic-values/def05.reject.lc 1:1-1:4
\ No newline at end of file
diff --git a/testdata/language-features/basic-values/def06.reject.out b/testdata/language-features/basic-values/def06.reject.out
index 79952277..852fa677 100644
--- a/testdata/language-features/basic-values/def06.reject.out
+++ b/testdata/language-features/basic-values/def06.reject.out
@@ -1,4 +1,4 @@
 "testdata/language-features/basic-values/def06.reject.lc" (line 5, column 1):
 unexpected end of input
-expecting projection, swizzling, "@", char literal, literal string, float literal, "#", natural, "_", "'", identifier, "[", "(", "{", "let", symbols, backquoted ident, "~", expression, lambda, "::", "->", "=>", "where", "data", "class", "instance", type family, type instance, "type", typed ident, "infix", "infixl", "infixr", operator definition, lhs or pattern
+expecting projection, swizzling, "@", literal, "_", "'", identifier, "[", "(", "{", "let", symbols, backquoted ident, "~", expression, lambda, "::", "->", "=>", "where", "data", "class", "instance", type family, type instance, "type", typed ident, "infix", "infixl", "infixr", operator definition, lhs or pattern
 different number of arguments of fun2 at testdata/language-features/basic-values/def06.reject.lc 1:1-1:5
\ No newline at end of file
diff --git a/testdata/language-features/basic-values/redefine03.reject.out b/testdata/language-features/basic-values/redefine03.reject.out
index e0050e16..95b587a1 100644
--- a/testdata/language-features/basic-values/redefine03.reject.out
+++ b/testdata/language-features/basic-values/redefine03.reject.out
@@ -1,4 +1,4 @@
 "testdata/language-features/basic-values/redefine03.reject.lc" (line 4, column 1):
 unexpected end of input
-expecting projection, swizzling, "@", char literal, literal string, float literal, "#", natural, "_", "'", identifier, "[", "(", "{", "let", symbols, backquoted ident, "~", expression, lambda, "::", "->", "=>", "where", "data", "class", "instance", type family, type instance, "type", typed ident, "infix", "infixl", "infixr", operator definition, lhs or pattern
+expecting projection, swizzling, "@", literal, "_", "'", identifier, "[", "(", "{", "let", symbols, backquoted ident, "~", expression, lambda, "::", "->", "=>", "where", "data", "class", "instance", type family, type instance, "type", typed ident, "infix", "infixl", "infixr", operator definition, lhs or pattern
 redefined x at testdata/language-features/basic-values/redefine03.reject.lc 2:9-2:10
\ No newline at end of file
diff --git a/testdata/language-features/guard/guard10.reject.out b/testdata/language-features/guard/guard10.reject.out
index 5b95a423..be68325a 100644
--- a/testdata/language-features/guard/guard10.reject.out
+++ b/testdata/language-features/guard/guard10.reject.out
@@ -1,3 +1,3 @@
 "testdata/language-features/guard/guard10.reject.lc" (line 2, column 1):
 unexpected '|'
-expecting projection, swizzling, "@", char literal, literal string, float literal, "#", natural, "_", "'", identifier, "[", "(", "{", "let", symbols, backquoted ident, "~", expression, lambda, "::", "->", "=>", "|", "data", "class", "instance", type family, type instance, "type", typed ident, "infix", "infixl", "infixr", operator definition, lhs, pattern or end of input
\ No newline at end of file
+expecting projection, swizzling, "@", literal, "_", "'", identifier, "[", "(", "{", "let", symbols, backquoted ident, "~", expression, lambda, "::", "->", "=>", "|", "data", "class", "instance", type family, type instance, "type", typed ident, "infix", "infixl", "infixr", operator definition, lhs, pattern or end of input
\ No newline at end of file
diff --git a/testdata/listcompr01.reject.out b/testdata/listcompr01.reject.out
index 94560015..81949c98 100644
--- a/testdata/listcompr01.reject.out
+++ b/testdata/listcompr01.reject.out
@@ -1,3 +1,3 @@
 "testdata/listcompr01.reject.lc" (line 6, column 42):
 unexpected ','
-expecting projection, swizzling, "@", char literal, literal string, float literal, "#", natural, "_", "'", identifier, "[", "(", "{", "let", symbols, backquoted ident, "~", expression, lambda, "::", "->", "=>", "where", "data", "class", "instance", type family, type instance, "type", typed ident, "infix", "infixl", "infixr", operator definition, lhs, pattern or end of input
\ No newline at end of file
+expecting projection, swizzling, "@", literal, "_", "'", identifier, "[", "(", "{", "let", symbols, backquoted ident, "~", expression, lambda, "::", "->", "=>", "where", "data", "class", "instance", type family, type instance, "type", typed ident, "infix", "infixl", "infixr", operator definition, lhs, pattern or end of input
\ No newline at end of file