module Hakyllbars.Source.Parser where

import Data.Functor
import Data.List.NonEmpty as NEL
import Data.Maybe
import Data.String
import Hakyllbars.Ast
import Hakyllbars.Source.Lexer
import Hakyllbars.Source.Util
import Text.Parsec hiding (parse, runParser, token, tokens, (<?>))
import qualified Text.Parsec as P
import Prelude hiding (lex)

type Parser a = Parsec [Token] ParserState a

parse :: SourceName -> String -> Either ParseError Template
parse :: SourceName -> SourceName -> Either ParseError Template
parse SourceName
origin SourceName
input = do
  [Token]
tokens <- SourceName -> SourceName -> Either ParseError [Token]
lex SourceName
origin SourceName
input
  [Block]
blocks <- forall s t a.
Stream s Identity t =>
Parsec s ParserState a -> SourceName -> s -> Either ParseError a
runParser (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser Block
block forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof) SourceName
origin [Token]
tokens
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Block] -> SourceName -> Template
Template [Block]
blocks SourceName
origin

block :: Parser Block
block :: Parser Block
block =
  forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
tryOne
    [ Parser Block
offBlock,
      Parser Block
commentBlock,
      Parser Block
chromeBlock,
      Parser Block
altBlock,
      Parser Block
expressionBlock,
      Parser Block
textBlock
    ]

commentBlock :: Parser Block
commentBlock :: Parser Block
commentBlock = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"CommentBlock" forall a b. (a -> b) -> a -> b
$
  forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
    -- {{!
    TokenTag -> Parser ()
withTag TokenTag
CommentBlockToken
    -- ...text...
    SourceName
value <- forall a. (Token -> Maybe a) -> Parser a
withToken \case
      TextToken SourceName
value SourcePos
_ -> forall a. a -> Maybe a
Just SourceName
value
      Token
_ -> forall a. Maybe a
Nothing
    -- }}
    Parser ()
closeBlock
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SourceName -> SourcePos -> Block
CommentBlock SourceName
value

offBlock :: Parser Block
offBlock :: Parser Block
offBlock = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"OffBlock" forall a b. (a -> b) -> a -> b
$
  forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
    -- {{*
    TokenTag -> Parser ()
withTag TokenTag
TurnOffToken
    -- ...text...
    SourceName
value <- forall a. (Token -> Maybe a) -> Parser a
withToken \case
      TextToken SourceName
value SourcePos
_ -> forall a. a -> Maybe a
Just SourceName
value
      Token
_ -> forall a. Maybe a
Nothing
    -- }}
    TokenTag -> Parser ()
withTag TokenTag
CloseBlockToken
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SourceName -> SourcePos -> Block
TextBlock SourceName
value

expressionBlock :: Parser Block
expressionBlock :: Parser Block
expressionBlock = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"ExpressionBlock" forall a b. (a -> b) -> a -> b
$
  forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
    -- {{
    TokenTag -> Parser ()
withTag TokenTag
ExpressionBlockToken
    -- ...1 + 2...
    Expression
e <- Parser Expression
expression
    -- }}
    Parser ()
closeBlock
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Expression -> SourcePos -> Block
ExpressionBlock Expression
e

chromeBlock :: Parser Block
chromeBlock :: Parser Block
chromeBlock = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"ChromeBlock" forall a b. (a -> b) -> a -> b
$
  forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
    -- {{@
    TokenTag -> Parser ()
withTag TokenTag
ChromeBlockToken
    -- ...layout "body"...
    Expression
e <- Parser Expression
expression
    -- }}
    Parser ()
closeBlock
    -- {{...}}+
    [Block]
bs <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser Block
block
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Expression -> [Block] -> SourcePos -> Block
ChromeBlock Expression
e [Block]
bs

altBlock :: Parser Block
altBlock :: Parser Block
altBlock = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"AltBlock" forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
  -- {{#if doThis}} <- one of these
  ApplyBlock
startAlt <- forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"StartAlt" forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
    Expression
e <- forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between Parser ()
altToken Parser ()
closeBlock Parser Expression
expression
    [Block]
bs <- forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
manyTill Parser Block
block Parser ()
closeAlt
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Expression -> [Block] -> SourcePos -> ApplyBlock
ApplyBlock Expression
e [Block]
bs
  -- {{#else doThat}} <- zero or more of these
  [ApplyBlock]
elseAlts <- forall a b c. (a -> b -> c) -> b -> a -> c
flip forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
manyTill Parser ()
closeElses forall a b. (a -> b) -> a -> b
$
    forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"ElseAlt" forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
      Expression
e <- forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (Parser ()
altToken forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ()
elseToken) Parser ()
closeBlock Parser Expression
expression
      [Block]
bs <- forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
manyTill Parser Block
block Parser ()
closeAlt
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Expression -> [Block] -> SourcePos -> ApplyBlock
ApplyBlock Expression
e [Block]
bs
  -- {{#else}} <- zero or one of these
  Maybe DefaultBlock
defaultAlt <- forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$
    forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"DefaultAlt" forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
      Parser ()
defaultBlock
      [Block]
bs <- forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
manyTill Parser Block
block Parser ()
closeDefault
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Block] -> SourcePos -> DefaultBlock
DefaultBlock [Block]
bs
  -- {{#end}}
  Parser ()
endBlock
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ NonEmpty ApplyBlock -> Maybe DefaultBlock -> SourcePos -> Block
AltBlock (ApplyBlock
startAlt forall a. a -> [a] -> NonEmpty a
:| [ApplyBlock]
elseAlts) Maybe DefaultBlock
defaultAlt
  where
    closeAlt :: Parser ()
closeAlt = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
tryOne [Parser ()
endBlock, Parser ()
defaultBlock, Parser ()
elseBlock]
    closeElses :: Parser ()
closeElses = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
tryOne [Parser ()
endBlock, Parser ()
defaultBlock]
    closeDefault :: Parser ()
closeDefault = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead forall a b. (a -> b) -> a -> b
$ forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser ()
endBlock
    --
    endBlock :: Parser ()
endBlock = Parser ()
altToken forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ()
endToken forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ()
closeBlock
    defaultBlock :: Parser ()
defaultBlock = Parser ()
altToken forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ()
elseToken forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ()
closeBlock
    elseBlock :: Parser ()
elseBlock = Parser ()
altToken forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ()
elseToken
    --
    altToken :: Parser ()
altToken = TokenTag -> Parser ()
withTag TokenTag
AltBlockToken
    elseToken :: Parser ()
elseToken = TokenTag -> Parser ()
withTag TokenTag
ElseToken
    endToken :: Parser ()
endToken = TokenTag -> Parser ()
withTag TokenTag
EndToken

textBlock :: Parser Block
textBlock :: Parser Block
textBlock = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"TextBlock" forall a b. (a -> b) -> a -> b
$
  forall a. (Token -> Maybe a) -> Parser a
withToken \case
    TextToken SourceName
x SourcePos
pos -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ SourceName -> SourcePos -> Block
TextBlock SourceName
x SourcePos
pos
    Token
_ -> forall a. Maybe a
Nothing

expression :: Parser Expression
expression :: Parser Expression
expression = Parser Expression
filterExpression forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
ParsecT s ParserState m a
-> SourceName -> ParsecT s ParserState m a
<?> SourceName
"Expression"
{-# INLINE expression #-}

filterExpression :: Parser Expression
filterExpression :: Parser Expression
filterExpression = Parser Expression
applyExpression forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
`chainl1` ParsecT
  [Token]
  ParserState
  Identity
  (Expression -> Expression -> Expression)
filtered forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
ParsecT s ParserState m a
-> SourceName -> ParsecT s ParserState m a
<?> SourceName
"FilterExpression"
  where
    filtered :: ParsecT
  [Token]
  ParserState
  Identity
  (Expression -> Expression -> Expression)
filtered = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
      TokenTag -> Parser ()
withTag TokenTag
PipeToken
      forall (m :: * -> *) a. Monad m => a -> m a
return SourcePos -> Expression -> Expression -> Expression
f
    f :: SourcePos -> Expression -> Expression -> Expression
f SourcePos
pos Expression
x Expression
y = Expression -> Expression -> SourcePos -> Expression
FilterExpression Expression
x Expression
y SourcePos
pos

applyExpression :: Parser Expression
applyExpression :: Parser Expression
applyExpression = NonEmpty Expression -> Expression
chain forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> NonEmpty a
NEL.fromList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many1 Parser Expression
accessExpression forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
ParsecT s ParserState m a
-> SourceName -> ParsecT s ParserState m a
<?> SourceName
"ApplyExpression"
  where
    chain :: NonEmpty Expression -> Expression
chain (Expression
fn :| [Expression]
args) = Expression -> [Expression] -> Expression
chain' Expression
fn [Expression]
args
    chain' :: Expression -> [Expression] -> Expression
chain' Expression
fn (Expression
arg : [Expression]
rest) = Expression -> [Expression] -> Expression
chain' (Expression -> Expression -> SourcePos -> Expression
ApplyExpression Expression
fn Expression
arg (Expression -> SourcePos
getExpressionPos Expression
arg)) [Expression]
rest
    chain' Expression
done [] = Expression
done

accessExpression :: Parser Expression
accessExpression :: Parser Expression
accessExpression = Parser Expression
simpleExpression forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
`chainl1` forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT
  [Token]
  ParserState
  Identity
  (Expression -> Expression -> Expression)
accessed forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
ParsecT s ParserState m a
-> SourceName -> ParsecT s ParserState m a
<?> SourceName
"AccessExpression"
  where
    accessed :: ParsecT
  [Token]
  ParserState
  Identity
  (Expression -> Expression -> Expression)
accessed = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
      TokenTag -> Parser ()
withTag TokenTag
DotToken
      forall (m :: * -> *) a. Monad m => a -> m a
return SourcePos -> Expression -> Expression -> Expression
f
    f :: SourcePos -> Expression -> Expression -> Expression
f SourcePos
pos Expression
x (NameExpression SourceName
id' SourcePos
pos') = SourcePos -> Expression -> Expression -> Expression
f SourcePos
pos Expression
x (SourceName -> SourcePos -> Expression
StringExpression SourceName
id' SourcePos
pos')
    f SourcePos
pos Expression
x Expression
y = Expression -> Expression -> SourcePos -> Expression
AccessExpression Expression
x Expression
y SourcePos
pos

simpleExpression :: Parser Expression
simpleExpression :: Parser Expression
simpleExpression =
  forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
tryOne
    [ Parser Expression
stringExpression,
      Parser Expression
intExpression,
      Parser Expression
doubleExpression,
      Parser Expression
boolExpression,
      Parser Expression
nameExpression,
      Parser Expression
parensExpression,
      Parser Expression
contextExpression,
      Parser Expression
listExpression
    ]

stringExpression :: Parser Expression
stringExpression :: Parser Expression
stringExpression = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"StringLiteral" forall a b. (a -> b) -> a -> b
$
  forall a. (Token -> Maybe a) -> Parser a
withToken \case
    StringToken SourceName
value SourcePos
pos -> forall a. a -> Maybe a
Just (SourceName -> SourcePos -> Expression
StringExpression SourceName
value SourcePos
pos)
    Token
_ -> forall a. Maybe a
Nothing

intExpression :: Parser Expression
intExpression :: Parser Expression
intExpression = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"IntLiteral" forall a b. (a -> b) -> a -> b
$
  forall a. (Token -> Maybe a) -> Parser a
withToken \case
    IntToken Int
value SourcePos
pos -> forall a. a -> Maybe a
Just (Int -> SourcePos -> Expression
IntExpression Int
value SourcePos
pos)
    Token
_ -> forall a. Maybe a
Nothing

doubleExpression :: Parser Expression
doubleExpression :: Parser Expression
doubleExpression = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"DoubleLiteral" forall a b. (a -> b) -> a -> b
$
  forall a. (Token -> Maybe a) -> Parser a
withToken \case
    DoubleToken Double
value SourcePos
pos -> forall a. a -> Maybe a
Just (Double -> SourcePos -> Expression
DoubleExpression Double
value SourcePos
pos)
    Token
_ -> forall a. Maybe a
Nothing

boolExpression :: Parser Expression
boolExpression :: Parser Expression
boolExpression = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"BoolLiteral" forall a b. (a -> b) -> a -> b
$
  forall a. (Token -> Maybe a) -> Parser a
withToken \case
    BoolToken Bool
value SourcePos
pos -> forall a. a -> Maybe a
Just (Bool -> SourcePos -> Expression
BoolExpression Bool
value SourcePos
pos)
    Token
_ -> forall a. Maybe a
Nothing

nameExpression :: Parser Expression
nameExpression :: Parser Expression
nameExpression = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"Name" forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
  SourcePos -> Expression
n <- SourceName -> SourcePos -> Expression
NameExpression forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SourceName
withName
  forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy forall a b. (a -> b) -> a -> b
$ TokenTag -> Parser ()
withTag TokenTag
ColonToken
  forall (m :: * -> *) a. Monad m => a -> m a
return SourcePos -> Expression
n

parensExpression :: Parser Expression
parensExpression :: Parser Expression
parensExpression = do
  TokenTag -> Parser ()
withTag TokenTag
OpenParenToken
  Expression
expression' <- Parser Expression
expression
  TokenTag -> Parser ()
withTag TokenTag
CloseParenToken
  forall (m :: * -> *) a. Monad m => a -> m a
return Expression
expression'

contextExpression :: Parser Expression
contextExpression :: Parser Expression
contextExpression =
  (Parser Expression
braced forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
ParsecT s ParserState m a
-> SourceName -> ParsecT s ParserState m a
<?> SourceName
"BracedContext")
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Parser Expression
unbraced forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
ParsecT s ParserState m a
-> SourceName -> ParsecT s ParserState m a
<?> SourceName
"UnbracedContext")
  where
    braced :: Parser Expression
braced = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
      TokenTag -> Parser ()
withTag TokenTag
OpenBraceToken
      [(SourceName, Expression)]
pairs <- Parser (SourceName, Expression)
contextKeyValue forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
`sepEndBy` Parser ()
comma
      TokenTag -> Parser ()
withTag TokenTag
CloseBraceToken
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [(SourceName, Expression)] -> SourcePos -> Expression
ContextExpression [(SourceName, Expression)]
pairs
    unbraced :: Parser Expression
unbraced = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
      [(SourceName, Expression)]
pairs <- Parser (SourceName, Expression)
contextKeyValue forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
`sepBy1` Parser ()
comma
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [(SourceName, Expression)] -> SourcePos -> Expression
ContextExpression [(SourceName, Expression)]
pairs

contextKeyValue :: Parser (String, Expression)
contextKeyValue :: Parser (SourceName, Expression)
contextKeyValue = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"ContextLiteralPair" do
  SourceName
key <- Parser SourceName
withName
  TokenTag -> Parser ()
withTag TokenTag
ColonToken
  Expression
value <- Parser Expression
expression
  forall (m :: * -> *) a. Monad m => a -> m a
return (SourceName
key, Expression
value)

listExpression :: Parser Expression
listExpression :: Parser Expression
listExpression = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"ListLiteral" do
  forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition do
    TokenTag -> Parser ()
withTag TokenTag
OpenBracketToken
    [Expression]
values <- Parser Expression
expression forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
`sepEndBy` Parser ()
comma
    TokenTag -> Parser ()
withTag TokenTag
CloseBracketToken
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Expression] -> SourcePos -> Expression
ListExpression [Expression]
values

comma :: Parser ()
comma :: Parser ()
comma =
  forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"Comma" forall a b. (a -> b) -> a -> b
$
    TokenTag -> Parser ()
withTag TokenTag
CommaToken

closeBlock :: Parser ()
closeBlock :: Parser ()
closeBlock =
  forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
SourceName
-> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled SourceName
"CloseBlock" forall a b. (a -> b) -> a -> b
$
    TokenTag -> Parser ()
withTag TokenTag
CloseBlockToken

withToken :: (Token -> Maybe a) -> Parser a
withToken :: forall a. (Token -> Maybe a) -> Parser a
withToken = forall s t a u.
Stream s Identity t =>
(t -> SourceName)
-> (t -> SourcePos) -> (t -> Maybe a) -> Parsec s u a
P.token forall a. Show a => a -> SourceName
show Token -> SourcePos
getTokenPos

withTag :: TokenTag -> Parser ()
withTag :: TokenTag -> Parser ()
withTag TokenTag
tag = forall s t a u.
Stream s Identity t =>
(t -> SourceName)
-> (t -> SourcePos) -> (t -> Maybe a) -> Parsec s u a
P.token forall a. Show a => a -> SourceName
show Token -> SourcePos
getTokenPos Token -> Maybe ()
f
  where
    f :: Token -> Maybe ()
f = \case
      TaggedToken TokenTag
t SourcePos
_ | TokenTag
t forall a. Eq a => a -> a -> Bool
== TokenTag
tag -> forall a. a -> Maybe a
Just ()
      Token
_ -> forall a. Maybe a
Nothing

withName :: Parser String
withName :: Parser SourceName
withName = forall a. (Token -> Maybe a) -> Parser a
withToken \case
  NameToken SourceName
n SourcePos
_ -> forall a. a -> Maybe a
Just SourceName
n
  Token
_ -> forall a. Maybe a
Nothing