{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TupleSections #-}

-- |
-- Module                  : Language.Jsonnet.Parser
-- Copyright               : (c) 2020-2021 Alexandre Moreno
-- SPDX-License-Identifier : BSD-3-Clause OR Apache-2.0
-- Maintainer              : Alexandre Moreno <alexmorenocano@gmail.com>
-- Stability               : experimental
-- Portability             : non-portable
--
-- Parser for Jsonnet source code.
module Language.Jsonnet.Parser
  ( parse,
    resolveImports,
  )
where

import Control.Applicative hiding (many, some)
import Control.Arrow (left)
import Control.Monad
import Control.Monad.Combinators.Expr
import qualified Control.Monad.Combinators.NonEmpty as NE
import Control.Monad.Except
import Data.Char
import Data.Either
import Data.Fix
import Data.Functor
import Data.Functor.Sum
import Data.List (intercalate)
import Data.List.NonEmpty (NonEmpty)
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Data.Void
import GHC.IO.Exception hiding (IOError)
import Language.Jsonnet.Annotate
import Language.Jsonnet.Common
import Language.Jsonnet.Error
import Language.Jsonnet.Parser.SrcSpan
import Language.Jsonnet.Syntax
import Language.Jsonnet.Syntax.Annotated
import System.Directory
import System.FilePath.Posix (takeDirectory)
import System.IO.Error (tryIOError)
import Text.Megaparsec hiding (ParseError, parse)
import Text.Megaparsec.Char
import qualified Text.Megaparsec.Char.Lexer as L

type Parser = Parsec Void Text

parse ::
  MonadError Error m =>
  -- | File name (only for source location annotations)
  FilePath ->
  -- | Input for parser
  Text ->
  -- | AST with unresolved imports
  m Expr'
parse :: FilePath -> Text -> m Expr'
parse FilePath
fp Text
inp =
  Either Error Expr' -> m Expr'
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either Error Expr' -> m Expr') -> Either Error Expr' -> m Expr'
forall a b. (a -> b) -> a -> b
$
    (ParseErrorBundle Text Void -> Error)
-> Either (ParseErrorBundle Text Void) Expr' -> Either Error Expr'
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left (ParserError -> Error
ParserError (ParserError -> Error)
-> (ParseErrorBundle Text Void -> ParserError)
-> ParseErrorBundle Text Void
-> Error
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseErrorBundle Text Void -> ParserError
ParseError) (Either (ParseErrorBundle Text Void) Expr' -> Either Error Expr')
-> Either (ParseErrorBundle Text Void) Expr' -> Either Error Expr'
forall a b. (a -> b) -> a -> b
$
      Parsec Void Text Expr'
-> FilePath -> Text -> Either (ParseErrorBundle Text Void) Expr'
forall e s a.
Parsec e s a -> FilePath -> s -> Either (ParseErrorBundle s e) a
runParser (Parser ()
sc Parser () -> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text Expr'
exprP Parsec Void Text Expr' -> Parser () -> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
eof) FilePath
fp Text
inp

resolveImports ::
  (MonadError Error m, MonadIO m) =>
  -- | File path (modules are resolved relative to this path)
  FilePath ->
  -- | AST with unresolved imports
  Expr' ->
  -- | AST with imports resolved
  m Expr
resolveImports :: FilePath -> Expr' -> m Expr
resolveImports FilePath
fp = (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr -> m Expr)
-> Expr' -> m Expr
forall (m :: * -> *) (t :: * -> *) a.
(Monad m, Traversable t) =>
(t a -> m a) -> Fix t -> m a
foldFixM Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr -> m Expr
forall (f :: * -> *).
(MonadError Error f, MonadIO f) =>
Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr -> f Expr
go
  where
    go :: Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr -> f Expr
go (AnnF (InL ExprF Expr
e) SrcSpan
a) = Expr -> f Expr
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Expr -> f Expr) -> Expr -> f Expr
forall a b. (a -> b) -> a -> b
$ Product (Const SrcSpan) ExprF Expr -> Expr
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) ExprF Expr -> Expr)
-> Product (Const SrcSpan) ExprF Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ExprF Expr -> SrcSpan -> Product (Const SrcSpan) ExprF Expr
forall a1 (g :: * -> *) a2. g a2 -> a1 -> Product (Const a1) g a2
AnnF ExprF Expr
e SrcSpan
a
    go (AnnF (InR (Const (Import FilePath
fp'))) SrcSpan
a) =
      FilePath -> Expr' -> f Expr
forall (m :: * -> *).
(MonadError Error m, MonadIO m) =>
FilePath -> Expr' -> m Expr
resolveImports FilePath
fp'
        (Expr' -> f Expr) -> f Expr' -> f Expr
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< FilePath -> Text -> f Expr'
forall (m :: * -> *).
MonadError Error m =>
FilePath -> Text -> m Expr'
parse FilePath
fp'
        (Text -> f Expr') -> f Text -> f Expr'
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< FilePath -> SrcSpan -> f Text
forall (m :: * -> *).
(MonadError Error m, MonadIO m) =>
FilePath -> SrcSpan -> m Text
readImportFile FilePath
fp' SrcSpan
a
    readImportFile :: FilePath -> SrcSpan -> m Text
readImportFile FilePath
fp' SrcSpan
a = do
      Either IOError Text
inp <- FilePath -> m (Either IOError Text)
readFile' FilePath
fp'
      Either Error Text -> m Text
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either Error Text -> m Text) -> Either Error Text -> m Text
forall a b. (a -> b) -> a -> b
$ (IOError -> Error) -> Either IOError Text -> Either Error Text
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left (ParserError -> Error
ParserError (ParserError -> Error)
-> (IOError -> ParserError) -> IOError -> Error
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (IOError -> Maybe SrcSpan -> ParserError)
-> Maybe SrcSpan -> IOError -> ParserError
forall a b c. (a -> b -> c) -> b -> a -> c
flip IOError -> Maybe SrcSpan -> ParserError
ImportError (SrcSpan -> Maybe SrcSpan
forall a. a -> Maybe a
Just SrcSpan
a)) Either IOError Text
inp
      where
        readFile' :: FilePath -> m (Either IOError Text)
readFile' =
          IO (Either IOError Text) -> m (Either IOError Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO
            (IO (Either IOError Text) -> m (Either IOError Text))
-> (FilePath -> IO (Either IOError Text))
-> FilePath
-> m (Either IOError Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO Text -> IO (Either IOError Text)
forall a. IO a -> IO (Either IOError a)
tryIOError
            (IO Text -> IO (Either IOError Text))
-> (FilePath -> IO Text) -> FilePath -> IO (Either IOError Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> IO Text -> IO Text
forall a. FilePath -> IO a -> IO a
withCurrentDirectory (FilePath -> FilePath
takeDirectory FilePath
fp)
            (IO Text -> IO Text)
-> (FilePath -> IO Text) -> FilePath -> IO Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> IO Text
T.readFile

sc :: Parser ()
sc :: Parser ()
sc = Parser () -> Parser () -> Parser () -> Parser ()
forall e s (m :: * -> *).
MonadParsec e s m =>
m () -> m () -> m () -> m ()
L.space Parser ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
space1 Parser ()
lineComment Parser ()
blockComment
  where
    lineComment :: Parser ()
lineComment = Tokens Text -> Parser ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Tokens s -> m ()
L.skipLineComment Tokens Text
"//" Parser () -> Parser () -> Parser ()
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Tokens Text -> Parser ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Tokens s -> m ()
L.skipLineComment Tokens Text
"#"
    blockComment :: Parser ()
blockComment = Tokens Text -> Tokens Text -> Parser ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Tokens s -> Tokens s -> m ()
L.skipBlockComment Tokens Text
"/*" Tokens Text
"*/"

symbol :: Text -> Parser Text
symbol :: Text -> Parser Text
symbol = Parser ()
-> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
m () -> Tokens s -> m (Tokens s)
L.symbol Parser ()
sc

lexeme :: Parser a -> Parser a
lexeme :: Parser a -> Parser a
lexeme = Parser () -> Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m () -> m a -> m a
L.lexeme Parser ()
sc

braces :: Parser a -> Parser a
braces :: Parser a -> Parser a
braces = Parser Text -> Parser Text -> Parser a -> Parser a
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (Text -> Parser Text
symbol Text
"{") (Text -> Parser Text
symbol Text
"}")

brackets :: Parser a -> Parser a
brackets :: Parser a -> Parser a
brackets = Parser Text -> Parser Text -> Parser a -> Parser a
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (Text -> Parser Text
symbol Text
"[") (Text -> Parser Text
symbol Text
"]")

parens :: Parser a -> Parser a
parens :: Parser a -> Parser a
parens = Parser Text -> Parser Text -> Parser a -> Parser a
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (Text -> Parser Text
symbol Text
"(") (Text -> Parser Text
symbol Text
")")

comma :: Parser Text
comma :: Parser Text
comma = Text -> Parser Text
symbol Text
","

colon :: Parser Text
colon :: Parser Text
colon = Text -> Parser Text
symbol Text
":"

annotateLoc :: Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc :: Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc Parser (f a)
p = do
  SourcePos
begin <- ParsecT Void Text Identity SourcePos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m SourcePos
getSourcePos
  f a
res <- Parser (f a)
p
  f a -> SrcSpan -> AnnF f SrcSpan a
forall a1 (g :: * -> *) a2. g a2 -> a1 -> Product (Const a1) g a2
AnnF f a
res (SrcSpan -> AnnF f SrcSpan a)
-> (SourcePos -> SrcSpan) -> SourcePos -> AnnF f SrcSpan a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourcePos -> SourcePos -> SrcSpan
SrcSpan SourcePos
begin (SourcePos -> AnnF f SrcSpan a)
-> ParsecT Void Text Identity SourcePos
-> Parser (AnnF f SrcSpan a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity SourcePos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m SourcePos
getSourcePos

identifier :: Parser String
identifier :: Parser FilePath
identifier = do
  FilePath
ident <- Parser FilePath
p
  Bool -> Parser () -> Parser ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (FilePath
ident FilePath -> [FilePath] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [FilePath]
reservedKeywords) (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$
    FilePath -> Parser ()
forall (m :: * -> *) a. MonadFail m => FilePath -> m a
fail (FilePath -> Parser ()) -> FilePath -> Parser ()
forall a b. (a -> b) -> a -> b
$
      FilePath
"Keyword " FilePath -> FilePath -> FilePath
forall a. Semigroup a => a -> a -> a
<> FilePath
ident FilePath -> FilePath -> FilePath
forall a. Semigroup a => a -> a -> a
<> FilePath
" cannot be an identifier."
  FilePath -> Parser FilePath
forall (f :: * -> *) a. Applicative f => a -> f a
pure FilePath
ident
  where
    p :: Parser FilePath
p =
      Parser FilePath -> Parser FilePath
forall a. Parser a -> Parser a
lexeme
        ( (:)
            (Char -> FilePath -> FilePath)
-> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity (FilePath -> FilePath)
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, Token s ~ Char) =>
m (Token s)
letterChar ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Char
forall (f :: * -> *) a. Alternative f => f a -> f a -> 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
'_')
            ParsecT Void Text Identity (FilePath -> FilePath)
-> Parser FilePath -> Parser FilePath
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Char -> Parser FilePath
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (ParsecT Void Text Identity Char
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
alphaNumChar ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Char
forall (f :: * -> *) a. Alternative f => f a -> f a -> 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
'_')
        )

keywordP :: Text -> Parser Text
keywordP :: Text -> Parser Text
keywordP Text
keyword = Parser Text -> Parser Text
forall a. Parser a -> Parser a
lexeme (Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Text
Tokens Text
keyword Parser Text -> Parser () -> Parser Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity Char -> Parser ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy ParsecT Void Text Identity Char
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
alphaNumChar)

-- unfinished string parser
stringLiteral :: Parser String
stringLiteral :: Parser FilePath
stringLiteral = ParsecT Void Text Identity Char -> Parser FilePath
forall end. ParsecT Void Text Identity end -> Parser FilePath
quoted (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
'\"') Parser FilePath -> Parser FilePath -> Parser FilePath
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity Char -> Parser FilePath
forall end. ParsecT Void Text Identity end -> Parser FilePath
quoted (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
'\'')
  where
    quoted :: ParsecT Void Text Identity end -> Parser FilePath
quoted ParsecT Void Text Identity end
c =
      ParsecT Void Text Identity end
c
        ParsecT Void Text Identity end
-> Parser FilePath -> Parser FilePath
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity end -> Parser FilePath
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
manyTill
          ( ParsecT Void Text Identity Char -> ParsecT Void Text Identity Char
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ParsecT Void Text Identity Char
escapeUnicode ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Char
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity Char
escapeAscii
              ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity Char
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity Char
forall e s (m :: * -> *). MonadParsec e s m => m (Token s)
anySingle
          )
          ParsecT Void Text Identity end
c

escapeAscii :: Parser Char
escapeAscii :: ParsecT Void Text Identity Char
escapeAscii = do
  ParsecT Void Text Identity Char -> Parser ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (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 Char
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice
    [ 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
-> Char -> ParsecT Void Text Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\"',
      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
-> Char -> ParsecT Void Text Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\'', -- this one is jsonnet specific
      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
-> Char -> ParsecT Void Text Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\\',
      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
-> Char -> ParsecT Void Text Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'/',
      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
'n' ParsecT Void Text Identity Char
-> Char -> ParsecT Void Text Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\n',
      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
'r' ParsecT Void Text Identity Char
-> Char -> ParsecT Void Text Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\r',
      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
'f' ParsecT Void Text Identity Char
-> Char -> ParsecT Void Text Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\f',
      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
't' ParsecT Void Text Identity Char
-> Char -> ParsecT Void Text Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\t',
      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
'b' ParsecT Void Text Identity Char
-> Char -> ParsecT Void Text Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\b'
    ]

escapeUnicode :: Parser Char
escapeUnicode :: ParsecT Void Text Identity Char
escapeUnicode = do
  Text
_ <- Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"\\u"
  FilePath
hex <- (FilePath
"0x" FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++) (FilePath -> FilePath) -> Parser FilePath -> Parser FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> ParsecT Void Text Identity Char -> Parser FilePath
forall (m :: * -> *) a. Monad m => Int -> m a -> m [a]
count Int
4 ParsecT Void Text Identity Char
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
hexDigitChar
  Char -> ParsecT Void Text Identity Char
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> Char
chr (Int -> Char) -> Int -> Char
forall a b. (a -> b) -> a -> b
$ FilePath -> Int
forall a. Read a => FilePath -> a
read FilePath
hex)

verbatimString :: Parser String
verbatimString :: Parser FilePath
verbatimString = 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
-> Parser FilePath -> Parser FilePath
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (ParsecT Void Text Identity (Token Text)
-> ParsecT Void Text Identity [Token Text]
forall (m :: * -> *) e s.
MonadParsec e s m =>
m (Token s) -> m [Token s]
quoted (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
'\'') Parser FilePath -> Parser FilePath -> Parser FilePath
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity (Token Text)
-> ParsecT Void Text Identity [Token Text]
forall (m :: * -> *) e s.
MonadParsec e s m =>
m (Token s) -> m [Token s]
quoted (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
'\"'))
  where
    quoted :: m (Token s) -> m [Token s]
quoted m (Token s)
c =
      m (Token s)
c
        m (Token s) -> m [Token s] -> m [Token s]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m (Token s) -> m (Token s) -> m [Token s]
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
manyTill
          (m (Token s)
c m (Token s) -> m (Token s) -> m (Token s)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m (Token s)
c m (Token s) -> m (Token s) -> m (Token s)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m (Token s)
forall e s (m :: * -> *). MonadParsec e s m => m (Token s)
anySingle)
          (m (Token s) -> m (Token s)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (m (Token s) -> m (Token s)) -> m (Token s) -> m (Token s)
forall a b. (a -> b) -> a -> b
$ m (Token s)
c m (Token s) -> m () -> m (Token s)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* m (Token s) -> m ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy m (Token s)
c)

textBlock :: Parser String
textBlock :: Parser FilePath
textBlock = do
  Text
_ <- Text -> Parser Text
symbol Text
"|||" Parser Text -> Parser () -> Parser Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
sc'
  Pos
ref <- ParsecT Void Text Identity Pos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m Pos
L.indentLevel
  FilePath
x <- Parser FilePath
line
  [FilePath]
xs <-
    Parser FilePath
-> Parser Text -> ParsecT Void Text Identity [FilePath]
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
manyTill
      (Parser () -> Ordering -> Pos -> ParsecT Void Text Identity Pos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m () -> Ordering -> Pos -> m Pos
L.indentGuard (Pos -> Parser ()
sc'' Pos
ref) Ordering
EQ Pos
ref ParsecT Void Text Identity Pos
-> Parser FilePath -> Parser FilePath
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser FilePath
line)
      (Parser Text -> Parser Text
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser Text -> Parser Text) -> Parser Text -> Parser Text
forall a b. (a -> b) -> a -> b
$ Parser ()
sc' Parser () -> Parser Text -> Parser Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> Parser Text
symbol Text
"|||")
  FilePath -> Parser FilePath
forall (f :: * -> *) a. Applicative f => a -> f a
pure (FilePath -> Parser FilePath) -> FilePath -> Parser FilePath
forall a b. (a -> b) -> a -> b
$ [FilePath] -> FilePath
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (FilePath
x FilePath -> [FilePath] -> [FilePath]
forall a. a -> [a] -> [a]
: [FilePath]
xs)
  where
    line :: Parser String
    line :: Parser FilePath
line = FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
(++) (FilePath -> FilePath -> FilePath)
-> Parser FilePath
-> ParsecT Void Text Identity (FilePath -> FilePath)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity Char -> Parser FilePath
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (Token Text -> ParsecT Void Text Identity (Token Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
anySingleBut Char
Token Text
'\n') ParsecT Void Text Identity (FilePath -> FilePath)
-> Parser FilePath -> Parser FilePath
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Char -> Parser FilePath
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some (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
'\n')
    sc' :: Parser ()
    sc' :: Parser ()
sc' = Parser () -> Parser () -> Parser () -> Parser ()
forall e s (m :: * -> *).
MonadParsec e s m =>
m () -> m () -> m () -> m ()
L.space (Parser FilePath -> Parser ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Parser FilePath -> Parser ()) -> Parser FilePath -> Parser ()
forall a b. (a -> b) -> a -> b
$ ParsecT Void Text Identity Char -> Parser FilePath
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some (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 Char
-> ParsecT Void Text Identity Char
forall (f :: * -> *) a. Alternative f => f a -> f a -> 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
'\t')) Parser ()
forall (f :: * -> *) a. Alternative f => f a
empty Parser ()
forall (f :: * -> *) a. Alternative f => f a
empty
    sc'' :: Pos -> Parser ()
    sc'' :: Pos -> Parser ()
sc'' Pos
x = Parser FilePath -> Parser ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Parser FilePath -> Parser ()) -> Parser FilePath -> Parser ()
forall a b. (a -> b) -> a -> b
$ Int -> Int -> ParsecT Void Text Identity Char -> Parser FilePath
forall (m :: * -> *) a. MonadPlus m => Int -> Int -> m a -> m [a]
count' Int
0 (Pos -> Int
unPos Pos
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) ([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
'\t'])

unquoted :: Parser Expr'
unquoted :: Parsec Void Text Expr'
unquoted = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc (FilePath -> Sum ExprF (Const Import) Expr'
forall a. FilePath -> ExprF' a
mkStrF (FilePath -> Sum ExprF (Const Import) Expr')
-> Parser FilePath -> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser FilePath
identifier)

stringP :: Parser Expr'
stringP :: Parsec Void Text Expr'
stringP =
  Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix
    (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc
      ( FilePath -> Sum ExprF (Const Import) Expr'
forall a. FilePath -> ExprF' a
mkStrF
          (FilePath -> Sum ExprF (Const Import) Expr')
-> Parser FilePath -> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ( Parser FilePath
verbatimString
                  Parser FilePath -> Parser FilePath -> Parser FilePath
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser FilePath
stringLiteral
                  Parser FilePath -> Parser FilePath -> Parser FilePath
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser FilePath
textBlock
              )
      )

numberP :: Parser Expr'
numberP :: Parsec Void Text Expr'
numberP = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc Parser (Sum ExprF (Const Import) Expr')
forall a. ParsecT Void Text Identity (ExprF' a)
number
  where
    number :: ParsecT Void Text Identity (ExprF' a)
number = Scientific -> ExprF' a
forall a. Scientific -> ExprF' a
mkFloatF (Scientific -> ExprF' a)
-> ParsecT Void Text Identity Scientific
-> ParsecT Void Text Identity (ExprF' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity Scientific
-> ParsecT Void Text Identity Scientific
forall a. Parser a -> Parser a
lexeme ParsecT Void Text Identity Scientific
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Scientific
L.scientific

identP :: Parser Expr'
identP :: Parsec Void Text Expr'
identP = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc (FilePath -> Sum ExprF (Const Import) Expr'
forall a. FilePath -> ExprF' a
mkIdentF (FilePath -> Sum ExprF (Const Import) Expr')
-> Parser FilePath -> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser FilePath -> Parser FilePath
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Text -> FilePath
T.unpack (Text -> FilePath) -> Parser Text -> Parser FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Parser Text
symbol Text
"$") Parser FilePath -> Parser FilePath -> Parser FilePath
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser FilePath
identifier))

booleanP :: Parser Expr'
booleanP :: Parsec Void Text Expr'
booleanP = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc Parser (Sum ExprF (Const Import) Expr')
forall a. ParsecT Void Text Identity (ExprF' a)
boolean
  where
    boolean :: ParsecT Void Text Identity (ExprF' a)
boolean =
      Text -> Parser Text
keywordP Text
"true" Parser Text -> ExprF' a -> ParsecT Void Text Identity (ExprF' a)
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool -> ExprF' a
forall a. Bool -> ExprF' a
mkBoolF Bool
True
        ParsecT Void Text Identity (ExprF' a)
-> ParsecT Void Text Identity (ExprF' a)
-> ParsecT Void Text Identity (ExprF' a)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Text -> Parser Text
keywordP Text
"false" Parser Text -> ExprF' a -> ParsecT Void Text Identity (ExprF' a)
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool -> ExprF' a
forall a. Bool -> ExprF' a
mkBoolF Bool
False

nullP :: Parser Expr'
nullP :: Parsec Void Text Expr'
nullP = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc Parser (Sum ExprF (Const Import) Expr')
forall a. ParsecT Void Text Identity (ExprF' a)
null
  where
    null :: ParsecT Void Text Identity (ExprF' a)
null = Text -> Parser Text
keywordP Text
"null" Parser Text -> ExprF' a -> ParsecT Void Text Identity (ExprF' a)
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ExprF' a
forall a. ExprF' a
mkNullF

errorP :: Parser Expr'
errorP :: Parsec Void Text Expr'
errorP = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc Parser (Sum ExprF (Const Import) Expr')
error
  where
    error :: Parser (Sum ExprF (Const Import) Expr')
error = Text -> Parser Text
keywordP Text
"error" Parser Text
-> Parser (Sum ExprF (Const Import) Expr')
-> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Expr' -> Sum ExprF (Const Import) Expr'
forall a. a -> ExprF' a
mkErrorF (Expr' -> Sum ExprF (Const Import) Expr')
-> Parsec Void Text Expr'
-> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text Expr'
exprP)

assertP :: Parser Expr'
assertP :: Parsec Void Text Expr'
assertP = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc Parser (Sum ExprF (Const Import) Expr')
assert
  where
    assert :: Parser (Sum ExprF (Const Import) Expr')
assert = do
      Expr'
cond <- Text -> Parser Text
keywordP Text
"assert" Parser Text -> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text Expr'
exprP
      Maybe Expr'
msg <- Parsec Void Text Expr' -> ParsecT Void Text Identity (Maybe Expr')
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Parser Text
colon Parser Text -> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text Expr'
exprP)
      Text
_ <- Text -> Parser Text
symbol Text
";"
      Expr' -> Maybe Expr' -> Expr' -> Sum ExprF (Const Import) Expr'
forall a. a -> Maybe a -> a -> ExprF' a
mkAssertF Expr'
cond Maybe Expr'
msg (Expr' -> Sum ExprF (Const Import) Expr')
-> Parsec Void Text Expr'
-> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text Expr'
exprP

ifElseP :: Parser Expr'
ifElseP :: Parsec Void Text Expr'
ifElseP = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc Parser (Sum ExprF (Const Import) Expr')
ifElseExpr
  where
    ifElseExpr :: Parser (Sum ExprF (Const Import) Expr')
ifElseExpr = do
      Expr'
cond <- Text -> Parser Text
keywordP Text
"if" Parser Text -> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text Expr'
exprP
      Expr'
expr <- Text -> Parser Text
keywordP Text
"then" Parser Text -> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text Expr'
exprP
      Sum ExprF (Const Import) Expr'
-> Parser (Sum ExprF (Const Import) Expr')
-> Parser (Sum ExprF (Const Import) Expr')
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option
        (Expr' -> Expr' -> Sum ExprF (Const Import) Expr'
forall a. a -> a -> ExprF' a
mkIfF Expr'
cond Expr'
expr)
        (Text -> Parser Text
keywordP Text
"else" Parser Text
-> Parser (Sum ExprF (Const Import) Expr')
-> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Expr' -> Expr' -> Expr' -> Sum ExprF (Const Import) Expr'
forall a. a -> a -> a -> ExprF' a
mkIfElseF Expr'
cond Expr'
expr (Expr' -> Sum ExprF (Const Import) Expr')
-> Parsec Void Text Expr'
-> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text Expr'
exprP))

paramsP :: Parser [Param Expr']
paramsP :: Parser [Param Expr']
paramsP = Parser [Param Expr'] -> Parser [Param Expr']
forall a. Parser a -> Parser a
parens (ParsecT Void Text Identity (Param Expr')
param ParsecT Void Text Identity (Param Expr')
-> Parser Text -> Parser [Param Expr']
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
`sepEndBy` Parser Text
comma)
  where
    param :: ParsecT Void Text Identity (Param Expr')
param = (,) (FilePath -> Maybe Expr' -> Param Expr')
-> Parser FilePath
-> ParsecT Void Text Identity (Maybe Expr' -> Param Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser FilePath
identifier ParsecT Void Text Identity (Maybe Expr' -> Param Expr')
-> ParsecT Void Text Identity (Maybe Expr')
-> ParsecT Void Text Identity (Param Expr')
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parsec Void Text Expr' -> ParsecT Void Text Identity (Maybe Expr')
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Text -> Parser Text
symbol Text
"=" Parser Text -> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text Expr'
exprP)

function ::
  Parser [Param Expr'] ->
  Parser Expr' ->
  Parser Expr'
function :: Parser [Param Expr']
-> Parsec Void Text Expr' -> Parsec Void Text Expr'
function Parser [Param Expr']
ps Parsec Void Text Expr'
expr = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc ([Param Expr'] -> Expr' -> Sum ExprF (Const Import) Expr'
forall a. [Param a] -> a -> ExprF' a
mkFunF ([Param Expr'] -> Expr' -> Sum ExprF (Const Import) Expr')
-> Parser [Param Expr']
-> ParsecT
     Void Text Identity (Expr' -> Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [Param Expr']
ps ParsecT
  Void Text Identity (Expr' -> Sum ExprF (Const Import) Expr')
-> Parsec Void Text Expr'
-> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parsec Void Text Expr'
expr)

functionP :: Parser Expr'
functionP :: Parsec Void Text Expr'
functionP = Text -> Parser Text
keywordP Text
"function" Parser Text -> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser [Param Expr']
-> Parsec Void Text Expr' -> Parsec Void Text Expr'
function Parser [Param Expr']
paramsP Parsec Void Text Expr'
exprP

forspecP :: Parser (CompSpec Expr')
forspecP :: Parser (CompSpec Expr')
forspecP = do
  Text
_ <- Text -> Parser Text
keywordP Text
"for"
  FilePath
var <- Parser FilePath
identifier
  Text
_ <- Text -> Parser Text
keywordP Text
"in"
  Expr'
forspec <- Parsec Void Text Expr'
exprP
  Maybe Expr'
ifspec <- Parsec Void Text Expr' -> ParsecT Void Text Identity (Maybe Expr')
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Text -> Parser Text
keywordP Text
"if" Parser Text -> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text Expr'
exprP)
  CompSpec Expr' -> Parser (CompSpec Expr')
forall (f :: * -> *) a. Applicative f => a -> f a
pure CompSpec :: forall a. FilePath -> a -> Maybe a -> CompSpec a
CompSpec {FilePath
Maybe Expr'
Expr'
ifspec :: Maybe Expr'
forspec :: Expr'
var :: FilePath
ifspec :: Maybe Expr'
forspec :: Expr'
var :: FilePath
..}

binding :: Parser (String, Expr')
binding :: Parser (FilePath, Expr')
binding = do
  FilePath
name <- Parser FilePath
identifier
  Text
_ <- Text -> Parser Text
symbol Text
"="
  Expr'
expr <- Parsec Void Text Expr'
exprP
  (FilePath, Expr') -> Parser (FilePath, Expr')
forall (f :: * -> *) a. Applicative f => a -> f a
pure (FilePath
name, Expr'
expr)

localFunc :: Parser (String, Expr')
localFunc :: Parser (FilePath, Expr')
localFunc = do
  FilePath
name <- Parser FilePath
identifier
  [Param Expr']
ps <- Parser [Param Expr']
paramsP
  Text
_ <- Text -> Parser Text
symbol Text
"="
  Expr'
expr <- Parser [Param Expr']
-> Parsec Void Text Expr' -> Parsec Void Text Expr'
function ([Param Expr'] -> Parser [Param Expr']
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Param Expr']
ps) Parsec Void Text Expr'
exprP
  (FilePath, Expr') -> Parser (FilePath, Expr')
forall (f :: * -> *) a. Applicative f => a -> f a
pure (FilePath
name, Expr'
expr)

localBndsP :: Parser (NonEmpty (String, Expr'))
localBndsP :: Parser (NonEmpty (FilePath, Expr'))
localBndsP = do
  Text
_ <- Text -> Parser Text
keywordP Text
"local"
  (Parser (FilePath, Expr') -> Parser (FilePath, Expr')
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser (FilePath, Expr')
binding Parser (FilePath, Expr')
-> Parser (FilePath, Expr') -> Parser (FilePath, Expr')
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (FilePath, Expr')
localFunc) Parser (FilePath, Expr')
-> Parser Text -> Parser (NonEmpty (FilePath, Expr'))
forall (m :: * -> *) a sep.
MonadPlus m =>
m a -> m sep -> m (NonEmpty a)
`NE.sepBy1` Parser Text
comma

localP :: Parser Expr'
localP :: Parsec Void Text Expr'
localP = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc Parser (Sum ExprF (Const Import) Expr')
localExpr
  where
    localExpr :: Parser (Sum ExprF (Const Import) Expr')
localExpr = do
      NonEmpty (FilePath, Expr')
bnds <- Parser (NonEmpty (FilePath, Expr'))
localBndsP
      Text
_ <- Text -> Parser Text
symbol Text
";"
      NonEmpty (FilePath, Expr')
-> Expr' -> Sum ExprF (Const Import) Expr'
forall a. NonEmpty (FilePath, a) -> a -> ExprF' a
mkLocalF NonEmpty (FilePath, Expr')
bnds (Expr' -> Sum ExprF (Const Import) Expr')
-> Parsec Void Text Expr'
-> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text Expr'
exprP

arrayP :: Parser Expr'
arrayP :: Parsec Void Text Expr'
arrayP = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc (Parser (Sum ExprF (Const Import) Expr')
-> Parser (Sum ExprF (Const Import) Expr')
forall a. Parser a -> Parser a
brackets (Parser (Sum ExprF (Const Import) Expr')
-> Parser (Sum ExprF (Const Import) Expr')
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser (Sum ExprF (Const Import) Expr')
arrayComp Parser (Sum ExprF (Const Import) Expr')
-> Parser (Sum ExprF (Const Import) Expr')
-> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Sum ExprF (Const Import) Expr')
array))
  where
    array :: Parser (Sum ExprF (Const Import) Expr')
array = [Expr'] -> Sum ExprF (Const Import) Expr'
forall a. [a] -> ExprF' a
mkArrayF ([Expr'] -> Sum ExprF (Const Import) Expr')
-> ParsecT Void Text Identity [Expr']
-> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parsec Void Text Expr'
exprP Parsec Void Text Expr'
-> Parser Text -> ParsecT Void Text Identity [Expr']
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
`sepEndBy` Parser Text
comma)
    arrayComp :: Parser (Sum ExprF (Const Import) Expr')
arrayComp = do
      Expr'
expr <- Parsec Void Text Expr'
exprP Parsec Void Text Expr'
-> ParsecT Void Text Identity (Maybe Text)
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser Text -> ParsecT Void Text Identity (Maybe Text)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Text
comma
      NonEmpty (CompSpec Expr')
comps <- Parser (CompSpec Expr')
-> ParsecT Void Text Identity (NonEmpty (CompSpec Expr'))
forall (m :: * -> *) a. MonadPlus m => m a -> m (NonEmpty a)
NE.some Parser (CompSpec Expr')
forspecP
      Sum ExprF (Const Import) Expr'
-> Parser (Sum ExprF (Const Import) Expr')
forall (m :: * -> *) a. Monad m => a -> m a
return (Sum ExprF (Const Import) Expr'
 -> Parser (Sum ExprF (Const Import) Expr'))
-> Sum ExprF (Const Import) Expr'
-> Parser (Sum ExprF (Const Import) Expr')
forall a b. (a -> b) -> a -> b
$ Expr'
-> NonEmpty (CompSpec Expr') -> Sum ExprF (Const Import) Expr'
forall a. a -> NonEmpty (CompSpec a) -> ExprF' a
mkArrCompF Expr'
expr NonEmpty (CompSpec Expr')
comps

objectP :: Parser Expr'
objectP :: Parsec Void Text Expr'
objectP = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc (Parser (Sum ExprF (Const Import) Expr')
-> Parser (Sum ExprF (Const Import) Expr')
forall a. Parser a -> Parser a
braces (Parser (Sum ExprF (Const Import) Expr')
-> Parser (Sum ExprF (Const Import) Expr')
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser (Sum ExprF (Const Import) Expr')
objectComp Parser (Sum ExprF (Const Import) Expr')
-> Parser (Sum ExprF (Const Import) Expr')
-> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Sum ExprF (Const Import) Expr')
object))
  where
    object :: Parser (Sum ExprF (Const Import) Expr')
object = do
      [Either (FilePath, Expr') (EField Expr')]
xs <- Parser (FilePath, Expr')
-> ParsecT Void Text Identity (EField Expr')
-> ParsecT
     Void Text Identity (Either (FilePath, Expr') (EField Expr'))
forall (m :: * -> *) a b.
Alternative m =>
m a -> m b -> m (Either a b)
eitherP Parser (FilePath, Expr')
localP ParsecT Void Text Identity (EField Expr')
fieldP ParsecT
  Void Text Identity (Either (FilePath, Expr') (EField Expr'))
-> Parser Text
-> ParsecT
     Void Text Identity [Either (FilePath, Expr') (EField Expr')]
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
`sepEndBy` Parser Text
comma
      let ([(FilePath, Expr')]
ls, [EField Expr']
fs) = ([Either (FilePath, Expr') (EField Expr')] -> [(FilePath, Expr')]
forall a b. [Either a b] -> [a]
lefts [Either (FilePath, Expr') (EField Expr')]
xs, [Either (FilePath, Expr') (EField Expr')] -> [EField Expr']
forall a b. [Either a b] -> [b]
rights [Either (FilePath, Expr') (EField Expr')]
xs)
      Sum ExprF (Const Import) Expr'
-> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Sum ExprF (Const Import) Expr'
 -> Parser (Sum ExprF (Const Import) Expr'))
-> Sum ExprF (Const Import) Expr'
-> Parser (Sum ExprF (Const Import) Expr')
forall a b. (a -> b) -> a -> b
$ [EField Expr']
-> [(FilePath, Expr')] -> Sum ExprF (Const Import) Expr'
forall a. [EField a] -> [(FilePath, a)] -> ExprF' a
mkObjectF [EField Expr']
fs [(FilePath, Expr')]
ls
    fieldP :: ParsecT Void Text Identity (EField Expr')
fieldP = ParsecT Void Text Identity (EField Expr')
-> ParsecT Void Text Identity (EField Expr')
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ParsecT Void Text Identity (EField Expr')
methodP ParsecT Void Text Identity (EField Expr')
-> ParsecT Void Text Identity (EField Expr')
-> ParsecT Void Text Identity (EField Expr')
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity (EField Expr')
pairP
    pairP :: ParsecT Void Text Identity (EField Expr')
pairP = do
      Expr'
key <- Parsec Void Text Expr'
keyP
      (Bool
override, Visibility
visibility) <-
        (,)
          (Bool -> Visibility -> (Bool, Visibility))
-> ParsecT Void Text Identity Bool
-> ParsecT Void Text Identity (Visibility -> (Bool, Visibility))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool
-> ParsecT Void Text Identity Bool
-> ParsecT Void Text Identity Bool
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Bool
False (Text -> Parser Text
symbol Text
"+" Parser Text -> Bool -> ParsecT Void Text Identity Bool
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool
True) ParsecT Void Text Identity (Visibility -> (Bool, Visibility))
-> ParsecT Void Text Identity Visibility
-> ParsecT Void Text Identity (Bool, Visibility)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Visibility
sepP
      Expr'
value <- Parsec Void Text Expr'
exprP
      EField Expr' -> ParsecT Void Text Identity (EField Expr')
forall (f :: * -> *) a. Applicative f => a -> f a
pure (EField Expr' -> ParsecT Void Text Identity (EField Expr'))
-> EField Expr' -> ParsecT Void Text Identity (EField Expr')
forall a b. (a -> b) -> a -> b
$ EField :: forall a. a -> a -> Visibility -> Bool -> EField a
EField {Bool
Expr'
Visibility
override :: Bool
visibility :: Visibility
value :: Expr'
key :: Expr'
value :: Expr'
visibility :: Visibility
override :: Bool
key :: Expr'
..}
    keyP :: Parsec Void Text Expr'
keyP = Parsec Void Text Expr' -> Parsec Void Text Expr'
forall a. Parser a -> Parser a
brackets Parsec Void Text Expr'
exprP Parsec Void Text Expr'
-> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parsec Void Text Expr'
unquoted Parsec Void Text Expr'
-> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parsec Void Text Expr'
stringP
    methodP :: ParsecT Void Text Identity (EField Expr')
methodP = do
      let override :: Bool
override = Bool
False
      Expr'
key <- Parsec Void Text Expr'
unquoted
      [Param Expr']
ps <- Parser [Param Expr']
paramsP
      Visibility
visibility <- ParsecT Void Text Identity Visibility
sepP
      Expr'
value <- Parser [Param Expr']
-> Parsec Void Text Expr' -> Parsec Void Text Expr'
function ([Param Expr'] -> Parser [Param Expr']
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Param Expr']
ps) Parsec Void Text Expr'
exprP
      EField Expr' -> ParsecT Void Text Identity (EField Expr')
forall (f :: * -> *) a. Applicative f => a -> f a
pure (EField Expr' -> ParsecT Void Text Identity (EField Expr'))
-> EField Expr' -> ParsecT Void Text Identity (EField Expr')
forall a b. (a -> b) -> a -> b
$ EField :: forall a. a -> a -> Visibility -> Bool -> EField a
EField {Bool
Expr'
Visibility
value :: Expr'
visibility :: Visibility
key :: Expr'
override :: Bool
override :: Bool
visibility :: Visibility
value :: Expr'
key :: Expr'
..}
    sepP :: ParsecT Void Text Identity Visibility
sepP =
      ParsecT Void Text Identity Visibility
-> ParsecT Void Text Identity Visibility
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Text -> Parser Text
symbol Text
":::" Parser Text -> Visibility -> ParsecT Void Text Identity Visibility
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Visibility
Forced)
        ParsecT Void Text Identity Visibility
-> ParsecT Void Text Identity Visibility
-> ParsecT Void Text Identity Visibility
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity Visibility
-> ParsecT Void Text Identity Visibility
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Text -> Parser Text
symbol Text
"::" Parser Text -> Visibility -> ParsecT Void Text Identity Visibility
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Visibility
Hidden)
        ParsecT Void Text Identity Visibility
-> ParsecT Void Text Identity Visibility
-> ParsecT Void Text Identity Visibility
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Text -> Parser Text
symbol Text
":" Parser Text -> Visibility -> ParsecT Void Text Identity Visibility
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Visibility
Visible
    localP :: Parser (FilePath, Expr')
localP = do
      Text
_ <- Text -> Parser Text
keywordP Text
"local"
      Parser (FilePath, Expr') -> Parser (FilePath, Expr')
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser (FilePath, Expr')
binding Parser (FilePath, Expr')
-> Parser (FilePath, Expr') -> Parser (FilePath, Expr')
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (FilePath, Expr')
localFunc
    objectComp :: Parser (Sum ExprF (Const Import) Expr')
objectComp = do
      [(FilePath, Expr')]
locals1 <- Parser (FilePath, Expr')
localP Parser (FilePath, Expr')
-> Parser Text -> ParsecT Void Text Identity [(FilePath, Expr')]
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
`sepEndBy` Parser Text
comma
      EField Expr'
expr <- ParsecT Void Text Identity (EField Expr')
pairP ParsecT Void Text Identity (EField Expr')
-> ParsecT Void Text Identity (Maybe Text)
-> ParsecT Void Text Identity (EField Expr')
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser Text -> ParsecT Void Text Identity (Maybe Text)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Text
comma
      [(FilePath, Expr')]
locals2 <- Parser (FilePath, Expr')
localP Parser (FilePath, Expr')
-> Parser Text -> ParsecT Void Text Identity [(FilePath, Expr')]
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
`sepEndBy` Parser Text
comma
      NonEmpty (CompSpec Expr')
comps <- Parser (CompSpec Expr')
-> ParsecT Void Text Identity (NonEmpty (CompSpec Expr'))
forall (m :: * -> *) a. MonadPlus m => m a -> m (NonEmpty a)
NE.some Parser (CompSpec Expr')
forspecP
      Sum ExprF (Const Import) Expr'
-> Parser (Sum ExprF (Const Import) Expr')
forall (m :: * -> *) a. Monad m => a -> m a
return (Sum ExprF (Const Import) Expr'
 -> Parser (Sum ExprF (Const Import) Expr'))
-> Sum ExprF (Const Import) Expr'
-> Parser (Sum ExprF (Const Import) Expr')
forall a b. (a -> b) -> a -> b
$ EField Expr'
-> [(FilePath, Expr')]
-> NonEmpty (CompSpec Expr')
-> Sum ExprF (Const Import) Expr'
forall a.
EField a -> [(FilePath, a)] -> NonEmpty (CompSpec a) -> ExprF' a
mkObjCompF EField Expr'
expr ([(FilePath, Expr')]
locals1 [(FilePath, Expr')] -> [(FilePath, Expr')] -> [(FilePath, Expr')]
forall a. Semigroup a => a -> a -> a
<> [(FilePath, Expr')]
locals2) NonEmpty (CompSpec Expr')
comps

importP :: Parser Expr'
importP :: Parsec Void Text Expr'
importP = Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr'
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr' -> Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
-> Parsec Void Text Expr'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Sum ExprF (Const Import) Expr')
-> ParsecT
     Void
     Text
     Identity
     (Product (Const SrcSpan) (Sum ExprF (Const Import)) Expr')
forall (f :: * -> *) a. Parser (f a) -> Parser (AnnF f SrcSpan a)
annotateLoc Parser (Sum ExprF (Const Import) Expr')
forall a. ParsecT Void Text Identity (ExprF' a)
importDecl
  where
    importDecl :: ParsecT Void Text Identity (ExprF' a)
importDecl = FilePath -> ExprF' a
forall a. FilePath -> ExprF' a
mkImportF (FilePath -> ExprF' a)
-> Parser FilePath -> ParsecT Void Text Identity (ExprF' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text -> Parser Text
keywordP Text
"import" Parser Text -> Parser FilePath -> Parser FilePath
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser FilePath
stringLiteral)

binary ::
  Text ->
  (Expr' -> Expr' -> Expr') ->
  Operator Parser Expr'
binary :: Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
name Expr' -> Expr' -> Expr'
f = ParsecT Void Text Identity (Expr' -> Expr' -> Expr')
-> Operator Parser Expr'
forall (m :: * -> *) a. m (a -> a -> a) -> Operator m a
InfixL (Expr' -> Expr' -> Expr'
f (Expr' -> Expr' -> Expr')
-> Parser Text
-> ParsecT Void Text Identity (Expr' -> Expr' -> Expr')
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Text -> Parser Text
operator Text
name)
  where
    operator :: Text -> Parser Text
operator Text
sym = Parser Text -> Parser Text
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser Text -> Parser Text) -> Parser Text -> Parser Text
forall a b. (a -> b) -> a -> b
$ Text -> Parser Text
symbol Text
sym Parser Text -> Parser () -> Parser Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity Char -> Parser ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy ParsecT Void Text Identity Char
opChar
    opChar :: ParsecT Void Text Identity Char
opChar = [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 (FilePath
":~+&|^=<>*/%" :: String) ParsecT Void Text Identity Char
-> FilePath -> ParsecT Void Text Identity Char
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> FilePath -> m a
<?> FilePath
"operator"

prefix ::
  Text ->
  (Expr' -> Expr') ->
  Operator Parser Expr'
prefix :: Text -> (Expr' -> Expr') -> Operator Parser Expr'
prefix Text
name Expr' -> Expr'
f = ParsecT Void Text Identity (Expr' -> Expr')
-> Operator Parser Expr'
forall (m :: * -> *) a. m (a -> a) -> Operator m a
Prefix (Expr' -> Expr'
f (Expr' -> Expr')
-> Parser Text -> ParsecT Void Text Identity (Expr' -> Expr')
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Text -> Parser Text
symbol Text
name)

-- | associativity and operator precedence
--  1. @e(...)@ @e[...]@ @e.f@ (application and indexing)
--  2. @+@ @-@ @!@ @~@ (the unary operators)
--  3. @*@ @/@ @%@ (these, and the remainder below, are binary operators)
--  4. @+@ @-@
--  5. @<<@ @>>@
--  6. @<@ @>@ @<=@ @>=@ @in@
--  7. @==@ @!=@
--  8. @&@
--  9. @^@
-- 10. @|@
-- 11. @&&@
-- 12. @||@
-- default is associate to the left
opTable :: [[Operator Parser Expr']]
opTable :: [[Operator Parser Expr']]
opTable =
  [ [ParsecT Void Text Identity (Expr' -> Expr')
-> Operator Parser Expr'
forall (m :: * -> *) a. m (a -> a) -> Operator m a
Postfix ParsecT Void Text Identity (Expr' -> Expr')
postfixOperators],
    [ Text -> (Expr' -> Expr') -> Operator Parser Expr'
prefix Text
"+" (UnyOp -> Expr' -> Expr'
mkUnyOp UnyOp
Plus),
      Text -> (Expr' -> Expr') -> Operator Parser Expr'
prefix Text
"-" (UnyOp -> Expr' -> Expr'
mkUnyOp UnyOp
Minus),
      Text -> (Expr' -> Expr') -> Operator Parser Expr'
prefix Text
"!" (UnyOp -> Expr' -> Expr'
mkUnyOp UnyOp
LNot),
      Text -> (Expr' -> Expr') -> Operator Parser Expr'
prefix Text
"~" (UnyOp -> Expr' -> Expr'
mkUnyOp UnyOp
Compl)
    ],
    [ Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"*" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Mul),
      Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"/" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Div),
      Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"%" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Mod)
    ],
    [ Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"+" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Add),
      Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"-" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Sub),
      ParsecT Void Text Identity (Expr' -> Expr')
-> Operator Parser Expr'
forall (m :: * -> *) a. m (a -> a) -> Operator m a
Postfix ParsecT Void Text Identity (Expr' -> Expr')
postfixObjectMerge
    ],
    [ Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
">>" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
ShiftR),
      Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"<<" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
ShiftL)
    ],
    [ Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"in" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
In),
      Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
">" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Gt),
      Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"<=" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Le),
      Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
">=" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Ge),
      Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"<" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Lt)
    ],
    [ Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"==" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Eq),
      Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"!=" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Ne)
    ],
    [Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"&" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
And)],
    [Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"^" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Xor)],
    [Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"|" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Or)],
    [Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"&&" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
LAnd)],
    [Text -> (Expr' -> Expr' -> Expr') -> Operator Parser Expr'
binary Text
"||" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
LOr)]
  ]

-- | shorthand syntax for object composition:
-- when the right-hand side is an object literal the '+'
-- operator can be elided.
postfixObjectMerge :: Parser (Expr' -> Expr')
postfixObjectMerge :: ParsecT Void Text Identity (Expr' -> Expr')
postfixObjectMerge = (Expr' -> Expr' -> Expr') -> Expr' -> Expr' -> Expr'
forall a b c. (a -> b -> c) -> b -> a -> c
flip (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Add) (Expr' -> Expr' -> Expr')
-> Parsec Void Text Expr'
-> ParsecT Void Text Identity (Expr' -> Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text Expr'
objectP

-- | application, indexing and lookup: e(...) e[...] e.f
-- all have the same precedence (the highest)
postfixOperators :: Parser (Expr' -> Expr')
postfixOperators :: ParsecT Void Text Identity (Expr' -> Expr')
postfixOperators =
  ((Expr' -> Expr') -> (Expr' -> Expr') -> Expr' -> Expr')
-> [Expr' -> Expr'] -> Expr' -> Expr'
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 (((Expr' -> Expr') -> (Expr' -> Expr') -> Expr' -> Expr')
-> (Expr' -> Expr') -> (Expr' -> Expr') -> Expr' -> Expr'
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Expr' -> Expr') -> (Expr' -> Expr') -> Expr' -> Expr'
forall b c a. (b -> c) -> (a -> b) -> a -> c
(.))
    ([Expr' -> Expr'] -> Expr' -> Expr')
-> ParsecT Void Text Identity [Expr' -> Expr']
-> ParsecT Void Text Identity (Expr' -> Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity (Expr' -> Expr')
-> ParsecT Void Text Identity [Expr' -> Expr']
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some
      ( ParsecT Void Text Identity (Expr' -> Expr')
applyP
          ParsecT Void Text Identity (Expr' -> Expr')
-> ParsecT Void Text Identity (Expr' -> Expr')
-> ParsecT Void Text Identity (Expr' -> Expr')
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity (Expr' -> Expr')
-> ParsecT Void Text Identity (Expr' -> Expr')
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ParsecT Void Text Identity (Expr' -> Expr')
sliceP
          ParsecT Void Text Identity (Expr' -> Expr')
-> ParsecT Void Text Identity (Expr' -> Expr')
-> ParsecT Void Text Identity (Expr' -> Expr')
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity (Expr' -> Expr')
indexP
          ParsecT Void Text Identity (Expr' -> Expr')
-> ParsecT Void Text Identity (Expr' -> Expr')
-> ParsecT Void Text Identity (Expr' -> Expr')
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity (Expr' -> Expr')
lookupP
      )

indexP :: Parser (Expr' -> Expr')
indexP :: ParsecT Void Text Identity (Expr' -> Expr')
indexP = (Expr' -> Expr' -> Expr') -> Expr' -> Expr' -> Expr'
forall a b c. (a -> b -> c) -> b -> a -> c
flip Expr' -> Expr' -> Expr'
mkIndex (Expr' -> Expr' -> Expr')
-> Parsec Void Text Expr'
-> ParsecT Void Text Identity (Expr' -> Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall a. Parser a -> Parser a
brackets Parsec Void Text Expr'
exprP

lookupP :: Parser (Expr' -> Expr')
lookupP :: ParsecT Void Text Identity (Expr' -> Expr')
lookupP = (Expr' -> Expr' -> Expr') -> Expr' -> Expr' -> Expr'
forall a b c. (a -> b -> c) -> b -> a -> c
flip Expr' -> Expr' -> Expr'
mkLookup (Expr' -> Expr' -> Expr')
-> Parsec Void Text Expr'
-> ParsecT Void Text Identity (Expr' -> Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text -> Parser Text
symbol Text
"." Parser Text -> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text Expr'
unquoted)

-- arguments are many postional followed by many named
-- just like Python
applyP :: Parser (Expr' -> Expr')
applyP :: ParsecT Void Text Identity (Expr' -> Expr')
applyP = (Expr' -> Args Expr' -> Expr') -> Args Expr' -> Expr' -> Expr'
forall a b c. (a -> b -> c) -> b -> a -> c
flip Expr' -> Args Expr' -> Expr'
mkApply (Args Expr' -> Expr' -> Expr')
-> ParsecT Void Text Identity (Args Expr')
-> ParsecT Void Text Identity (Expr' -> Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity (Args Expr')
argsP
  where
    argsP :: Parser (Args Expr')
    argsP :: ParsecT Void Text Identity (Args Expr')
argsP = [Arg Expr'] -> Strictness -> Args Expr'
forall a. [Arg a] -> Strictness -> Args a
Args ([Arg Expr'] -> Strictness -> Args Expr')
-> ParsecT Void Text Identity [Arg Expr']
-> ParsecT Void Text Identity (Strictness -> Args Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity [Arg Expr']
-> ParsecT Void Text Identity [Arg Expr']
forall a. Parser a -> Parser a
parens (ParsecT Void Text Identity (Arg Expr')
args ParsecT Void Text Identity (Arg Expr')
-> Parser Text -> ParsecT Void Text Identity [Arg Expr']
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
`sepEndBy` Parser Text
comma) ParsecT Void Text Identity (Strictness -> Args Expr')
-> ParsecT Void Text Identity Strictness
-> ParsecT Void Text Identity (Args Expr')
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Strictness
tailstrict
      where
        args :: ParsecT Void Text Identity (Arg Expr')
args = ParsecT Void Text Identity (Arg Expr')
-> ParsecT Void Text Identity (Arg Expr')
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ParsecT Void Text Identity (Arg Expr')
named ParsecT Void Text Identity (Arg Expr')
-> ParsecT Void Text Identity (Arg Expr')
-> ParsecT Void Text Identity (Arg Expr')
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity (Arg Expr')
posal
        posal :: ParsecT Void Text Identity (Arg Expr')
posal = Expr' -> Arg Expr'
forall a. a -> Arg a
Pos (Expr' -> Arg Expr')
-> Parsec Void Text Expr' -> ParsecT Void Text Identity (Arg Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Void Text Expr'
exprP
        named :: ParsecT Void Text Identity (Arg Expr')
named = FilePath -> Expr' -> Arg Expr'
forall a. FilePath -> a -> Arg a
Named (FilePath -> Expr' -> Arg Expr')
-> Parser FilePath
-> ParsecT Void Text Identity (Expr' -> Arg Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser FilePath
identifier ParsecT Void Text Identity (Expr' -> Arg Expr')
-> Parsec Void Text Expr' -> ParsecT Void Text Identity (Arg Expr')
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Text -> Parser Text
symbol Text
"=" Parser Text -> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text Expr'
exprP)
        tailstrict :: ParsecT Void Text Identity Strictness
tailstrict = Strictness
-> ParsecT Void Text Identity Strictness
-> ParsecT Void Text Identity Strictness
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Strictness
Lazy (Text -> Parser Text
keywordP Text
"tailstrict" Parser Text -> Strictness -> ParsecT Void Text Identity Strictness
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Strictness
Strict)

sliceP :: Parser (Expr' -> Expr')
sliceP :: ParsecT Void Text Identity (Expr' -> Expr')
sliceP = ParsecT Void Text Identity (Expr' -> Expr')
-> ParsecT Void Text Identity (Expr' -> Expr')
forall a. Parser a -> Parser a
brackets (ParsecT Void Text Identity (Expr' -> Expr')
 -> ParsecT Void Text Identity (Expr' -> Expr'))
-> ParsecT Void Text Identity (Expr' -> Expr')
-> ParsecT Void Text Identity (Expr' -> Expr')
forall a b. (a -> b) -> a -> b
$ do
  Maybe Expr'
start <- Parsec Void Text Expr' -> ParsecT Void Text Identity (Maybe Expr')
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parsec Void Text Expr'
exprP ParsecT Void Text Identity (Maybe Expr')
-> Parser Text -> ParsecT Void Text Identity (Maybe Expr')
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser Text
colon
  Maybe Expr'
end <- Parsec Void Text Expr' -> ParsecT Void Text Identity (Maybe Expr')
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parsec Void Text Expr'
exprP
  Maybe (Maybe Expr')
step <- ParsecT Void Text Identity (Maybe Expr')
-> ParsecT Void Text Identity (Maybe (Maybe Expr'))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Parser Text
colon Parser Text
-> ParsecT Void Text Identity (Maybe Expr')
-> ParsecT Void Text Identity (Maybe Expr')
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text Expr' -> ParsecT Void Text Identity (Maybe Expr')
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parsec Void Text Expr'
exprP)
  (Expr' -> Expr') -> ParsecT Void Text Identity (Expr' -> Expr')
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Expr' -> Expr') -> ParsecT Void Text Identity (Expr' -> Expr'))
-> (Expr' -> Expr') -> ParsecT Void Text Identity (Expr' -> Expr')
forall a b. (a -> b) -> a -> b
$ Maybe Expr' -> Maybe Expr' -> Maybe Expr' -> Expr' -> Expr'
mkSlice Maybe Expr'
start Maybe Expr'
end (Maybe (Maybe Expr') -> Maybe Expr'
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join Maybe (Maybe Expr')
step)

primP :: Parser Expr'
primP :: Parsec Void Text Expr'
primP =
  Parsec Void Text Expr' -> Parsec Void Text Expr'
forall a. Parser a -> Parser a
lexeme (Parsec Void Text Expr' -> Parsec Void Text Expr')
-> Parsec Void Text Expr' -> Parsec Void Text Expr'
forall a b. (a -> b) -> a -> b
$
    [Parsec Void Text Expr'] -> Parsec Void Text Expr'
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice
      [ Parsec Void Text Expr' -> Parsec Void Text Expr'
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parsec Void Text Expr'
identP,
        Parsec Void Text Expr'
numberP,
        Parsec Void Text Expr'
stringP,
        Parsec Void Text Expr'
booleanP,
        Parsec Void Text Expr'
nullP,
        Parsec Void Text Expr'
ifElseP,
        Parsec Void Text Expr'
functionP,
        Parsec Void Text Expr'
objectP,
        Parsec Void Text Expr'
arrayP,
        Parsec Void Text Expr'
localP,
        Parsec Void Text Expr'
importP,
        Parsec Void Text Expr'
errorP,
        Parsec Void Text Expr'
assertP,
        Parsec Void Text Expr' -> Parsec Void Text Expr'
forall a. Parser a -> Parser a
parens Parsec Void Text Expr'
exprP
      ]

exprP :: Parser Expr'
exprP :: Parsec Void Text Expr'
exprP = Parsec Void Text Expr'
-> [[Operator Parser Expr']] -> Parsec Void Text Expr'
forall (m :: * -> *) a.
MonadPlus m =>
m a -> [[Operator m a]] -> m a
makeExprParser Parsec Void Text Expr'
primP [[Operator Parser Expr']]
opTable

reservedKeywords :: [String]
reservedKeywords :: [FilePath]
reservedKeywords =
  [ FilePath
"assert",
    FilePath
"else",
    FilePath
"error",
    FilePath
"false",
    FilePath
"for",
    FilePath
"function",
    FilePath
"if",
    FilePath
"import",
    FilePath
"importstr",
    FilePath
"in",
    FilePath
"local",
    FilePath
"null",
    FilePath
"tailstrict",
    FilePath
"then",
    FilePath
"true"
  ]