{- © 2019 Serokell <hi@serokell.io>
 - © 2019 Lars Jellema <lars.jellema@gmail.com>
 -
 - SPDX-License-Identifier: MPL-2.0
 -}

{-# LANGUAGE LambdaCase, OverloadedStrings #-}

module Nixfmt.Parser where

import Prelude hiding (String)

import Control.Monad (guard, liftM2)
import Control.Monad.Combinators (sepBy)
import qualified Control.Monad.Combinators.Expr as MPExpr
  (Operator(..), makeExprParser)
import Data.Char (isAlpha)
import Data.Foldable (toList)
import Data.Maybe (fromMaybe, mapMaybe, maybeToList)
import Data.Text as Text (Text, cons, empty, singleton, split, stripPrefix)
import Text.Megaparsec
  (anySingle, chunk, eof, label, lookAhead, many, notFollowedBy, oneOf,
  optional, satisfy, some, try, (<|>))
import Text.Megaparsec.Char (char)
import qualified Text.Megaparsec.Char.Lexer as L (decimal, float)

import Nixfmt.Lexer (lexeme)
import Nixfmt.Types
  (Ann, Binder(..), Expression(..), File(..), Fixity(..), Leaf, Operator(..),
  ParamAttr(..), Parameter(..), Parser, Path, Selector(..), SimpleSelector(..),
  String, StringPart(..), Term(..), Token(..), operators, tokenText)
import Nixfmt.Util
  (commonIndentation, identChar, isSpaces, manyP, manyText, pathChar,
  schemeChar, someP, someText, uriChar)

-- HELPER FUNCTIONS

ann :: (a -> b) -> Parser a -> Parser (Ann b)
ann :: (a -> b) -> Parser a -> Parser (Ann b)
ann a -> b
f Parser a
p = Parser (Ann b) -> Parser (Ann b)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser (Ann b) -> Parser (Ann b))
-> Parser (Ann b) -> Parser (Ann b)
forall a b. (a -> b) -> a -> b
$ Parser b -> Parser (Ann b)
forall a. Parser a -> Parser (Ann a)
lexeme (Parser b -> Parser (Ann b)) -> Parser b -> Parser (Ann b)
forall a b. (a -> b) -> a -> b
$ a -> b
f (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a
p

-- | parses a token without parsing trivia after it
rawSymbol :: Token -> Parser Token
rawSymbol :: Token -> Parser Token
rawSymbol Token
t = Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (Token -> Text
tokenText Token
t) ParsecT Void Text Identity Text -> Parser Token -> Parser Token
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Token -> Parser Token
forall (m :: * -> *) a. Monad m => a -> m a
return Token
t

symbol :: Token -> Parser (Ann Token)
symbol :: Token -> Parser (Ann Token)
symbol = Parser Token -> Parser (Ann Token)
forall a. Parser a -> Parser (Ann a)
lexeme (Parser Token -> Parser (Ann Token))
-> (Token -> Parser Token) -> Token -> Parser (Ann Token)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Token -> Parser Token
rawSymbol

reservedNames :: [Text]
reservedNames :: [Text]
reservedNames =
    [ Text
"let", Text
"in"
    , Text
"if", Text
"then", Text
"else"
    , Text
"assert"
    , Text
"with"
    , Text
"rec"
    , Text
"inherit"
    ]

reserved :: Token -> Parser (Ann Token)
reserved :: Token -> Parser (Ann Token)
reserved Token
t = Parser (Ann Token) -> Parser (Ann Token)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser (Ann Token) -> Parser (Ann Token))
-> Parser (Ann Token) -> Parser (Ann Token)
forall a b. (a -> b) -> a -> b
$ Parser Token -> Parser (Ann Token)
forall a. Parser a -> Parser (Ann a)
lexeme (Parser Token -> Parser (Ann Token))
-> Parser Token -> Parser (Ann Token)
forall a b. (a -> b) -> a -> b
$ Token -> Parser Token
rawSymbol Token
t
    Parser Token -> ParsecT Void Text Identity Char -> Parser Token
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity Char -> ParsecT Void Text Identity Char
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead ((Token Text -> Bool) -> ParsecT Void Text Identity (Token Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy (\Token Text
x -> Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Char -> Bool
identChar Char
Token Text
x Bool -> Bool -> Bool
|| Char -> Bool
pathChar Char
Token Text
x))

-- VALUES

integer :: Parser (Ann Token)
integer :: Parser (Ann Token)
integer = (Int -> Token) -> Parser Int -> Parser (Ann Token)
forall a b. (a -> b) -> Parser a -> Parser (Ann b)
ann Int -> Token
Integer Parser Int
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal

float :: Parser (Ann Token)
float :: Parser (Ann Token)
float = (Double -> Token) -> Parser Double -> Parser (Ann Token)
forall a b. (a -> b) -> Parser a -> Parser (Ann b)
ann Double -> Token
Float Parser Double
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, RealFloat a) =>
m a
L.float

identifier :: Parser (Ann Token)
identifier :: Parser (Ann Token)
identifier = (Text -> Token)
-> ParsecT Void Text Identity Text -> Parser (Ann Token)
forall a b. (a -> b) -> Parser a -> Parser (Ann b)
ann Text -> Token
Identifier (ParsecT Void Text Identity Text -> Parser (Ann Token))
-> ParsecT Void Text Identity Text -> Parser (Ann Token)
forall a b. (a -> b) -> a -> b
$ do
    Text
ident <- Char -> Text -> Text
Text.cons (Char -> Text -> Text)
-> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity (Text -> Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Token Text -> Bool) -> ParsecT Void Text Identity (Token Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy (\Token Text
x -> Char -> Bool
isAlpha Char
Token Text
x Bool -> Bool -> Bool
|| Char
Token Text
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_')
                       ParsecT Void Text Identity (Text -> Text)
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Token Text -> Bool) -> ParsecT Void Text Identity (Tokens Text)
forall s e (m :: * -> *).
(Stream s, Ord e) =>
(Token s -> Bool) -> ParsecT e s m (Tokens s)
manyP Char -> Bool
Token Text -> Bool
identChar
    Bool -> ParsecT Void Text Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> ParsecT Void Text Identity ())
-> Bool -> ParsecT Void Text Identity ()
forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Text
ident Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
reservedNames
    Text -> ParsecT Void Text Identity Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
ident

slash :: Parser Text
slash :: ParsecT Void Text Identity Text
slash = Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"/" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity Char -> ParsecT Void Text Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy (Token Text -> ParsecT Void Text Identity (Token Text)
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
Token Text
'/')

envPath :: Parser (Ann Token)
envPath :: Parser (Ann Token)
envPath = (Text -> Token)
-> ParsecT Void Text Identity Text -> Parser (Ann Token)
forall a b. (a -> b) -> Parser a -> Parser (Ann b)
ann Text -> Token
EnvPath (ParsecT Void Text Identity Text -> Parser (Ann Token))
-> ParsecT Void Text Identity Text -> Parser (Ann Token)
forall a b. (a -> b) -> a -> b
$ Token Text -> ParsecT Void Text Identity (Token Text)
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
Token Text
'<' ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
    (Token Text -> Bool) -> ParsecT Void Text Identity (Tokens Text)
forall s e (m :: * -> *).
(Stream s, Ord e) =>
(Token s -> Bool) -> ParsecT e s m (Tokens s)
someP Char -> Bool
Token Text -> Bool
pathChar ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall a. Semigroup a => a -> a -> a
<> ParsecT Void Text Identity Text -> ParsecT Void Text Identity Text
forall s e (m :: * -> *).
(Stream s, Ord e) =>
ParsecT e s m Text -> ParsecT e s m Text
manyText (ParsecT Void Text Identity Text
slash ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall a. Semigroup a => a -> a -> a
<> (Token Text -> Bool) -> ParsecT Void Text Identity (Tokens Text)
forall s e (m :: * -> *).
(Stream s, Ord e) =>
(Token s -> Bool) -> ParsecT e s m (Tokens s)
someP Char -> Bool
Token Text -> Bool
pathChar)
    ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token Text -> ParsecT Void Text Identity (Token Text)
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
Token Text
'>'

pathText :: Parser StringPart
pathText :: Parser StringPart
pathText = Text -> StringPart
TextPart (Text -> StringPart)
-> ParsecT Void Text Identity Text -> Parser StringPart
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Token Text -> Bool) -> ParsecT Void Text Identity (Tokens Text)
forall s e (m :: * -> *).
(Stream s, Ord e) =>
(Token s -> Bool) -> ParsecT e s m (Tokens s)
someP Char -> Bool
Token Text -> Bool
pathChar

pathTraversal :: Parser [StringPart]
pathTraversal :: Parser [StringPart]
pathTraversal = (StringPart -> [StringPart] -> [StringPart])
-> Parser StringPart -> Parser [StringPart] -> Parser [StringPart]
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (:) (Text -> StringPart
TextPart (Text -> StringPart)
-> ParsecT Void Text Identity Text -> Parser StringPart
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity Text
slash) (Parser StringPart -> Parser [StringPart]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some (Parser StringPart
pathText Parser StringPart -> Parser StringPart -> Parser StringPart
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser StringPart
interpolation))

path :: Parser Path
path :: Parser Path
path = Parser Path -> Parser Path
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser Path -> Parser Path) -> Parser Path -> Parser Path
forall a b. (a -> b) -> a -> b
$ Parser [StringPart] -> Parser Path
forall a. Parser a -> Parser (Ann a)
lexeme (Parser [StringPart] -> Parser Path)
-> Parser [StringPart] -> Parser Path
forall a b. (a -> b) -> a -> b
$ ([StringPart] -> [StringPart])
-> Parser [StringPart] -> Parser [StringPart]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [StringPart] -> [StringPart]
normalizeLine (Parser [StringPart] -> Parser [StringPart])
-> Parser [StringPart] -> Parser [StringPart]
forall a b. (a -> b) -> a -> b
$
    (Maybe StringPart -> [StringPart]
forall a. Maybe a -> [a]
maybeToList (Maybe StringPart -> [StringPart])
-> ParsecT Void Text Identity (Maybe StringPart)
-> Parser [StringPart]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser StringPart -> ParsecT Void Text Identity (Maybe StringPart)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser StringPart
pathText) Parser [StringPart] -> Parser [StringPart] -> Parser [StringPart]
forall a. Semigroup a => a -> a -> a
<> ([[StringPart]] -> [StringPart]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[StringPart]] -> [StringPart])
-> ParsecT Void Text Identity [[StringPart]] -> Parser [StringPart]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [StringPart] -> ParsecT Void Text Identity [[StringPart]]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some Parser [StringPart]
pathTraversal)

uri :: Parser [[StringPart]]
uri :: ParsecT Void Text Identity [[StringPart]]
uri = (Text -> [[StringPart]])
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity [[StringPart]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([StringPart] -> [[StringPart]]
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([StringPart] -> [[StringPart]])
-> (Text -> [StringPart]) -> Text -> [[StringPart]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StringPart -> [StringPart]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (StringPart -> [StringPart])
-> (Text -> StringPart) -> Text -> [StringPart]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> StringPart
TextPart) (ParsecT Void Text Identity Text
 -> ParsecT Void Text Identity [[StringPart]])
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity [[StringPart]]
forall a b. (a -> b) -> a -> b
$ ParsecT Void Text Identity Text -> ParsecT Void Text Identity Text
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (ParsecT Void Text Identity Text
 -> ParsecT Void Text Identity Text)
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall a b. (a -> b) -> a -> b
$
    (Token Text -> Bool) -> ParsecT Void Text Identity (Tokens Text)
forall s e (m :: * -> *).
(Stream s, Ord e) =>
(Token s -> Bool) -> ParsecT e s m (Tokens s)
someP Char -> Bool
Token Text -> Bool
schemeChar ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall a. Semigroup a => a -> a -> a
<> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
":" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall a. Semigroup a => a -> a -> a
<> (Token Text -> Bool) -> ParsecT Void Text Identity (Tokens Text)
forall s e (m :: * -> *).
(Stream s, Ord e) =>
(Token s -> Bool) -> ParsecT e s m (Tokens s)
someP Char -> Bool
Token Text -> Bool
uriChar

-- STRINGS

interpolation :: Parser StringPart
interpolation :: Parser StringPart
interpolation = Ann Token -> Expression -> Token -> StringPart
Interpolation (Ann Token -> Expression -> Token -> StringPart)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Expression -> Token -> StringPart)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    Token -> Parser (Ann Token)
symbol Token
TInterOpen ParsecT Void Text Identity (Expression -> Token -> StringPart)
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity (Token -> StringPart)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression ParsecT Void Text Identity (Token -> StringPart)
-> Parser Token -> Parser StringPart
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Token -> Parser Token
rawSymbol Token
TInterClose

simpleStringPart :: Parser StringPart
simpleStringPart :: Parser StringPart
simpleStringPart = Text -> StringPart
TextPart (Text -> StringPart)
-> ParsecT Void Text Identity Text -> Parser StringPart
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity Text -> ParsecT Void Text Identity Text
forall s e (m :: * -> *).
(Stream s, Ord e) =>
ParsecT e s m Text -> ParsecT e s m Text
someText (
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"\\n" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
"\n" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"\\r" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
"\r" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"\\t" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
"\t" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"\\" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Char -> Text
Text.singleton (Char -> Text)
-> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity Char
forall e s (m :: * -> *). MonadParsec e s m => m (Token s)
anySingle) ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"$$" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    ParsecT Void Text Identity Text -> ParsecT Void Text Identity Text
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"$" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity Char -> ParsecT Void Text Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy (Token Text -> ParsecT Void Text Identity (Token Text)
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
Token Text
'{')) ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    (Token Text -> Bool) -> ParsecT Void Text Identity (Tokens Text)
forall s e (m :: * -> *).
(Stream s, Ord e) =>
(Token s -> Bool) -> ParsecT e s m (Tokens s)
someP (\Token Text
t -> Char
Token Text
t Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'"' Bool -> Bool -> Bool
&& Char
Token Text
t Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\\' Bool -> Bool -> Bool
&& Char
Token Text
t Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'$'))

indentedStringPart :: Parser StringPart
indentedStringPart :: Parser StringPart
indentedStringPart = Text -> StringPart
TextPart (Text -> StringPart)
-> ParsecT Void Text Identity Text -> Parser StringPart
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity Text -> ParsecT Void Text Identity Text
forall s e (m :: * -> *).
(Stream s, Ord e) =>
ParsecT e s m Text -> ParsecT e s m Text
someText (
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"''\\n" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
"\n" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"''\\r" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
"\r" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"''\\t" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
"\t" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"''\\" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Char -> Text
Text.singleton (Char -> Text)
-> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity Char
forall e s (m :: * -> *). MonadParsec e s m => m (Token s)
anySingle) ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"''$" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
"$" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"'''" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
"''" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"$$" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    ParsecT Void Text Identity Text -> ParsecT Void Text Identity Text
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"$" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity Char -> ParsecT Void Text Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy (Token Text -> ParsecT Void Text Identity (Token Text)
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
Token Text
'{')) ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    ParsecT Void Text Identity Text -> ParsecT Void Text Identity Text
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"'" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity Char -> ParsecT Void Text Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy (Token Text -> ParsecT Void Text Identity (Token Text)
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
Token Text
'\'')) ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    (Token Text -> Bool) -> ParsecT Void Text Identity (Tokens Text)
forall s e (m :: * -> *).
(Stream s, Ord e) =>
(Token s -> Bool) -> ParsecT e s m (Tokens s)
someP (\Token Text
t -> Char
Token Text
t Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\'' Bool -> Bool -> Bool
&& Char
Token Text
t Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'$' Bool -> Bool -> Bool
&& Char
Token Text
t Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\n'))

indentedLine :: Parser [StringPart]
indentedLine :: Parser [StringPart]
indentedLine = Parser StringPart -> Parser [StringPart]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (Parser StringPart
indentedStringPart Parser StringPart -> Parser StringPart -> Parser StringPart
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser StringPart
interpolation)

isEmptyLine :: [StringPart] -> Bool
isEmptyLine :: [StringPart] -> Bool
isEmptyLine []           = Bool
True
isEmptyLine [TextPart Text
t] = Text -> Bool
isSpaces Text
t
isEmptyLine [StringPart]
_            = Bool
False

-- | Drop the first line of a string if it is empty.
fixFirstLine :: [[StringPart]] -> [[StringPart]]
fixFirstLine :: [[StringPart]] -> [[StringPart]]
fixFirstLine []       = []
fixFirstLine ([StringPart]
x : [[StringPart]]
xs) = if [StringPart] -> Bool
isEmptyLine [StringPart]
x' then [[StringPart]]
xs else [StringPart]
x' [StringPart] -> [[StringPart]] -> [[StringPart]]
forall a. a -> [a] -> [a]
: [[StringPart]]
xs
    where x' :: [StringPart]
x' = [StringPart] -> [StringPart]
normalizeLine [StringPart]
x

-- | Empty the last line if it contains only spaces.
fixLastLine :: [[StringPart]] -> [[StringPart]]
fixLastLine :: [[StringPart]] -> [[StringPart]]
fixLastLine []       = []
fixLastLine [[StringPart]
line]   = if [StringPart] -> Bool
isEmptyLine [StringPart]
line' then [[]] else [[StringPart]
line']
    where line' :: [StringPart]
line' = [StringPart] -> [StringPart]
normalizeLine [StringPart]
line
fixLastLine ([StringPart]
x : [[StringPart]]
xs) = [StringPart]
x [StringPart] -> [[StringPart]] -> [[StringPart]]
forall a. a -> [a] -> [a]
: [[StringPart]] -> [[StringPart]]
fixLastLine [[StringPart]]
xs

lineHead :: [StringPart] -> Maybe Text
lineHead :: [StringPart] -> Maybe Text
lineHead []                        = Maybe Text
forall a. Maybe a
Nothing
lineHead [StringPart]
line | [StringPart] -> Bool
isEmptyLine [StringPart]
line   = Maybe Text
forall a. Maybe a
Nothing
lineHead (TextPart Text
t : [StringPart]
_)          = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
t
lineHead (Interpolation Ann Token
_ Expression
_ Token
_ : [StringPart]
_) = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
""

stripParts :: Text -> [StringPart] -> [StringPart]
stripParts :: Text -> [StringPart] -> [StringPart]
stripParts Text
indentation (TextPart Text
t : [StringPart]
xs) =
    Text -> StringPart
TextPart (Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
Text.empty (Maybe Text -> Text) -> Maybe Text -> Text
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Maybe Text
Text.stripPrefix Text
indentation Text
t) StringPart -> [StringPart] -> [StringPart]
forall a. a -> [a] -> [a]
: [StringPart]
xs
stripParts Text
_ [StringPart]
xs = [StringPart]
xs

-- | Split a list of StringParts on the newlines in their TextParts.
-- Invariant: result is never empty.
splitLines :: [StringPart] -> [[StringPart]]
splitLines :: [StringPart] -> [[StringPart]]
splitLines [] = [[]]
splitLines (TextPart Text
t : [StringPart]
xs) =
    let ts :: [[StringPart]]
ts = (Text -> [StringPart]) -> [Text] -> [[StringPart]]
forall a b. (a -> b) -> [a] -> [b]
map (StringPart -> [StringPart]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (StringPart -> [StringPart])
-> (Text -> StringPart) -> Text -> [StringPart]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> StringPart
TextPart) ([Text] -> [[StringPart]]) -> [Text] -> [[StringPart]]
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> Text -> [Text]
Text.split (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
'\n') Text
t
    in case [StringPart] -> [[StringPart]]
splitLines [StringPart]
xs of
        ([StringPart]
xs' : [[StringPart]]
xss) -> [[StringPart]] -> [[StringPart]]
forall a. [a] -> [a]
init [[StringPart]]
ts [[StringPart]] -> [[StringPart]] -> [[StringPart]]
forall a. [a] -> [a] -> [a]
++ (([[StringPart]] -> [StringPart]
forall a. [a] -> a
last [[StringPart]]
ts [StringPart] -> [StringPart] -> [StringPart]
forall a. [a] -> [a] -> [a]
++ [StringPart]
xs') [StringPart] -> [[StringPart]] -> [[StringPart]]
forall a. a -> [a] -> [a]
: [[StringPart]]
xss)
        [[StringPart]]
_           -> [Char] -> [[StringPart]]
forall a. HasCallStack => [Char] -> a
error [Char]
"unreachable"

splitLines (StringPart
x : [StringPart]
xs) =
    case [StringPart] -> [[StringPart]]
splitLines [StringPart]
xs of
        ([StringPart]
xs' : [[StringPart]]
xss) -> ((StringPart
x StringPart -> [StringPart] -> [StringPart]
forall a. a -> [a] -> [a]
: [StringPart]
xs') [StringPart] -> [[StringPart]] -> [[StringPart]]
forall a. a -> [a] -> [a]
: [[StringPart]]
xss)
        [[StringPart]]
_           -> [Char] -> [[StringPart]]
forall a. HasCallStack => [Char] -> a
error [Char]
"unreachable"

stripIndentation :: [[StringPart]] -> [[StringPart]]
stripIndentation :: [[StringPart]] -> [[StringPart]]
stripIndentation [[StringPart]]
parts = case [Text] -> Maybe Text
commonIndentation ([Text] -> Maybe Text) -> [Text] -> Maybe Text
forall a b. (a -> b) -> a -> b
$ ([StringPart] -> Maybe Text) -> [[StringPart]] -> [Text]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe [StringPart] -> Maybe Text
lineHead [[StringPart]]
parts of
    Maybe Text
Nothing -> ([StringPart] -> [StringPart]) -> [[StringPart]] -> [[StringPart]]
forall a b. (a -> b) -> [a] -> [b]
map ([StringPart] -> [StringPart] -> [StringPart]
forall a b. a -> b -> a
const []) [[StringPart]]
parts
    Just Text
indentation -> ([StringPart] -> [StringPart]) -> [[StringPart]] -> [[StringPart]]
forall a b. (a -> b) -> [a] -> [b]
map (Text -> [StringPart] -> [StringPart]
stripParts Text
indentation) [[StringPart]]
parts

normalizeLine :: [StringPart] -> [StringPart]
normalizeLine :: [StringPart] -> [StringPart]
normalizeLine [] = []
normalizeLine (TextPart Text
"" : [StringPart]
xs) = [StringPart] -> [StringPart]
normalizeLine [StringPart]
xs
normalizeLine (TextPart Text
x : TextPart Text
y : [StringPart]
xs) = [StringPart] -> [StringPart]
normalizeLine (Text -> StringPart
TextPart (Text
x Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
y) StringPart -> [StringPart] -> [StringPart]
forall a. a -> [a] -> [a]
: [StringPart]
xs)
normalizeLine (StringPart
x : [StringPart]
xs) = StringPart
x StringPart -> [StringPart] -> [StringPart]
forall a. a -> [a] -> [a]
: [StringPart] -> [StringPart]
normalizeLine [StringPart]
xs

fixSimpleString :: [StringPart] -> [[StringPart]]
fixSimpleString :: [StringPart] -> [[StringPart]]
fixSimpleString = ([StringPart] -> [StringPart]) -> [[StringPart]] -> [[StringPart]]
forall a b. (a -> b) -> [a] -> [b]
map [StringPart] -> [StringPart]
normalizeLine ([[StringPart]] -> [[StringPart]])
-> ([StringPart] -> [[StringPart]])
-> [StringPart]
-> [[StringPart]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [StringPart] -> [[StringPart]]
splitLines

simpleString :: Parser [[StringPart]]
simpleString :: ParsecT Void Text Identity [[StringPart]]
simpleString = Token -> Parser Token
rawSymbol Token
TDoubleQuote Parser Token
-> ParsecT Void Text Identity [[StringPart]]
-> ParsecT Void Text Identity [[StringPart]]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
    ([StringPart] -> [[StringPart]])
-> Parser [StringPart] -> ParsecT Void Text Identity [[StringPart]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [StringPart] -> [[StringPart]]
fixSimpleString (Parser StringPart -> Parser [StringPart]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (Parser StringPart
simpleStringPart Parser StringPart -> Parser StringPart -> Parser StringPart
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser StringPart
interpolation)) ParsecT Void Text Identity [[StringPart]]
-> Parser Token -> ParsecT Void Text Identity [[StringPart]]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*
    Token -> Parser Token
rawSymbol Token
TDoubleQuote

fixIndentedString :: [[StringPart]] -> [[StringPart]]
fixIndentedString :: [[StringPart]] -> [[StringPart]]
fixIndentedString
    = ([StringPart] -> [StringPart]) -> [[StringPart]] -> [[StringPart]]
forall a b. (a -> b) -> [a] -> [b]
map [StringPart] -> [StringPart]
normalizeLine
    ([[StringPart]] -> [[StringPart]])
-> ([[StringPart]] -> [[StringPart]])
-> [[StringPart]]
-> [[StringPart]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([StringPart] -> [[StringPart]])
-> [[StringPart]] -> [[StringPart]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap [StringPart] -> [[StringPart]]
splitLines
    ([[StringPart]] -> [[StringPart]])
-> ([[StringPart]] -> [[StringPart]])
-> [[StringPart]]
-> [[StringPart]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[StringPart]] -> [[StringPart]]
stripIndentation
    ([[StringPart]] -> [[StringPart]])
-> ([[StringPart]] -> [[StringPart]])
-> [[StringPart]]
-> [[StringPart]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[StringPart]] -> [[StringPart]]
fixLastLine
    ([[StringPart]] -> [[StringPart]])
-> ([[StringPart]] -> [[StringPart]])
-> [[StringPart]]
-> [[StringPart]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[StringPart]] -> [[StringPart]]
fixFirstLine

indentedString :: Parser [[StringPart]]
indentedString :: ParsecT Void Text Identity [[StringPart]]
indentedString = Token -> Parser Token
rawSymbol Token
TDoubleSingleQuote Parser Token
-> ParsecT Void Text Identity [[StringPart]]
-> ParsecT Void Text Identity [[StringPart]]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
    ([[StringPart]] -> [[StringPart]])
-> ParsecT Void Text Identity [[StringPart]]
-> ParsecT Void Text Identity [[StringPart]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [[StringPart]] -> [[StringPart]]
fixIndentedString (Parser [StringPart]
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity [[StringPart]]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy Parser [StringPart]
indentedLine (Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"\n")) ParsecT Void Text Identity [[StringPart]]
-> Parser Token -> ParsecT Void Text Identity [[StringPart]]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*
    Token -> Parser Token
rawSymbol Token
TDoubleSingleQuote

string :: Parser String
string :: Parser String
string = ParsecT Void Text Identity [[StringPart]] -> Parser String
forall a. Parser a -> Parser (Ann a)
lexeme (ParsecT Void Text Identity [[StringPart]] -> Parser String)
-> ParsecT Void Text Identity [[StringPart]] -> Parser String
forall a b. (a -> b) -> a -> b
$ ParsecT Void Text Identity [[StringPart]]
simpleString ParsecT Void Text Identity [[StringPart]]
-> ParsecT Void Text Identity [[StringPart]]
-> ParsecT Void Text Identity [[StringPart]]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity [[StringPart]]
indentedString ParsecT Void Text Identity [[StringPart]]
-> ParsecT Void Text Identity [[StringPart]]
-> ParsecT Void Text Identity [[StringPart]]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity [[StringPart]]
uri

-- TERMS

parens :: Parser Term
parens :: Parser Term
parens = Ann Token -> Expression -> Ann Token -> Term
Parenthesized (Ann Token -> Expression -> Ann Token -> Term)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Expression -> Ann Token -> Term)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    Token -> Parser (Ann Token)
symbol Token
TParenOpen ParsecT Void Text Identity (Expression -> Ann Token -> Term)
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity (Ann Token -> Term)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression ParsecT Void Text Identity (Ann Token -> Term)
-> Parser (Ann Token) -> Parser Term
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Token -> Parser (Ann Token)
symbol Token
TParenClose

selector :: Maybe (Parser Leaf) -> Parser Selector
selector :: Maybe (Parser (Ann Token)) -> Parser Selector
selector Maybe (Parser (Ann Token))
parseDot = Maybe (Ann Token)
-> SimpleSelector -> Maybe (Ann Token, Term) -> Selector
Selector (Maybe (Ann Token)
 -> SimpleSelector -> Maybe (Ann Token, Term) -> Selector)
-> ParsecT Void Text Identity (Maybe (Ann Token))
-> ParsecT
     Void
     Text
     Identity
     (SimpleSelector -> Maybe (Ann Token, Term) -> Selector)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    Maybe (Parser (Ann Token))
-> ParsecT Void Text Identity (Maybe (Ann Token))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence Maybe (Parser (Ann Token))
parseDot ParsecT
  Void
  Text
  Identity
  (SimpleSelector -> Maybe (Ann Token, Term) -> Selector)
-> ParsecT Void Text Identity ()
-> ParsecT
     Void
     Text
     Identity
     (SimpleSelector -> Maybe (Ann Token, Term) -> Selector)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser Path -> ParsecT Void Text Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy Parser Path
path ParsecT
  Void
  Text
  Identity
  (SimpleSelector -> Maybe (Ann Token, Term) -> Selector)
-> ParsecT Void Text Identity SimpleSelector
-> ParsecT Void Text Identity (Maybe (Ann Token, Term) -> Selector)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    ((Ann Token -> SimpleSelector
IDSelector (Ann Token -> SimpleSelector)
-> Parser (Ann Token) -> ParsecT Void Text Identity SimpleSelector
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Ann Token)
identifier) ParsecT Void Text Identity SimpleSelector
-> ParsecT Void Text Identity SimpleSelector
-> ParsecT Void Text Identity SimpleSelector
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
     (Ann StringPart -> SimpleSelector
InterpolSelector (Ann StringPart -> SimpleSelector)
-> ParsecT Void Text Identity (Ann StringPart)
-> ParsecT Void Text Identity SimpleSelector
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser StringPart -> ParsecT Void Text Identity (Ann StringPart)
forall a. Parser a -> Parser (Ann a)
lexeme Parser StringPart
interpolation) ParsecT Void Text Identity SimpleSelector
-> ParsecT Void Text Identity SimpleSelector
-> ParsecT Void Text Identity SimpleSelector
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
     (String -> SimpleSelector
StringSelector (String -> SimpleSelector)
-> Parser String -> ParsecT Void Text Identity SimpleSelector
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity [[StringPart]] -> Parser String
forall a. Parser a -> Parser (Ann a)
lexeme ParsecT Void Text Identity [[StringPart]]
simpleString)) ParsecT Void Text Identity (Maybe (Ann Token, Term) -> Selector)
-> ParsecT Void Text Identity (Maybe (Ann Token, Term))
-> Parser Selector
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    ParsecT Void Text Identity (Ann Token, Term)
-> ParsecT Void Text Identity (Maybe (Ann Token, Term))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ((Ann Token -> Term -> (Ann Token, Term))
-> Parser (Ann Token)
-> Parser Term
-> ParsecT Void Text Identity (Ann Token, Term)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) (Token -> Parser (Ann Token)
reserved Token
KOr) Parser Term
term)

selectorPath :: Parser [Selector]
selectorPath :: Parser [Selector]
selectorPath = (Selector -> [Selector]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Selector -> [Selector]) -> Parser Selector -> Parser [Selector]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Parser (Ann Token)) -> Parser Selector
selector Maybe (Parser (Ann Token))
forall a. Maybe a
Nothing) Parser [Selector] -> Parser [Selector] -> Parser [Selector]
forall a. Semigroup a => a -> a -> a
<>
    Parser Selector -> Parser [Selector]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (Maybe (Parser (Ann Token)) -> Parser Selector
selector (Maybe (Parser (Ann Token)) -> Parser Selector)
-> Maybe (Parser (Ann Token)) -> Parser Selector
forall a b. (a -> b) -> a -> b
$ Parser (Ann Token) -> Maybe (Parser (Ann Token))
forall a. a -> Maybe a
Just (Parser (Ann Token) -> Maybe (Parser (Ann Token)))
-> Parser (Ann Token) -> Maybe (Parser (Ann Token))
forall a b. (a -> b) -> a -> b
$ Token -> Parser (Ann Token)
symbol Token
TDot)

simpleTerm :: Parser Term
simpleTerm :: Parser Term
simpleTerm = (String -> Term
String (String -> Term) -> Parser String -> Parser Term
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser String
string) Parser Term -> Parser Term -> Parser Term
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Path -> Term
Path (Path -> Term) -> Parser Path -> Parser Term
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Path
path) Parser Term -> Parser Term -> Parser Term
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    (Ann Token -> Term
Token (Ann Token -> Term) -> Parser (Ann Token) -> Parser Term
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser (Ann Token)
envPath Parser (Ann Token) -> Parser (Ann Token) -> Parser (Ann Token)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Ann Token)
float Parser (Ann Token) -> Parser (Ann Token) -> Parser (Ann Token)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Ann Token)
integer Parser (Ann Token) -> Parser (Ann Token) -> Parser (Ann Token)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Ann Token)
identifier)) Parser Term -> Parser Term -> Parser Term
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Parser Term
parens Parser Term -> Parser Term -> Parser Term
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Term
set Parser Term -> Parser Term -> Parser Term
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Term
list

term :: Parser Term
term :: Parser Term
term = [Char] -> Parser Term -> Parser Term
forall e s (m :: * -> *) a.
MonadParsec e s m =>
[Char] -> m a -> m a
label [Char]
"term" (Parser Term -> Parser Term) -> Parser Term -> Parser Term
forall a b. (a -> b) -> a -> b
$ do
    Term
t <- Parser Term
simpleTerm
    [Selector]
s <- Parser Selector -> Parser [Selector]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (Parser Selector -> Parser [Selector])
-> Parser Selector -> Parser [Selector]
forall a b. (a -> b) -> a -> b
$ Parser Selector -> Parser Selector
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser Selector -> Parser Selector)
-> Parser Selector -> Parser Selector
forall a b. (a -> b) -> a -> b
$ Maybe (Parser (Ann Token)) -> Parser Selector
selector (Maybe (Parser (Ann Token)) -> Parser Selector)
-> Maybe (Parser (Ann Token)) -> Parser Selector
forall a b. (a -> b) -> a -> b
$ Parser (Ann Token) -> Maybe (Parser (Ann Token))
forall a. a -> Maybe a
Just (Parser (Ann Token) -> Maybe (Parser (Ann Token)))
-> Parser (Ann Token) -> Maybe (Parser (Ann Token))
forall a b. (a -> b) -> a -> b
$ Token -> Parser (Ann Token)
symbol Token
TDot
    Term -> Parser Term
forall (m :: * -> *) a. Monad m => a -> m a
return (Term -> Parser Term) -> Term -> Parser Term
forall a b. (a -> b) -> a -> b
$ case [Selector]
s of [] -> Term
t
                       [Selector]
_  -> Term -> [Selector] -> Term
Selection Term
t [Selector]
s

-- ABSTRACTIONS

attrParameter :: Maybe (Parser Leaf) -> Parser ParamAttr
attrParameter :: Maybe (Parser (Ann Token)) -> Parser ParamAttr
attrParameter Maybe (Parser (Ann Token))
parseComma = Ann Token
-> Maybe (Ann Token, Expression) -> Maybe (Ann Token) -> ParamAttr
ParamAttr (Ann Token
 -> Maybe (Ann Token, Expression) -> Maybe (Ann Token) -> ParamAttr)
-> Parser (Ann Token)
-> ParsecT
     Void
     Text
     Identity
     (Maybe (Ann Token, Expression) -> Maybe (Ann Token) -> ParamAttr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    Parser (Ann Token)
identifier ParsecT
  Void
  Text
  Identity
  (Maybe (Ann Token, Expression) -> Maybe (Ann Token) -> ParamAttr)
-> ParsecT Void Text Identity (Maybe (Ann Token, Expression))
-> ParsecT Void Text Identity (Maybe (Ann Token) -> ParamAttr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity (Ann Token, Expression)
-> ParsecT Void Text Identity (Maybe (Ann Token, Expression))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ((Ann Token -> Expression -> (Ann Token, Expression))
-> Parser (Ann Token)
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity (Ann Token, Expression)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) (Token -> Parser (Ann Token)
symbol Token
TQuestion) ParsecT Void Text Identity Expression
expression) ParsecT Void Text Identity (Maybe (Ann Token) -> ParamAttr)
-> ParsecT Void Text Identity (Maybe (Ann Token))
-> Parser ParamAttr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Maybe (Parser (Ann Token))
-> ParsecT Void Text Identity (Maybe (Ann Token))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence Maybe (Parser (Ann Token))
parseComma

idParameter :: Parser Parameter
idParameter :: Parser Parameter
idParameter = Ann Token -> Parameter
IDParameter (Ann Token -> Parameter) -> Parser (Ann Token) -> Parser Parameter
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Ann Token)
identifier

setParameter :: Parser Parameter
setParameter :: Parser Parameter
setParameter = Ann Token -> [ParamAttr] -> Ann Token -> Parameter
SetParameter (Ann Token -> [ParamAttr] -> Ann Token -> Parameter)
-> Parser (Ann Token)
-> ParsecT
     Void Text Identity ([ParamAttr] -> Ann Token -> Parameter)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Ann Token)
bopen ParsecT Void Text Identity ([ParamAttr] -> Ann Token -> Parameter)
-> ParsecT Void Text Identity [ParamAttr]
-> ParsecT Void Text Identity (Ann Token -> Parameter)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity [ParamAttr]
attrs ParsecT Void Text Identity (Ann Token -> Parameter)
-> Parser (Ann Token) -> Parser Parameter
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Ann Token)
bclose
    where bopen :: Parser (Ann Token)
bopen      = Token -> Parser (Ann Token)
symbol Token
TBraceOpen
          bclose :: Parser (Ann Token)
bclose     = Token -> Parser (Ann Token)
symbol Token
TBraceClose
          commaAttrs :: ParsecT Void Text Identity [ParamAttr]
commaAttrs = Parser ParamAttr -> ParsecT Void Text Identity [ParamAttr]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (Parser ParamAttr -> ParsecT Void Text Identity [ParamAttr])
-> Parser ParamAttr -> ParsecT Void Text Identity [ParamAttr]
forall a b. (a -> b) -> a -> b
$ Parser ParamAttr -> Parser ParamAttr
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser ParamAttr -> Parser ParamAttr)
-> Parser ParamAttr -> Parser ParamAttr
forall a b. (a -> b) -> a -> b
$ Maybe (Parser (Ann Token)) -> Parser ParamAttr
attrParameter (Maybe (Parser (Ann Token)) -> Parser ParamAttr)
-> Maybe (Parser (Ann Token)) -> Parser ParamAttr
forall a b. (a -> b) -> a -> b
$ Parser (Ann Token) -> Maybe (Parser (Ann Token))
forall a. a -> Maybe a
Just (Parser (Ann Token) -> Maybe (Parser (Ann Token)))
-> Parser (Ann Token) -> Maybe (Parser (Ann Token))
forall a b. (a -> b) -> a -> b
$ Token -> Parser (Ann Token)
symbol Token
TComma
          ellipsis :: Parser ParamAttr
ellipsis   = Ann Token -> ParamAttr
ParamEllipsis (Ann Token -> ParamAttr) -> Parser (Ann Token) -> Parser ParamAttr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser (Ann Token)
symbol Token
TEllipsis
          lastAttr :: Parser ParamAttr
lastAttr   = Maybe (Parser (Ann Token)) -> Parser ParamAttr
attrParameter Maybe (Parser (Ann Token))
forall a. Maybe a
Nothing Parser ParamAttr -> Parser ParamAttr -> Parser ParamAttr
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParamAttr
ellipsis
          attrs :: ParsecT Void Text Identity [ParamAttr]
attrs      = ParsecT Void Text Identity [ParamAttr]
commaAttrs ParsecT Void Text Identity [ParamAttr]
-> ParsecT Void Text Identity [ParamAttr]
-> ParsecT Void Text Identity [ParamAttr]
forall a. Semigroup a => a -> a -> a
<> (Maybe ParamAttr -> [ParamAttr]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (Maybe ParamAttr -> [ParamAttr])
-> ParsecT Void Text Identity (Maybe ParamAttr)
-> ParsecT Void Text Identity [ParamAttr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ParamAttr -> ParsecT Void Text Identity (Maybe ParamAttr)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Parser ParamAttr
lastAttr))

contextParameter :: Parser Parameter
contextParameter :: Parser Parameter
contextParameter =
    Parser Parameter -> Parser Parameter
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parameter -> Ann Token -> Parameter -> Parameter
ContextParameter (Parameter -> Ann Token -> Parameter -> Parameter)
-> Parser Parameter
-> ParsecT Void Text Identity (Ann Token -> Parameter -> Parameter)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Parameter
setParameter ParsecT Void Text Identity (Ann Token -> Parameter -> Parameter)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Parameter -> Parameter)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Token -> Parser (Ann Token)
symbol Token
TAt ParsecT Void Text Identity (Parameter -> Parameter)
-> Parser Parameter -> Parser Parameter
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Parameter
idParameter) Parser Parameter -> Parser Parameter -> Parser Parameter
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    Parser Parameter -> Parser Parameter
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parameter -> Ann Token -> Parameter -> Parameter
ContextParameter (Parameter -> Ann Token -> Parameter -> Parameter)
-> Parser Parameter
-> ParsecT Void Text Identity (Ann Token -> Parameter -> Parameter)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Parameter
idParameter ParsecT Void Text Identity (Ann Token -> Parameter -> Parameter)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Parameter -> Parameter)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Token -> Parser (Ann Token)
symbol Token
TAt ParsecT Void Text Identity (Parameter -> Parameter)
-> Parser Parameter -> Parser Parameter
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Parameter
setParameter)

abstraction :: Parser Expression
abstraction :: ParsecT Void Text Identity Expression
abstraction = ParsecT Void Text Identity (Expression -> Expression)
-> ParsecT Void Text Identity (Expression -> Expression)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parameter -> Ann Token -> Expression -> Expression
Abstraction (Parameter -> Ann Token -> Expression -> Expression)
-> Parser Parameter
-> ParsecT
     Void Text Identity (Ann Token -> Expression -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    (Parser Parameter
contextParameter Parser Parameter -> Parser Parameter -> Parser Parameter
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Parameter
setParameter Parser Parameter -> Parser Parameter -> Parser Parameter
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Parameter
idParameter) ParsecT Void Text Identity (Ann Token -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Token -> Parser (Ann Token)
symbol Token
TColon) ParsecT Void Text Identity (Expression -> Expression)
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression

-- SETS AND LISTS

inherit :: Parser Binder
inherit :: Parser Binder
inherit = Ann Token -> Maybe Term -> [Ann Token] -> Ann Token -> Binder
Inherit (Ann Token -> Maybe Term -> [Ann Token] -> Ann Token -> Binder)
-> Parser (Ann Token)
-> ParsecT
     Void
     Text
     Identity
     (Maybe Term -> [Ann Token] -> Ann Token -> Binder)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser (Ann Token)
reserved Token
KInherit ParsecT
  Void
  Text
  Identity
  (Maybe Term -> [Ann Token] -> Ann Token -> Binder)
-> ParsecT Void Text Identity (Maybe Term)
-> ParsecT Void Text Identity ([Ann Token] -> Ann Token -> Binder)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Term -> ParsecT Void Text Identity (Maybe Term)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Term
parens ParsecT Void Text Identity ([Ann Token] -> Ann Token -> Binder)
-> ParsecT Void Text Identity [Ann Token]
-> ParsecT Void Text Identity (Ann Token -> Binder)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Parser (Ann Token) -> ParsecT Void Text Identity [Ann Token]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many Parser (Ann Token)
identifier ParsecT Void Text Identity (Ann Token -> Binder)
-> Parser (Ann Token) -> Parser Binder
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Token -> Parser (Ann Token)
symbol Token
TSemicolon

assignment :: Parser Binder
assignment :: Parser Binder
assignment = [Selector] -> Ann Token -> Expression -> Ann Token -> Binder
Assignment ([Selector] -> Ann Token -> Expression -> Ann Token -> Binder)
-> Parser [Selector]
-> ParsecT
     Void Text Identity (Ann Token -> Expression -> Ann Token -> Binder)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    Parser [Selector]
selectorPath ParsecT
  Void Text Identity (Ann Token -> Expression -> Ann Token -> Binder)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Expression -> Ann Token -> Binder)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Token -> Parser (Ann Token)
symbol Token
TAssign ParsecT Void Text Identity (Expression -> Ann Token -> Binder)
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity (Ann Token -> Binder)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression ParsecT Void Text Identity (Ann Token -> Binder)
-> Parser (Ann Token) -> Parser Binder
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Token -> Parser (Ann Token)
symbol Token
TSemicolon

binders :: Parser [Binder]
binders :: Parser [Binder]
binders = Parser Binder -> Parser [Binder]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (Parser Binder
assignment Parser Binder -> Parser Binder -> Parser Binder
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Binder
inherit)

set :: Parser Term
set :: Parser Term
set = Maybe (Ann Token) -> Ann Token -> [Binder] -> Ann Token -> Term
Set (Maybe (Ann Token) -> Ann Token -> [Binder] -> Ann Token -> Term)
-> ParsecT Void Text Identity (Maybe (Ann Token))
-> ParsecT
     Void Text Identity (Ann Token -> [Binder] -> Ann Token -> Term)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Ann Token)
-> ParsecT Void Text Identity (Maybe (Ann Token))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Token -> Parser (Ann Token)
reserved Token
KRec Parser (Ann Token) -> Parser (Ann Token) -> Parser (Ann Token)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Token -> Parser (Ann Token)
reserved Token
KLet) ParsecT
  Void Text Identity (Ann Token -> [Binder] -> Ann Token -> Term)
-> Parser (Ann Token)
-> ParsecT Void Text Identity ([Binder] -> Ann Token -> Term)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Token -> Parser (Ann Token)
symbol Token
TBraceOpen ParsecT Void Text Identity ([Binder] -> Ann Token -> Term)
-> Parser [Binder]
-> ParsecT Void Text Identity (Ann Token -> Term)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser [Binder]
binders ParsecT Void Text Identity (Ann Token -> Term)
-> Parser (Ann Token) -> Parser Term
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Token -> Parser (Ann Token)
symbol Token
TBraceClose

list :: Parser Term
list :: Parser Term
list = Ann Token -> [Term] -> Ann Token -> Term
List (Ann Token -> [Term] -> Ann Token -> Term)
-> Parser (Ann Token)
-> ParsecT Void Text Identity ([Term] -> Ann Token -> Term)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser (Ann Token)
symbol Token
TBrackOpen ParsecT Void Text Identity ([Term] -> Ann Token -> Term)
-> ParsecT Void Text Identity [Term]
-> ParsecT Void Text Identity (Ann Token -> Term)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Term -> ParsecT Void Text Identity [Term]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many Parser Term
term ParsecT Void Text Identity (Ann Token -> Term)
-> Parser (Ann Token) -> Parser Term
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Token -> Parser (Ann Token)
symbol Token
TBrackClose

-- OPERATORS

opChars :: [Char]
opChars :: [Char]
opChars = [Char]
"<>=+*/."

operator :: Token -> Parser Leaf
operator :: Token -> Parser (Ann Token)
operator Token
t = [Char] -> Parser (Ann Token) -> Parser (Ann Token)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
[Char] -> m a -> m a
label [Char]
"operator" (Parser (Ann Token) -> Parser (Ann Token))
-> Parser (Ann Token) -> Parser (Ann Token)
forall a b. (a -> b) -> a -> b
$ Parser (Ann Token) -> Parser (Ann Token)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser (Ann Token) -> Parser (Ann Token))
-> Parser (Ann Token) -> Parser (Ann Token)
forall a b. (a -> b) -> a -> b
$ Parser Token -> Parser (Ann Token)
forall a. Parser a -> Parser (Ann a)
lexeme (Parser Token -> Parser (Ann Token))
-> Parser Token -> Parser (Ann Token)
forall a b. (a -> b) -> a -> b
$
    Token -> Parser Token
rawSymbol Token
t Parser Token -> ParsecT Void Text Identity () -> Parser Token
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity Char -> ParsecT Void Text Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy ([Token Text] -> ParsecT Void Text Identity (Token Text)
forall (f :: * -> *) e s (m :: * -> *).
(Foldable f, MonadParsec e s m) =>
f (Token s) -> m (Token s)
oneOf [Char]
[Token Text]
opChars)

opCombiner :: Operator -> MPExpr.Operator Parser Expression
opCombiner :: Operator -> Operator Parser Expression
opCombiner Operator
Apply = Parser (Expression -> Expression -> Expression)
-> Operator Parser Expression
forall (m :: * -> *) a. m (a -> a -> a) -> Operator m a
MPExpr.InfixL (Parser (Expression -> Expression -> Expression)
 -> Operator Parser Expression)
-> Parser (Expression -> Expression -> Expression)
-> Operator Parser Expression
forall a b. (a -> b) -> a -> b
$ (Expression -> Expression -> Expression)
-> Parser (Expression -> Expression -> Expression)
forall (m :: * -> *) a. Monad m => a -> m a
return Expression -> Expression -> Expression
Application

opCombiner (Op Fixity
Prefix Token
TMinus) = ParsecT Void Text Identity (Expression -> Expression)
-> Operator Parser Expression
forall (m :: * -> *) a. m (a -> a) -> Operator m a
MPExpr.Prefix (ParsecT Void Text Identity (Expression -> Expression)
 -> Operator Parser Expression)
-> ParsecT Void Text Identity (Expression -> Expression)
-> Operator Parser Expression
forall a b. (a -> b) -> a -> b
$ Ann Token -> Expression -> Expression
Negation (Ann Token -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Expression -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser (Ann Token)
operator Token
TMinus
opCombiner (Op Fixity
Prefix Token
TNot)   = ParsecT Void Text Identity (Expression -> Expression)
-> Operator Parser Expression
forall (m :: * -> *) a. m (a -> a) -> Operator m a
MPExpr.Prefix (ParsecT Void Text Identity (Expression -> Expression)
 -> Operator Parser Expression)
-> ParsecT Void Text Identity (Expression -> Expression)
-> Operator Parser Expression
forall a b. (a -> b) -> a -> b
$ Ann Token -> Expression -> Expression
Inversion (Ann Token -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Expression -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser (Ann Token)
operator Token
TNot
opCombiner (Op Fixity
Prefix Token
_)      = Operator Parser Expression
forall a. HasCallStack => a
undefined

opCombiner (Op Fixity
Postfix Token
TQuestion) = ParsecT Void Text Identity (Expression -> Expression)
-> Operator Parser Expression
forall (m :: * -> *) a. m (a -> a) -> Operator m a
MPExpr.Postfix (ParsecT Void Text Identity (Expression -> Expression)
 -> Operator Parser Expression)
-> ParsecT Void Text Identity (Expression -> Expression)
-> Operator Parser Expression
forall a b. (a -> b) -> a -> b
$
    (\Ann Token
question [Selector]
sel Expression
expr -> Expression -> Ann Token -> [Selector] -> Expression
MemberCheck Expression
expr Ann Token
question [Selector]
sel) (Ann Token -> [Selector] -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT
     Void Text Identity ([Selector] -> Expression -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    Token -> Parser (Ann Token)
operator Token
TQuestion ParsecT Void Text Identity ([Selector] -> Expression -> Expression)
-> Parser [Selector]
-> ParsecT Void Text Identity (Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser [Selector]
selectorPath

opCombiner (Op Fixity
Postfix Token
_) = Operator Parser Expression
forall a. HasCallStack => a
undefined

opCombiner (Op Fixity
InfixL Token
tok) = Parser (Expression -> Expression -> Expression)
-> Operator Parser Expression
forall (m :: * -> *) a. m (a -> a -> a) -> Operator m a
MPExpr.InfixL (Parser (Expression -> Expression -> Expression)
 -> Operator Parser Expression)
-> Parser (Expression -> Expression -> Expression)
-> Operator Parser Expression
forall a b. (a -> b) -> a -> b
$ (Expression -> Ann Token -> Expression -> Expression)
-> Ann Token -> Expression -> Expression -> Expression
forall a b c. (a -> b -> c) -> b -> a -> c
flip Expression -> Ann Token -> Expression -> Expression
Operation (Ann Token -> Expression -> Expression -> Expression)
-> Parser (Ann Token)
-> Parser (Expression -> Expression -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser (Ann Token)
operator Token
tok
opCombiner (Op Fixity
InfixN Token
tok) = Parser (Expression -> Expression -> Expression)
-> Operator Parser Expression
forall (m :: * -> *) a. m (a -> a -> a) -> Operator m a
MPExpr.InfixN (Parser (Expression -> Expression -> Expression)
 -> Operator Parser Expression)
-> Parser (Expression -> Expression -> Expression)
-> Operator Parser Expression
forall a b. (a -> b) -> a -> b
$ (Expression -> Ann Token -> Expression -> Expression)
-> Ann Token -> Expression -> Expression -> Expression
forall a b c. (a -> b -> c) -> b -> a -> c
flip Expression -> Ann Token -> Expression -> Expression
Operation (Ann Token -> Expression -> Expression -> Expression)
-> Parser (Ann Token)
-> Parser (Expression -> Expression -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser (Ann Token)
operator Token
tok
opCombiner (Op Fixity
InfixR Token
tok) = Parser (Expression -> Expression -> Expression)
-> Operator Parser Expression
forall (m :: * -> *) a. m (a -> a -> a) -> Operator m a
MPExpr.InfixR (Parser (Expression -> Expression -> Expression)
 -> Operator Parser Expression)
-> Parser (Expression -> Expression -> Expression)
-> Operator Parser Expression
forall a b. (a -> b) -> a -> b
$ (Expression -> Ann Token -> Expression -> Expression)
-> Ann Token -> Expression -> Expression -> Expression
forall a b c. (a -> b -> c) -> b -> a -> c
flip Expression -> Ann Token -> Expression -> Expression
Operation (Ann Token -> Expression -> Expression -> Expression)
-> Parser (Ann Token)
-> Parser (Expression -> Expression -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser (Ann Token)
operator Token
tok

operation :: Parser Expression
operation :: ParsecT Void Text Identity Expression
operation = ParsecT Void Text Identity Expression
-> [[Operator Parser Expression]]
-> ParsecT Void Text Identity Expression
forall (m :: * -> *) a.
MonadPlus m =>
m a -> [[Operator m a]] -> m a
MPExpr.makeExprParser
    (Term -> Expression
Term (Term -> Expression)
-> Parser Term -> ParsecT Void Text Identity Expression
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Term
term ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Expression
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity Char -> ParsecT Void Text Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy ([Token Text] -> ParsecT Void Text Identity (Token Text)
forall (f :: * -> *) e s (m :: * -> *).
(Foldable f, MonadParsec e s m) =>
f (Token s) -> m (Token s)
oneOf ([Char]
":@" :: [Char])))
    (([Operator] -> [Operator Parser Expression])
-> [[Operator]] -> [[Operator Parser Expression]]
forall a b. (a -> b) -> [a] -> [b]
map ((Operator -> Operator Parser Expression)
-> [Operator] -> [Operator Parser Expression]
forall a b. (a -> b) -> [a] -> [b]
map Operator -> Operator Parser Expression
opCombiner) [[Operator]]
operators)

-- EXPRESSIONS

with :: Parser Expression
with :: ParsecT Void Text Identity Expression
with = Ann Token -> Expression -> Ann Token -> Expression -> Expression
With (Ann Token -> Expression -> Ann Token -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT
     Void
     Text
     Identity
     (Expression -> Ann Token -> Expression -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    Token -> Parser (Ann Token)
reserved Token
KWith ParsecT
  Void
  Text
  Identity
  (Expression -> Ann Token -> Expression -> Expression)
-> ParsecT Void Text Identity Expression
-> ParsecT
     Void Text Identity (Ann Token -> Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression ParsecT Void Text Identity (Ann Token -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Token -> Parser (Ann Token)
symbol Token
TSemicolon ParsecT Void Text Identity (Expression -> Expression)
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression

letIn :: Parser Expression
letIn :: ParsecT Void Text Identity Expression
letIn = Ann Token -> [Binder] -> Ann Token -> Expression -> Expression
Let (Ann Token -> [Binder] -> Ann Token -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT
     Void
     Text
     Identity
     ([Binder] -> Ann Token -> Expression -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser (Ann Token)
reserved Token
KLet ParsecT
  Void
  Text
  Identity
  ([Binder] -> Ann Token -> Expression -> Expression)
-> Parser [Binder]
-> ParsecT
     Void Text Identity (Ann Token -> Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser [Binder]
binders ParsecT Void Text Identity (Ann Token -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Token -> Parser (Ann Token)
reserved Token
KIn ParsecT Void Text Identity (Expression -> Expression)
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression

ifThenElse :: Parser Expression
ifThenElse :: ParsecT Void Text Identity Expression
ifThenElse = Ann Token
-> Expression
-> Ann Token
-> Expression
-> Ann Token
-> Expression
-> Expression
If (Ann Token
 -> Expression
 -> Ann Token
 -> Expression
 -> Ann Token
 -> Expression
 -> Expression)
-> Parser (Ann Token)
-> ParsecT
     Void
     Text
     Identity
     (Expression
      -> Ann Token
      -> Expression
      -> Ann Token
      -> Expression
      -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    Token -> Parser (Ann Token)
reserved Token
KIf ParsecT
  Void
  Text
  Identity
  (Expression
   -> Ann Token
   -> Expression
   -> Ann Token
   -> Expression
   -> Expression)
-> ParsecT Void Text Identity Expression
-> ParsecT
     Void
     Text
     Identity
     (Ann Token -> Expression -> Ann Token -> Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression ParsecT
  Void
  Text
  Identity
  (Ann Token -> Expression -> Ann Token -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT
     Void
     Text
     Identity
     (Expression -> Ann Token -> Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Token -> Parser (Ann Token)
reserved Token
KThen ParsecT
  Void
  Text
  Identity
  (Expression -> Ann Token -> Expression -> Expression)
-> ParsecT Void Text Identity Expression
-> ParsecT
     Void Text Identity (Ann Token -> Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression ParsecT Void Text Identity (Ann Token -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Token -> Parser (Ann Token)
reserved Token
KElse ParsecT Void Text Identity (Expression -> Expression)
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression

assert :: Parser Expression
assert :: ParsecT Void Text Identity Expression
assert = Ann Token -> Expression -> Ann Token -> Expression -> Expression
Assert (Ann Token -> Expression -> Ann Token -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT
     Void
     Text
     Identity
     (Expression -> Ann Token -> Expression -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser (Ann Token)
reserved Token
KAssert ParsecT
  Void
  Text
  Identity
  (Expression -> Ann Token -> Expression -> Expression)
-> ParsecT Void Text Identity Expression
-> ParsecT
     Void Text Identity (Ann Token -> Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression ParsecT Void Text Identity (Ann Token -> Expression -> Expression)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Expression -> Expression)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Token -> Parser (Ann Token)
symbol Token
TSemicolon ParsecT Void Text Identity (Expression -> Expression)
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression

expression :: Parser Expression
expression :: ParsecT Void Text Identity Expression
expression = [Char]
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall e s (m :: * -> *) a.
MonadParsec e s m =>
[Char] -> m a -> m a
label [Char]
"expression" (ParsecT Void Text Identity Expression
 -> ParsecT Void Text Identity Expression)
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall a b. (a -> b) -> a -> b
$ ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ParsecT Void Text Identity Expression
operation ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity Expression
abstraction ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    ParsecT Void Text Identity Expression
with ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity Expression
letIn ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity Expression
ifThenElse ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
-> ParsecT Void Text Identity Expression
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity Expression
assert

file :: Parser File
file :: Parser File
file = Ann Token -> Expression -> File
File (Ann Token -> Expression -> File)
-> Parser (Ann Token)
-> ParsecT Void Text Identity (Expression -> File)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Token -> Parser (Ann Token)
forall a. Parser a -> Parser (Ann a)
lexeme (Token -> Parser Token
forall (m :: * -> *) a. Monad m => a -> m a
return Token
SOF) ParsecT Void Text Identity (Expression -> File)
-> ParsecT Void Text Identity Expression -> Parser File
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Expression
expression Parser File -> ParsecT Void Text Identity () -> Parser File
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
eof