default.nix is parsing again, but not all-packages.nix

Nix/Parser.hs

@@ -18,7 +18,7 @@ import           Prelude hiding (elem)
 
 nixApp :: Parser NExpr
 nixApp = go <$> someTill (whiteSpace *> nixExpr True)
-                         (try (lookAhead (char ';')))
+    (try (lookAhead (() <$ oneOf "=,;])}" <|> eof)))
   where
     go []     = error "some has failed us"
     go [x]    = x
@@ -44,34 +44,32 @@ nixExpr = buildExpressionParser table . nixTerm
     --     Postfix (pure (Fix . NOper . fun) <* symbol name)
 
 nixTerm :: Bool -> Parser NExpr
-nixTerm allowLambdas = trace "in nixTerm" (return ()) >> choice
+nixTerm allowLambdas = choice
     [ nixInt
     , nixBool
     , nixNull
     , nixParens
     , nixList
     , nixPath
-    , maybeSetOrLambda allowLambdas
+    , setLambdaStringOrSym allowLambdas
     ]
 
 nixInt :: Parser NExpr
 nixInt = mkInt <$> decimal <?> "integer"
 
 nixBool :: Parser NExpr
-nixBool =  (string "true"  *> pure (mkBool True))
+nixBool =  (try (string "true")  *> pure (mkBool True))
-       <|> (string "false" *> pure (mkBool False))
+       <|> (try (string "false") *> pure (mkBool False))
        <?> "bool"
 
 nixNull :: Parser NExpr
-nixNull = string "null" *> pure mkNull <?> "null"
+nixNull = try (string "null") *> pure mkNull <?> "null"
 
 nixParens :: Parser NExpr
 nixParens = parens nixApp <?> "parens"
 
 nixList :: Parser NExpr
-nixList = do
+nixList = brackets (Fix . NList <$> many (trace "in nixList" $ nixTerm False)) <?> "list"
-    trace "in nixList" $ return ()
-    brackets (Fix . NList <$> many (nixTerm False)) <?> "list"
 
 nixPath :: Parser NExpr
 nixPath = try $ do
@@ -82,9 +80,9 @@ nixPath = try $ do
   where
     isPathChar c = isAlpha c || c `Prelude.elem` ".:/"
 
-maybeSetOrLambda :: Bool -> Parser NExpr
+setLambdaStringOrSym :: Bool -> Parser NExpr
-maybeSetOrLambda allowLambdas = do
+setLambdaStringOrSym allowLambdas = do
-    trace "maybeSetOrLambda" $ return ()
+    trace "setLambdaStringOrSym" $ return ()
     x <- try (lookAhead symName)
         <|> try (lookAhead (singleton <$> char '{'))
         <|> return ""
@@ -92,8 +90,7 @@ maybeSetOrLambda allowLambdas = do
         then setOrArgs
         else do
             trace "might still have a lambda" $ return ()
-            y <- try (lookAhead (symName *> whiteSpace *> symbolic ':'
+            y <- try (lookAhead (True <$ (symName *> whiteSpace *> symbolic ':')))
-                                     *> return True))
                 <|> return False
             trace ("results are = " ++ show y) $ return ()
             if y
@@ -124,25 +121,16 @@ stringish
         oneChar = mkStr . singleton <$> anyChar
 
 argExpr :: Parser NExpr
-argExpr = do
+argExpr =  (Fix . NArgSet . Map.fromList <$> argList)
-    trace "in argExpr" $ return ()
+       <|> ((mkSym <$> symName) <?> "argname")
-    (Fix . NArgSet . Map.fromList <$> argList)
-        <|> ((mkSym <$> symName) <?> "argname")
   where
-    argList = do
+    argList = braces ((argName <* whiteSpace) `sepBy` symbolic ',')
-        trace "in argList" $ return ()
+                  <?> "arglist"
-        braces ((argName <* trace "FOO" whiteSpace) `sepBy` trace "BAR" (symbolic ','))
+    argName = (,) <$> (symName <* whiteSpace)
-            <?> "arglist"
+                  <*> optional (symbolic '?' *> nixExpr False)
-
-    argName = do
-        trace "in argName" $ return ()
-        (,) <$> (symName <* whiteSpace)
-            <*> optional (symbolic '?' *> nixExpr False)
 
 nvPair :: Parser (NExpr, NExpr)
-nvPair = do
+nvPair = (,) <$> keyName <*> (symbolic '=' *> nixApp)
-    trace "in nvPair" $ return ()
-    (,) <$> keyName <*> (symbolic '=' *> nixApp)
 
 keyName :: Parser NExpr
 keyName = (stringish <|> (mkSym <$> symName)) <* whiteSpace

Nix/Parser/Library.hs

@@ -69,7 +69,7 @@ import Text.Trifecta as X
 #endif
 
 someTill :: Parser a -> Parser end -> Parser [a]
-someTill p end = go *> scan
+someTill p end = go
   where
-    go = do { x <- p; xs <- scan; return (x:xs) }
+    go   = (:) <$> p <*> scan
     scan = (end *> return []) <|>  go