{- |
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.

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

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 :: forall (m :: * -> *).
MonadError Error m =>
[Char] -> Text -> m Expr'
parse [Char]
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'
-> [Char] -> Text -> Either (ParseErrorBundle Text Void) Expr'
forall e s a.
Parsec e s a -> [Char] -> 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) [Char]
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 :: forall (m :: * -> *).
(MonadError Error m, MonadIO m) =>
[Char] -> Expr' -> m Expr
resolveImports [Char]
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 [Char]
fp'))) SrcSpan
a) =
      [Char] -> Expr' -> f Expr
forall (m :: * -> *).
(MonadError Error m, MonadIO m) =>
[Char] -> Expr' -> m Expr
resolveImports [Char]
fp'
        (Expr' -> f Expr) -> f Expr' -> f Expr
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Char] -> Text -> f Expr'
forall (m :: * -> *).
MonadError Error m =>
[Char] -> Text -> m Expr'
parse [Char]
fp'
        (Text -> f Expr') -> f Text -> f Expr'
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Char] -> SrcSpan -> f Text
forall {m :: * -> *}.
(MonadError Error m, MonadIO m) =>
[Char] -> SrcSpan -> m Text
readImportFile [Char]
fp' SrcSpan
a
    readImportFile :: [Char] -> SrcSpan -> m Text
readImportFile [Char]
fp' SrcSpan
a = do
      Either IOError Text
inp <- [Char] -> m (Either IOError Text)
readFile' [Char]
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' :: [Char] -> 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))
-> ([Char] -> IO (Either IOError Text))
-> [Char]
-> 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))
-> ([Char] -> IO Text) -> [Char] -> IO (Either IOError Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> IO Text -> IO Text
forall a. [Char] -> IO a -> IO a
withCurrentDirectory ([Char] -> [Char]
takeDirectory [Char]
fp)
            (IO Text -> IO Text) -> ([Char] -> IO Text) -> [Char] -> IO Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> 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 :: forall a. Parser a -> Parser a
lexeme = Parser ()
-> ParsecT Void Text Identity a -> ParsecT Void Text Identity 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 :: forall a. Parser a -> Parser a
braces = Parser Text
-> Parser Text
-> ParsecT Void Text Identity a
-> ParsecT Void Text Identity 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 :: forall a. Parser a -> Parser a
brackets = Parser Text
-> Parser Text
-> ParsecT Void Text Identity a
-> ParsecT Void Text Identity 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 :: forall a. Parser a -> Parser a
parens = Parser Text
-> Parser Text
-> ParsecT Void Text Identity a
-> ParsecT Void Text Identity 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 :: forall (f :: * -> *) a. 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 [Char]
identifier = do
  [Char]
ident <- Parser [Char]
p
  Bool -> Parser () -> Parser ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ([Char]
ident [Char] -> [[Char]] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
reservedKeywords) (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$
    [Char] -> Parser ()
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> Parser ()) -> [Char] -> Parser ()
forall a b. (a -> b) -> a -> b
$
      [Char]
"Keyword " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
ident [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" cannot be an identifier."
  [Char] -> Parser [Char]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
ident
  where
    p :: Parser [Char]
p =
      Parser [Char] -> Parser [Char]
forall a. Parser a -> Parser a
lexeme
        ( (:)
            (Char -> [Char] -> [Char])
-> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity ([Char] -> [Char])
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 ([Char] -> [Char])
-> Parser [Char] -> Parser [Char]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Char -> Parser [Char]
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 [Char]
stringLiteral = ParsecT Void Text Identity Char -> Parser [Char]
forall {end}. ParsecT Void Text Identity end -> Parser [Char]
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 [Char] -> Parser [Char] -> Parser [Char]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity Char -> Parser [Char]
forall {end}. ParsecT Void Text Identity end -> Parser [Char]
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 [Char]
quoted ParsecT Void Text Identity end
c =
      ParsecT Void Text Identity end
c
        ParsecT Void Text Identity end -> Parser [Char] -> Parser [Char]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity Char
-> ParsecT Void Text Identity end -> Parser [Char]
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"
  [Char]
hex <- ([Char]
"0x" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char]) -> Parser [Char] -> Parser [Char]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> ParsecT Void Text Identity Char -> Parser [Char]
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
$ [Char] -> Int
forall a. Read a => [Char] -> a
read [Char]
hex)

verbatimString :: Parser String
verbatimString :: Parser [Char]
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 [Char] -> Parser [Char]
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 [Char] -> Parser [Char] -> Parser [Char]
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 [Char]
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
  [Char]
x <- Parser [Char]
line
  [[Char]]
xs <-
    Parser [Char] -> Parser Text -> ParsecT Void Text Identity [[Char]]
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 [Char] -> Parser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser [Char]
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
"|||")
  [Char] -> Parser [Char]
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Char] -> Parser [Char]) -> [Char] -> Parser [Char]
forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([Char]
x [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [[Char]]
xs)
  where
    line :: Parser String
    line :: Parser [Char]
line = [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
(++) ([Char] -> [Char] -> [Char])
-> Parser [Char] -> ParsecT Void Text Identity ([Char] -> [Char])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Void Text Identity Char -> Parser [Char]
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 ([Char] -> [Char])
-> Parser [Char] -> Parser [Char]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity Char -> Parser [Char]
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 [Char] -> Parser ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Parser [Char] -> Parser ()) -> Parser [Char] -> Parser ()
forall a b. (a -> b) -> a -> b
$ ParsecT Void Text Identity Char -> Parser [Char]
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 [Char] -> Parser ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Parser [Char] -> Parser ()) -> Parser [Char] -> Parser ()
forall a b. (a -> b) -> a -> b
$ Int -> Int -> ParsecT Void Text Identity Char -> Parser [Char]
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 ([Char] -> Sum ExprF (Const Import) Expr'
forall a. [Char] -> ExprF' a
mkStrF ([Char] -> Sum ExprF (Const Import) Expr')
-> Parser [Char] -> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [Char]
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
      ( [Char] -> Sum ExprF (Const Import) Expr'
forall a. [Char] -> ExprF' a
mkStrF
          ([Char] -> Sum ExprF (Const Import) Expr')
-> Parser [Char] -> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ( Parser [Char]
verbatimString
                  Parser [Char] -> Parser [Char] -> Parser [Char]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser [Char]
stringLiteral
                  Parser [Char] -> Parser [Char] -> Parser [Char]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser [Char]
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 ([Char] -> Sum ExprF (Const Import) Expr'
forall a. [Char] -> ExprF' a
mkIdentF ([Char] -> Sum ExprF (Const Import) Expr')
-> Parser [Char] -> Parser (Sum ExprF (Const Import) Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser [Char] -> Parser [Char]
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Text -> [Char]
T.unpack (Text -> [Char]) -> Parser Text -> Parser [Char]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Parser Text
symbol Text
"$") Parser [Char] -> Parser [Char] -> Parser [Char]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser [Char]
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 = (,) ([Char] -> Maybe Expr' -> Param Expr')
-> Parser [Char]
-> ParsecT Void Text Identity (Maybe Expr' -> Param Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [Char]
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"
  [Char]
var <- Parser [Char]
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. [Char] -> a -> Maybe a -> CompSpec a
CompSpec {[Char]
Maybe Expr'
Expr'
ifspec :: Maybe Expr'
forspec :: Expr'
var :: [Char]
ifspec :: Maybe Expr'
forspec :: Expr'
var :: [Char]
..}

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

localFunc :: Parser (String, Expr')
localFunc :: Parser ([Char], Expr')
localFunc = do
  [Char]
name <- Parser [Char]
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
  ([Char], Expr') -> Parser ([Char], Expr')
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Char]
name, Expr'
expr)

localBndsP :: Parser (NonEmpty (String, Expr'))
localBndsP :: Parser (NonEmpty ([Char], Expr'))
localBndsP = do
  Text
_ <- Text -> Parser Text
keywordP Text
"local"
  (Parser ([Char], Expr') -> Parser ([Char], Expr')
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser ([Char], Expr')
binding Parser ([Char], Expr')
-> Parser ([Char], Expr') -> Parser ([Char], Expr')
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ([Char], Expr')
localFunc) Parser ([Char], Expr')
-> Parser Text -> Parser (NonEmpty ([Char], 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 ([Char], Expr')
bnds <- Parser (NonEmpty ([Char], Expr'))
localBndsP
      Text
_ <- Text -> Parser Text
symbol Text
";"
      NonEmpty ([Char], Expr') -> Expr' -> Sum ExprF (Const Import) Expr'
forall a. NonEmpty ([Char], a) -> a -> ExprF' a
mkLocalF NonEmpty ([Char], 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 ([Char], Expr') (EField Expr')]
xs <- Parser ([Char], Expr')
-> ParsecT Void Text Identity (EField Expr')
-> ParsecT
     Void Text Identity (Either ([Char], Expr') (EField Expr'))
forall (m :: * -> *) a b.
Alternative m =>
m a -> m b -> m (Either a b)
eitherP Parser ([Char], Expr')
localP ParsecT Void Text Identity (EField Expr')
fieldP ParsecT Void Text Identity (Either ([Char], Expr') (EField Expr'))
-> Parser Text
-> ParsecT
     Void Text Identity [Either ([Char], Expr') (EField Expr')]
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
`sepEndBy` Parser Text
comma
      let ([([Char], Expr')]
ls, [EField Expr']
fs) = ([Either ([Char], Expr') (EField Expr')] -> [([Char], Expr')]
forall a b. [Either a b] -> [a]
lefts [Either ([Char], Expr') (EField Expr')]
xs, [Either ([Char], Expr') (EField Expr')] -> [EField Expr']
forall a b. [Either a b] -> [b]
rights [Either ([Char], 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']
-> [([Char], Expr')] -> Sum ExprF (Const Import) Expr'
forall a. [EField a] -> [([Char], a)] -> ExprF' a
mkObjectF [EField Expr']
fs [([Char], 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 ([Char], Expr')
localP = do
      Text
_ <- Text -> Parser Text
keywordP Text
"local"
      Parser ([Char], Expr') -> Parser ([Char], Expr')
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser ([Char], Expr')
binding Parser ([Char], Expr')
-> Parser ([Char], Expr') -> Parser ([Char], Expr')
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ([Char], Expr')
localFunc
    objectComp :: Parser (Sum ExprF (Const Import) Expr')
objectComp = do
      [([Char], Expr')]
locals1 <- Parser ([Char], Expr')
localP Parser ([Char], Expr')
-> Parser Text -> ParsecT Void Text Identity [([Char], 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
      [([Char], Expr')]
locals2 <- Parser ([Char], Expr')
localP Parser ([Char], Expr')
-> Parser Text -> ParsecT Void Text Identity [([Char], 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'
-> [([Char], Expr')]
-> NonEmpty (CompSpec Expr')
-> Sum ExprF (Const Import) Expr'
forall a.
EField a -> [([Char], a)] -> NonEmpty (CompSpec a) -> ExprF' a
mkObjCompF EField Expr'
expr ([([Char], Expr')]
locals1 [([Char], Expr')] -> [([Char], Expr')] -> [([Char], Expr')]
forall a. Semigroup a => a -> a -> a
<> [([Char], 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 = [Char] -> ExprF' a
forall a. [Char] -> ExprF' a
mkImportF ([Char] -> ExprF' a)
-> Parser [Char] -> 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 [Char] -> Parser [Char]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser [Char]
stringLiteral)

binary ::
  Text ->
  (Expr' -> Expr' -> Expr') ->
  Operator Parser Expr'
binary :: Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
name Expr' -> Expr' -> Expr'
f = ParsecT Void Text Identity (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) 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 ([Char]
":~+&|^=<>*/%" :: String) ParsecT Void Text Identity Char
-> [Char] -> ParsecT Void Text Identity Char
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"operator"

prefix ::
  Text ->
  (Expr' -> Expr') ->
  Operator Parser Expr'
prefix :: Text
-> (Expr' -> Expr') -> Operator (ParsecT Void Text Identity) Expr'
prefix Text
name Expr' -> Expr'
f = ParsecT Void Text Identity (Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) 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 (ParsecT Void Text Identity) Expr']]
opTable =
  [ [ParsecT Void Text Identity (Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
forall (m :: * -> *) a. m (a -> a) -> Operator m a
Postfix ParsecT Void Text Identity (Expr' -> Expr')
postfixOperators],
    [ Text
-> (Expr' -> Expr') -> Operator (ParsecT Void Text Identity) Expr'
prefix Text
"+" (UnyOp -> Expr' -> Expr'
mkUnyOp UnyOp
Plus),
      Text
-> (Expr' -> Expr') -> Operator (ParsecT Void Text Identity) Expr'
prefix Text
"-" (UnyOp -> Expr' -> Expr'
mkUnyOp UnyOp
Minus),
      Text
-> (Expr' -> Expr') -> Operator (ParsecT Void Text Identity) Expr'
prefix Text
"!" (UnyOp -> Expr' -> Expr'
mkUnyOp UnyOp
LNot),
      Text
-> (Expr' -> Expr') -> Operator (ParsecT Void Text Identity) Expr'
prefix Text
"~" (UnyOp -> Expr' -> Expr'
mkUnyOp UnyOp
Compl)
    ],
    [ Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"*" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Mul),
      Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"/" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Div),
      Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"%" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Mod)
    ],
    [ Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"+" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Add),
      Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"-" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Sub),
      ParsecT Void Text Identity (Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
forall (m :: * -> *) a. m (a -> a) -> Operator m a
Postfix ParsecT Void Text Identity (Expr' -> Expr')
postfixObjectMerge
    ],
    [ Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
">>" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
ShiftR),
      Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"<<" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
ShiftL)
    ],
    [ Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"in" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
In),
      Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
">" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Gt),
      Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"<=" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Le),
      Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
">=" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Ge),
      Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"<" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Lt)
    ],
    [ Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"==" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Eq),
      Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"!=" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Ne)
    ],
    [Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"&" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
And)],
    [Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"^" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Xor)],
    [Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"|" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
Or)],
    [Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) Expr'
binary Text
"&&" (BinOp -> Expr' -> Expr' -> Expr'
mkBinOp BinOp
LAnd)],
    [Text
-> (Expr' -> Expr' -> Expr')
-> Operator (ParsecT Void Text Identity) 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 = [Char] -> Expr' -> Arg Expr'
forall a. [Char] -> a -> Arg a
Named ([Char] -> Expr' -> Arg Expr')
-> Parser [Char] -> ParsecT Void Text Identity (Expr' -> Arg Expr')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [Char]
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 (ParsecT Void Text Identity) Expr']]
-> Parsec Void Text Expr'
forall (m :: * -> *) a.
MonadPlus m =>
m a -> [[Operator m a]] -> m a
makeExprParser Parsec Void Text Expr'
primP [[Operator (ParsecT Void Text Identity) Expr']]
opTable

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