Simple code refactoring

Nix/Parser.hs

@@ -10,15 +10,17 @@ import           Data.Foldable
 import           Data.List (foldl1')
 import qualified Data.Map as Map
 import           Data.Text hiding (head, map, foldl1')
+import qualified Data.Text as T
 import           Nix.Types
 import           Nix.Internal
 import           Nix.Parser.Library
-import qualified Prelude
 import           Prelude hiding (elem)
+import qualified Prelude
 
 nixApp :: Parser NExpr
-nixApp = go <$> someTill (whiteSpace *> nixExpr True)
+nixApp = go <$>
-    (try (lookAhead (() <$ oneOf "=,;])}" <|> eof)))
+    someTill (whiteSpace *> nixExpr True)
+             (try (lookAhead (() <$ oneOf "=,;])}" <|> eof)))
   where
     go []     = error "some has failed us"
     go [x]    = x
@@ -36,12 +38,9 @@ nixExpr = buildExpressionParser table . nixTerm
             binary "-"  NMinus  AssocLeft ]
         ]
 
-    binary  name fun =
+    binary  name fun = Infix ((\x y -> Fix (NOper (fun x y))) <$ symbol name)
-        Infix (pure (\x y -> Fix (NOper (fun x y))) <* symbol name)
+    prefix  name fun = Prefix (Fix . NOper . fun <$ symbol name)
-    prefix  name fun =
+    -- postfix name fun = Postfix (Fix . NOper . fun <$ symbol name)
-        Prefix (pure (Fix . NOper . fun) <* symbol name)
-    -- postfix name fun =
-    --     Postfix (pure (Fix . NOper . fun) <* symbol name)
 
 nixTerm :: Bool -> Parser NExpr
 nixTerm allowLambdas = choice
@@ -58,28 +57,23 @@ nixInt :: Parser NExpr
 nixInt = mkInt <$> decimal <?> "integer"
 
 nixBool :: Parser NExpr
-nixBool =  (try (string "true")  *> pure (mkBool True))
+nixBool = try (mkBool . (== "true") <$> string "true") <?> "bool"
-       <|> (try (string "false") *> pure (mkBool False))
-       <?> "bool"
 
 nixNull :: Parser NExpr
-nixNull = try (string "null") *> pure mkNull <?> "null"
+nixNull = try (mkNull <$ string "null") <?> "null"
 
 nixParens :: Parser NExpr
 nixParens = parens nixApp <?> "parens"
 
 nixList :: Parser NExpr
-nixList = brackets (Fix . NList <$> many (trace "in nixList" $ nixTerm False)) <?> "list"
+nixList = brackets (Fix . NList <$> many (nixTerm False)) <?> "list"
 
 nixPath :: Parser NExpr
-nixPath = try $ do
+nixPath = try $ fmap mkPath $ mfilter ('/' `elem`) $ some (oneOf "A-Za-z_0-9.:/")
-    chars <- some (satisfy isPathChar)
-    trace ("Path chars: " ++ show chars) $ return ()
-    guard ('/' `elem` chars)
-    return $ mkPath chars
-  where
-    isPathChar c = isAlpha c || c `Prelude.elem` ".:/"
 
+-- | This is a bit tricky because we don't know whether we're looking at a set
+--   or a lambda until we've looked ahead a bit.  And then it may be neither,
+--   in which case we fall back to expected a plain string or identifier.
 setLambdaStringOrSym :: Bool -> Parser NExpr
 setLambdaStringOrSym allowLambdas = do
     trace "setLambdaStringOrSym" $ return ()
@@ -100,32 +94,25 @@ setLambdaStringOrSym allowLambdas = do
                 else keyName <?> "string"
 
 symName :: Parser Text
-symName = do
+symName = pack <$> ((:) <$> letter <*> many (alphaNum <|> char '.'))
-    chars <- some (satisfy (\c -> isAlpha c || c == '.'))
-    trace ("chars = " ++ show chars) $ return ()
-    guard (isLower (head chars))
-    return $ pack (trace ("chars: " ++ show chars) chars)
 
 stringish :: Parser NExpr
-stringish
+stringish =  (char '"' *> (merge <$> manyTill stringChar (char '"')))
-     =  (char '"' *> (merge <$> manyTill stringChar (char '"')))
+         <|> (char '$' *> braces nixApp)
-    <|> (char '$' *> braces nixApp)
   where
     merge = foldl1' (\x y -> Fix (NOper (NConcat x y)))
 
-    stringChar :: Parser NExpr
+    stringChar =  char '\\' *> (mkStr . singleton <$> anyChar)
-    stringChar = char '\\' *> oneChar
+              <|> (string "${" *> nixApp <* char '}')
-             <|> (string "${" *> nixApp <* char '}')
+              <|> (mkStr . pack <$> many (noneOf "\"\\"))
-             <|> (mkStr . pack <$> many (noneOf "\"\\"))
-      where
-        oneChar = mkStr . singleton <$> anyChar
 
 argExpr :: Parser NExpr
 argExpr =  (Fix . NArgSet . Map.fromList <$> argList)
        <|> ((mkSym <$> symName) <?> "argname")
   where
-    argList = braces ((argName <* whiteSpace) `sepBy` symbolic ',')
+    argList =  braces ((argName <* whiteSpace) `sepBy` symbolic ',')
-                  <?> "arglist"
+           <?> "arglist"
+
     argName = (,) <$> (symName <* whiteSpace)
                   <*> optional (symbolic '?' *> nixExpr False)