{-# LANGUAGE CPP, OverloadedStrings #-}
{-# OPTIONS_GHC -Wall -fwarn-tabs #-}
module Language.Hakaru.Parser.Parser
    (
      parseHakaru
    , parseHakaruWithImports
    , parseReplLine
    ) where

import Prelude hiding (Real)

#if __GLASGOW_HASKELL__ < 710
import           Data.Functor                  ((<$>), (<$))
import           Control.Applicative           (Applicative(..))
#endif
import           Data.Functor.Identity
import           Data.Text                     (Text)
import qualified Data.Text                     as Text
import           Data.Ratio                    ((%))
import           Data.Char                     (digitToInt)
import           Text.Parsec
import           Text.Parsec.Text              () -- instances only
import           Text.Parsec.Indentation
import           Text.Parsec.Indentation.Char
import qualified Text.Parsec.Indentation.Token as ITok
import           Text.Parsec.Expr              (Assoc(..), Operator(..))
import qualified Text.Parsec.Token             as Tok

import Language.Hakaru.Parser.AST
import Language.Hakaru.Syntax.IClasses (Some2(..))
import Language.Hakaru.Syntax.AST (allTransforms, transformName)

ops, names :: [String]
ops :: [String]
ops = String -> [String]
words String
"^ ** * / + - .  < > <= >= == /= && || <|> -> : <~ = _"
names :: [String]
names = (String -> [String]) -> [String] -> [String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap String -> [String]
words [ String
"def fn"
                        , String
"if else match"
                        , String
"return dirac"
                        , String
"integrate summate product from to"
                        , String
"array plate chain of"
                        , String
"r_nop r_split r_index r_fanout r_add bucket"
                        , String
"import data ∞" ] [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++
        (Some2 Transform -> String) -> [Some2 Transform] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (\(Some2 Transform i j
t) -> Transform i j -> String
forall (args :: [([Hakaru], Hakaru)]) (a :: Hakaru).
Transform args a -> String
transformName Transform i j
t) [Some2 Transform]
allTransforms

type ParserStream    = IndentStream (CharIndentStream Text)
type Parser          = ParsecT     ParserStream () Identity
type OperatorTable a = [[Operator ParserStream () Identity a]]

style :: Tok.GenLanguageDef ParserStream st Identity
style :: GenLanguageDef ParserStream st Identity
style = GenLanguageDef Text st Identity
-> GenLanguageDef ParserStream st Identity
forall (m :: * -> *) s st.
Monad m =>
GenLanguageDef s st m
-> GenLanguageDef (IndentStream (CharIndentStream s)) st m
ITok.makeIndentLanguageDef (GenLanguageDef Text st Identity
 -> GenLanguageDef ParserStream st Identity)
-> GenLanguageDef Text st Identity
-> GenLanguageDef ParserStream st Identity
forall a b. (a -> b) -> a -> b
$ LanguageDef :: forall s u (m :: * -> *).
String
-> String
-> String
-> Bool
-> ParsecT s u m Char
-> ParsecT s u m Char
-> ParsecT s u m Char
-> ParsecT s u m Char
-> [String]
-> [String]
-> Bool
-> GenLanguageDef s u m
Tok.LanguageDef
    { commentStart :: String
Tok.commentStart    = String
""
    , commentEnd :: String
Tok.commentEnd      = String
""
    , nestedComments :: Bool
Tok.nestedComments  = Bool
True
    , identStart :: ParsecT Text st Identity Char
Tok.identStart      = ParsecT Text st Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
letter ParsecT Text st Identity Char
-> ParsecT Text st Identity Char -> ParsecT Text st Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Char -> ParsecT Text st Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'_'
    , identLetter :: ParsecT Text st Identity Char
Tok.identLetter     = ParsecT Text st Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
alphaNum ParsecT Text st Identity Char
-> ParsecT Text st Identity Char -> ParsecT Text st Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> String -> ParsecT Text st Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf String
"_'"
    , opStart :: ParsecT Text st Identity Char
Tok.opStart         = String -> ParsecT Text st Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf [ Char
c | Char
c:String
_ <- [String]
ops ]
    , opLetter :: ParsecT Text st Identity Char
Tok.opLetter        = String -> ParsecT Text st Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf [ Char
c | Char
_:String
cs <- [String]
ops, Char
c <- String
cs ]
    , caseSensitive :: Bool
Tok.caseSensitive   = Bool
True
    , commentLine :: String
Tok.commentLine     = String
"#"
    , reservedOpNames :: [String]
Tok.reservedOpNames = [String]
ops
    , reservedNames :: [String]
Tok.reservedNames   = [String]
names
    }

lexer :: Tok.GenTokenParser ParserStream () Identity
lexer :: GenTokenParser ParserStream () Identity
lexer = GenLanguageDef ParserStream () Identity
-> GenTokenParser ParserStream () Identity
forall s (m :: * -> *) u.
Stream s m (Char, Indentation) =>
GenLanguageDef (IndentStream s) u m
-> GenTokenParser (IndentStream s) u m
ITok.makeTokenParser GenLanguageDef ParserStream () Identity
forall st. GenLanguageDef ParserStream st Identity
style

whiteSpace :: Parser ()
whiteSpace :: Parser ()
whiteSpace = GenTokenParser ParserStream () Identity -> Parser ()
forall s u (m :: * -> *). GenTokenParser s u m -> ParsecT s u m ()
Tok.whiteSpace GenTokenParser ParserStream () Identity
lexer

decimal :: Parser Integer
decimal :: Parser Integer
decimal = GenTokenParser ParserStream () Identity -> Parser Integer
forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m Integer
Tok.decimal GenTokenParser ParserStream () Identity
lexer

decimalFloat :: Parser Literal'
decimalFloat :: Parser Literal'
decimalFloat = do Integer
n <- Parser Integer
decimal
                  Literal' -> Parser Literal' -> Parser Literal'
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option (Integer -> Literal'
Nat Integer
n) (Rational -> Literal'
Prob (Rational -> Literal')
-> ParsecT ParserStream () Identity Rational -> Parser Literal'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Integer -> ParsecT ParserStream () Identity Rational
fractExponent Integer
n)

fractExponent   :: Integer -> Parser Rational
fractExponent :: Integer -> ParsecT ParserStream () Identity Rational
fractExponent Integer
n =  do{ Rational
fract <- ParsecT ParserStream () Identity Rational
fraction
                     ; Rational
expo  <- Rational
-> ParsecT ParserStream () Identity Rational
-> ParsecT ParserStream () Identity Rational
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Rational
1 ParsecT ParserStream () Identity Rational
exponent'
                     ; Rational -> ParsecT ParserStream () Identity Rational
forall (m :: * -> *) a. Monad m => a -> m a
return ((Integer -> Rational
forall a. Num a => Integer -> a
fromInteger Integer
n Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
+ Rational
fract)Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
*Rational
expo)
                     }
                  ParsecT ParserStream () Identity Rational
-> ParsecT ParserStream () Identity Rational
-> ParsecT ParserStream () Identity Rational
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
                  do{ Rational
expo <- ParsecT ParserStream () Identity Rational
exponent'
                    ; Rational -> ParsecT ParserStream () Identity Rational
forall (m :: * -> *) a. Monad m => a -> m a
return ((Integer -> Rational
forall a. Num a => Integer -> a
fromInteger Integer
n)Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
*Rational
expo)
                    }

fraction        :: Parser Rational
fraction :: ParsecT ParserStream () Identity Rational
fraction        =  do{ Char
d      <- ParsecT ParserStream () Identity Char
-> ParsecT ParserStream () Identity Char
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Char -> ParsecT ParserStream () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'.' ParsecT ParserStream () Identity Char
-> ParsecT ParserStream () Identity Char
-> ParsecT ParserStream () Identity Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT ParserStream () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit)
                     ; String
digits <- ParsecT ParserStream () Identity Char
-> ParsecT ParserStream () Identity String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT ParserStream () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit ParsecT ParserStream () Identity String
-> String -> ParsecT ParserStream () Identity String
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"fraction"
                     ; Rational -> ParsecT ParserStream () Identity Rational
forall (m :: * -> *) a. Monad m => a -> m a
return ((Rational -> Rational -> Rational) -> [Rational] -> Rational
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
op ((Char -> Rational) -> String -> [Rational]
forall a b. (a -> b) -> [a] -> [b]
map (Indentation -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral(Indentation -> Rational)
-> (Char -> Indentation) -> Char -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Char -> Indentation
digitToInt) (Char
dChar -> String -> String
forall a. a -> [a] -> [a]
:String
digits))
                               Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/ Rational
10)
                     }
                  ParsecT ParserStream () Identity Rational
-> String -> ParsecT ParserStream () Identity Rational
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"fraction"
                    where
                      op :: a -> a -> a
op a
d a
f    = a
d a -> a -> a
forall a. Num a => a -> a -> a
+ a
f a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
10

exponent'       :: Parser Rational
exponent' :: ParsecT ParserStream () Identity Rational
exponent'       =  do{ Char
_ <- String -> ParsecT ParserStream () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf String
"eE"
                     ; Integer -> Integer
f <- (Integer -> Integer
forall a. Num a => a -> a
negate (Integer -> Integer)
-> ParsecT ParserStream () Identity Char
-> ParsecT ParserStream () Identity (Integer -> Integer)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT ParserStream () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'-') ParsecT ParserStream () Identity (Integer -> Integer)
-> ParsecT ParserStream () Identity (Integer -> Integer)
-> ParsecT ParserStream () Identity (Integer -> Integer)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Integer -> Integer
forall a. a -> a
id (Integer -> Integer)
-> Parser ()
-> ParsecT ParserStream () Identity (Integer -> Integer)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParsecT ParserStream () Identity Char -> Parser ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (Char -> ParsecT ParserStream () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'+'))
                     ; Integer
e <- Parser Integer
decimal Parser Integer -> String -> Parser Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"exponent"
                     ; Rational -> ParsecT ParserStream () Identity Rational
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational
10 Rational -> Integer -> Rational
forall a b. (Fractional a, Integral b) => a -> b -> a
^^ Integer -> Integer
f Integer
e)
                     }
                  ParsecT ParserStream () Identity Rational
-> String -> ParsecT ParserStream () Identity Rational
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"exponent"

parens :: Parser a -> Parser a
parens :: Parser a -> Parser a
parens = GenTokenParser ParserStream () Identity
-> forall a.
   ParsecT ParserStream () Identity a
   -> ParsecT ParserStream () Identity a
forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
Tok.parens GenTokenParser ParserStream () Identity
lexer (Parser a -> Parser a)
-> (Parser a -> Parser a) -> Parser a -> Parser a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IndentationRel -> Parser a -> Parser a
forall (m :: * -> *) s u a.
Monad m =>
IndentationRel
-> ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
localIndentation IndentationRel
Any

brackets :: Parser a -> Parser a
brackets :: Parser a -> Parser a
brackets = GenTokenParser ParserStream () Identity
-> forall a.
   ParsecT ParserStream () Identity a
   -> ParsecT ParserStream () Identity a
forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
Tok.brackets GenTokenParser ParserStream () Identity
lexer (Parser a -> Parser a)
-> (Parser a -> Parser a) -> Parser a -> Parser a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IndentationRel -> Parser a -> Parser a
forall (m :: * -> *) s u a.
Monad m =>
IndentationRel
-> ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
localIndentation IndentationRel
Any

commaSep :: Parser a -> Parser [a]
commaSep :: Parser a -> Parser [a]
commaSep = GenTokenParser ParserStream () Identity
-> forall a.
   ParsecT ParserStream () Identity a
   -> ParsecT ParserStream () Identity [a]
forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m [a]
Tok.commaSep GenTokenParser ParserStream () Identity
lexer

identifier :: Parser Text
identifier :: Parser Text
identifier = String -> Text
Text.pack (String -> Text)
-> ParsecT ParserStream () Identity String -> Parser Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenTokenParser ParserStream () Identity
-> ParsecT ParserStream () Identity String
forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m String
Tok.identifier GenTokenParser ParserStream () Identity
lexer

reserved :: String -> Parser ()
reserved :: String -> Parser ()
reserved String
s
  | String
s String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String]
names -- assertion
  = GenTokenParser ParserStream () Identity -> String -> Parser ()
forall s u (m :: * -> *).
GenTokenParser s u m -> String -> ParsecT s u m ()
Tok.reserved GenTokenParser ParserStream () Identity
lexer String
s
  | Bool
otherwise
  = String -> Parser ()
forall a. HasCallStack => String -> a
error (String
"Parser failed to reserve the name " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
s)

reservedOp :: String -> Parser ()
reservedOp :: String -> Parser ()
reservedOp String
s
  | String
s String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String]
ops -- assertion
  = GenTokenParser ParserStream () Identity -> String -> Parser ()
forall s u (m :: * -> *).
GenTokenParser s u m -> String -> ParsecT s u m ()
Tok.reservedOp GenTokenParser ParserStream () Identity
lexer String
s
  | Bool
otherwise
  = String -> Parser ()
forall a. HasCallStack => String -> a
error (String
"Parser failed to reserve the operator " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
s)

app1 :: a -> AST' a -> AST' a
app1 :: a -> AST' a -> AST' a
app1 a
s AST' a
x = a -> AST' a
forall a. a -> AST' a
Var a
s AST' a -> AST' a -> AST' a
forall a. AST' a -> AST' a -> AST' a
`App` AST' a
x

app2 :: a -> AST' a -> AST' a -> AST' a
app2 :: a -> AST' a -> AST' a -> AST' a
app2 a
s AST' a
x AST' a
y = a -> AST' a
forall a. a -> AST' a
Var a
s AST' a -> AST' a -> AST' a
forall a. AST' a -> AST' a -> AST' a
`App` AST' a
x AST' a -> AST' a -> AST' a
forall a. AST' a -> AST' a -> AST' a
`App` AST' a
y

divide, sub :: AST' Text -> AST' Text -> AST' Text
divide :: AST' Text -> AST' Text -> AST' Text
divide       (WithMeta (ULiteral (Nat   Integer
x     )) (SourceSpan SourcePos
s SourcePos
_))
             (WithMeta (ULiteral (Nat       Integer
y )) (SourceSpan SourcePos
_ SourcePos
e))
           = (AST' Text -> SourceSpan -> AST' Text
forall a. AST' a -> SourceSpan -> AST' a
WithMeta (Literal' -> AST' Text
forall a. Literal' -> AST' a
ULiteral (Rational -> Literal'
Prob (Integer
x Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
y))) (SourcePos -> SourcePos -> SourceSpan
SourceSpan SourcePos
s SourcePos
e))
divide       (WithMeta (ULiteral (Nat   Integer
1     )) (SourceSpan SourcePos
_ SourcePos
_))
             AST' Text
y
           = Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a
app1 Text
"recip" AST' Text
y
divide AST' Text
x AST' Text
y = NaryOp -> [AST' Text] -> AST' Text
forall a. NaryOp -> [AST' a] -> AST' a
NaryOp NaryOp
Prod [AST' Text
x, Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a
app1 Text
"recip" AST' Text
y]
sub :: AST' Text -> AST' Text -> AST' Text
sub    AST' Text
x AST' Text
y = NaryOp -> [AST' Text] -> AST' Text
forall a. NaryOp -> [AST' a] -> AST' a
NaryOp NaryOp
Sum  [AST' Text
x, Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a
app1 Text
"negate" AST' Text
y]

bi :: ([a] -> b) -> a -> a -> b
bi :: ([a] -> b) -> a -> a -> b
bi [a] -> b
f a
x a
y = [a] -> b
f [a
x, a
y]

negate_rel :: (AST' Text -> AST' Text -> AST' Text)
           -> (AST' Text -> AST' Text -> AST' Text)
negate_rel :: (AST' Text -> AST' Text -> AST' Text)
-> AST' Text -> AST' Text -> AST' Text
negate_rel AST' Text -> AST' Text -> AST' Text
f AST' Text
x AST' Text
y = Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a
app1 Text
"not" (AST' Text -> AST' Text -> AST' Text
f AST' Text
x AST' Text
y)

binary :: String
       -> Assoc
       -> (a -> a -> a)
       -> Operator ParserStream () Identity a
binary :: String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
s Assoc
a a -> a -> a
f = ParsecT ParserStream () Identity (a -> a -> a)
-> Assoc -> Operator ParserStream () Identity a
forall s u (m :: * -> *) a.
ParsecT s u m (a -> a -> a) -> Assoc -> Operator s u m a
Infix (a -> a -> a
f (a -> a -> a)
-> Parser () -> ParsecT ParserStream () Identity (a -> a -> a)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> Parser ()
reservedOp String
s) Assoc
a

postfix :: Stream s m t
        => ParsecT s u m (AST' a -> AST' a)
        -> Operator s u m (AST' a)
postfix :: ParsecT s u m (AST' a -> AST' a) -> Operator s u m (AST' a)
postfix ParsecT s u m (AST' a -> AST' a)
p = ParsecT s u m (AST' a -> AST' a) -> Operator s u m (AST' a)
forall s u (m :: * -> *) a.
ParsecT s u m (a -> a) -> Operator s u m a
Postfix (ParsecT s u m (AST' a -> AST' a)
-> ParsecT
     s
     u
     m
     ((AST' a -> AST' a) -> (AST' a -> AST' a) -> AST' a -> AST' a)
-> ParsecT s u m (AST' a -> AST' a)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
chainl1 ParsecT s u m (AST' a -> AST' a)
p' (((AST' a -> AST' a) -> (AST' a -> AST' a) -> AST' a -> AST' a)
-> ParsecT
     s
     u
     m
     ((AST' a -> AST' a) -> (AST' a -> AST' a) -> AST' a -> AST' a)
forall (m :: * -> *) a. Monad m => a -> m a
return (((AST' a -> AST' a) -> (AST' a -> AST' a) -> AST' a -> AST' a)
-> (AST' a -> AST' a) -> (AST' a -> AST' a) -> AST' a -> AST' a
forall a b c. (a -> b -> c) -> b -> a -> c
flip (AST' a -> AST' a) -> (AST' a -> AST' a) -> AST' a -> AST' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
(.))))
  where p' :: ParsecT s u m (AST' a -> AST' a)
p' = do AST' a -> AST' a
f <- ParsecT s u m (AST' a -> AST' a)
p
                SourcePos
e <- ParsecT s u m SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
                (AST' a -> AST' a) -> ParsecT s u m (AST' a -> AST' a)
forall (m :: * -> *) a. Monad m => a -> m a
return (\AST' a
x -> case AST' a
x of
                  WithMeta AST' a
_ (SourceSpan SourcePos
s SourcePos
_) -> AST' a -> SourceSpan -> AST' a
forall a. AST' a -> SourceSpan -> AST' a
WithMeta (AST' a -> AST' a
f AST' a
x) (SourcePos -> SourcePos -> SourceSpan
SourceSpan SourcePos
s SourcePos
e)
                  AST' a
_                           ->           AST' a -> AST' a
f AST' a
x)

sign :: Parser (AST' Text -> AST' Text)
sign :: Parser (AST' Text -> AST' Text)
sign = do
  SourcePos
s <- ParsecT ParserStream () Identity SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  (Integer -> Integer
fNat, Rational -> Rational
fProb, AST' Text -> AST' Text
fRest)
    <- ((Integer -> Integer
forall a. a -> a
id    , Rational -> Rational
forall a. a -> a
id    , AST' Text -> AST' Text
forall a. a -> a
id           ) (Integer -> Integer, Rational -> Rational, AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream
     ()
     Identity
     (Integer -> Integer, Rational -> Rational, AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> Parser ()
reservedOp String
"+") ParsecT
  ParserStream
  ()
  Identity
  (Integer -> Integer, Rational -> Rational, AST' Text -> AST' Text)
-> ParsecT
     ParserStream
     ()
     Identity
     (Integer -> Integer, Rational -> Rational, AST' Text -> AST' Text)
-> ParsecT
     ParserStream
     ()
     Identity
     (Integer -> Integer, Rational -> Rational, AST' Text -> AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
       ((Integer -> Integer
forall a. Num a => a -> a
negate, Rational -> Rational
forall a. Num a => a -> a
negate, Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a
app1 Text
"negate") (Integer -> Integer, Rational -> Rational, AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream
     ()
     Identity
     (Integer -> Integer, Rational -> Rational, AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> Parser ()
reservedOp String
"-")
  let f :: AST' Text -> AST' Text
f     (WithMeta (ULiteral (Nat         Integer
x )) (SourceSpan SourcePos
_ SourcePos
e))
          = (AST' Text -> SourceSpan -> AST' Text
forall a. AST' a -> SourceSpan -> AST' a
WithMeta (Literal' -> AST' Text
forall a. Literal' -> AST' a
ULiteral (Integer -> Literal'
Int  (Integer -> Integer
fNat  Integer
x))) (SourcePos -> SourcePos -> SourceSpan
SourceSpan SourcePos
s SourcePos
e))
      f     (WithMeta (ULiteral (Prob        Rational
x )) (SourceSpan SourcePos
_ SourcePos
e))
          = (AST' Text -> SourceSpan -> AST' Text
forall a. AST' a -> SourceSpan -> AST' a
WithMeta (Literal' -> AST' Text
forall a. Literal' -> AST' a
ULiteral (Rational -> Literal'
Real (Rational -> Rational
fProb Rational
x))) (SourcePos -> SourcePos -> SourceSpan
SourceSpan SourcePos
s SourcePos
e))
      f AST' Text
x = AST' Text -> AST' Text
fRest AST' Text
x
  (AST' Text -> AST' Text) -> Parser (AST' Text -> AST' Text)
forall (m :: * -> *) a. Monad m => a -> m a
return AST' Text -> AST' Text
f

table :: OperatorTable (AST' Text)
table :: OperatorTable (AST' Text)
table = [ [ Parser (AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (AST' a -> AST' a) -> Operator s u m (AST' a)
postfix (Parser (AST' Text -> AST' Text)
array_index Parser (AST' Text -> AST' Text)
-> Parser (AST' Text -> AST' Text)
-> Parser (AST' Text -> AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (AST' Text -> AST' Text)
fun_call) ]
        , [ String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"^"   Assoc
AssocRight ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
app2 Text
"^"
          , String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"**"  Assoc
AssocRight ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
app2 Text
"**" ]
        , [ String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"*"   Assoc
AssocLeft  ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ ([AST' Text] -> AST' Text) -> AST' Text -> AST' Text -> AST' Text
forall a b. ([a] -> b) -> a -> a -> b
bi (NaryOp -> [AST' Text] -> AST' Text
forall a. NaryOp -> [AST' a] -> AST' a
NaryOp NaryOp
Prod)
          , String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"/"   Assoc
AssocLeft  ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ AST' Text -> AST' Text -> AST' Text
divide ]
        , [ Parser (AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m (a -> a) -> Operator s u m a
Prefix Parser (AST' Text -> AST' Text)
sign
          , String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"+"   Assoc
AssocLeft  ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ ([AST' Text] -> AST' Text) -> AST' Text -> AST' Text -> AST' Text
forall a b. ([a] -> b) -> a -> a -> b
bi (NaryOp -> [AST' Text] -> AST' Text
forall a. NaryOp -> [AST' a] -> AST' a
NaryOp NaryOp
Sum)
          , String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"-"   Assoc
AssocLeft  ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ AST' Text -> AST' Text -> AST' Text
sub ]
        , [ Parser (AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (AST' a -> AST' a) -> Operator s u m (AST' a)
postfix Parser (AST' Text -> AST' Text)
ann_expr ]
        , [ String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"<"   Assoc
AssocNone  ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$                     Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
app2 Text
"less"
          , String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
">"   Assoc
AssocNone  ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$              (AST' Text -> AST' Text -> AST' Text)
-> AST' Text -> AST' Text -> AST' Text
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((AST' Text -> AST' Text -> AST' Text)
 -> AST' Text -> AST' Text -> AST' Text)
-> (AST' Text -> AST' Text -> AST' Text)
-> AST' Text
-> AST' Text
-> AST' Text
forall a b. (a -> b) -> a -> b
$ Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
app2 Text
"less"
          , String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"<="  Assoc
AssocNone  ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ (AST' Text -> AST' Text -> AST' Text)
-> AST' Text -> AST' Text -> AST' Text
negate_rel ((AST' Text -> AST' Text -> AST' Text)
 -> AST' Text -> AST' Text -> AST' Text)
-> (AST' Text -> AST' Text -> AST' Text)
-> AST' Text
-> AST' Text
-> AST' Text
forall a b. (a -> b) -> a -> b
$ (AST' Text -> AST' Text -> AST' Text)
-> AST' Text -> AST' Text -> AST' Text
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((AST' Text -> AST' Text -> AST' Text)
 -> AST' Text -> AST' Text -> AST' Text)
-> (AST' Text -> AST' Text -> AST' Text)
-> AST' Text
-> AST' Text
-> AST' Text
forall a b. (a -> b) -> a -> b
$ Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
app2 Text
"less"
          , String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
">="  Assoc
AssocNone  ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ (AST' Text -> AST' Text -> AST' Text)
-> AST' Text -> AST' Text -> AST' Text
negate_rel ((AST' Text -> AST' Text -> AST' Text)
 -> AST' Text -> AST' Text -> AST' Text)
-> (AST' Text -> AST' Text -> AST' Text)
-> AST' Text
-> AST' Text
-> AST' Text
forall a b. (a -> b) -> a -> b
$        Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
app2 Text
"less"
          , String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"=="  Assoc
AssocNone  ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$                     Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
app2 Text
"equal"
          , String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"/="  Assoc
AssocNone  ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ (AST' Text -> AST' Text -> AST' Text)
-> AST' Text -> AST' Text -> AST' Text
negate_rel ((AST' Text -> AST' Text -> AST' Text)
 -> AST' Text -> AST' Text -> AST' Text)
-> (AST' Text -> AST' Text -> AST' Text)
-> AST' Text
-> AST' Text
-> AST' Text
forall a b. (a -> b) -> a -> b
$        Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
app2 Text
"equal" ]
        , [ String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"&&"  Assoc
AssocRight ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ ([AST' Text] -> AST' Text) -> AST' Text -> AST' Text -> AST' Text
forall a b. ([a] -> b) -> a -> a -> b
bi (NaryOp -> [AST' Text] -> AST' Text
forall a. NaryOp -> [AST' a] -> AST' a
NaryOp NaryOp
And) ]
        , [ String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"||"  Assoc
AssocRight ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ ([AST' Text] -> AST' Text) -> AST' Text -> AST' Text -> AST' Text
forall a b. ([a] -> b) -> a -> a -> b
bi (NaryOp -> [AST' Text] -> AST' Text
forall a. NaryOp -> [AST' a] -> AST' a
NaryOp NaryOp
Or) ]
        , [ String
-> Assoc
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a.
String
-> Assoc -> (a -> a -> a) -> Operator ParserStream () Identity a
binary String
"<|>" Assoc
AssocRight ((AST' Text -> AST' Text -> AST' Text)
 -> Operator ParserStream () Identity (AST' Text))
-> (AST' Text -> AST' Text -> AST' Text)
-> Operator ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ ([AST' Text] -> AST' Text) -> AST' Text -> AST' Text -> AST' Text
forall a b. ([a] -> b) -> a -> a -> b
bi [AST' Text] -> AST' Text
forall a. [AST' a] -> AST' a
Msum ] ]

red_expr :: Parser (Reducer' Text)
red_expr :: Parser (Reducer' Text)
red_expr =  Parser (Reducer' Text)
red_fanout
        Parser (Reducer' Text)
-> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (Reducer' Text)
red_index
        Parser (Reducer' Text)
-> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (Reducer' Text)
red_split
        Parser (Reducer' Text)
-> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (Reducer' Text)
red_nop
        Parser (Reducer' Text)
-> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (Reducer' Text)
red_add

red_fanout :: Parser (Reducer' Text)
red_fanout :: Parser (Reducer' Text)
red_fanout = String -> Parser ()
reserved String
"r_fanout" Parser () -> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
             (Reducer' Text -> Reducer' Text -> Reducer' Text
forall a. Reducer' a -> Reducer' a -> Reducer' a
R_Fanout
              (Reducer' Text -> Reducer' Text -> Reducer' Text)
-> Parser (Reducer' Text)
-> ParsecT
     ParserStream () Identity (Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Reducer' Text)
red_expr
              ParsecT ParserStream () Identity (Reducer' Text -> Reducer' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
"||"
              ParsecT ParserStream () Identity (Reducer' Text -> Reducer' Text)
-> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Reducer' Text)
red_expr
              )

red_split :: Parser (Reducer' Text)
red_split :: Parser (Reducer' Text)
red_split = String -> Parser ()
reserved String
"r_split" Parser () -> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
             (AST' Text -> Reducer' Text -> Reducer' Text -> Reducer' Text
forall a. AST' a -> Reducer' a -> Reducer' a -> Reducer' a
R_Split
              (AST' Text -> Reducer' Text -> Reducer' Text -> Reducer' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT
     ParserStream
     ()
     Identity
     (Reducer' Text -> Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity (AST' Text)
expr
              ParsecT
  ParserStream
  ()
  Identity
  (Reducer' Text -> Reducer' Text -> Reducer' Text)
-> Parser ()
-> ParsecT
     ParserStream
     ()
     Identity
     (Reducer' Text -> Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
              ParsecT
  ParserStream
  ()
  Identity
  (Reducer' Text -> Reducer' Text -> Reducer' Text)
-> Parser (Reducer' Text)
-> ParsecT
     ParserStream () Identity (Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Reducer' Text)
red_expr
              ParsecT ParserStream () Identity (Reducer' Text -> Reducer' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"else"
              ParsecT ParserStream () Identity (Reducer' Text -> Reducer' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
              ParsecT ParserStream () Identity (Reducer' Text -> Reducer' Text)
-> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Reducer' Text)
red_expr
              )

red_index :: Parser (Reducer' Text)
red_index :: Parser (Reducer' Text)
red_index = String -> Parser ()
reserved String
"r_index" Parser () -> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
             (Text -> AST' Text -> AST' Text -> Reducer' Text -> Reducer' Text
forall a. a -> AST' a -> AST' a -> Reducer' a -> Reducer' a
R_Index
              (Text -> AST' Text -> AST' Text -> Reducer' Text -> Reducer' Text)
-> Parser Text
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier
              ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> Reducer' Text -> Reducer' Text)
-> Parser ()
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
"="
              ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> Reducer' Text -> Reducer' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
              ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> Reducer' Text -> Reducer' Text)
-> Parser ()
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"of"
              ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> Reducer' Text -> Reducer' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT
     ParserStream () Identity (Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
              ParsecT ParserStream () Identity (Reducer' Text -> Reducer' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (Reducer' Text -> Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
              ParsecT ParserStream () Identity (Reducer' Text -> Reducer' Text)
-> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Reducer' Text)
red_expr
              )

red_nop :: Parser (Reducer' Text)
red_nop :: Parser (Reducer' Text)
red_nop = String -> Parser ()
reserved String
"r_nop" Parser () -> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Reducer' Text -> Parser (Reducer' Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Reducer' Text
forall a. Reducer' a
R_Nop

red_add :: Parser (Reducer' Text)
red_add :: Parser (Reducer' Text)
red_add = String -> Parser ()
reserved String
"r_add" Parser () -> Parser (Reducer' Text) -> Parser (Reducer' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (AST' Text -> Reducer' Text
forall a. AST' a -> Reducer' a
R_Add (AST' Text -> Reducer' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (Reducer' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity (AST' Text)
expr)


natOrProb :: Parser (AST' a)
natOrProb :: Parser (AST' a)
natOrProb = (Literal' -> AST' a
forall a. Literal' -> AST' a
ULiteral (Literal' -> AST' a) -> Parser Literal' -> Parser (AST' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Literal'
decimalFloat) Parser (AST' a) -> Parser () -> Parser (AST' a)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
whiteSpace

inf_ :: Parser (AST' a)
inf_ :: Parser (AST' a)
inf_ = String -> Parser ()
reserved String
"∞" Parser () -> Parser (AST' a) -> Parser (AST' a)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> AST' a -> Parser (AST' a)
forall (m :: * -> *) a. Monad m => a -> m a
return AST' a
forall a. AST' a
Infinity'

var :: Parser (AST' Text)
var :: ParsecT ParserStream () Identity (AST' Text)
var = Text -> AST' Text
forall a. a -> AST' a
Var (Text -> AST' Text)
-> Parser Text -> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier

parenthesized :: Parser (AST' Text)
parenthesized :: ParsecT ParserStream () Identity (AST' Text)
parenthesized = [AST' Text] -> AST' Text
forall a. [AST' a] -> AST' a
f ([AST' Text] -> AST' Text)
-> ParsecT ParserStream () Identity [AST' Text]
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity [AST' Text]
-> ParsecT ParserStream () Identity [AST' Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity a
parens (ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity [AST' Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity [a]
commaSep ParsecT ParserStream () Identity (AST' Text)
expr)
  where f :: [AST' a] -> AST' a
f [] = AST' a
forall a. AST' a
Unit
        f [AST' a]
xs = (AST' a -> AST' a -> AST' a) -> [AST' a] -> AST' a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 AST' a -> AST' a -> AST' a
forall a. AST' a -> AST' a -> AST' a
Pair [AST' a]
xs

type_var_or_app :: Parser TypeAST'
type_var_or_app :: Parser TypeAST'
type_var_or_app = do Text
x <- (Text
"array" Text -> Parser () -> Parser Text
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> Parser ()
reserved String
"array") Parser Text -> Parser Text -> Parser Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Text
identifier
                     TypeAST' -> Parser TypeAST' -> Parser TypeAST'
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option (Text -> TypeAST'
TypeVar Text
x) (Text -> [TypeAST'] -> TypeAST'
TypeApp Text
x ([TypeAST'] -> TypeAST')
-> ParsecT ParserStream () Identity [TypeAST'] -> Parser TypeAST'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity [TypeAST']
-> ParsecT ParserStream () Identity [TypeAST']
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity a
parens (Parser TypeAST' -> ParsecT ParserStream () Identity [TypeAST']
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity [a]
commaSep Parser TypeAST'
type_expr))

type_expr :: Parser TypeAST'
type_expr :: Parser TypeAST'
type_expr = (TypeAST' -> TypeAST' -> TypeAST') -> [TypeAST'] -> TypeAST'
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 TypeAST' -> TypeAST' -> TypeAST'
TypeFun ([TypeAST'] -> TypeAST')
-> ParsecT ParserStream () Identity [TypeAST'] -> Parser TypeAST'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TypeAST'
-> Parser () -> ParsecT ParserStream () Identity [TypeAST']
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]
sepBy1 (Parser TypeAST' -> Parser TypeAST'
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity a
parens Parser TypeAST'
type_expr Parser TypeAST' -> Parser TypeAST' -> Parser TypeAST'
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser TypeAST'
type_var_or_app)
                                      (String -> Parser ()
reservedOp String
"->")

ann_expr :: Parser (AST' Text -> AST' Text)
ann_expr :: Parser (AST' Text -> AST' Text)
ann_expr = String -> Parser ()
reservedOp String
"." Parser ()
-> Parser (AST' Text -> AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ((AST' Text -> TypeAST' -> AST' Text)
-> TypeAST' -> AST' Text -> AST' Text
forall a b c. (a -> b -> c) -> b -> a -> c
flip AST' Text -> TypeAST' -> AST' Text
forall a. AST' a -> TypeAST' -> AST' a
Ann (TypeAST' -> AST' Text -> AST' Text)
-> Parser TypeAST' -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TypeAST'
type_expr)

pdat_expr :: Parser (PDatum Text)
pdat_expr :: Parser (PDatum Text)
pdat_expr = Text -> [Pattern' Text] -> PDatum Text
forall a. Text -> [Pattern' a] -> PDatum a
DV (Text -> [Pattern' Text] -> PDatum Text)
-> Parser Text
-> ParsecT
     ParserStream () Identity ([Pattern' Text] -> PDatum Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier ParsecT ParserStream () Identity ([Pattern' Text] -> PDatum Text)
-> ParsecT ParserStream () Identity [Pattern' Text]
-> Parser (PDatum Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity [Pattern' Text]
-> ParsecT ParserStream () Identity [Pattern' Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity a
parens (Parser (Pattern' Text)
-> ParsecT ParserStream () Identity [Pattern' Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity [a]
commaSep Parser (Pattern' Text)
pat_expr)

pat_expr :: Parser (Pattern' Text)
pat_expr :: Parser (Pattern' Text)
pat_expr =  Parser (Pattern' Text) -> Parser (Pattern' Text)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (PDatum Text -> Pattern' Text
forall a. PDatum a -> Pattern' a
PData' (PDatum Text -> Pattern' Text)
-> Parser (PDatum Text) -> Parser (Pattern' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (PDatum Text)
pdat_expr)
        Parser (Pattern' Text)
-> Parser (Pattern' Text) -> Parser (Pattern' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (PDatum Text -> Pattern' Text
forall a. PDatum a -> Pattern' a
PData' (PDatum Text -> Pattern' Text)
-> Parser (PDatum Text) -> Parser (Pattern' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text -> [Pattern' Text] -> PDatum Text
forall a. Text -> [Pattern' a] -> PDatum a
DV Text
"pair" ([Pattern' Text] -> PDatum Text)
-> ParsecT ParserStream () Identity [Pattern' Text]
-> Parser (PDatum Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity [Pattern' Text]
-> ParsecT ParserStream () Identity [Pattern' Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity a
parens (Parser (Pattern' Text)
-> ParsecT ParserStream () Identity [Pattern' Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity [a]
commaSep Parser (Pattern' Text)
pat_expr)))
        Parser (Pattern' Text)
-> Parser (Pattern' Text) -> Parser (Pattern' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Pattern' Text
forall a. Pattern' a
PWild' Pattern' Text -> Parser () -> Parser (Pattern' Text)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$  String -> Parser ()
reservedOp String
"_")
        Parser (Pattern' Text)
-> Parser (Pattern' Text) -> Parser (Pattern' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Text -> Pattern' Text
forall a. a -> Pattern' a
PVar'  (Text -> Pattern' Text) -> Parser Text -> Parser (Pattern' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier)


-- | Blocks are indicated by colons, and must be indented.
blockOfMany :: Parser a -> Parser [a]
blockOfMany :: Parser a -> Parser [a]
blockOfMany Parser a
p = do
    String -> Parser ()
reservedOp String
":"
    IndentationRel -> Parser [a] -> Parser [a]
forall (m :: * -> *) s u a.
Monad m =>
IndentationRel
-> ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
localIndentation IndentationRel
Gt (Parser a -> Parser [a]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (Parser a -> Parser [a]) -> Parser a -> Parser [a]
forall a b. (a -> b) -> a -> b
$ Parser a -> Parser a
forall (m :: * -> *) s u a.
Monad m =>
ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
absoluteIndentation Parser a
p)


branch_expr :: Parser (Branch' Text)
branch_expr :: Parser (Branch' Text)
branch_expr = Pattern' Text -> AST' Text -> Branch' Text
forall a. Pattern' Text -> AST' a -> Branch' a
Branch' (Pattern' Text -> AST' Text -> Branch' Text)
-> Parser (Pattern' Text)
-> ParsecT ParserStream () Identity (AST' Text -> Branch' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Pattern' Text)
pat_expr ParsecT ParserStream () Identity (AST' Text -> Branch' Text)
-> Parser ()
-> ParsecT ParserStream () Identity (AST' Text -> Branch' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* String -> Parser ()
reservedOp String
":"
              ParsecT ParserStream () Identity (AST' Text -> Branch' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (Branch' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IndentationRel
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
IndentationRel
-> ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
localIndentation IndentationRel
Gt ParsecT ParserStream () Identity (AST' Text)
expr

match_expr :: Parser (AST' Text)
match_expr :: ParsecT ParserStream () Identity (AST' Text)
match_expr = AST' Text -> [Branch' Text] -> AST' Text
forall a. AST' a -> [Branch' a] -> AST' a
Case (AST' Text -> [Branch' Text] -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> [Branch' Text] -> AST' Text)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> Parser ()
reserved String
"match" ParsecT
  ParserStream () Identity (AST' Text -> [Branch' Text] -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity ([Branch' Text] -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr ParsecT ParserStream () Identity ([Branch' Text] -> AST' Text)
-> Parser ()
-> ParsecT ParserStream () Identity ([Branch' Text] -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* String -> Parser ()
reservedOp String
":"
             ParsecT ParserStream () Identity ([Branch' Text] -> AST' Text)
-> ParsecT ParserStream () Identity [Branch' Text]
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IndentationRel
-> ParsecT ParserStream () Identity [Branch' Text]
-> ParsecT ParserStream () Identity [Branch' Text]
forall (m :: * -> *) s u a.
Monad m =>
IndentationRel
-> ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
localIndentation IndentationRel
Ge (Parser (Branch' Text)
-> ParsecT ParserStream () Identity [Branch' Text]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (Parser (Branch' Text) -> Parser (Branch' Text)
forall (m :: * -> *) s u a.
Monad m =>
ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
absoluteIndentation Parser (Branch' Text)
branch_expr))

integrate_expr :: Parser (AST' Text)
integrate_expr :: ParsecT ParserStream () Identity (AST' Text)
integrate_expr =
    String -> Parser ()
reserved String
"integrate"
    Parser ()
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Text -> AST' Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a -> AST' a
Integrate
        (Text -> AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier
        ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"from"
        ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"to"
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        Parser (AST' Text -> AST' Text)
-> Parser () -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
        Parser (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        )

summate_expr :: Parser (AST' Text)
summate_expr :: ParsecT ParserStream () Identity (AST' Text)
summate_expr =
    String -> Parser ()
reserved String
"summate"
    Parser ()
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Text -> AST' Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a -> AST' a
Summate
        (Text -> AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier
        ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"from"
        ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"to"
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        Parser (AST' Text -> AST' Text)
-> Parser () -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
        Parser (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        )

product_expr :: Parser (AST' Text)
product_expr :: ParsecT ParserStream () Identity (AST' Text)
product_expr =
    String -> Parser ()
reserved String
"product"
    Parser ()
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Text -> AST' Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a -> AST' a
Product
        (Text -> AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier
        ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"from"
        ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"to"
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        Parser (AST' Text -> AST' Text)
-> Parser () -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
        Parser (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        )

transform_expr :: Parser (AST' Text)
transform_expr :: ParsecT ParserStream () Identity (AST' Text)
transform_expr = ParsecT ParserStream () Identity (AST' Text)
expect_expr ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
tr
  where
     trNm :: Parser Transform'
     trNm :: Parser Transform'
trNm = [Parser Transform'] -> Parser Transform'
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice ([Parser Transform'] -> Parser Transform')
-> [Parser Transform'] -> Parser Transform'
forall a b. (a -> b) -> a -> b
$
       (Some2 Transform -> Parser Transform')
-> [Some2 Transform] -> [Parser Transform']
forall a b. (a -> b) -> [a] -> [b]
map (\(Some2 Transform i j
t) -> String -> Parser ()
reserved (Transform i j -> String
forall (args :: [([Hakaru], Hakaru)]) (a :: Hakaru).
Transform args a -> String
transformName Transform i j
t)
                       Parser () -> Parser Transform' -> Parser Transform'
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Transform' -> Parser Transform'
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Transform i j -> Transform'
forall (as :: [([Hakaru], Hakaru)]) (x :: Hakaru).
Transform as x -> Transform'
trFromTyped Transform i j
t))
           [Some2 Transform]
allTransforms

     sarg :: Parser ([Text], AST' Text)
     sarg :: Parser ([Text], AST' Text)
sarg = (,)
       ([Text] -> AST' Text -> ([Text], AST' Text))
-> ParsecT ParserStream () Identity [Text]
-> ParsecT
     ParserStream () Identity (AST' Text -> ([Text], AST' Text))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Text]
-> ParsecT ParserStream () Identity [Text]
-> ParsecT ParserStream () Identity [Text]
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (ParsecT ParserStream () Identity [Text]
-> ParsecT ParserStream () Identity [Text]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Parser Text -> ParsecT ParserStream () Identity [Text]
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 Parser Text
identifier ParsecT ParserStream () Identity [Text]
-> Parser () -> ParsecT ParserStream () Identity [Text]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* String -> Parser ()
reservedOp String
":"))
       ParsecT ParserStream () Identity (AST' Text -> ([Text], AST' Text))
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser ([Text], AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr

     tr :: Parser (AST' Text)
     tr :: ParsecT ParserStream () Identity (AST' Text)
tr =  Transform' -> SArgs' Text -> AST' Text
forall a. Transform' -> SArgs' a -> AST' a
Transform
       (Transform' -> SArgs' Text -> AST' Text)
-> Parser Transform'
-> ParsecT ParserStream () Identity (SArgs' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Transform'
trNm
       ParsecT ParserStream () Identity (SArgs' Text -> AST' Text)
-> ParsecT ParserStream () Identity (SArgs' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ([([Text], AST' Text)] -> SArgs' Text
forall a. [([a], AST' a)] -> SArgs' a
SArgs' ([([Text], AST' Text)] -> SArgs' Text)
-> ParsecT ParserStream () Identity [([Text], AST' Text)]
-> ParsecT ParserStream () Identity (SArgs' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity [([Text], AST' Text)]
-> ParsecT ParserStream () Identity [([Text], AST' Text)]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity a
parens (Parser ([Text], AST' Text)
-> ParsecT ParserStream () Identity [([Text], AST' Text)]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity [a]
commaSep Parser ([Text], AST' Text)
sarg))

     expect_expr :: Parser (AST' Text)
     expect_expr :: ParsecT ParserStream () Identity (AST' Text)
expect_expr =
         String -> Parser ()
reserved String
"expect"
         Parser ()
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
_Expect
             (Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier
             ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
"<~"
             ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
             Parser (AST' Text -> AST' Text)
-> Parser () -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
             Parser (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
             )

bucket_expr :: Parser (AST' Text)
bucket_expr :: ParsecT ParserStream () Identity (AST' Text)
bucket_expr =
    String -> Parser ()
reserved String
"bucket"
    Parser ()
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Text -> AST' Text -> AST' Text -> Reducer' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> Reducer' a -> AST' a
Bucket
        (Text -> AST' Text -> AST' Text -> Reducer' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> Reducer' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier
        ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> Reducer' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> Reducer' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"from"
        ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> Reducer' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT
     ParserStream () Identity (AST' Text -> Reducer' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        ParsecT
  ParserStream () Identity (AST' Text -> Reducer' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> Reducer' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"to"
        ParsecT
  ParserStream () Identity (AST' Text -> Reducer' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (Reducer' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        ParsecT ParserStream () Identity (Reducer' Text -> AST' Text)
-> Parser ()
-> ParsecT ParserStream () Identity (Reducer' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
        ParsecT ParserStream () Identity (Reducer' Text -> AST' Text)
-> Parser (Reducer' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Reducer' Text)
red_expr
        )

array_expr :: Parser (AST' Text)
array_expr :: ParsecT ParserStream () Identity (AST' Text)
array_expr =
    String -> Parser ()
reserved String
"array"
    Parser ()
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
Array
        (Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"of"
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        Parser (AST' Text -> AST' Text)
-> Parser () -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
        Parser (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        )

array_index :: Parser (AST' Text -> AST' Text)
array_index :: Parser (AST' Text -> AST' Text)
array_index = (AST' Text -> AST' Text -> AST' Text)
-> AST' Text -> AST' Text -> AST' Text
forall a b c. (a -> b -> c) -> b -> a -> c
flip AST' Text -> AST' Text -> AST' Text
forall a. AST' a -> AST' a -> AST' a
Index (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity a
brackets ParsecT ParserStream () Identity (AST' Text)
expr

array_literal :: Parser (AST' Text)
array_literal :: ParsecT ParserStream () Identity (AST' Text)
array_literal = [AST' Text] -> AST' Text
forall a. [AST' a] -> AST' a
ArrayLiteral ([AST' Text] -> AST' Text)
-> ParsecT ParserStream () Identity [AST' Text]
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity [AST' Text]
-> ParsecT ParserStream () Identity [AST' Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity a
brackets (ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity [AST' Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity [a]
commaSep ParsecT ParserStream () Identity (AST' Text)
expr)

plate_expr :: Parser (AST' Text)
plate_expr :: ParsecT ParserStream () Identity (AST' Text)
plate_expr =
    String -> Parser ()
reserved String
"plate"
    Parser ()
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
Plate
        (Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"of"
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        Parser (AST' Text -> AST' Text)
-> Parser () -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
        Parser (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        )

chain_expr :: Parser (AST' Text)
chain_expr :: ParsecT ParserStream () Identity (AST' Text)
chain_expr =
    String -> Parser ()
reserved String
"chain"
    Parser ()
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ((AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> AST' Text -> AST' Text -> AST' Text -> AST' Text
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((AST' Text -> AST' Text -> AST' Text -> AST' Text)
 -> AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> (Text -> AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> Text
-> AST' Text
-> AST' Text
-> AST' Text
-> AST' Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> AST' Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a -> AST' a
Chain
        (Text -> AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier
        ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"from"
        ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reserved String
"of"
        ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        Parser (AST' Text -> AST' Text)
-> Parser () -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
        Parser (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        )


if_expr :: Parser (AST' Text)
if_expr :: ParsecT ParserStream () Identity (AST' Text)
if_expr = AST' Text -> AST' Text -> AST' Text -> AST' Text
forall a. AST' a -> AST' a -> AST' a -> AST' a
If (AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream
     ()
     Identity
     (AST' Text -> AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ String -> Parser ()
reserved String
"if" ParsecT
  ParserStream
  ()
  Identity
  (AST' Text -> AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* String -> Parser ()
reservedOp String
":" ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
             Parser (AST' Text -> AST' Text)
-> Parser () -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* String -> Parser ()
reserved String
"else"        Parser (AST' Text -> AST' Text)
-> Parser () -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* String -> Parser ()
reservedOp String
":" Parser (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr

lam_expr :: Parser (AST' Text)
lam_expr :: ParsecT ParserStream () Identity (AST' Text)
lam_expr =
    String -> Parser ()
reserved String
"fn"
    Parser ()
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>  (Text -> TypeAST' -> AST' Text -> AST' Text
forall a. a -> TypeAST' -> AST' a -> AST' a
Lam
        (Text -> TypeAST' -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream () Identity (TypeAST' -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier
        ParsecT
  ParserStream () Identity (TypeAST' -> AST' Text -> AST' Text)
-> Parser TypeAST' -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TypeAST'
type_expr
        Parser (AST' Text -> AST' Text)
-> Parser () -> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  String -> Parser ()
reservedOp String
":"
        Parser (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr
        )

bind_expr :: Parser (AST' Text)
bind_expr :: ParsecT ParserStream () Identity (AST' Text)
bind_expr = IndentationRel
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
IndentationRel
-> ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
localIndentation IndentationRel
Ge
  (Parser (AST' Text -> AST' Text) -> Parser (AST' Text -> AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
absoluteIndentation (ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
Bind (Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* String -> Parser ()
reservedOp String
"<~")
   ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IndentationRel
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
IndentationRel
-> ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
localIndentation IndentationRel
Gt ParsecT ParserStream () Identity (AST' Text)
expr)
   Parser (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
absoluteIndentation ParsecT ParserStream () Identity (AST' Text)
expr)

let_expr :: Parser (AST' Text)
let_expr :: ParsecT ParserStream () Identity (AST' Text)
let_expr = IndentationRel
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
IndentationRel
-> ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
localIndentation IndentationRel
Ge
  (Parser (AST' Text -> AST' Text) -> Parser (AST' Text -> AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
absoluteIndentation (ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
Let (Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* String -> Parser ()
reservedOp String
"=")
   ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IndentationRel
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
IndentationRel
-> ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
localIndentation IndentationRel
Gt ParsecT ParserStream () Identity (AST' Text)
expr)
   Parser (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
absoluteIndentation ParsecT ParserStream () Identity (AST' Text)
expr)

def_expr :: Parser (AST' Text)
def_expr :: ParsecT ParserStream () Identity (AST' Text)
def_expr = IndentationRel
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
IndentationRel
-> ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
localIndentation IndentationRel
Ge (ParsecT ParserStream () Identity (AST' Text)
 -> ParsecT ParserStream () Identity (AST' Text))
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall a b. (a -> b) -> a -> b
$ do
    Parser () -> Parser ()
forall (m :: * -> *) s u a.
Monad m =>
ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
absoluteIndentation (String -> Parser ()
reserved String
"def")
    Text
name <- Parser Text
identifier
    [(Text, TypeAST')]
vars <- Parser [(Text, TypeAST')] -> Parser [(Text, TypeAST')]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity a
parens (Parser (Text, TypeAST') -> Parser [(Text, TypeAST')]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity [a]
commaSep Parser (Text, TypeAST')
defarg)
    Maybe TypeAST'
bodyTyp <- Parser TypeAST'
-> ParsecT ParserStream () Identity (Maybe TypeAST')
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser TypeAST'
type_expr
    String -> Parser ()
reservedOp String
":"
    AST' Text
body    <- IndentationRel
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
IndentationRel
-> ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
localIndentation IndentationRel
Gt ParsecT ParserStream () Identity (AST' Text)
expr
    let body' :: AST' Text
body' = ((Text, TypeAST') -> AST' Text -> AST' Text)
-> AST' Text -> [(Text, TypeAST')] -> AST' Text
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\(Text
var', TypeAST'
varTyp) AST' Text
e -> Text -> TypeAST' -> AST' Text -> AST' Text
forall a. a -> TypeAST' -> AST' a -> AST' a
Lam Text
var' TypeAST'
varTyp AST' Text
e) AST' Text
body [(Text, TypeAST')]
vars
        typ :: Maybe TypeAST'
typ   = (TypeAST' -> TypeAST' -> TypeAST')
-> TypeAST' -> [TypeAST'] -> TypeAST'
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr TypeAST' -> TypeAST' -> TypeAST'
TypeFun (TypeAST' -> [TypeAST'] -> TypeAST')
-> Maybe TypeAST' -> Maybe ([TypeAST'] -> TypeAST')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe TypeAST'
bodyTyp Maybe ([TypeAST'] -> TypeAST')
-> Maybe [TypeAST'] -> Maybe TypeAST'
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [TypeAST'] -> Maybe [TypeAST']
forall (m :: * -> *) a. Monad m => a -> m a
return (((Text, TypeAST') -> TypeAST') -> [(Text, TypeAST')] -> [TypeAST']
forall a b. (a -> b) -> [a] -> [b]
map (Text, TypeAST') -> TypeAST'
forall a b. (a, b) -> b
snd [(Text, TypeAST')]
vars)
    Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
Let Text
name ((AST' Text -> AST' Text)
-> (TypeAST' -> AST' Text -> AST' Text)
-> Maybe TypeAST'
-> AST' Text
-> AST' Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe AST' Text -> AST' Text
forall a. a -> a
id ((AST' Text -> TypeAST' -> AST' Text)
-> TypeAST' -> AST' Text -> AST' Text
forall a b c. (a -> b -> c) -> b -> a -> c
flip AST' Text -> TypeAST' -> AST' Text
forall a. AST' a -> TypeAST' -> AST' a
Ann) Maybe TypeAST'
typ AST' Text
body')
        (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (m :: * -> *) s u a.
Monad m =>
ParsecT (IndentStream s) u m a -> ParsecT (IndentStream s) u m a
absoluteIndentation ParsecT ParserStream () Identity (AST' Text)
expr -- the \"rest\"; i.e., where the 'def' is in scope

defarg :: Parser (Text, TypeAST')
defarg :: Parser (Text, TypeAST')
defarg = (,) (Text -> TypeAST' -> (Text, TypeAST'))
-> Parser Text
-> ParsecT ParserStream () Identity (TypeAST' -> (Text, TypeAST'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier ParsecT ParserStream () Identity (TypeAST' -> (Text, TypeAST'))
-> Parser TypeAST' -> Parser (Text, TypeAST')
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TypeAST'
type_expr

fun_call :: Parser (AST' Text -> AST' Text)
fun_call :: Parser (AST' Text -> AST' Text)
fun_call = (AST' Text -> [AST' Text] -> AST' Text)
-> [AST' Text] -> AST' Text -> AST' Text
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((AST' Text -> AST' Text -> AST' Text)
-> AST' Text -> [AST' Text] -> AST' Text
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl AST' Text -> AST' Text -> AST' Text
forall a. AST' a -> AST' a -> AST' a
App) ([AST' Text] -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity [AST' Text]
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity [AST' Text]
-> ParsecT ParserStream () Identity [AST' Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity a
parens (ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity [AST' Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity [a]
commaSep ParsecT ParserStream () Identity (AST' Text)
expr)

return_expr :: Parser (AST' Text)
return_expr :: ParsecT ParserStream () Identity (AST' Text)
return_expr = do
    String -> Parser ()
reserved String
"return" Parser () -> Parser () -> Parser ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> String -> Parser ()
reserved String
"dirac"
    Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a
app1 Text
"dirac" (AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity (AST' Text)
expr

term :: Parser (AST' Text)
term :: ParsecT ParserStream () Identity (AST' Text)
term =  ParsecT ParserStream () Identity (AST' Text)
if_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
lam_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
def_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
match_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
data_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
integrate_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
summate_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
product_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
transform_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
bucket_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
array_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
plate_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
chain_expr
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
array_literal
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
forall a. Parser (AST' a)
inf_
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
forall a. Parser (AST' a)
natOrProb
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
var
    ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT ParserStream () Identity (AST' Text)
parenthesized
    ParsecT ParserStream () Identity (AST' Text)
-> String -> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"simple expression"

expr :: Parser (AST' Text)
expr :: ParsecT ParserStream () Identity (AST' Text)
expr = ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall a. Parser (AST' a) -> Parser (AST' a)
withPos (ParsecT ParserStream () Identity (AST' Text)
let_expr ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
                ParsecT ParserStream () Identity (AST' Text)
bind_expr ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
                ParsecT ParserStream () Identity (AST' Text)
return_expr ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
                OperatorTable (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall s (m :: * -> *) t u a.
Stream s m t =>
[[Operator s u m a]] -> ParsecT s u m a -> ParsecT s u m a
buildExpressionParser OperatorTable (AST' Text)
table (ParsecT ParserStream () Identity (AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
forall a. Parser (AST' a) -> Parser (AST' a)
withPos ParsecT ParserStream () Identity (AST' Text)
term))
       ParsecT ParserStream () Identity (AST' Text)
-> String -> ParsecT ParserStream () Identity (AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"expression"


indentConfig :: Text -> ParserStream
indentConfig :: Text -> ParserStream
indentConfig =
    Indentation
-> Indentation
-> Bool
-> IndentationRel
-> CharIndentStream Text
-> ParserStream
forall s.
Indentation
-> Indentation -> Bool -> IndentationRel -> s -> IndentStream s
mkIndentStream Indentation
0 Indentation
infIndentation Bool
True IndentationRel
Ge (CharIndentStream Text -> ParserStream)
-> (Text -> CharIndentStream Text) -> Text -> ParserStream
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> CharIndentStream Text
forall s. s -> CharIndentStream s
mkCharIndentStream

parseHakaru :: Text -> Either ParseError (AST' Text)
parseHakaru :: Text -> Either ParseError (AST' Text)
parseHakaru = ParsecT ParserStream () Identity (AST' Text)
-> Text -> Either ParseError (AST' Text)
forall a. Parser a -> Text -> Either ParseError a
parseAtTopLevel ParsecT ParserStream () Identity (AST' Text)
expr

parseHakaruWithImports :: Text -> Either ParseError (ASTWithImport' Text)
parseHakaruWithImports :: Text -> Either ParseError (ASTWithImport' Text)
parseHakaruWithImports = Parser (ASTWithImport' Text)
-> Text -> Either ParseError (ASTWithImport' Text)
forall a. Parser a -> Text -> Either ParseError a
parseAtTopLevel Parser (ASTWithImport' Text)
exprWithImport

parseAtTopLevel :: Parser a -> Text -> Either ParseError a
parseAtTopLevel :: Parser a -> Text -> Either ParseError a
parseAtTopLevel Parser a
p =
    Parser a -> () -> String -> ParserStream -> Either ParseError a
forall s t u a.
Stream s Identity t =>
Parsec s u a -> u -> String -> s -> Either ParseError a
runParser (Parser ()
whiteSpace Parser () -> Parser a -> Parser a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
               Parser a
p Parser a -> Parser () -> Parser a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof) () String
"<input>" (ParserStream -> Either ParseError a)
-> (Text -> ParserStream) -> Text -> Either ParseError a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ParserStream
indentConfig

withPos :: Parser (AST' a) -> Parser (AST' a)
withPos :: Parser (AST' a) -> Parser (AST' a)
withPos Parser (AST' a)
x = do
    SourcePos
s  <- ParsecT ParserStream () Identity SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
    AST' a
x' <- Parser (AST' a)
x
    SourcePos
e  <- ParsecT ParserStream () Identity SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
    AST' a -> Parser (AST' a)
forall (m :: * -> *) a. Monad m => a -> m a
return (AST' a -> Parser (AST' a)) -> AST' a -> Parser (AST' a)
forall a b. (a -> b) -> a -> b
$ AST' a -> SourceSpan -> AST' a
forall a. AST' a -> SourceSpan -> AST' a
WithMeta AST' a
x' (SourcePos -> SourcePos -> SourceSpan
SourceSpan SourcePos
s SourcePos
e)

{-
user-defined types:

data either(a,b):
  left(a)
  right(a)

data maybe(a):
  nothing
  just(a)
-}

data_expr :: Parser (AST' Text)
data_expr :: ParsecT ParserStream () Identity (AST' Text)
data_expr = do
    String -> Parser ()
reserved String
"data"
    Text
ident <- Parser Text
identifier
    [Text]
typvars <- ParsecT ParserStream () Identity [Text]
-> ParsecT ParserStream () Identity [Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity a
parens (Parser Text -> ParsecT ParserStream () Identity [Text]
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity [a]
commaSep Parser Text
identifier)
    [TypeAST']
ts <- Parser TypeAST' -> ParsecT ParserStream () Identity [TypeAST']
forall a.
ParsecT ParserStream () Identity a
-> ParsecT ParserStream () Identity [a]
blockOfMany Parser TypeAST'
type_var_or_app
    AST' Text
e <- ParsecT ParserStream () Identity (AST' Text)
expr
    AST' Text -> ParsecT ParserStream () Identity (AST' Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> [Text] -> [TypeAST'] -> AST' Text -> AST' Text
forall a. a -> [a] -> [TypeAST'] -> AST' a -> AST' a
Data Text
ident [Text]
typvars [TypeAST']
ts AST' Text
e)

import_expr :: Parser (Import Text)
import_expr :: Parser (Import Text)
import_expr =
    String -> Parser ()
reserved String
"import" Parser () -> Parser (Import Text) -> Parser (Import Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Text -> Import Text
forall a. a -> Import a
Import (Text -> Import Text) -> Parser Text -> Parser (Import Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier)

exprWithImport :: Parser (ASTWithImport' Text)
exprWithImport :: Parser (ASTWithImport' Text)
exprWithImport = [Import Text] -> AST' Text -> ASTWithImport' Text
forall a. [Import a] -> AST' a -> ASTWithImport' a
ASTWithImport' ([Import Text] -> AST' Text -> ASTWithImport' Text)
-> ParsecT ParserStream () Identity [Import Text]
-> ParsecT
     ParserStream () Identity (AST' Text -> ASTWithImport' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser (Import Text)
-> ParsecT ParserStream () Identity [Import Text]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser (Import Text)
import_expr) ParsecT ParserStream () Identity (AST' Text -> ASTWithImport' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (ASTWithImport' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr

-- Parsing bindings for Hakaru Repl
type Binding = (AST' Text.Text -> AST' Text.Text)

let_parse :: Parser Binding
let_parse :: Parser (AST' Text -> AST' Text)
let_parse = Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
Let (Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* String -> Parser ()
reservedOp String
"=" ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr

bind_parse :: Parser Binding
bind_parse :: Parser (AST' Text -> AST' Text)
bind_parse = Text -> AST' Text -> AST' Text -> AST' Text
forall a. a -> AST' a -> AST' a -> AST' a
Bind (Text -> AST' Text -> AST' Text -> AST' Text)
-> Parser Text
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
identifier ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> Parser ()
-> ParsecT
     ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* String -> Parser ()
reservedOp String
"<~" ParsecT
  ParserStream () Identity (AST' Text -> AST' Text -> AST' Text)
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (AST' Text -> AST' Text)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT ParserStream () Identity (AST' Text)
expr

binding_parse :: Parser Binding
binding_parse :: Parser (AST' Text -> AST' Text)
binding_parse = Parser (AST' Text -> AST' Text) -> Parser (AST' Text -> AST' Text)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser (AST' Text -> AST' Text)
let_parse Parser (AST' Text -> AST' Text)
-> Parser (AST' Text -> AST' Text)
-> Parser (AST' Text -> AST' Text)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (AST' Text -> AST' Text)
bind_parse

bindingOrExpr :: Parser (Either Binding (AST' Text.Text))
bindingOrExpr :: Parser (Either (AST' Text -> AST' Text) (AST' Text))
bindingOrExpr = (AST' Text -> AST' Text)
-> Either (AST' Text -> AST' Text) (AST' Text)
forall a b. a -> Either a b
Left ((AST' Text -> AST' Text)
 -> Either (AST' Text -> AST' Text) (AST' Text))
-> Parser (AST' Text -> AST' Text)
-> Parser (Either (AST' Text -> AST' Text) (AST' Text))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (AST' Text -> AST' Text) -> Parser (AST' Text -> AST' Text)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser (AST' Text -> AST' Text)
binding_parse Parser (Either (AST' Text -> AST' Text) (AST' Text))
-> Parser (Either (AST' Text -> AST' Text) (AST' Text))
-> Parser (Either (AST' Text -> AST' Text) (AST' Text))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> AST' Text -> Either (AST' Text -> AST' Text) (AST' Text)
forall a b. b -> Either a b
Right (AST' Text -> Either (AST' Text -> AST' Text) (AST' Text))
-> ParsecT ParserStream () Identity (AST' Text)
-> Parser (Either (AST' Text -> AST' Text) (AST' Text))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT ParserStream () Identity (AST' Text)
expr

parseReplLine :: Text.Text -> Either ParseError (Either Binding (AST' Text.Text))
parseReplLine :: Text
-> Either ParseError (Either (AST' Text -> AST' Text) (AST' Text))
parseReplLine Text
x = Parser (Either (AST' Text -> AST' Text) (AST' Text))
-> Text
-> Either ParseError (Either (AST' Text -> AST' Text) (AST' Text))
forall a. Parser a -> Text -> Either ParseError a
parseAtTopLevel Parser (Either (AST' Text -> AST' Text) (AST' Text))
bindingOrExpr Text
x

-- | A variant of @Text.Parsec.Expr.buildExpressionParser@ (parsec-3.1.11)
-- that behaves more restrictively when a precedence level contains both
-- unary and binary operators.  Unary operators are only allowed on the
-- first operand when parsing left-associatively and on the last operand
-- when parsing right-associatively.  This restriction lets us recover the
-- behavior of unary negation in Haskell.

buildExpressionParser :: (Stream s m t)
                      => [[Operator s u m a]]
                      -> ParsecT s u m a
                      -> ParsecT s u m a
buildExpressionParser :: [[Operator s u m a]] -> ParsecT s u m a -> ParsecT s u m a
buildExpressionParser [[Operator s u m a]]
operators ParsecT s u m a
simpleExpr
    = (ParsecT s u m a -> [Operator s u m a] -> ParsecT s u m a)
-> ParsecT s u m a -> [[Operator s u m a]] -> ParsecT s u m a
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (ParsecT s u m a -> [Operator s u m a] -> ParsecT s u m a
forall (t :: * -> *) s (m :: * -> *) t t t t t u b.
(Foldable t, Stream s m t, Stream s m t, Stream s m t,
 Stream s m t, Stream s m t) =>
ParsecT s u m b -> t (Operator s u m b) -> ParsecT s u m b
makeParser) ParsecT s u m a
simpleExpr [[Operator s u m a]]
operators
    where
      makeParser :: ParsecT s u m b -> t (Operator s u m b) -> ParsecT s u m b
makeParser ParsecT s u m b
term' t (Operator s u m b)
ops'
        = let ([ParsecT s u m (b -> b -> b)]
rassoc,[ParsecT s u m (b -> b -> b)]
lassoc,[ParsecT s u m (b -> b -> b)]
nassoc
               ,[ParsecT s u m (b -> b)]
prefix,[ParsecT s u m (b -> b)]
postfix')      = (Operator s u m b
 -> ([ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b -> b)],
     [ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b)],
     [ParsecT s u m (b -> b)])
 -> ([ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b -> b)],
     [ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b)],
     [ParsecT s u m (b -> b)]))
-> ([ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b -> b)],
    [ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b)],
    [ParsecT s u m (b -> b)])
-> t (Operator s u m b)
-> ([ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b -> b)],
    [ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b)],
    [ParsecT s u m (b -> b)])
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Operator s u m b
-> ([ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b -> b)],
    [ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b)],
    [ParsecT s u m (b -> b)])
-> ([ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b -> b)],
    [ParsecT s u m (b -> b -> b)], [ParsecT s u m (b -> b)],
    [ParsecT s u m (b -> b)])
forall s u (m :: * -> *) a.
Operator s u m a
-> ([ParsecT s u m (a -> a -> a)], [ParsecT s u m (a -> a -> a)],
    [ParsecT s u m (a -> a -> a)], [ParsecT s u m (a -> a)],
    [ParsecT s u m (a -> a)])
-> ([ParsecT s u m (a -> a -> a)], [ParsecT s u m (a -> a -> a)],
    [ParsecT s u m (a -> a -> a)], [ParsecT s u m (a -> a)],
    [ParsecT s u m (a -> a)])
splitOp ([],[],[],[],[]) t (Operator s u m b)
ops'

              rassocOp :: ParsecT s u m (b -> b -> b)
rassocOp   = [ParsecT s u m (b -> b -> b)] -> ParsecT s u m (b -> b -> b)
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice [ParsecT s u m (b -> b -> b)]
rassoc
              lassocOp :: ParsecT s u m (b -> b -> b)
lassocOp   = [ParsecT s u m (b -> b -> b)] -> ParsecT s u m (b -> b -> b)
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice [ParsecT s u m (b -> b -> b)]
lassoc
              nassocOp :: ParsecT s u m (b -> b -> b)
nassocOp   = [ParsecT s u m (b -> b -> b)] -> ParsecT s u m (b -> b -> b)
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice [ParsecT s u m (b -> b -> b)]
nassoc
              prefixOp :: ParsecT s u m (b -> b)
prefixOp   = [ParsecT s u m (b -> b)] -> ParsecT s u m (b -> b)
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice [ParsecT s u m (b -> b)]
prefix  ParsecT s u m (b -> b) -> String -> ParsecT s u m (b -> b)
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
""
              postfixOp :: ParsecT s u m (b -> b)
postfixOp  = [ParsecT s u m (b -> b)] -> ParsecT s u m (b -> b)
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice [ParsecT s u m (b -> b)]
postfix' ParsecT s u m (b -> b) -> String -> ParsecT s u m (b -> b)
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
""

              ambigious :: String -> ParsecT s u m a -> ParsecT s u m a
ambigious String
assoc ParsecT s u m a
op= ParsecT s u m a -> ParsecT s u m a
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT s u m a -> ParsecT s u m a)
-> ParsecT s u m a -> ParsecT s u m a
forall a b. (a -> b) -> a -> b
$
                                  do{ a
_ <- ParsecT s u m a
op
                                    ; String -> ParsecT s u m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"ambiguous use of a " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
assoc
                                            String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" associative operator")
                                    }

              ambigiousRight :: ParsecT s u m a
ambigiousRight    = String -> ParsecT s u m (b -> b -> b) -> ParsecT s u m a
forall s u (m :: * -> *) a a.
String -> ParsecT s u m a -> ParsecT s u m a
ambigious String
"right" ParsecT s u m (b -> b -> b)
rassocOp
              ambigiousLeft :: ParsecT s u m a
ambigiousLeft     = String -> ParsecT s u m (b -> b -> b) -> ParsecT s u m a
forall s u (m :: * -> *) a a.
String -> ParsecT s u m a -> ParsecT s u m a
ambigious String
"left" ParsecT s u m (b -> b -> b)
lassocOp
              ambigiousNon :: ParsecT s u m a
ambigiousNon      = String -> ParsecT s u m (b -> b -> b) -> ParsecT s u m a
forall s u (m :: * -> *) a a.
String -> ParsecT s u m a -> ParsecT s u m a
ambigious String
"non" ParsecT s u m (b -> b -> b)
nassocOp

              termP :: ParsecT s u m (Bool, b)
termP      = do{ (Bool
preU, b -> b
pre)   <- ParsecT s u m (Bool, b -> b)
prefixP
                             ; b
x             <- ParsecT s u m b
term'
                             ; (Bool
postU, b -> b
post) <- ParsecT s u m (Bool, b -> b)
postfixP
                             ; (Bool, b) -> ParsecT s u m (Bool, b)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
preU Bool -> Bool -> Bool
|| Bool
postU, b -> b
post (b -> b
pre b
x))
                             }

              postfixP :: ParsecT s u m (Bool, b -> b)
postfixP   = ((,) Bool
True) ((b -> b) -> (Bool, b -> b))
-> ParsecT s u m (b -> b) -> ParsecT s u m (Bool, b -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m (b -> b)
postfixOp ParsecT s u m (Bool, b -> b)
-> ParsecT s u m (Bool, b -> b) -> ParsecT s u m (Bool, b -> b)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Bool, b -> b) -> ParsecT s u m (Bool, b -> b)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
False, b -> b
forall a. a -> a
id)

              prefixP :: ParsecT s u m (Bool, b -> b)
prefixP    = ((,) Bool
True) ((b -> b) -> (Bool, b -> b))
-> ParsecT s u m (b -> b) -> ParsecT s u m (Bool, b -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m (b -> b)
prefixOp ParsecT s u m (Bool, b -> b)
-> ParsecT s u m (Bool, b -> b) -> ParsecT s u m (Bool, b -> b)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Bool, b -> b) -> ParsecT s u m (Bool, b -> b)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
False, b -> b
forall a. a -> a
id)

              rassocP :: b -> ParsecT s u m b
rassocP b
x  = do{ b -> b -> b
f      <- ParsecT s u m (b -> b -> b)
rassocOp
                             ; (Bool
u, b
z) <- ParsecT s u m (Bool, b)
termP
                             ; b
y      <- if Bool
u then b -> ParsecT s u m b
forall (m :: * -> *) a. Monad m => a -> m a
return b
z else b -> ParsecT s u m b
rassocP1 b
z
                             ; b -> ParsecT s u m b
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> b -> b
f b
x b
y)
                             }
                           ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m b
forall a. ParsecT s u m a
ambigiousLeft
                           ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m b
forall a. ParsecT s u m a
ambigiousNon
                           -- <|> return x

              rassocP1 :: b -> ParsecT s u m b
rassocP1 b
x = b -> ParsecT s u m b
rassocP b
x  ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> b -> ParsecT s u m b
forall (m :: * -> *) a. Monad m => a -> m a
return b
x

              lassocP :: b -> ParsecT s u m b
lassocP b
x  = do{ b -> b -> b
f <- ParsecT s u m (b -> b -> b)
lassocOp
                             ; b
y <- ParsecT s u m b
term'
                             ; b -> ParsecT s u m b
lassocP1 (b -> b -> b
f b
x b
y)
                             }
                           ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m b
forall a. ParsecT s u m a
ambigiousRight
                           ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m b
forall a. ParsecT s u m a
ambigiousNon
                           -- <|> return x

              lassocP1 :: b -> ParsecT s u m b
lassocP1 b
x = b -> ParsecT s u m b
lassocP b
x ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> b -> ParsecT s u m b
forall (m :: * -> *) a. Monad m => a -> m a
return b
x

              nassocP :: b -> ParsecT s u m b
nassocP b
x  = do{ b -> b -> b
f <- ParsecT s u m (b -> b -> b)
nassocOp
                             ; b
y <- ParsecT s u m b
term'
                             ;    ParsecT s u m b
forall a. ParsecT s u m a
ambigiousRight
                              ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m b
forall a. ParsecT s u m a
ambigiousLeft
                              ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m b
forall a. ParsecT s u m a
ambigiousNon
                              ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> b -> ParsecT s u m b
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> b -> b
f b
x b
y)
                             }
                           -- <|> return x

           in  do{ (Bool
u, b
x) <- ParsecT s u m (Bool, b)
termP
                 ;     (if Bool
u then ParsecT s u m b
forall s u (m :: * -> *) a. ParsecT s u m a
parserZero else b -> ParsecT s u m b
rassocP b
x)
                   ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>                            b -> ParsecT s u m b
lassocP b
x
                   ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (if Bool
u then ParsecT s u m b
forall s u (m :: * -> *) a. ParsecT s u m a
parserZero else b -> ParsecT s u m b
nassocP b
x)
                   ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>                            b -> ParsecT s u m b
forall (m :: * -> *) a. Monad m => a -> m a
return  b
x
                   ParsecT s u m b -> String -> ParsecT s u m b
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"operator"
                 }


      splitOp :: Operator s u m a
-> ([ParsecT s u m (a -> a -> a)], [ParsecT s u m (a -> a -> a)],
    [ParsecT s u m (a -> a -> a)], [ParsecT s u m (a -> a)],
    [ParsecT s u m (a -> a)])
-> ([ParsecT s u m (a -> a -> a)], [ParsecT s u m (a -> a -> a)],
    [ParsecT s u m (a -> a -> a)], [ParsecT s u m (a -> a)],
    [ParsecT s u m (a -> a)])
splitOp (Infix ParsecT s u m (a -> a -> a)
op Assoc
assoc) ([ParsecT s u m (a -> a -> a)]
rassoc,[ParsecT s u m (a -> a -> a)]
lassoc,[ParsecT s u m (a -> a -> a)]
nassoc,[ParsecT s u m (a -> a)]
prefix,[ParsecT s u m (a -> a)]
postfix')
        = case Assoc
assoc of
            Assoc
AssocNone  -> ([ParsecT s u m (a -> a -> a)]
rassoc,[ParsecT s u m (a -> a -> a)]
lassoc,ParsecT s u m (a -> a -> a)
opParsecT s u m (a -> a -> a)
-> [ParsecT s u m (a -> a -> a)] -> [ParsecT s u m (a -> a -> a)]
forall a. a -> [a] -> [a]
:[ParsecT s u m (a -> a -> a)]
nassoc,[ParsecT s u m (a -> a)]
prefix,[ParsecT s u m (a -> a)]
postfix')
            Assoc
AssocLeft  -> ([ParsecT s u m (a -> a -> a)]
rassoc,ParsecT s u m (a -> a -> a)
opParsecT s u m (a -> a -> a)
-> [ParsecT s u m (a -> a -> a)] -> [ParsecT s u m (a -> a -> a)]
forall a. a -> [a] -> [a]
:[ParsecT s u m (a -> a -> a)]
lassoc,[ParsecT s u m (a -> a -> a)]
nassoc,[ParsecT s u m (a -> a)]
prefix,[ParsecT s u m (a -> a)]
postfix')
            Assoc
AssocRight -> (ParsecT s u m (a -> a -> a)
opParsecT s u m (a -> a -> a)
-> [ParsecT s u m (a -> a -> a)] -> [ParsecT s u m (a -> a -> a)]
forall a. a -> [a] -> [a]
:[ParsecT s u m (a -> a -> a)]
rassoc,[ParsecT s u m (a -> a -> a)]
lassoc,[ParsecT s u m (a -> a -> a)]
nassoc,[ParsecT s u m (a -> a)]
prefix,[ParsecT s u m (a -> a)]
postfix')

      splitOp (Prefix ParsecT s u m (a -> a)
op) ([ParsecT s u m (a -> a -> a)]
rassoc,[ParsecT s u m (a -> a -> a)]
lassoc,[ParsecT s u m (a -> a -> a)]
nassoc,[ParsecT s u m (a -> a)]
prefix,[ParsecT s u m (a -> a)]
postfix')
        = ([ParsecT s u m (a -> a -> a)]
rassoc,[ParsecT s u m (a -> a -> a)]
lassoc,[ParsecT s u m (a -> a -> a)]
nassoc,ParsecT s u m (a -> a)
opParsecT s u m (a -> a)
-> [ParsecT s u m (a -> a)] -> [ParsecT s u m (a -> a)]
forall a. a -> [a] -> [a]
:[ParsecT s u m (a -> a)]
prefix,[ParsecT s u m (a -> a)]
postfix')

      splitOp (Postfix ParsecT s u m (a -> a)
op) ([ParsecT s u m (a -> a -> a)]
rassoc,[ParsecT s u m (a -> a -> a)]
lassoc,[ParsecT s u m (a -> a -> a)]
nassoc,[ParsecT s u m (a -> a)]
prefix,[ParsecT s u m (a -> a)]
postfix')
        = ([ParsecT s u m (a -> a -> a)]
rassoc,[ParsecT s u m (a -> a -> a)]
lassoc,[ParsecT s u m (a -> a -> a)]
nassoc,[ParsecT s u m (a -> a)]
prefix,ParsecT s u m (a -> a)
opParsecT s u m (a -> a)
-> [ParsecT s u m (a -> a)] -> [ParsecT s u m (a -> a)]
forall a. a -> [a] -> [a]
:[ParsecT s u m (a -> a)]
postfix')