-----------------------------------------------------------------------------
-- |
-- Module      :  Sindre.Parser
-- License     :  MIT-style (see LICENSE)
--
-- Stability   :  provisional
-- Portability :  portable
--
-- Parser for the Sindre programming language.  The documentation for
-- this module does not include a description of the language syntax.
--
-----------------------------------------------------------------------------
module Sindre.Parser( parseSindre
                    , parseInteger
                    )
    where

import Sindre.Sindre hiding (SourcePos, position, string)
import qualified Sindre.Sindre as Sindre

import System.Console.GetOpt

import Text.Parsec hiding ((<|>), many, optional)
import Text.Parsec.Expr
import Text.Parsec.String
import Text.Parsec.Token (LanguageDef, GenLanguageDef(..))
import qualified Text.Parsec.Token as P

import Control.Applicative
import Control.Monad.Identity
import Data.Char hiding (Control)
import Data.Function
import Data.List hiding (insert)
import Data.Maybe
import qualified Data.Map as M
import qualified Data.Set as S

-- | @parseSindre prog filename string@ extends the 'Program' @prog@
-- with the declarations in the given Sindre source code.  In case of
-- mutually-exclusive definitions (such as the @BEGIN@ block, or
-- identically named functions), the new definitions in @string@ take
-- precedence.
parseSindre :: Program -> SourceName -> String -> Either ParseError Program
parseSindre :: Program -> SourceName -> SourceName -> Either ParseError Program
parseSindre Program
prog = Parsec SourceName () Program
-> SourceName -> SourceName -> Either ParseError Program
forall s t a.
Stream s Identity t =>
Parsec s () a -> SourceName -> s -> Either ParseError a
parse (GenTokenParser SourceName () Identity
-> ParsecT SourceName () Identity ()
forall s u (m :: * -> *). GenTokenParser s u m -> ParsecT s u m ()
P.whiteSpace GenTokenParser SourceName () Identity
lexer ParsecT SourceName () Identity ()
-> Parsec SourceName () Program -> Parsec SourceName () Program
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Program -> Parsec SourceName () Program
sindre Program
prog)

-- | Try to parse an integer according to the Sindre syntax, ignoring
-- trailing whitespace.
parseInteger :: String -> Maybe Double
parseInteger :: SourceName -> Maybe Double
parseInteger = (ParseError -> Maybe Double)
-> (Double -> Maybe Double)
-> Either ParseError Double
-> Maybe Double
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe Double -> ParseError -> Maybe Double
forall a b. a -> b -> a
const Maybe Double
forall a. Maybe a
Nothing) Double -> Maybe Double
forall a. a -> Maybe a
Just (Either ParseError Double -> Maybe Double)
-> (SourceName -> Either ParseError Double)
-> SourceName
-> Maybe Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
               Parsec SourceName () Double
-> SourceName -> SourceName -> Either ParseError Double
forall s t a.
Stream s Identity t =>
Parsec s () a -> SourceName -> s -> Either ParseError a
parse (Parsec SourceName () Double
decimal Parsec SourceName () Double
-> ParsecT SourceName () Identity () -> Parsec SourceName () Double
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT SourceName () Identity ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof) SourceName
""

data Directive = GUIDirective (Maybe (P Expr), GUI)
               | ActionDirective (Pattern, Action)
               | GlobalDirective (Identifier, P Expr)
               | FuncDirective (Identifier, Function)
               | OptDirective (Identifier, (SindreOption, Maybe Value))
               | BeginDirective [P Stmt]

definedBy :: [Directive] -> S.Set Identifier
definedBy :: [Directive] -> Set SourceName
definedBy = (Directive -> Set SourceName -> Set SourceName)
-> Set SourceName -> [Directive] -> Set SourceName
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Directive -> Set SourceName -> Set SourceName
f Set SourceName
forall a. Set a
S.empty
    where f :: Directive -> Set SourceName -> Set SourceName
f (GlobalDirective (SourceName
k, P Expr
_)) = SourceName -> Set SourceName -> Set SourceName
forall a. Ord a => a -> Set a -> Set a
S.insert SourceName
k
          f (OptDirective (SourceName
k, (SindreOption, Maybe Value)
_)) = SourceName -> Set SourceName -> Set SourceName
forall a. Ord a => a -> Set a -> Set a
S.insert SourceName
k
          f Directive
_ = Set SourceName -> Set SourceName
forall a. a -> a
id

getGUI :: [Directive] -> Either String (Maybe (Maybe (P Expr), GUI))
getGUI :: [Directive] -> Either SourceName (Maybe (Maybe (P Expr), GUI))
getGUI [Directive]
ds  = case ([(Maybe (P Expr), GUI)] -> Directive -> [(Maybe (P Expr), GUI)])
-> [(Maybe (P Expr), GUI)]
-> [Directive]
-> [(Maybe (P Expr), GUI)]
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl [(Maybe (P Expr), GUI)] -> Directive -> [(Maybe (P Expr), GUI)]
f [] [Directive]
ds of
               [(Maybe (P Expr), GUI)
gui'] -> Maybe (Maybe (P Expr), GUI)
-> Either SourceName (Maybe (Maybe (P Expr), GUI))
forall a b. b -> Either a b
Right (Maybe (Maybe (P Expr), GUI)
 -> Either SourceName (Maybe (Maybe (P Expr), GUI)))
-> Maybe (Maybe (P Expr), GUI)
-> Either SourceName (Maybe (Maybe (P Expr), GUI))
forall a b. (a -> b) -> a -> b
$ (Maybe (P Expr), GUI) -> Maybe (Maybe (P Expr), GUI)
forall a. a -> Maybe a
Just (Maybe (P Expr), GUI)
gui'
               []     -> Maybe (Maybe (P Expr), GUI)
-> Either SourceName (Maybe (Maybe (P Expr), GUI))
forall a b. b -> Either a b
Right Maybe (Maybe (P Expr), GUI)
forall a. Maybe a
Nothing
               [(Maybe (P Expr), GUI)]
_      -> SourceName -> Either SourceName (Maybe (Maybe (P Expr), GUI))
forall a b. a -> Either a b
Left SourceName
"Multiple GUI definitions"
    where f :: [(Maybe (P Expr), GUI)] -> Directive -> [(Maybe (P Expr), GUI)]
f [(Maybe (P Expr), GUI)]
l (GUIDirective (Maybe (P Expr), GUI)
x) = (Maybe (P Expr), GUI)
x(Maybe (P Expr), GUI)
-> [(Maybe (P Expr), GUI)] -> [(Maybe (P Expr), GUI)]
forall a. a -> [a] -> [a]
:[(Maybe (P Expr), GUI)]
l
          f [(Maybe (P Expr), GUI)]
l Directive
_                      = [(Maybe (P Expr), GUI)]
l

getActions :: [P Directive] -> [P (Pattern, Action)]
getActions :: [P Directive] -> [P (Pattern, Action)]
getActions = ([P (Pattern, Action)] -> P Directive -> [P (Pattern, Action)])
-> [P (Pattern, Action)] -> [P Directive] -> [P (Pattern, Action)]
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl [P (Pattern, Action)] -> P Directive -> [P (Pattern, Action)]
f []
    where f :: [P (Pattern, Action)] -> P Directive -> [P (Pattern, Action)]
f [P (Pattern, Action)]
l (P SourcePos
p (ActionDirective (Pattern, Action)
x)) = SourcePos -> (Pattern, Action) -> P (Pattern, Action)
forall a. SourcePos -> a -> P a
P SourcePos
p (Pattern, Action)
xP (Pattern, Action)
-> [P (Pattern, Action)] -> [P (Pattern, Action)]
forall a. a -> [a] -> [a]
:[P (Pattern, Action)]
l
          f [P (Pattern, Action)]
l P Directive
_                         = [P (Pattern, Action)]
l

getGlobals :: [P Directive] -> [P (Identifier, P Expr)]
getGlobals :: [P Directive] -> [P (SourceName, P Expr)]
getGlobals = ([P (SourceName, P Expr)]
 -> P Directive -> [P (SourceName, P Expr)])
-> [P (SourceName, P Expr)]
-> [P Directive]
-> [P (SourceName, P Expr)]
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl [P (SourceName, P Expr)] -> P Directive -> [P (SourceName, P Expr)]
f []
    where f :: [P (SourceName, P Expr)] -> P Directive -> [P (SourceName, P Expr)]
f [P (SourceName, P Expr)]
m (P SourcePos
p (GlobalDirective (SourceName, P Expr)
x)) = SourcePos -> (SourceName, P Expr) -> P (SourceName, P Expr)
forall a. SourcePos -> a -> P a
P SourcePos
p (SourceName, P Expr)
xP (SourceName, P Expr)
-> [P (SourceName, P Expr)] -> [P (SourceName, P Expr)]
forall a. a -> [a] -> [a]
:[P (SourceName, P Expr)]
m
          f [P (SourceName, P Expr)]
m       P Directive
_                   = [P (SourceName, P Expr)]
m

getFunctions :: [P Directive] -> [P (Identifier, Function)]
getFunctions :: [P Directive] -> [P (SourceName, Function)]
getFunctions = ([P (SourceName, Function)]
 -> P Directive -> [P (SourceName, Function)])
-> [P (SourceName, Function)]
-> [P Directive]
-> [P (SourceName, Function)]
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl [P (SourceName, Function)]
-> P Directive -> [P (SourceName, Function)]
f []
    where f :: [P (SourceName, Function)]
-> P Directive -> [P (SourceName, Function)]
f [P (SourceName, Function)]
m (P SourcePos
p (FuncDirective (SourceName, Function)
x)) = SourcePos -> (SourceName, Function) -> P (SourceName, Function)
forall a. SourcePos -> a -> P a
P SourcePos
p (SourceName, Function)
xP (SourceName, Function)
-> [P (SourceName, Function)] -> [P (SourceName, Function)]
forall a. a -> [a] -> [a]
:[P (SourceName, Function)]
m
          f [P (SourceName, Function)]
m P Directive
_                       = [P (SourceName, Function)]
m

getOptions :: [P Directive] -> [P (Identifier, (SindreOption, Maybe Value))]
getOptions :: [P Directive] -> [P (SourceName, (SindreOption, Maybe Value))]
getOptions = ([P (SourceName, (SindreOption, Maybe Value))]
 -> P Directive -> [P (SourceName, (SindreOption, Maybe Value))])
-> [P (SourceName, (SindreOption, Maybe Value))]
-> [P Directive]
-> [P (SourceName, (SindreOption, Maybe Value))]
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl [P (SourceName, (SindreOption, Maybe Value))]
-> P Directive -> [P (SourceName, (SindreOption, Maybe Value))]
f []
    where f :: [P (SourceName, (SindreOption, Maybe Value))]
-> P Directive -> [P (SourceName, (SindreOption, Maybe Value))]
f [P (SourceName, (SindreOption, Maybe Value))]
m (P SourcePos
p (OptDirective (SourceName, (SindreOption, Maybe Value))
x)) = SourcePos
-> (SourceName, (SindreOption, Maybe Value))
-> P (SourceName, (SindreOption, Maybe Value))
forall a. SourcePos -> a -> P a
P SourcePos
p (SourceName, (SindreOption, Maybe Value))
xP (SourceName, (SindreOption, Maybe Value))
-> [P (SourceName, (SindreOption, Maybe Value))]
-> [P (SourceName, (SindreOption, Maybe Value))]
forall a. a -> [a] -> [a]
:[P (SourceName, (SindreOption, Maybe Value))]
m
          f [P (SourceName, (SindreOption, Maybe Value))]
m P Directive
_                      = [P (SourceName, (SindreOption, Maybe Value))]
m

getBegin :: [Directive] -> [P Stmt]
getBegin :: [Directive] -> [P Stmt]
getBegin = ([P Stmt] -> Directive -> [P Stmt])
-> [P Stmt] -> [Directive] -> [P Stmt]
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl [P Stmt] -> Directive -> [P Stmt]
f []
    where f :: [P Stmt] -> Directive -> [P Stmt]
f [P Stmt]
m (BeginDirective [P Stmt]
x) = [P Stmt]
m[P Stmt] -> [P Stmt] -> [P Stmt]
forall a. [a] -> [a] -> [a]
++[P Stmt]
x
          f [P Stmt]
m Directive
_                        = [P Stmt]
m

applyDirectives :: [P Directive] -> Program -> Either String Program
applyDirectives :: [P Directive] -> Program -> Either SourceName Program
applyDirectives [P Directive]
ds Program
prog = do
  let prog' :: Program
prog' = Program
prog {
                programActions :: [P (Pattern, Action)]
programActions = [P Directive] -> [P (Pattern, Action)]
getActions [P Directive]
ds [P (Pattern, Action)]
-> [P (Pattern, Action)] -> [P (Pattern, Action)]
forall a. [a] -> [a] -> [a]
++ Program -> [P (Pattern, Action)]
programActions Program
prog
              , programGlobals :: [P (SourceName, P Expr)]
programGlobals = [P (SourceName, P Expr)]
globals' [P (SourceName, P Expr)]
-> [P (SourceName, P Expr)] -> [P (SourceName, P Expr)]
forall a. [a] -> [a] -> [a]
++ [P Directive] -> [P (SourceName, P Expr)]
getGlobals [P Directive]
ds
              , programFunctions :: [P (SourceName, Function)]
programFunctions =
                  [P (SourceName, Function)]
-> [P (SourceName, Function)] -> [P (SourceName, Function)]
forall b.
[P (SourceName, b)] -> [P (SourceName, b)] -> [P (SourceName, b)]
merge ([P Directive] -> [P (SourceName, Function)]
getFunctions [P Directive]
ds) (Program -> [P (SourceName, Function)]
programFunctions Program
prog)
              , programOptions :: [P (SourceName, (SindreOption, Maybe Value))]
programOptions = [P (SourceName, (SindreOption, Maybe Value))]
options' [P (SourceName, (SindreOption, Maybe Value))]
-> [P (SourceName, (SindreOption, Maybe Value))]
-> [P (SourceName, (SindreOption, Maybe Value))]
forall a. [a] -> [a] -> [a]
++ [P Directive] -> [P (SourceName, (SindreOption, Maybe Value))]
getOptions [P Directive]
ds
              , programBegin :: [P Stmt]
programBegin = [Directive] -> [P Stmt]
getBegin [Directive]
ds' [P Stmt] -> [P Stmt] -> [P Stmt]
forall a. [a] -> [a] -> [a]
++ Program -> [P Stmt]
programBegin Program
prog
              }
  Program
-> ((Maybe (P Expr), GUI) -> Program)
-> Maybe (Maybe (P Expr), GUI)
-> Program
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Program
prog' (\(Maybe (P Expr), GUI)
gui' -> Program
prog' { programGUI :: (Maybe (P Expr), GUI)
programGUI = (Maybe (P Expr), GUI)
gui' }) (Maybe (Maybe (P Expr), GUI) -> Program)
-> Either SourceName (Maybe (Maybe (P Expr), GUI))
-> Either SourceName Program
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Directive] -> Either SourceName (Maybe (Maybe (P Expr), GUI))
getGUI [Directive]
ds'
    where options' :: [P (SourceName, (SindreOption, Maybe Value))]
options' = (P (SourceName, (SindreOption, Maybe Value)) -> Bool)
-> [P (SourceName, (SindreOption, Maybe Value))]
-> [P (SourceName, (SindreOption, Maybe Value))]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool)
-> (P (SourceName, (SindreOption, Maybe Value)) -> Bool)
-> P (SourceName, (SindreOption, Maybe Value))
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceName -> Bool
hasNewDef (SourceName -> Bool)
-> (P (SourceName, (SindreOption, Maybe Value)) -> SourceName)
-> P (SourceName, (SindreOption, Maybe Value))
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceName, (SindreOption, Maybe Value)) -> SourceName
forall a b. (a, b) -> a
fst ((SourceName, (SindreOption, Maybe Value)) -> SourceName)
-> (P (SourceName, (SindreOption, Maybe Value))
    -> (SourceName, (SindreOption, Maybe Value)))
-> P (SourceName, (SindreOption, Maybe Value))
-> SourceName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. P (SourceName, (SindreOption, Maybe Value))
-> (SourceName, (SindreOption, Maybe Value))
forall a. P a -> a
unP) (Program -> [P (SourceName, (SindreOption, Maybe Value))]
programOptions Program
prog)
          globals' :: [P (SourceName, P Expr)]
globals' = (P (SourceName, P Expr) -> Bool)
-> [P (SourceName, P Expr)] -> [P (SourceName, P Expr)]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool)
-> (P (SourceName, P Expr) -> Bool)
-> P (SourceName, P Expr)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceName -> Bool
hasNewDef (SourceName -> Bool)
-> (P (SourceName, P Expr) -> SourceName)
-> P (SourceName, P Expr)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceName, P Expr) -> SourceName
forall a b. (a, b) -> a
fst ((SourceName, P Expr) -> SourceName)
-> (P (SourceName, P Expr) -> (SourceName, P Expr))
-> P (SourceName, P Expr)
-> SourceName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. P (SourceName, P Expr) -> (SourceName, P Expr)
forall a. P a -> a
unP) (Program -> [P (SourceName, P Expr)]
programGlobals Program
prog)
          hasNewDef :: SourceName -> Bool
hasNewDef SourceName
k = SourceName -> Set SourceName -> Bool
forall a. Ord a => a -> Set a -> Bool
S.member SourceName
k (Set SourceName -> Bool) -> Set SourceName -> Bool
forall a b. (a -> b) -> a -> b
$ [Directive] -> Set SourceName
definedBy [Directive]
ds'
          merge :: [P (SourceName, b)] -> [P (SourceName, b)] -> [P (SourceName, b)]
merge = (P (SourceName, b) -> P (SourceName, b) -> Bool)
-> [P (SourceName, b)]
-> [P (SourceName, b)]
-> [P (SourceName, b)]
forall a. (a -> a -> Bool) -> [a] -> [a] -> [a]
unionBy (SourceName -> SourceName -> Bool
forall a. Eq a => a -> a -> Bool
(==) (SourceName -> SourceName -> Bool)
-> (P (SourceName, b) -> SourceName)
-> P (SourceName, b)
-> P (SourceName, b)
-> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` (SourceName, b) -> SourceName
forall a b. (a, b) -> a
fst ((SourceName, b) -> SourceName)
-> (P (SourceName, b) -> (SourceName, b))
-> P (SourceName, b)
-> SourceName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. P (SourceName, b) -> (SourceName, b)
forall a. P a -> a
unP)
          ds' :: [Directive]
ds' = (P Directive -> Directive) -> [P Directive] -> [Directive]
forall a b. (a -> b) -> [a] -> [b]
map P Directive -> Directive
forall a. P a -> a
unP [P Directive]
ds

position :: Parser (String, Int, Int)
position :: Parser SourcePos
position = do SourcePos
pos <- ParsecT SourceName () Identity SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
              SourcePos -> Parser SourcePos
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SourcePos -> SourceName
sourceName SourcePos
pos, SourcePos -> Line
sourceLine SourcePos
pos, SourcePos -> Line
sourceColumn SourcePos
pos)

node :: Parser a -> Parser (P a)
node :: Parser a -> Parser (P a)
node Parser a
p = (SourcePos -> a -> P a)
-> ParsecT SourceName () Identity (SourcePos -> a -> P a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure SourcePos -> a -> P a
forall a. SourcePos -> a -> P a
P ParsecT SourceName () Identity (SourcePos -> a -> P a)
-> Parser SourcePos -> ParsecT SourceName () Identity (a -> P a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SourcePos
position ParsecT SourceName () Identity (a -> P a)
-> Parser a -> Parser (P a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a
p

sindre :: Program -> Parser Program
sindre :: Program -> Parsec SourceName () Program
sindre Program
prog = do [P Directive]
ds <- [P Directive] -> [P Directive]
forall a. [a] -> [a]
reverse ([P Directive] -> [P Directive])
-> ParsecT SourceName () Identity [P Directive]
-> ParsecT SourceName () Identity [P Directive]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity (P Directive)
-> ParsecT SourceName () Identity [P Directive]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many ParsecT SourceName () Identity (P Directive)
directive ParsecT SourceName () Identity [P Directive]
-> ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity [P Directive]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT SourceName () Identity ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof
                 (SourceName -> Parsec SourceName () Program)
-> (Program -> Parsec SourceName () Program)
-> Either SourceName Program
-> Parsec SourceName () Program
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either SourceName -> Parsec SourceName () Program
forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail Program -> Parsec SourceName () Program
forall (m :: * -> *) a. Monad m => a -> m a
return (Either SourceName Program -> Parsec SourceName () Program)
-> Either SourceName Program -> Parsec SourceName () Program
forall a b. (a -> b) -> a -> b
$ [P Directive] -> Program -> Either SourceName Program
applyDirectives [P Directive]
ds Program
prog

directive :: Parser (P Directive)
directive :: ParsecT SourceName () Identity (P Directive)
directive = ParsecT SourceName () Identity (P Directive)
directive' ParsecT SourceName () Identity (P Directive)
-> ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (P Directive)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany ParsecT SourceName () Identity SourceName
semi
    where directive' :: ParsecT SourceName () Identity (P Directive)
directive' = Parser Directive -> ParsecT SourceName () Identity (P Directive)
forall a. Parser a -> Parser (P a)
node (Parser Directive -> ParsecT SourceName () Identity (P Directive))
-> Parser Directive -> ParsecT SourceName () Identity (P Directive)
forall a b. (a -> b) -> a -> b
$
                           [P Stmt] -> Directive
BeginDirective ([P Stmt] -> Directive)
-> ParsecT SourceName () Identity [P Stmt] -> Parser Directive
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity [P Stmt]
begindef
                       Parser Directive -> Parser Directive -> Parser Directive
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Pattern, Action) -> Directive
ActionDirective ((Pattern, Action) -> Directive)
-> ParsecT SourceName () Identity (Pattern, Action)
-> Parser Directive
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity (Pattern, Action)
reaction
                       Parser Directive -> Parser Directive -> Parser Directive
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Maybe (P Expr), GUI) -> Directive
GUIDirective ((Maybe (P Expr), GUI) -> Directive)
-> ParsecT SourceName () Identity (Maybe (P Expr), GUI)
-> Parser Directive
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity (Maybe (P Expr), GUI)
gui
                       Parser Directive -> Parser Directive -> Parser Directive
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (SourceName, P Expr) -> Directive
GlobalDirective ((SourceName, P Expr) -> Directive)
-> ParsecT SourceName () Identity (SourceName, P Expr)
-> Parser Directive
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity (SourceName, P Expr)
constdef
                       Parser Directive -> Parser Directive -> Parser Directive
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (SourceName, Function) -> Directive
FuncDirective ((SourceName, Function) -> Directive)
-> ParsecT SourceName () Identity (SourceName, Function)
-> Parser Directive
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity (SourceName, Function)
functiondef
                       Parser Directive -> Parser Directive -> Parser Directive
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (SourceName, (SindreOption, Maybe Value)) -> Directive
OptDirective ((SourceName, (SindreOption, Maybe Value)) -> Directive)
-> ParsecT
     SourceName () Identity (SourceName, (SindreOption, Maybe Value))
-> Parser Directive
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  SourceName () Identity (SourceName, (SindreOption, Maybe Value))
optiondef

gui :: Parser (Maybe (P Expr), GUI)
gui :: ParsecT SourceName () Identity (Maybe (P Expr), GUI)
gui = SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"GUI" ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (Maybe (P Expr), GUI)
-> ParsecT SourceName () Identity (Maybe (P Expr), GUI)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT SourceName () Identity (Maybe (P Expr), GUI)
-> ParsecT SourceName () Identity (Maybe (P Expr), GUI)
forall a. Parser a -> Parser a
braces ParsecT SourceName () Identity (Maybe (P Expr), GUI)
gui'
      ParsecT SourceName () Identity (Maybe (P Expr), GUI)
-> SourceName
-> ParsecT SourceName () Identity (Maybe (P Expr), GUI)
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> SourceName
"GUI definition"
    where gui' :: ParsecT SourceName () Identity (Maybe (P Expr), GUI)
gui' = do
            Maybe SourceName
name' <- ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity SourceName
name
            P SourceName
clss <- ParsecT SourceName () Identity SourceName -> Parser (P SourceName)
forall a. Parser a -> Parser (P a)
node ParsecT SourceName () Identity SourceName
className
            Map SourceName (P Expr)
args' <- [(SourceName, P Expr)] -> Map SourceName (P Expr)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(SourceName, P Expr)] -> Map SourceName (P Expr))
-> ParsecT SourceName () Identity [(SourceName, P Expr)]
-> ParsecT SourceName () Identity (Map SourceName (P Expr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity [(SourceName, P Expr)]
args ParsecT SourceName () Identity (Map SourceName (P Expr))
-> ParsecT SourceName () Identity (Map SourceName (P Expr))
-> ParsecT SourceName () Identity (Map SourceName (P Expr))
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Map SourceName (P Expr)
-> ParsecT SourceName () Identity (Map SourceName (P Expr))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Map SourceName (P Expr)
forall k a. Map k a
M.empty
            Maybe (P Expr)
orient' <- ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (Maybe (P Expr))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity (P Expr)
orient
            [(Maybe (P Expr), GUI)]
children' <- ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
children ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
-> ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
-> ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [(Maybe (P Expr), GUI)]
-> ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
            (Maybe (P Expr), GUI)
-> ParsecT SourceName () Identity (Maybe (P Expr), GUI)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (P Expr)
orient',
                    GUI :: Maybe SourceName
-> P SourceName
-> Map SourceName (P Expr)
-> [(Maybe (P Expr), GUI)]
-> GUI
GUI { widgetName :: Maybe SourceName
widgetName = Maybe SourceName
name'
                       , widgetClass :: P SourceName
widgetClass = P SourceName
clss
                       , widgetArgs :: Map SourceName (P Expr)
widgetArgs = Map SourceName (P Expr)
args'
                       , widgetChildren :: [(Maybe (P Expr), GUI)]
widgetChildren = [(Maybe (P Expr), GUI)]
children'
                       })
          name :: ParsecT SourceName () Identity SourceName
name = ParsecT SourceName () Identity SourceName
varName ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity SourceName
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourceName -> ParsecT SourceName () Identity ()
reservedOp SourceName
"="
          args :: ParsecT SourceName () Identity [(SourceName, P Expr)]
args = ParsecT SourceName () Identity [(SourceName, P Expr)]
-> ParsecT SourceName () Identity [(SourceName, P Expr)]
forall a. Parser a -> Parser a
parens (ParsecT SourceName () Identity [(SourceName, P Expr)]
 -> ParsecT SourceName () Identity [(SourceName, P Expr)])
-> ParsecT SourceName () Identity [(SourceName, P Expr)]
-> ParsecT SourceName () Identity [(SourceName, P Expr)]
forall a b. (a -> b) -> a -> b
$ ParsecT SourceName () Identity (SourceName, P Expr)
-> ParsecT SourceName () Identity [(SourceName, P Expr)]
forall a. Parser a -> Parser [a]
commaSep ParsecT SourceName () Identity (SourceName, P Expr)
arg
          arg :: ParsecT SourceName () Identity (SourceName, P Expr)
arg = (SourceName -> P Expr -> (SourceName, P Expr))
-> ParsecT
     SourceName
     ()
     Identity
     (SourceName -> P Expr -> (SourceName, P Expr))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (,) ParsecT
  SourceName
  ()
  Identity
  (SourceName -> P Expr -> (SourceName, P Expr))
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (P Expr -> (SourceName, P Expr))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity SourceName
varName ParsecT SourceName () Identity (P Expr -> (SourceName, P Expr))
-> ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (P Expr -> (SourceName, P Expr))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourceName -> ParsecT SourceName () Identity ()
reservedOp SourceName
"=" ParsecT SourceName () Identity (P Expr -> (SourceName, P Expr))
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (SourceName, P Expr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (P Expr)
expression
          children :: ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
children = ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
-> ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
forall a. Parser a -> Parser a
braces (ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
 -> ParsecT SourceName () Identity [(Maybe (P Expr), GUI)])
-> ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
-> ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
forall a b. (a -> b) -> a -> b
$ ParsecT SourceName () Identity (Maybe (P Expr), GUI)
-> ParsecT SourceName () Identity [(Maybe (P Expr), GUI)]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (ParsecT SourceName () Identity (Maybe (P Expr), GUI)
gui' ParsecT SourceName () Identity (Maybe (P Expr), GUI)
-> ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (Maybe (P Expr), GUI)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany ParsecT SourceName () Identity SourceName
semi)
          orient :: ParsecT SourceName () Identity (P Expr)
orient = SourceName -> ParsecT SourceName () Identity ()
reservedOp SourceName
"@" ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT SourceName () Identity (P Expr)
expression

functiondef :: Parser (Identifier, Function)
functiondef :: ParsecT SourceName () Identity (SourceName, Function)
functiondef = SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"function" ParsecT SourceName () Identity ()
-> ParsecT
     SourceName
     ()
     Identity
     (SourceName -> Function -> (SourceName, Function))
-> ParsecT
     SourceName
     ()
     Identity
     (SourceName -> Function -> (SourceName, Function))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (SourceName -> Function -> (SourceName, Function))
-> ParsecT
     SourceName
     ()
     Identity
     (SourceName -> Function -> (SourceName, Function))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (,)
              ParsecT
  SourceName
  ()
  Identity
  (SourceName -> Function -> (SourceName, Function))
-> ParsecT SourceName () Identity SourceName
-> ParsecT
     SourceName () Identity (Function -> (SourceName, Function))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT SourceName () Identity SourceName
varName ParsecT SourceName () Identity (Function -> (SourceName, Function))
-> ParsecT SourceName () Identity Function
-> ParsecT SourceName () Identity (SourceName, Function)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity Function
function
              ParsecT SourceName () Identity (SourceName, Function)
-> SourceName
-> ParsecT SourceName () Identity (SourceName, Function)
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> SourceName
"function definition"
    where function :: ParsecT SourceName () Identity Function
function = ([SourceName] -> [P Stmt] -> Function)
-> ParsecT
     SourceName () Identity ([SourceName] -> [P Stmt] -> Function)
forall (f :: * -> *) a. Applicative f => a -> f a
pure [SourceName] -> [P Stmt] -> Function
Function 
                     ParsecT
  SourceName () Identity ([SourceName] -> [P Stmt] -> Function)
-> ParsecT SourceName () Identity [SourceName]
-> ParsecT SourceName () Identity ([P Stmt] -> Function)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity [SourceName]
-> ParsecT SourceName () Identity [SourceName]
forall a. Parser a -> Parser a
parens (ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity [SourceName]
forall a. Parser a -> Parser [a]
commaSep ParsecT SourceName () Identity SourceName
varName)
                     ParsecT SourceName () Identity ([P Stmt] -> Function)
-> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity Function
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall a. Parser a -> Parser a
braces ParsecT SourceName () Identity [P Stmt]
statements

optiondef :: Parser (Identifier, (SindreOption, Maybe Value))
optiondef :: ParsecT
  SourceName () Identity (SourceName, (SindreOption, Maybe Value))
optiondef = SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"option" ParsecT SourceName () Identity ()
-> ParsecT
     SourceName () Identity (SourceName, (SindreOption, Maybe Value))
-> ParsecT
     SourceName () Identity (SourceName, (SindreOption, Maybe Value))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> do
              SourceName
var <- ParsecT SourceName () Identity SourceName
varName
              ((SindreOption, Maybe Value)
 -> (SourceName, (SindreOption, Maybe Value)))
-> ParsecT
     SourceName
     ()
     Identity
     ((SindreOption, Maybe Value)
      -> (SourceName, (SindreOption, Maybe Value)))
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((,) SourceName
var) ParsecT
  SourceName
  ()
  Identity
  ((SindreOption, Maybe Value)
   -> (SourceName, (SindreOption, Maybe Value)))
-> ParsecT SourceName () Identity (SindreOption, Maybe Value)
-> ParsecT
     SourceName () Identity (SourceName, (SindreOption, Maybe Value))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (SindreOption, Maybe Value)
-> ParsecT SourceName () Identity (SindreOption, Maybe Value)
forall a. Parser a -> Parser a
parens (SourceName
-> ParsecT SourceName () Identity (SindreOption, Maybe Value)
forall k.
Ord k =>
k
-> ParsecT
     SourceName
     ()
     Identity
     (OptDescr (Map k SourceName -> Map k SourceName), Maybe Value)
option' SourceName
var)
              ParsecT
  SourceName () Identity (SourceName, (SindreOption, Maybe Value))
-> SourceName
-> ParsecT
     SourceName () Identity (SourceName, (SindreOption, Maybe Value))
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> SourceName
"option definition"
    where option' :: k
-> ParsecT
     SourceName
     ()
     Identity
     (OptDescr (Map k SourceName -> Map k SourceName), Maybe Value)
option' k
var = do
            Maybe Char
s <- ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity (Maybe Char)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity Char
shortopt ParsecT SourceName () Identity (Maybe Char)
-> ParsecT SourceName () Identity (Maybe SourceName)
-> ParsecT SourceName () Identity (Maybe Char)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity SourceName
comma
            Maybe SourceName
l <- ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity SourceName
longopt ParsecT SourceName () Identity (Maybe SourceName)
-> ParsecT SourceName () Identity (Maybe SourceName)
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity SourceName
comma
            Maybe SourceName
odesc <- ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity SourceName
optdesc ParsecT SourceName () Identity (Maybe SourceName)
-> ParsecT SourceName () Identity (Maybe SourceName)
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity SourceName
comma
            Maybe SourceName
adesc <- ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity SourceName
argdesc ParsecT SourceName () Identity (Maybe SourceName)
-> ParsecT SourceName () Identity (Maybe SourceName)
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity SourceName
comma
            Maybe Value
defval <- ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity (Maybe Value)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity Value
literal
            let (SourceName
s', [SourceName]
l') = (Maybe Char -> SourceName
forall a. Maybe a -> [a]
maybeToList Maybe Char
s, Maybe SourceName -> [SourceName]
forall a. Maybe a -> [a]
maybeToList Maybe SourceName
l)
            let noargfun :: ArgDescr (Map k SourceName -> Map k SourceName)
noargfun = (Map k SourceName -> Map k SourceName)
-> ArgDescr (Map k SourceName -> Map k SourceName)
forall a. a -> ArgDescr a
NoArg ((Map k SourceName -> Map k SourceName)
 -> ArgDescr (Map k SourceName -> Map k SourceName))
-> (Map k SourceName -> Map k SourceName)
-> ArgDescr (Map k SourceName -> Map k SourceName)
forall a b. (a -> b) -> a -> b
$ k -> SourceName -> Map k SourceName -> Map k SourceName
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert k
var SourceName
"true"
            let argfun :: SourceName -> ArgDescr (Map k SourceName -> Map k SourceName)
argfun = (SourceName -> Map k SourceName -> Map k SourceName)
-> SourceName -> ArgDescr (Map k SourceName -> Map k SourceName)
forall a. (SourceName -> a) -> SourceName -> ArgDescr a
ReqArg ((SourceName -> Map k SourceName -> Map k SourceName)
 -> SourceName -> ArgDescr (Map k SourceName -> Map k SourceName))
-> (SourceName -> Map k SourceName -> Map k SourceName)
-> SourceName
-> ArgDescr (Map k SourceName -> Map k SourceName)
forall a b. (a -> b) -> a -> b
$ \SourceName
arg -> k -> SourceName -> Map k SourceName -> Map k SourceName
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert k
var SourceName
arg
            (OptDescr (Map k SourceName -> Map k SourceName), Maybe Value)
-> ParsecT
     SourceName
     ()
     Identity
     (OptDescr (Map k SourceName -> Map k SourceName), Maybe Value)
forall (m :: * -> *) a. Monad m => a -> m a
return (SourceName
-> [SourceName]
-> ArgDescr (Map k SourceName -> Map k SourceName)
-> SourceName
-> OptDescr (Map k SourceName -> Map k SourceName)
forall a.
SourceName
-> [SourceName] -> ArgDescr a -> SourceName -> OptDescr a
Option SourceName
s' [SourceName]
l'
                    (ArgDescr (Map k SourceName -> Map k SourceName)
-> (SourceName -> ArgDescr (Map k SourceName -> Map k SourceName))
-> Maybe SourceName
-> ArgDescr (Map k SourceName -> Map k SourceName)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ArgDescr (Map k SourceName -> Map k SourceName)
noargfun SourceName -> ArgDescr (Map k SourceName -> Map k SourceName)
argfun Maybe SourceName
adesc)
                    (SourceName -> Maybe SourceName -> SourceName
forall a. a -> Maybe a -> a
fromMaybe SourceName
"" Maybe SourceName
odesc)
                   , Maybe Value
defval)
          shortopt :: ParsecT SourceName () Identity Char
shortopt = ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity Char
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT SourceName () Identity Char
 -> ParsecT SourceName () Identity Char)
-> ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity Char
forall a b. (a -> b) -> a -> b
$ ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity Char
forall a. Parser a -> Parser a
lexeme (ParsecT SourceName () Identity Char
 -> ParsecT SourceName () Identity Char)
-> ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity Char
forall a b. (a -> b) -> a -> b
$ Char -> ParsecT SourceName () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'-' ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT SourceName () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
alphaNum
          longopt :: ParsecT SourceName () Identity SourceName
longopt = SourceName -> ParsecT SourceName () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"--" ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT SourceName () Identity SourceName
identifier
          optdesc :: ParsecT SourceName () Identity SourceName
optdesc = ParsecT SourceName () Identity SourceName
stringLiteral
          argdesc :: ParsecT SourceName () Identity SourceName
argdesc = ParsecT SourceName () Identity SourceName
stringLiteral

begindef :: Parser [P Stmt]
begindef :: ParsecT SourceName () Identity [P Stmt]
begindef = SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"BEGIN" ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall a. Parser a -> Parser a
braces ParsecT SourceName () Identity [P Stmt]
statements

reaction :: Parser (Pattern, Action)
reaction :: ParsecT SourceName () Identity (Pattern, Action)
reaction = (Pattern -> Action -> (Pattern, Action))
-> ParsecT
     SourceName () Identity (Pattern -> Action -> (Pattern, Action))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (,) ParsecT
  SourceName () Identity (Pattern -> Action -> (Pattern, Action))
-> ParsecT SourceName () Identity Pattern
-> ParsecT SourceName () Identity (Action -> (Pattern, Action))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity Pattern
-> ParsecT SourceName () Identity Pattern
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT SourceName () Identity Pattern
pattern ParsecT SourceName () Identity (Action -> (Pattern, Action))
-> ParsecT SourceName () Identity Action
-> ParsecT SourceName () Identity (Pattern, Action)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity Action
action ParsecT SourceName () Identity (Pattern, Action)
-> SourceName -> ParsecT SourceName () Identity (Pattern, Action)
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> SourceName
"action"

constdef :: Parser (Identifier, P Expr)
constdef :: ParsecT SourceName () Identity (SourceName, P Expr)
constdef = (SourceName -> P Expr -> (SourceName, P Expr))
-> ParsecT
     SourceName
     ()
     Identity
     (SourceName -> P Expr -> (SourceName, P Expr))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (,) ParsecT
  SourceName
  ()
  Identity
  (SourceName -> P Expr -> (SourceName, P Expr))
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (P Expr -> (SourceName, P Expr))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT SourceName () Identity SourceName
varName ParsecT SourceName () Identity (P Expr -> (SourceName, P Expr))
-> ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (P Expr -> (SourceName, P Expr))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourceName -> ParsecT SourceName () Identity ()
reservedOp SourceName
"=" ParsecT SourceName () Identity (P Expr -> (SourceName, P Expr))
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (SourceName, P Expr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (P Expr)
expression

pattern :: Parser Pattern
pattern :: ParsecT SourceName () Identity Pattern
pattern = ParsecT SourceName () Identity Pattern
simplepat ParsecT SourceName () Identity Pattern
-> ParsecT SourceName () Identity (Pattern -> Pattern -> Pattern)
-> ParsecT SourceName () Identity Pattern
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` (SourceName -> ParsecT SourceName () Identity ()
reservedOp SourceName
"||" ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (Pattern -> Pattern -> Pattern)
-> ParsecT SourceName () Identity (Pattern -> Pattern -> Pattern)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Pattern -> Pattern -> Pattern)
-> ParsecT SourceName () Identity (Pattern -> Pattern -> Pattern)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Pattern -> Pattern -> Pattern
OrPattern)
    where simplepat :: ParsecT SourceName () Identity Pattern
simplepat =
                (Chord -> Pattern)
-> ParsecT SourceName () Identity (Chord -> Pattern)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Chord -> Pattern
ChordPattern ParsecT SourceName () Identity (Chord -> Pattern)
-> ParsecT SourceName () Identity Chord
-> ParsecT SourceName () Identity Pattern
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                     (SourceName -> ParsecT SourceName () Identity ()
reservedOp SourceName
"<" ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity Chord
-> ParsecT SourceName () Identity Chord
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT SourceName () Identity Chord
chord ParsecT SourceName () Identity Chord
-> ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity Chord
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourceName -> ParsecT SourceName () Identity ()
reservedOp SourceName
">")
            ParsecT SourceName () Identity Pattern
-> ParsecT SourceName () Identity Pattern
-> ParsecT SourceName () Identity Pattern
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (SourcePat -> SourceName -> [SourceName] -> Pattern)
-> ParsecT
     SourceName
     ()
     Identity
     (SourcePat -> SourceName -> [SourceName] -> Pattern)
forall (f :: * -> *) a. Applicative f => a -> f a
pure SourcePat -> SourceName -> [SourceName] -> Pattern
SourcedPattern
                    ParsecT
  SourceName
  ()
  Identity
  (SourcePat -> SourceName -> [SourceName] -> Pattern)
-> ParsecT SourceName () Identity SourcePat
-> ParsecT
     SourceName () Identity (SourceName -> [SourceName] -> Pattern)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity SourcePat
source ParsecT
  SourceName () Identity (SourceName -> [SourceName] -> Pattern)
-> ParsecT SourceName () Identity SourceName
-> ParsecT
     SourceName () Identity (SourceName -> [SourceName] -> Pattern)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourceName -> ParsecT SourceName () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"->"
                    ParsecT
  SourceName () Identity (SourceName -> [SourceName] -> Pattern)
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity ([SourceName] -> Pattern)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity SourceName
varName
                    ParsecT SourceName () Identity ([SourceName] -> Pattern)
-> ParsecT SourceName () Identity [SourceName]
-> ParsecT SourceName () Identity Pattern
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity [SourceName]
-> ParsecT SourceName () Identity [SourceName]
forall a. Parser a -> Parser a
parens (ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity [SourceName]
forall a. Parser a -> Parser [a]
commaSep ParsecT SourceName () Identity SourceName
varName)

source :: Parser SourcePat
source :: ParsecT SourceName () Identity SourcePat
source =     (SourceName -> Maybe SourceName -> SourcePat)
-> ParsecT
     SourceName
     ()
     Identity
     (SourceName -> Maybe SourceName -> SourcePat)
forall (f :: * -> *) a. Applicative f => a -> f a
pure SourceName -> Maybe SourceName -> SourcePat
NamedSource ParsecT
  SourceName
  ()
  Identity
  (SourceName -> Maybe SourceName -> SourcePat)
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName -> SourcePat)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity SourceName
varName ParsecT SourceName () Identity (Maybe SourceName -> SourcePat)
-> ParsecT SourceName () Identity (Maybe SourceName)
-> ParsecT SourceName () Identity SourcePat
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (Maybe SourceName)
field
         ParsecT SourceName () Identity SourcePat
-> ParsecT SourceName () Identity SourcePat
-> ParsecT SourceName () Identity SourcePat
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (SourceName -> SourceName -> Maybe SourceName -> SourcePat)
-> ParsecT
     SourceName
     ()
     Identity
     (SourceName -> SourceName -> Maybe SourceName -> SourcePat)
forall (f :: * -> *) a. Applicative f => a -> f a
pure SourceName -> SourceName -> Maybe SourceName -> SourcePat
GenericSource
                 ParsecT
  SourceName
  ()
  Identity
  (SourceName -> SourceName -> Maybe SourceName -> SourcePat)
-> ParsecT SourceName () Identity SourceName
-> ParsecT
     SourceName
     ()
     Identity
     (SourceName -> Maybe SourceName -> SourcePat)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Char -> ParsecT SourceName () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'$' ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT SourceName () Identity SourceName
className) ParsecT
  SourceName
  ()
  Identity
  (SourceName -> Maybe SourceName -> SourcePat)
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName -> SourcePat)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall a. Parser a -> Parser a
parens ParsecT SourceName () Identity SourceName
varName ParsecT SourceName () Identity (Maybe SourceName -> SourcePat)
-> ParsecT SourceName () Identity (Maybe SourceName)
-> ParsecT SourceName () Identity SourcePat
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (Maybe SourceName)
field
    where field :: ParsecT SourceName () Identity (Maybe SourceName)
field = ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParsecT SourceName () Identity SourceName
 -> ParsecT SourceName () Identity (Maybe SourceName))
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (Maybe SourceName)
forall a b. (a -> b) -> a -> b
$ Char -> ParsecT SourceName () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'.' ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT SourceName () Identity SourceName
varName

action :: Parser Action
action :: ParsecT SourceName () Identity Action
action = [P Stmt] -> Action
StmtAction ([P Stmt] -> Action)
-> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity Action
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall a. Parser a -> Parser a
braces ParsecT SourceName () Identity [P Stmt]
statements

key :: Parser Key
key :: Parser Key
key = do SourceName
s <- ParsecT SourceName () Identity SourceName
identifier
         case SourceName
s of [Char
c] -> Key -> Parser Key
forall (m :: * -> *) a. Monad m => a -> m a
return (Key -> Parser Key) -> Key -> Parser Key
forall a b. (a -> b) -> a -> b
$ Char -> Key
CharKey Char
c
                   SourceName
"Space" -> Key -> Parser Key
forall (m :: * -> *) a. Monad m => a -> m a
return (Key -> Parser Key) -> Key -> Parser Key
forall a b. (a -> b) -> a -> b
$ Char -> Key
CharKey Char
' '
                   SourceName
_   -> Key -> Parser Key
forall (m :: * -> *) a. Monad m => a -> m a
return (Key -> Parser Key) -> Key -> Parser Key
forall a b. (a -> b) -> a -> b
$ SourceName -> Key
CtrlKey SourceName
s

modifier :: Parser KeyModifier
modifier :: Parser KeyModifier
modifier =     SourceName -> ParsecT SourceName () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"C" ParsecT SourceName () Identity SourceName
-> Parser KeyModifier -> Parser KeyModifier
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> KeyModifier -> Parser KeyModifier
forall (m :: * -> *) a. Monad m => a -> m a
return KeyModifier
Control
           Parser KeyModifier -> Parser KeyModifier -> Parser KeyModifier
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> SourceName -> ParsecT SourceName () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"M" ParsecT SourceName () Identity SourceName
-> Parser KeyModifier -> Parser KeyModifier
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> KeyModifier -> Parser KeyModifier
forall (m :: * -> *) a. Monad m => a -> m a
return KeyModifier
Meta
           Parser KeyModifier -> Parser KeyModifier -> Parser KeyModifier
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> SourceName -> ParsecT SourceName () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"Shift" ParsecT SourceName () Identity SourceName
-> Parser KeyModifier -> Parser KeyModifier
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> KeyModifier -> Parser KeyModifier
forall (m :: * -> *) a. Monad m => a -> m a
return KeyModifier
Shift
           Parser KeyModifier -> Parser KeyModifier -> Parser KeyModifier
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> SourceName -> ParsecT SourceName () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"S" ParsecT SourceName () Identity SourceName
-> Parser KeyModifier -> Parser KeyModifier
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> KeyModifier -> Parser KeyModifier
forall (m :: * -> *) a. Monad m => a -> m a
return KeyModifier
Super
           Parser KeyModifier -> Parser KeyModifier -> Parser KeyModifier
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> SourceName -> ParsecT SourceName () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"H" ParsecT SourceName () Identity SourceName
-> Parser KeyModifier -> Parser KeyModifier
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> KeyModifier -> Parser KeyModifier
forall (m :: * -> *) a. Monad m => a -> m a
return KeyModifier
Hyper

chord :: Parser Chord
chord :: ParsecT SourceName () Identity Chord
chord = (Set KeyModifier -> Key -> Chord)
-> ParsecT SourceName () Identity (Set KeyModifier -> Key -> Chord)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (,) ParsecT SourceName () Identity (Set KeyModifier -> Key -> Chord)
-> ParsecT SourceName () Identity (Set KeyModifier)
-> ParsecT SourceName () Identity (Key -> Chord)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ([KeyModifier] -> Set KeyModifier
forall a. Ord a => [a] -> Set a
S.fromList ([KeyModifier] -> Set KeyModifier)
-> ParsecT SourceName () Identity [KeyModifier]
-> ParsecT SourceName () Identity (Set KeyModifier)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser KeyModifier -> ParsecT SourceName () Identity [KeyModifier]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser KeyModifier -> Parser KeyModifier
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser KeyModifier
modifier Parser KeyModifier
-> ParsecT SourceName () Identity Char -> Parser KeyModifier
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> ParsecT SourceName () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'-')) ParsecT SourceName () Identity (Key -> Chord)
-> Parser Key -> ParsecT SourceName () Identity Chord
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Key
key

statements :: Parser [P Stmt]
statements :: ParsecT SourceName () Identity [P Stmt]
statements = ParsecT SourceName () Identity (P Stmt)
-> ParsecT SourceName () Identity [P Stmt]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (ParsecT SourceName () Identity (P Stmt)
statement ParsecT SourceName () Identity (P Stmt)
-> ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (P Stmt)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany ParsecT SourceName () Identity SourceName
semi) ParsecT SourceName () Identity [P Stmt]
-> SourceName -> ParsecT SourceName () Identity [P Stmt]
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> SourceName
"statement"

statement :: Parser (P Stmt)
statement :: ParsecT SourceName () Identity (P Stmt)
statement = Parser Stmt -> ParsecT SourceName () Identity (P Stmt)
forall a. Parser a -> Parser (P a)
node (Parser Stmt -> ParsecT SourceName () Identity (P Stmt))
-> Parser Stmt -> ParsecT SourceName () Identity (P Stmt)
forall a b. (a -> b) -> a -> b
$     
                 Parser Stmt
printstmt
             Parser Stmt -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Stmt
quitstmt
             Parser Stmt -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Stmt
returnstmt
             Parser Stmt -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"next" ParsecT SourceName () Identity () -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Stmt -> Parser Stmt
forall (f :: * -> *) a. Applicative f => a -> f a
pure Stmt
Next)
             Parser Stmt -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"continue" ParsecT SourceName () Identity () -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Stmt -> Parser Stmt
forall (f :: * -> *) a. Applicative f => a -> f a
pure Stmt
Continue)
             Parser Stmt -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"break" ParsecT SourceName () Identity () -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Stmt -> Parser Stmt
forall (f :: * -> *) a. Applicative f => a -> f a
pure Stmt
Break)
             Parser Stmt -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Stmt
ifstmt
             Parser Stmt -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Stmt
whilestmt
             Parser Stmt -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Stmt
forstmt
             Parser Stmt -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Stmt
dostmt
             Parser Stmt -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Stmt
focusstmt
             Parser Stmt -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> P Expr -> Stmt
Expr (P Expr -> Stmt)
-> ParsecT SourceName () Identity (P Expr) -> Parser Stmt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity (P Expr)
expression
    where printstmt :: Parser Stmt
printstmt = SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"print" ParsecT SourceName () Identity () -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
                      ([P Expr] -> Stmt
Print ([P Expr] -> Stmt)
-> ParsecT SourceName () Identity [P Expr] -> Parser Stmt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity [P Expr]
forall a. Parser a -> Parser [a]
commaSep ParsecT SourceName () Identity (P Expr)
expression)
          quitstmt :: Parser Stmt
quitstmt  = SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"exit" ParsecT SourceName () Identity () -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
                      (Maybe (P Expr) -> Stmt
Exit (Maybe (P Expr) -> Stmt)
-> ParsecT SourceName () Identity (Maybe (P Expr)) -> Parser Stmt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (Maybe (P Expr))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity (P Expr)
expression)
          returnstmt :: Parser Stmt
returnstmt = SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"return" ParsecT SourceName () Identity () -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
                       (Maybe (P Expr) -> Stmt
Return (Maybe (P Expr) -> Stmt)
-> ParsecT SourceName () Identity (Maybe (P Expr)) -> Parser Stmt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (Maybe (P Expr))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT SourceName () Identity (P Expr)
expression)
          ifstmt :: Parser Stmt
ifstmt = (SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"if" ParsecT SourceName () Identity ()
-> ParsecT
     SourceName () Identity (P Expr -> [P Stmt] -> [P Stmt] -> Stmt)
-> ParsecT
     SourceName () Identity (P Expr -> [P Stmt] -> [P Stmt] -> Stmt)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (P Expr -> [P Stmt] -> [P Stmt] -> Stmt)
-> ParsecT
     SourceName () Identity (P Expr -> [P Stmt] -> [P Stmt] -> Stmt)
forall (f :: * -> *) a. Applicative f => a -> f a
pure P Expr -> [P Stmt] -> [P Stmt] -> Stmt
If)
                   ParsecT
  SourceName () Identity (P Expr -> [P Stmt] -> [P Stmt] -> Stmt)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity ([P Stmt] -> [P Stmt] -> Stmt)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall a. Parser a -> Parser a
parens ParsecT SourceName () Identity (P Expr)
expression 
                   ParsecT SourceName () Identity ([P Stmt] -> [P Stmt] -> Stmt)
-> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity ([P Stmt] -> Stmt)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall a. Parser a -> Parser a
braces ParsecT SourceName () Identity [P Stmt]
statements
                   ParsecT SourceName () Identity ([P Stmt] -> Stmt)
-> ParsecT SourceName () Identity [P Stmt] -> Parser Stmt
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (    SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"else" ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
                            ((P Stmt -> [P Stmt] -> [P Stmt]
forall a. a -> [a] -> [a]
:[]) (P Stmt -> [P Stmt])
-> ParsecT SourceName () Identity (P Stmt)
-> ParsecT SourceName () Identity [P Stmt]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Stmt -> ParsecT SourceName () Identity (P Stmt)
forall a. Parser a -> Parser (P a)
node Parser Stmt
ifstmt ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall a. Parser a -> Parser a
braces ParsecT SourceName () Identity [P Stmt]
statements)
                        ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [P Stmt] -> ParsecT SourceName () Identity [P Stmt]
forall (m :: * -> *) a. Monad m => a -> m a
return [])
          whilestmt :: Parser Stmt
whilestmt = (SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"while" ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (P Expr -> [P Stmt] -> Stmt)
-> ParsecT SourceName () Identity (P Expr -> [P Stmt] -> Stmt)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (P Expr -> [P Stmt] -> Stmt)
-> ParsecT SourceName () Identity (P Expr -> [P Stmt] -> Stmt)
forall (f :: * -> *) a. Applicative f => a -> f a
pure P Expr -> [P Stmt] -> Stmt
While)
                      ParsecT SourceName () Identity (P Expr -> [P Stmt] -> Stmt)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity ([P Stmt] -> Stmt)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall a. Parser a -> Parser a
parens ParsecT SourceName () Identity (P Expr)
expression
                      ParsecT SourceName () Identity ([P Stmt] -> Stmt)
-> ParsecT SourceName () Identity [P Stmt] -> Parser Stmt
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall a. Parser a -> Parser a
braces ParsecT SourceName () Identity [P Stmt]
statements
          forstmt :: Parser Stmt
forstmt = SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"for" ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity ([P Stmt] -> Stmt)
-> ParsecT SourceName () Identity ([P Stmt] -> Stmt)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT SourceName () Identity ([P Stmt] -> Stmt)
-> ParsecT SourceName () Identity ([P Stmt] -> Stmt)
forall a. Parser a -> Parser a
parens
                    ((P Expr -> P Expr -> P Expr -> [P Stmt] -> Stmt)
-> ParsecT
     SourceName
     ()
     Identity
     (P Expr -> P Expr -> P Expr -> [P Stmt] -> Stmt)
forall (f :: * -> *) a. Applicative f => a -> f a
pure P Expr -> P Expr -> P Expr -> [P Stmt] -> Stmt
For ParsecT
  SourceName
  ()
  Identity
  (P Expr -> P Expr -> P Expr -> [P Stmt] -> Stmt)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT
     SourceName () Identity (P Expr -> P Expr -> [P Stmt] -> Stmt)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (P Expr)
expression ParsecT
  SourceName () Identity (P Expr -> P Expr -> [P Stmt] -> Stmt)
-> ParsecT SourceName () Identity SourceName
-> ParsecT
     SourceName () Identity (P Expr -> P Expr -> [P Stmt] -> Stmt)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT SourceName () Identity SourceName
semi
                              ParsecT
  SourceName () Identity (P Expr -> P Expr -> [P Stmt] -> Stmt)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr -> [P Stmt] -> Stmt)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (P Expr)
expression ParsecT SourceName () Identity (P Expr -> [P Stmt] -> Stmt)
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity (P Expr -> [P Stmt] -> Stmt)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT SourceName () Identity SourceName
semi
                              ParsecT SourceName () Identity (P Expr -> [P Stmt] -> Stmt)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity ([P Stmt] -> Stmt)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (P Expr)
expression)
                    ParsecT SourceName () Identity ([P Stmt] -> Stmt)
-> ParsecT SourceName () Identity [P Stmt] -> Parser Stmt
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall a. Parser a -> Parser a
braces ParsecT SourceName () Identity [P Stmt]
statements
          dostmt :: Parser Stmt
dostmt = (SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"do" ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity ([P Stmt] -> P Expr -> Stmt)
-> ParsecT SourceName () Identity ([P Stmt] -> P Expr -> Stmt)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ([P Stmt] -> P Expr -> Stmt)
-> ParsecT SourceName () Identity ([P Stmt] -> P Expr -> Stmt)
forall (f :: * -> *) a. Applicative f => a -> f a
pure [P Stmt] -> P Expr -> Stmt
Do)
                   ParsecT SourceName () Identity ([P Stmt] -> P Expr -> Stmt)
-> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity (P Expr -> Stmt)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity [P Stmt]
-> ParsecT SourceName () Identity [P Stmt]
forall a. Parser a -> Parser a
braces ParsecT SourceName () Identity [P Stmt]
statements
                   ParsecT SourceName () Identity (P Expr -> Stmt)
-> ParsecT SourceName () Identity (P Expr) -> Parser Stmt
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"while" ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall a. Parser a -> Parser a
parens ParsecT SourceName () Identity (P Expr)
expression)
          focusstmt :: Parser Stmt
focusstmt = SourceName -> ParsecT SourceName () Identity ()
reserved SourceName
"focus" ParsecT SourceName () Identity () -> Parser Stmt -> Parser Stmt
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (P Expr -> Stmt
Focus (P Expr -> Stmt)
-> ParsecT SourceName () Identity (P Expr) -> Parser Stmt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity (P Expr)
expression)

keywords :: [String]
keywords :: [SourceName]
keywords = [SourceName
"if", SourceName
"else", SourceName
"while", SourceName
"for", SourceName
"do",
            SourceName
"function", SourceName
"return", SourceName
"continue", SourceName
"break",
            SourceName
"exit", SourceName
"print", SourceName
"GUI", SourceName
"option"]

sindrelang :: LanguageDef ()
sindrelang :: LanguageDef ()
sindrelang = LanguageDef :: forall s u (m :: * -> *).
SourceName
-> SourceName
-> SourceName
-> Bool
-> ParsecT s u m Char
-> ParsecT s u m Char
-> ParsecT s u m Char
-> ParsecT s u m Char
-> [SourceName]
-> [SourceName]
-> Bool
-> GenLanguageDef s u m
LanguageDef {
             commentStart :: SourceName
commentStart = SourceName
"/*"
           , commentEnd :: SourceName
commentEnd = SourceName
"*/"
           , commentLine :: SourceName
commentLine = SourceName
"//"
           , nestedComments :: Bool
nestedComments = Bool
True
           , identStart :: ParsecT SourceName () Identity Char
identStart = ParsecT SourceName () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
letter
           , identLetter :: ParsecT SourceName () Identity Char
identLetter = ParsecT SourceName () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
alphaNum ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity Char
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> ParsecT SourceName () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'_'
           , opStart :: ParsecT SourceName () Identity Char
opStart = SourceName -> ParsecT SourceName () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf SourceName
"+-/*&|;,<>"
           , opLetter :: ParsecT SourceName () Identity Char
opLetter = SourceName -> ParsecT SourceName () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf SourceName
"=+-|&"
           , reservedNames :: [SourceName]
reservedNames = [SourceName]
keywords
           , reservedOpNames :: [SourceName]
reservedOpNames = [ SourceName
"++", SourceName
"--"
                               , SourceName
"^", SourceName
"**"
                               , SourceName
"+", SourceName
"-", SourceName
"/", SourceName
"*", SourceName
"%"
                               , SourceName
"&&", SourceName
"||", SourceName
";", SourceName
","
                               , SourceName
"<", SourceName
">", SourceName
"<=", SourceName
">=", SourceName
"!="
                               , SourceName
"=", SourceName
"*=", SourceName
"/=", SourceName
"+=", SourceName
"-="
                               , SourceName
"%=", SourceName
"^="
                               , SourceName
"?", SourceName
":"]
           , caseSensitive :: Bool
caseSensitive = Bool
True
  }

exprOperators :: OperatorTable String () Identity (P Expr)
compOperators :: OperatorTable String () Identity (P Expr)
assignOperators :: OperatorTable String () Identity (P Expr)
(OperatorTable SourceName () Identity (P Expr)
exprOperators, OperatorTable SourceName () Identity (P Expr)
compOperators, OperatorTable SourceName () Identity (P Expr)
assignOperators) =
  ( [ [ SourceName
-> (P Expr -> Expr) -> Operator SourceName () Identity (P Expr)
forall a.
SourceName -> (P a -> a) -> Operator SourceName () Identity (P a)
prefix SourceName
"++" ((P Expr -> Expr) -> Operator SourceName () Identity (P Expr))
-> (P Expr -> Expr) -> Operator SourceName () Identity (P Expr)
forall a b. (a -> b) -> a -> b
$
        (P Expr -> P Expr -> Expr) -> Expr -> P Expr -> Expr
forall a. (P Expr -> P a -> Expr) -> a -> P Expr -> Expr
preop P Expr -> P Expr -> Expr
Plus (Value -> Expr
Literal (Value -> Expr) -> Value -> Expr
forall a b. (a -> b) -> a -> b
$ Double -> Value
Number Double
1)
      , SourceName
-> (P Expr -> Expr) -> Operator SourceName () Identity (P Expr)
forall a.
SourceName -> (P a -> a) -> Operator SourceName () Identity (P a)
postfix SourceName
"++" P Expr -> Expr
PostInc
      , SourceName
-> (P Expr -> Expr) -> Operator SourceName () Identity (P Expr)
forall a.
SourceName -> (P a -> a) -> Operator SourceName () Identity (P a)
prefix SourceName
"--" ((P Expr -> Expr) -> Operator SourceName () Identity (P Expr))
-> (P Expr -> Expr) -> Operator SourceName () Identity (P Expr)
forall a b. (a -> b) -> a -> b
$
        (P Expr -> P Expr -> Expr) -> Expr -> P Expr -> Expr
forall a. (P Expr -> P a -> Expr) -> a -> P Expr -> Expr
preop P Expr -> P Expr -> Expr
Plus (Value -> Expr
Literal (Value -> Expr) -> Value -> Expr
forall a b. (a -> b) -> a -> b
$ Double -> Value
Number (Double -> Value) -> Double -> Value
forall a b. (a -> b) -> a -> b
$ -Double
1)
      , SourceName
-> (P Expr -> Expr) -> Operator SourceName () Identity (P Expr)
forall a.
SourceName -> (P a -> a) -> Operator SourceName () Identity (P a)
postfix SourceName
"--" P Expr -> Expr
PostDec
      , ParsecT SourceName () Identity (P Expr -> P Expr)
-> Operator SourceName () Identity (P Expr)
forall s u (m :: * -> *) a.
ParsecT s u m (a -> a) -> Operator s u m a
Postfix (ParsecT SourceName () Identity (P Expr -> P Expr)
 -> Operator SourceName () Identity (P Expr))
-> ParsecT SourceName () Identity (P Expr -> P Expr)
-> Operator SourceName () Identity (P Expr)
forall a b. (a -> b) -> a -> b
$ do SourcePos
p <- Parser SourcePos
position
                     ParsecT SourceName () Identity (P Expr -> P Expr)
-> ParsecT SourceName () Identity (P Expr -> P Expr)
forall a. Parser a -> Parser a
brackets (ParsecT SourceName () Identity (P Expr -> P Expr)
 -> ParsecT SourceName () Identity (P Expr -> P Expr))
-> ParsecT SourceName () Identity (P Expr -> P Expr)
-> ParsecT SourceName () Identity (P Expr -> P Expr)
forall a b. (a -> b) -> a -> b
$ do
                       P Expr
idx <- ParsecT SourceName () Identity (P Expr)
expression
                       (P Expr -> P Expr)
-> ParsecT SourceName () Identity (P Expr -> P Expr)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (\P Expr
e -> SourcePos -> Expr -> P Expr
forall a. SourcePos -> a -> P a
P SourcePos
p (Expr -> P Expr) -> Expr -> P Expr
forall a b. (a -> b) -> a -> b
$ P Expr
e P Expr -> P Expr -> Expr
`Lookup` P Expr
idx)]
    , [ SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"**" P Expr -> P Expr -> Expr
RaisedTo Assoc
AssocRight
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"^" P Expr -> P Expr -> Expr
RaisedTo Assoc
AssocRight ]
    , [ SourceName
-> (P Expr -> Expr) -> Operator SourceName () Identity (P Expr)
forall a.
SourceName -> (P a -> a) -> Operator SourceName () Identity (P a)
prefix SourceName
"-" ((P Expr -> Expr) -> Operator SourceName () Identity (P Expr))
-> (P Expr -> Expr) -> Operator SourceName () Identity (P Expr)
forall a b. (a -> b) -> a -> b
$ \P Expr
e -> P Expr -> P Expr -> Expr
Times (Value -> Expr
Literal (Double -> Value
Number (Double -> Value) -> Double -> Value
forall a b. (a -> b) -> a -> b
$ -Double
1) Expr -> P Expr -> P Expr
forall a b. a -> P b -> P a
`at` P Expr
e) P Expr
e
      , SourceName
-> (P Expr -> Expr) -> Operator SourceName () Identity (P Expr)
forall a.
SourceName -> (P a -> a) -> Operator SourceName () Identity (P a)
prefix SourceName
"+" ((P Expr -> Expr) -> Operator SourceName () Identity (P Expr))
-> (P Expr -> Expr) -> Operator SourceName () Identity (P Expr)
forall a b. (a -> b) -> a -> b
$ \(P SourcePos
_ Expr
e) -> Expr
e
      , SourceName
-> (P Expr -> Expr) -> Operator SourceName () Identity (P Expr)
forall a.
SourceName -> (P a -> a) -> Operator SourceName () Identity (P a)
prefix SourceName
"!" P Expr -> Expr
Not ]
    , [ SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"*" P Expr -> P Expr -> Expr
Times Assoc
AssocLeft,
        SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"/" P Expr -> P Expr -> Expr
Divided Assoc
AssocLeft, SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"%" P Expr -> P Expr -> Expr
Modulo Assoc
AssocLeft ]
    , [ SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"+" P Expr -> P Expr -> Expr
Plus Assoc
AssocLeft, SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"-" P Expr -> P Expr -> Expr
Minus Assoc
AssocLeft ]]
  , [ [ SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"==" P Expr -> P Expr -> Expr
Equal Assoc
AssocNone 
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"<" P Expr -> P Expr -> Expr
LessThan Assoc
AssocNone 
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
">" ((P Expr -> P Expr -> Expr) -> P Expr -> P Expr -> Expr
forall a b c. (a -> b -> c) -> b -> a -> c
flip P Expr -> P Expr -> Expr
LessThan) Assoc
AssocNone 
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"<=" P Expr -> P Expr -> Expr
LessEql Assoc
AssocNone
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
">=" ((P Expr -> P Expr -> Expr) -> P Expr -> P Expr -> Expr
forall a b c. (a -> b -> c) -> b -> a -> c
flip P Expr -> P Expr -> Expr
LessEql) Assoc
AssocNone
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"!=" (\P Expr
e1 P Expr
e2 -> P Expr -> Expr
Not (P Expr -> Expr) -> P Expr -> Expr
forall a b. (a -> b) -> a -> b
$ P Expr -> P Expr -> Expr
Equal P Expr
e1 P Expr
e2 Expr -> P Expr -> P Expr
forall a b. a -> P b -> P a
`at` P Expr
e1) Assoc
AssocNone ]
    , [ SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"&&" (\P Expr
x P Expr
y -> P Expr -> P Expr -> P Expr -> Expr
Cond P Expr
x P Expr
y (P Expr -> Expr) -> P Expr -> Expr
forall a b. (a -> b) -> a -> b
$ Value -> Expr
Literal Value
falsity Expr -> P Expr -> P Expr
forall a b. a -> P b -> P a
`at` P Expr
x) Assoc
AssocRight ]
    , [ SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"||" (\P Expr
x P Expr
y -> P Expr -> P Expr -> P Expr -> Expr
Cond P Expr
x (Value -> Expr
Literal Value
truth Expr -> P Expr -> P Expr
forall a b. a -> P b -> P a
`at` P Expr
x) P Expr
y) Assoc
AssocRight ]]
  , [ [ SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"=" P Expr -> P Expr -> Expr
Assign Assoc
AssocRight
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"*=" ((P Expr -> P Expr -> Expr) -> P Expr -> P Expr -> Expr
forall t. (P Expr -> t -> Expr) -> P Expr -> t -> Expr
inplace P Expr -> P Expr -> Expr
Times) Assoc
AssocLeft
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"/=" ((P Expr -> P Expr -> Expr) -> P Expr -> P Expr -> Expr
forall t. (P Expr -> t -> Expr) -> P Expr -> t -> Expr
inplace P Expr -> P Expr -> Expr
Divided) Assoc
AssocLeft
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"+=" ((P Expr -> P Expr -> Expr) -> P Expr -> P Expr -> Expr
forall t. (P Expr -> t -> Expr) -> P Expr -> t -> Expr
inplace P Expr -> P Expr -> Expr
Plus) Assoc
AssocLeft
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"-=" ((P Expr -> P Expr -> Expr) -> P Expr -> P Expr -> Expr
forall t. (P Expr -> t -> Expr) -> P Expr -> t -> Expr
inplace P Expr -> P Expr -> Expr
Minus) Assoc
AssocLeft
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"%=" ((P Expr -> P Expr -> Expr) -> P Expr -> P Expr -> Expr
forall t. (P Expr -> t -> Expr) -> P Expr -> t -> Expr
inplace P Expr -> P Expr -> Expr
Modulo) Assoc
AssocLeft
      , SourceName
-> (P Expr -> P Expr -> Expr)
-> Assoc
-> Operator SourceName () Identity (P Expr)
forall a.
SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary SourceName
"^=" ((P Expr -> P Expr -> Expr) -> P Expr -> P Expr -> Expr
forall t. (P Expr -> t -> Expr) -> P Expr -> t -> Expr
inplace P Expr -> P Expr -> Expr
RaisedTo) Assoc
AssocLeft]])
    where binary :: SourceName
-> (P a -> P a -> a)
-> Assoc
-> Operator SourceName () Identity (P a)
binary  SourceName
name P a -> P a -> a
fun       = ParsecT SourceName () Identity (P a -> P a -> P a)
-> Assoc -> Operator SourceName () Identity (P a)
forall s u (m :: * -> *) a.
ParsecT s u m (a -> a -> a) -> Assoc -> Operator s u m a
Infix (ParsecT SourceName () Identity (P a -> P a -> P a)
 -> Assoc -> Operator SourceName () Identity (P a))
-> ParsecT SourceName () Identity (P a -> P a -> P a)
-> Assoc
-> Operator SourceName () Identity (P a)
forall a b. (a -> b) -> a -> b
$ do
                                     SourcePos
p <- Parser SourcePos
position
                                     SourceName -> ParsecT SourceName () Identity ()
reservedOp SourceName
name
                                     (P a -> P a -> P a)
-> ParsecT SourceName () Identity (P a -> P a -> P a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (\P a
e1 P a
e2 -> SourcePos -> a -> P a
forall a. SourcePos -> a -> P a
P SourcePos
p (a -> P a) -> a -> P a
forall a b. (a -> b) -> a -> b
$ P a -> P a -> a
fun P a
e1 P a
e2)
          unary :: SourceName -> (a -> a) -> ParsecT SourceName () Identity (a -> P a)
unary   SourceName
name a -> a
fun       = do SourcePos
p <- Parser SourcePos
position
                                      SourceName -> ParsecT SourceName () Identity ()
reservedOp SourceName
name
                                      (a -> P a) -> ParsecT SourceName () Identity (a -> P a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((a -> P a) -> ParsecT SourceName () Identity (a -> P a))
-> (a -> P a) -> ParsecT SourceName () Identity (a -> P a)
forall a b. (a -> b) -> a -> b
$ SourcePos -> a -> P a
forall a. SourcePos -> a -> P a
P SourcePos
p (a -> P a) -> (a -> a) -> a -> P a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
fun
          prefix :: SourceName -> (P a -> a) -> Operator SourceName () Identity (P a)
prefix  SourceName
name P a -> a
fun       = ParsecT SourceName () Identity (P a -> P a)
-> Operator SourceName () Identity (P a)
forall s u (m :: * -> *) a.
ParsecT s u m (a -> a) -> Operator s u m a
Prefix (ParsecT SourceName () Identity (P a -> P a)
 -> Operator SourceName () Identity (P a))
-> ParsecT SourceName () Identity (P a -> P a)
-> Operator SourceName () Identity (P a)
forall a b. (a -> b) -> a -> b
$ SourceName
-> (P a -> a) -> ParsecT SourceName () Identity (P a -> P a)
forall a a.
SourceName -> (a -> a) -> ParsecT SourceName () Identity (a -> P a)
unary SourceName
name P a -> a
fun
          postfix :: SourceName -> (P a -> a) -> Operator SourceName () Identity (P a)
postfix SourceName
name P a -> a
fun       = ParsecT SourceName () Identity (P a -> P a)
-> Operator SourceName () Identity (P a)
forall s u (m :: * -> *) a.
ParsecT s u m (a -> a) -> Operator s u m a
Postfix (ParsecT SourceName () Identity (P a -> P a)
 -> Operator SourceName () Identity (P a))
-> ParsecT SourceName () Identity (P a -> P a)
-> Operator SourceName () Identity (P a)
forall a b. (a -> b) -> a -> b
$ SourceName
-> (P a -> a) -> ParsecT SourceName () Identity (P a -> P a)
forall a a.
SourceName -> (a -> a) -> ParsecT SourceName () Identity (a -> P a)
unary SourceName
name P a -> a
fun
          inplace :: (P Expr -> t -> Expr) -> P Expr -> t -> Expr
inplace P Expr -> t -> Expr
op e1 :: P Expr
e1@(P SourcePos
pos Expr
_) t
e2 = P Expr
e1 P Expr -> P Expr -> Expr
`Assign` SourcePos -> Expr -> P Expr
forall a. SourcePos -> a -> P a
P SourcePos
pos (P Expr
e1 P Expr -> t -> Expr
`op` t
e2)
          preop :: (P Expr -> P a -> Expr) -> a -> P Expr -> Expr
preop P Expr -> P a -> Expr
op a
e1 e2 :: P Expr
e2@(P SourcePos
pos Expr
_) = P Expr
e2 P Expr -> P Expr -> Expr
`Assign` SourcePos -> Expr -> P Expr
forall a. SourcePos -> a -> P a
P SourcePos
pos (P Expr
e2 P Expr -> P a -> Expr
`op` SourcePos -> a -> P a
forall a. SourcePos -> a -> P a
P SourcePos
pos a
e1)

expression :: Parser (P Expr)
expression :: ParsecT SourceName () Identity (P Expr)
expression = ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT SourceName () Identity (P Expr)
condexp ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT SourceName () Identity (P Expr)
expr1 ParsecT SourceName () Identity (P Expr)
-> SourceName -> ParsecT SourceName () Identity (P Expr)
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> SourceName
"expression"
    where condexp :: ParsecT SourceName () Identity (P Expr)
condexp = Parser Expr -> ParsecT SourceName () Identity (P Expr)
forall a. Parser a -> Parser (P a)
node (Parser Expr -> ParsecT SourceName () Identity (P Expr))
-> Parser Expr -> ParsecT SourceName () Identity (P Expr)
forall a b. (a -> b) -> a -> b
$ (P Expr -> P Expr -> P Expr -> Expr)
-> ParsecT
     SourceName () Identity (P Expr -> P Expr -> P Expr -> Expr)
forall (f :: * -> *) a. Applicative f => a -> f a
pure P Expr -> P Expr -> P Expr -> Expr
Cond ParsecT SourceName () Identity (P Expr -> P Expr -> P Expr -> Expr)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr -> P Expr -> Expr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (P Expr)
expr2 ParsecT SourceName () Identity (P Expr -> P Expr -> Expr)
-> ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (P Expr -> P Expr -> Expr)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourceName -> ParsecT SourceName () Identity ()
reservedOp SourceName
"?"
                                     ParsecT SourceName () Identity (P Expr -> P Expr -> Expr)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr -> Expr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (P Expr)
expression ParsecT SourceName () Identity (P Expr -> Expr)
-> ParsecT SourceName () Identity ()
-> ParsecT SourceName () Identity (P Expr -> Expr)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourceName -> ParsecT SourceName () Identity ()
reservedOp SourceName
":"
                                     ParsecT SourceName () Identity (P Expr -> Expr)
-> ParsecT SourceName () Identity (P Expr) -> Parser Expr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity (P Expr)
expression
          expr1 :: ParsecT SourceName () Identity (P Expr)
expr1 = OperatorTable SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall s (m :: * -> *) t u a.
Stream s m t =>
OperatorTable s u m a -> ParsecT s u m a -> ParsecT s u m a
buildExpressionParser OperatorTable SourceName () Identity (P Expr)
assignOperators (ParsecT SourceName () Identity (P Expr)
 -> ParsecT SourceName () Identity (P Expr))
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall a b. (a -> b) -> a -> b
$
                  ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT SourceName () Identity (P Expr)
condexp ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT SourceName () Identity (P Expr)
expr2
          expr2 :: ParsecT SourceName () Identity (P Expr)
expr2 = OperatorTable SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall s (m :: * -> *) t u a.
Stream s m t =>
OperatorTable s u m a -> ParsecT s u m a -> ParsecT s u m a
buildExpressionParser OperatorTable SourceName () Identity (P Expr)
compOperators (ParsecT SourceName () Identity (P Expr)
 -> ParsecT SourceName () Identity (P Expr))
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall a b. (a -> b) -> a -> b
$
                  ParsecT SourceName () Identity (P Expr)
expr3 ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr -> P Expr -> P Expr)
-> ParsecT SourceName () Identity (P Expr)
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` (P Expr -> P Expr -> P Expr)
-> ParsecT SourceName () Identity (P Expr -> P Expr -> P Expr)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (\P Expr
x P Expr
y -> P Expr -> P Expr -> Expr
Concat P Expr
x P Expr
y Expr -> P Expr -> P Expr
forall a b. a -> P b -> P a
`at` P Expr
x)
          expr3 :: ParsecT SourceName () Identity (P Expr)
expr3 = OperatorTable SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall s (m :: * -> *) t u a.
Stream s m t =>
OperatorTable s u m a -> ParsecT s u m a -> ParsecT s u m a
buildExpressionParser OperatorTable SourceName () Identity (P Expr)
exprOperators (ParsecT SourceName () Identity (P Expr)
 -> ParsecT SourceName () Identity (P Expr))
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall a b. (a -> b) -> a -> b
$
                  ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT SourceName () Identity (P Expr)
atomic ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT SourceName () Identity (P Expr)
compound

atomic :: Parser (P Expr)
atomic :: ParsecT SourceName () Identity (P Expr)
atomic =     ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall a. Parser a -> Parser a
parens ParsecT SourceName () Identity (P Expr)
expression
         ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Expr -> ParsecT SourceName () Identity (P Expr)
forall a. Parser a -> Parser (P a)
node (Value -> Expr
Literal (Value -> Expr)
-> ParsecT SourceName () Identity Value -> Parser Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity Value
literal)

literal :: Parser Value
literal :: ParsecT SourceName () Identity Value
literal =     (Double -> Value)
-> ParsecT SourceName () Identity (Double -> Value)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Double -> Value
Number ParsecT SourceName () Identity (Double -> Value)
-> Parsec SourceName () Double
-> ParsecT SourceName () Identity Value
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parsec SourceName () Double
decimal
          ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity Value
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (SourceName -> Value)
-> ParsecT SourceName () Identity (SourceName -> Value)
forall (f :: * -> *) a. Applicative f => a -> f a
pure SourceName -> Value
Sindre.string ParsecT SourceName () Identity (SourceName -> Value)
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity Value
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity SourceName
stringLiteral
          ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity Value
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT SourceName () Identity Value
boolean
          ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity Value
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT SourceName () Identity Value
dict
          ParsecT SourceName () Identity Value
-> SourceName -> ParsecT SourceName () Identity Value
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> SourceName
"literal value"

boolean :: Parser Value
boolean :: ParsecT SourceName () Identity Value
boolean =     ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall a. Parser a -> Parser a
lexeme (SourceName -> ParsecT SourceName () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"true") ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity Value
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Value -> ParsecT SourceName () Identity Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
truth
          ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity Value
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall a. Parser a -> Parser a
lexeme (SourceName -> ParsecT SourceName () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"false") ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity Value
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Value -> ParsecT SourceName () Identity Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
falsity

dict :: Parser Value
dict :: ParsecT SourceName () Identity Value
dict = ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall a. Parser a -> Parser a
lexeme (SourceName -> ParsecT SourceName () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"[]") ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity Value
-> ParsecT SourceName () Identity Value
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Value -> ParsecT SourceName () Identity Value
forall (m :: * -> *) a. Monad m => a -> m a
return (Map Value Value -> Value
Dict Map Value Value
forall k a. Map k a
M.empty)

compound :: Parser (P Expr)
compound :: ParsecT SourceName () Identity (P Expr)
compound =
  ParsecT SourceName () Identity (P Expr)
field' ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr -> P Expr -> P Expr)
-> ParsecT SourceName () Identity (P Expr)
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` (Char -> ParsecT SourceName () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'.' ParsecT SourceName () Identity Char
-> ParsecT SourceName () Identity (P Expr -> P Expr -> P Expr)
-> ParsecT SourceName () Identity (P Expr -> P Expr -> P Expr)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (P Expr -> P Expr -> P Expr)
-> ParsecT SourceName () Identity (P Expr -> P Expr -> P Expr)
forall (f :: * -> *) a. Applicative f => a -> f a
pure P Expr -> P Expr -> P Expr
comb)
    where comb :: P Expr -> P Expr -> P Expr
comb P Expr
e (P SourcePos
_ (Var SourceName
v)) = SourceName -> P Expr -> Expr
FieldOf SourceName
v P Expr
e Expr -> P Expr -> P Expr
forall a b. a -> P b -> P a
`at` P Expr
e
          comb P Expr
e (P SourcePos
_ (Funcall SourceName
v [P Expr]
es)) = P Expr -> SourceName -> [P Expr] -> Expr
Methcall P Expr
e SourceName
v [P Expr]
es Expr -> P Expr -> P Expr
forall a b. a -> P b -> P a
`at` P Expr
e
          comb P Expr
_ P Expr
_ = P Expr
forall a. HasCallStack => a
undefined -- Will never happen
          field' :: ParsecT SourceName () Identity (P Expr)
field' = ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT SourceName () Identity (P Expr)
fcall ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity (P Expr)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Expr -> ParsecT SourceName () Identity (P Expr)
forall a. Parser a -> Parser (P a)
node (SourceName -> Expr
Var (SourceName -> Expr)
-> ParsecT SourceName () Identity SourceName -> Parser Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT SourceName () Identity SourceName
varName)

lexer :: P.TokenParser ()
lexer :: GenTokenParser SourceName () Identity
lexer = LanguageDef () -> GenTokenParser SourceName () Identity
forall s (m :: * -> *) u.
Stream s m Char =>
GenLanguageDef s u m -> GenTokenParser s u m
P.makeTokenParser LanguageDef ()
sindrelang
lexeme :: Parser a -> Parser a
lexeme :: Parser a -> Parser a
lexeme = GenTokenParser SourceName () Identity
-> forall a. Parser a -> Parser a
forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
P.lexeme GenTokenParser SourceName () Identity
lexer
comma :: Parser String
comma :: ParsecT SourceName () Identity SourceName
comma = GenTokenParser SourceName () Identity
-> ParsecT SourceName () Identity SourceName
forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m SourceName
P.comma GenTokenParser SourceName () Identity
lexer
commaSep :: Parser a -> Parser [a]
commaSep :: Parser a -> Parser [a]
commaSep = GenTokenParser SourceName () Identity
-> forall a. Parser a -> Parser [a]
forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m [a]
P.commaSep GenTokenParser SourceName () Identity
lexer
semi :: Parser String
semi :: ParsecT SourceName () Identity SourceName
semi = GenTokenParser SourceName () Identity
-> ParsecT SourceName () Identity SourceName
forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m SourceName
P.semi GenTokenParser SourceName () Identity
lexer
parens :: Parser a -> Parser a
parens :: Parser a -> Parser a
parens = GenTokenParser SourceName () Identity
-> forall a. Parser a -> Parser a
forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
P.parens GenTokenParser SourceName () Identity
lexer
braces :: Parser a -> Parser a
braces :: Parser a -> Parser a
braces = GenTokenParser SourceName () Identity
-> forall a. Parser a -> Parser a
forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
P.braces GenTokenParser SourceName () Identity
lexer
brackets :: Parser a -> Parser a
brackets :: Parser a -> Parser a
brackets = GenTokenParser SourceName () Identity
-> forall a. Parser a -> Parser a
forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
P.brackets GenTokenParser SourceName () Identity
lexer
fcall :: Parser (P Expr)
fcall :: ParsecT SourceName () Identity (P Expr)
fcall = Parser Expr -> ParsecT SourceName () Identity (P Expr)
forall a. Parser a -> Parser (P a)
node (Parser Expr -> ParsecT SourceName () Identity (P Expr))
-> Parser Expr -> ParsecT SourceName () Identity (P Expr)
forall a b. (a -> b) -> a -> b
$ (SourceName -> [P Expr] -> Expr)
-> ParsecT SourceName () Identity (SourceName -> [P Expr] -> Expr)
forall (f :: * -> *) a. Applicative f => a -> f a
pure SourceName -> [P Expr] -> Expr
Funcall ParsecT SourceName () Identity (SourceName -> [P Expr] -> Expr)
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity ([P Expr] -> Expr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT SourceName () Identity SourceName
varName ParsecT SourceName () Identity ([P Expr] -> Expr)
-> ParsecT SourceName () Identity [P Expr] -> Parser Expr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
        ParsecT SourceName () Identity [P Expr]
-> ParsecT SourceName () Identity [P Expr]
forall a. Parser a -> Parser a
parens (ParsecT SourceName () Identity (P Expr)
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity [P Expr]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT SourceName () Identity (P Expr)
expression ParsecT SourceName () Identity SourceName
comma)
check :: (a -> Bool) -> a -> Parser a
check :: (a -> Bool) -> a -> Parser a
check a -> Bool
f a
x | a -> Bool
f a
x       = a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x
check a -> Bool
_ a
_ = SourceName -> Parser a
forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail SourceName
"Failed check"
isClassName :: String -> Bool
isClassName :: SourceName -> Bool
isClassName SourceName
""      = Bool
False
isClassName s :: SourceName
s@(Char
c:SourceName
_) = Bool -> Bool
not ((Char -> Bool) -> SourceName -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isUpper SourceName
s) Bool -> Bool -> Bool
&& Char -> Bool
isUpper Char
c
className :: Parser String
className :: ParsecT SourceName () Identity SourceName
className = ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ((SourceName -> Bool)
-> SourceName -> ParsecT SourceName () Identity SourceName
forall a. (a -> Bool) -> a -> Parser a
check SourceName -> Bool
isClassName (SourceName -> ParsecT SourceName () Identity SourceName)
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ParsecT SourceName () Identity SourceName
identifier) ParsecT SourceName () Identity SourceName
-> SourceName -> ParsecT SourceName () Identity SourceName
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> SourceName
"class"
varName :: Parser String
varName :: ParsecT SourceName () Identity SourceName
varName =  ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ((SourceName -> Bool)
-> SourceName -> ParsecT SourceName () Identity SourceName
forall a. (a -> Bool) -> a -> Parser a
check (Bool -> Bool
not (Bool -> Bool) -> (SourceName -> Bool) -> SourceName -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceName -> Bool
isClassName) (SourceName -> ParsecT SourceName () Identity SourceName)
-> ParsecT SourceName () Identity SourceName
-> ParsecT SourceName () Identity SourceName
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ParsecT SourceName () Identity SourceName
identifier) ParsecT SourceName () Identity SourceName
-> SourceName -> ParsecT SourceName () Identity SourceName
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> SourceName
"variable"
identifier :: Parser String
identifier :: ParsecT SourceName () Identity SourceName
identifier = GenTokenParser SourceName () Identity
-> ParsecT SourceName () Identity SourceName
forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m SourceName
P.identifier GenTokenParser SourceName () Identity
lexer
decimal :: Parser Double
decimal :: Parsec SourceName () Double
decimal = (Integer -> Double)
-> (Double -> Double) -> Either Integer Double -> Double
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Double -> Double
forall a. a -> a
id (Either Integer Double -> Double)
-> ParsecT SourceName () Identity (Either Integer Double)
-> Parsec SourceName () Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenTokenParser SourceName () Identity
-> ParsecT SourceName () Identity (Either Integer Double)
forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m (Either Integer Double)
P.naturalOrFloat GenTokenParser SourceName () Identity
lexer
stringLiteral :: Parser String
stringLiteral :: ParsecT SourceName () Identity SourceName
stringLiteral = GenTokenParser SourceName () Identity
-> ParsecT SourceName () Identity SourceName
forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m SourceName
P.stringLiteral GenTokenParser SourceName () Identity
lexer
reservedOp :: String -> Parser ()
reservedOp :: SourceName -> ParsecT SourceName () Identity ()
reservedOp = GenTokenParser SourceName () Identity
-> SourceName -> ParsecT SourceName () Identity ()
forall s u (m :: * -> *).
GenTokenParser s u m -> SourceName -> ParsecT s u m ()
P.reservedOp GenTokenParser SourceName () Identity
lexer
reserved :: String -> Parser ()
reserved :: SourceName -> ParsecT SourceName () Identity ()
reserved = GenTokenParser SourceName () Identity
-> SourceName -> ParsecT SourceName () Identity ()
forall s u (m :: * -> *).
GenTokenParser s u m -> SourceName -> ParsecT s u m ()
P.reserved GenTokenParser SourceName () Identity
lexer