Simple code refactoring
This commit is contained in:
parent
831e96fc85
commit
d2df092907
|
@ -10,15 +10,17 @@ import Data.Foldable
|
||||||
import Data.List (foldl1')
|
import Data.List (foldl1')
|
||||||
import qualified Data.Map as Map
|
import qualified Data.Map as Map
|
||||||
import Data.Text hiding (head, map, foldl1')
|
import Data.Text hiding (head, map, foldl1')
|
||||||
|
import qualified Data.Text as T
|
||||||
import Nix.Types
|
import Nix.Types
|
||||||
import Nix.Internal
|
import Nix.Internal
|
||||||
import Nix.Parser.Library
|
import Nix.Parser.Library
|
||||||
import qualified Prelude
|
|
||||||
import Prelude hiding (elem)
|
import Prelude hiding (elem)
|
||||||
|
import qualified Prelude
|
||||||
|
|
||||||
nixApp :: Parser NExpr
|
nixApp :: Parser NExpr
|
||||||
nixApp = go <$> someTill (whiteSpace *> nixExpr True)
|
nixApp = go <$>
|
||||||
(try (lookAhead (() <$ oneOf "=,;])}" <|> eof)))
|
someTill (whiteSpace *> nixExpr True)
|
||||||
|
(try (lookAhead (() <$ oneOf "=,;])}" <|> eof)))
|
||||||
where
|
where
|
||||||
go [] = error "some has failed us"
|
go [] = error "some has failed us"
|
||||||
go [x] = x
|
go [x] = x
|
||||||
|
@ -36,12 +38,9 @@ nixExpr = buildExpressionParser table . nixTerm
|
||||||
binary "-" NMinus AssocLeft ]
|
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 :: Bool -> Parser NExpr
|
||||||
nixTerm allowLambdas = choice
|
nixTerm allowLambdas = choice
|
||||||
|
@ -58,28 +57,23 @@ nixInt :: Parser NExpr
|
||||||
nixInt = mkInt <$> decimal <?> "integer"
|
nixInt = mkInt <$> decimal <?> "integer"
|
||||||
|
|
||||||
nixBool :: Parser NExpr
|
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 :: Parser NExpr
|
||||||
nixNull = try (string "null") *> pure mkNull <?> "null"
|
nixNull = try (mkNull <$ string "null") <?> "null"
|
||||||
|
|
||||||
nixParens :: Parser NExpr
|
nixParens :: Parser NExpr
|
||||||
nixParens = parens nixApp <?> "parens"
|
nixParens = parens nixApp <?> "parens"
|
||||||
|
|
||||||
nixList :: Parser NExpr
|
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 :: 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 :: Bool -> Parser NExpr
|
||||||
setLambdaStringOrSym allowLambdas = do
|
setLambdaStringOrSym allowLambdas = do
|
||||||
trace "setLambdaStringOrSym" $ return ()
|
trace "setLambdaStringOrSym" $ return ()
|
||||||
|
@ -100,32 +94,25 @@ setLambdaStringOrSym allowLambdas = do
|
||||||
else keyName <?> "string"
|
else keyName <?> "string"
|
||||||
|
|
||||||
symName :: Parser Text
|
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 :: Parser NExpr
|
||||||
stringish
|
stringish = (char '"' *> (merge <$> manyTill stringChar (char '"')))
|
||||||
= (char '"' *> (merge <$> manyTill stringChar (char '"')))
|
<|> (char '$' *> braces nixApp)
|
||||||
<|> (char '$' *> braces nixApp)
|
|
||||||
where
|
where
|
||||||
merge = foldl1' (\x y -> Fix (NOper (NConcat x y)))
|
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 :: Parser NExpr
|
||||||
argExpr = (Fix . NArgSet . Map.fromList <$> argList)
|
argExpr = (Fix . NArgSet . Map.fromList <$> argList)
|
||||||
<|> ((mkSym <$> symName) <?> "argname")
|
<|> ((mkSym <$> symName) <?> "argname")
|
||||||
where
|
where
|
||||||
argList = braces ((argName <* whiteSpace) `sepBy` symbolic ',')
|
argList = braces ((argName <* whiteSpace) `sepBy` symbolic ',')
|
||||||
<?> "arglist"
|
<?> "arglist"
|
||||||
|
|
||||||
argName = (,) <$> (symName <* whiteSpace)
|
argName = (,) <$> (symName <* whiteSpace)
|
||||||
<*> optional (symbolic '?' *> nixExpr False)
|
<*> optional (symbolic '?' *> nixExpr False)
|
||||||
|
|
||||||
|
|
Loading…
Reference in a new issue