{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE CPP #-}
module Text.Haiji.Syntax.Expression
       ( Expression(..)
       , expression
       , Expr(..)
       , External
       ) where

import Prelude hiding (filter)
#if MIN_VERSION_base(4,8,0)
#else
import Control.Applicative
#endif
import Data.Attoparsec.Text
import Data.Bool
import Data.List hiding (filter)
import Data.Scientific
import Text.Haiji.Syntax.Identifier
import Text.Haiji.Syntax.Filter
import Text.Haiji.Syntax.Literal

-- $setup
-- >>> import Control.Arrow (left)

data Z
data S a

type Level0 = Z
type Level1 = S Level0
type Level2 = S Level1
type Level3 = S Level2
type Level4 = S Level3
type Level5 = S Level4
type Level6 = S Level5
type Level7 = S Level6
type Level8 = S Level7

type LevelMax = Level8

data MulDiv = Mul | DivF | DivI | Mod deriving MulDiv -> MulDiv -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MulDiv -> MulDiv -> Bool
$c/= :: MulDiv -> MulDiv -> Bool
== :: MulDiv -> MulDiv -> Bool
$c== :: MulDiv -> MulDiv -> Bool
Eq

instance Show MulDiv where
  show :: MulDiv -> String
show MulDiv
Mul = String
"*"
  show MulDiv
DivF = String
"/"
  show MulDiv
DivI = String
"//"
  show MulDiv
Mod = String
"%"

data AddSub = Add | Sub deriving AddSub -> AddSub -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AddSub -> AddSub -> Bool
$c/= :: AddSub -> AddSub -> Bool
== :: AddSub -> AddSub -> Bool
$c== :: AddSub -> AddSub -> Bool
Eq

instance Show AddSub where
  show :: AddSub -> String
show AddSub
Add = String
"+"
  show AddSub
Sub = String
"-"

data Internal
data External

data Expr visibility level where
  ExprLift :: Expr visibility lv -> Expr visibility (S lv)
  ExprIntegerLiteral :: Integer -> Expr visibility Level0
  ExprStringLiteral :: StringLiteral -> Expr visibility Level0
  ExprBooleanLiteral :: Bool -> Expr visibility Level0
  ExprVariable :: Identifier -> Expr visibility Level0
  ExprParen :: Expr visibility LevelMax -> Expr visibility Level0
  ExprRange :: [Expr visibility LevelMax] -> Expr visibility Level0
  ExprAttributed :: Expr visibility Level0 -> [Identifier] -> Expr visibility Level1
  ExprFiltered :: Expr visibility Level1 -> [Filter] -> Expr visibility Level2
  ExprInternalPow :: Expr Internal Level2 -> [Expr Internal Level2] -> Expr Internal Level3
  ExprPow :: Expr External Level3 -> Expr External Level2 -> Expr External Level3
  ExprInternalMulDiv :: Expr Internal Level3 -> [(MulDiv, Expr Internal Level3)] -> Expr Internal Level4
  ExprMul :: Expr External Level4 -> Expr External Level3 -> Expr External Level4
  ExprDivF :: Expr External Level4 -> Expr External Level3 -> Expr External Level4
  ExprDivI :: Expr External Level4 -> Expr External Level3 -> Expr External Level4
  ExprMod :: Expr External Level4 -> Expr External Level3 -> Expr External Level4
  ExprInternalAddSub :: Expr Internal Level4 -> [(AddSub, Expr Internal Level4)] -> Expr Internal Level5
  ExprAdd :: Expr External Level5 -> Expr External Level4 -> Expr External Level5
  ExprSub :: Expr External Level5 -> Expr External Level4 -> Expr External Level5
  ExprEQ :: Expr visibility Level5 -> Expr visibility Level5 -> Expr visibility Level6
  ExprNEQ :: Expr visibility Level5 -> Expr visibility Level5 -> Expr visibility Level6
  ExprGT :: Expr visibility Level5 -> Expr visibility Level5 -> Expr visibility Level6
  ExprGE :: Expr visibility Level5 -> Expr visibility Level5 -> Expr visibility Level6
  ExprLT :: Expr visibility Level5 -> Expr visibility Level5 -> Expr visibility Level6
  ExprLE :: Expr visibility Level5 -> Expr visibility Level5 -> Expr visibility Level6
  ExprInternalAnd :: Expr Internal Level6 -> [Expr Internal Level6] -> Expr Internal Level7
  ExprAnd :: Expr External Level7 -> Expr External Level6 -> Expr External Level7
  ExprInternalOr :: Expr Internal Level7 -> [Expr Internal Level7] -> Expr Internal Level8
  ExprOr :: Expr External Level8 -> Expr External Level7 -> Expr External Level8

toExternal :: Expr Internal level -> Expr External level
toExternal :: forall level. Expr Internal level -> Expr External level
toExternal (ExprLift Expr Internal lv
e) = forall visibility lv. Expr visibility lv -> Expr visibility (S lv)
ExprLift forall a b. (a -> b) -> a -> b
$ forall level. Expr Internal level -> Expr External level
toExternal Expr Internal lv
e
toExternal (ExprIntegerLiteral Integer
n) = forall visibility. Integer -> Expr visibility Z
ExprIntegerLiteral Integer
n
toExternal (ExprStringLiteral StringLiteral
n) = forall visibility. StringLiteral -> Expr visibility Z
ExprStringLiteral StringLiteral
n
toExternal (ExprBooleanLiteral Bool
b) = forall visibility. Bool -> Expr visibility Z
ExprBooleanLiteral Bool
b
toExternal (ExprVariable Identifier
i) = forall visibility. Identifier -> Expr visibility Z
ExprVariable Identifier
i
toExternal (ExprParen Expr Internal LevelMax
e) = forall visibility. Expr visibility LevelMax -> Expr visibility Z
ExprParen forall a b. (a -> b) -> a -> b
$ forall level. Expr Internal level -> Expr External level
toExternal Expr Internal LevelMax
e
toExternal (ExprRange [Expr Internal LevelMax]
args) = forall visibility. [Expr visibility LevelMax] -> Expr visibility Z
ExprRange forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall level. Expr Internal level -> Expr External level
toExternal [Expr Internal LevelMax]
args
toExternal (ExprAttributed Expr Internal Z
e [Identifier]
attrs) = forall visibility.
Expr visibility Z -> [Identifier] -> Expr visibility (S Z)
ExprAttributed (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal Z
e) [Identifier]
attrs
toExternal (ExprFiltered Expr Internal (S Z)
e [Filter]
filters) = forall visibility.
Expr visibility (S Z) -> [Filter] -> Expr visibility (S (S Z))
ExprFiltered (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S Z)
e) [Filter]
filters
toExternal (ExprInternalPow Expr Internal (S (S Z))
e []) = forall visibility lv. Expr visibility lv -> Expr visibility (S lv)
ExprLift forall a b. (a -> b) -> a -> b
$ forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S Z))
e
toExternal (ExprInternalPow Expr Internal (S (S Z))
e [Expr Internal (S (S Z))]
es) = Expr External (S (S (S Z)))
-> Expr External (S (S Z)) -> Expr External (S (S (S Z)))
ExprPow (forall level. Expr Internal level -> Expr External level
toExternal (Expr Internal (S (S Z))
-> [Expr Internal (S (S Z))] -> Expr Internal (S (S (S Z)))
ExprInternalPow Expr Internal (S (S Z))
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
init [Expr Internal (S (S Z))]
es)) (forall level. Expr Internal level -> Expr External level
toExternal forall a b. (a -> b) -> a -> b
$ forall a. [a] -> a
last [Expr Internal (S (S Z))]
es)
toExternal (ExprInternalMulDiv Expr Internal (S (S (S Z)))
e []) = forall visibility lv. Expr visibility lv -> Expr visibility (S lv)
ExprLift forall a b. (a -> b) -> a -> b
$ forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S Z)))
e
toExternal (ExprInternalMulDiv Expr Internal (S (S (S Z)))
e [(MulDiv, Expr Internal (S (S (S Z))))]
es) = case forall a. [a] -> a
last [(MulDiv, Expr Internal (S (S (S Z))))]
es of
  (MulDiv
Mul , Expr Internal (S (S (S Z)))
e') -> Expr External (S (S (S (S Z))))
-> Expr External (S (S (S Z))) -> Expr External (S (S (S (S Z))))
ExprMul  (forall level. Expr Internal level -> Expr External level
toExternal (Expr Internal (S (S (S Z)))
-> [(MulDiv, Expr Internal (S (S (S Z))))]
-> Expr Internal (S (S (S (S Z))))
ExprInternalMulDiv Expr Internal (S (S (S Z)))
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
init [(MulDiv, Expr Internal (S (S (S Z))))]
es)) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S Z)))
e')
  (MulDiv
DivF, Expr Internal (S (S (S Z)))
e') -> Expr External (S (S (S (S Z))))
-> Expr External (S (S (S Z))) -> Expr External (S (S (S (S Z))))
ExprDivF (forall level. Expr Internal level -> Expr External level
toExternal (Expr Internal (S (S (S Z)))
-> [(MulDiv, Expr Internal (S (S (S Z))))]
-> Expr Internal (S (S (S (S Z))))
ExprInternalMulDiv Expr Internal (S (S (S Z)))
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
init [(MulDiv, Expr Internal (S (S (S Z))))]
es)) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S Z)))
e')
  (MulDiv
DivI, Expr Internal (S (S (S Z)))
e') -> Expr External (S (S (S (S Z))))
-> Expr External (S (S (S Z))) -> Expr External (S (S (S (S Z))))
ExprDivI (forall level. Expr Internal level -> Expr External level
toExternal (Expr Internal (S (S (S Z)))
-> [(MulDiv, Expr Internal (S (S (S Z))))]
-> Expr Internal (S (S (S (S Z))))
ExprInternalMulDiv Expr Internal (S (S (S Z)))
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
init [(MulDiv, Expr Internal (S (S (S Z))))]
es)) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S Z)))
e')
  (MulDiv
Mod , Expr Internal (S (S (S Z)))
e') -> Expr External (S (S (S (S Z))))
-> Expr External (S (S (S Z))) -> Expr External (S (S (S (S Z))))
ExprMod  (forall level. Expr Internal level -> Expr External level
toExternal (Expr Internal (S (S (S Z)))
-> [(MulDiv, Expr Internal (S (S (S Z))))]
-> Expr Internal (S (S (S (S Z))))
ExprInternalMulDiv Expr Internal (S (S (S Z)))
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
init [(MulDiv, Expr Internal (S (S (S Z))))]
es)) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S Z)))
e')
toExternal (ExprInternalAddSub Expr Internal (S (S (S (S Z))))
e []) = forall visibility lv. Expr visibility lv -> Expr visibility (S lv)
ExprLift forall a b. (a -> b) -> a -> b
$ forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S Z))))
e
toExternal (ExprInternalAddSub Expr Internal (S (S (S (S Z))))
e [(AddSub, Expr Internal (S (S (S (S Z)))))]
es) = case forall a. [a] -> a
last [(AddSub, Expr Internal (S (S (S (S Z)))))]
es of
  (AddSub
Add, Expr Internal (S (S (S (S Z))))
e') -> Expr External (S (S (S (S (S Z)))))
-> Expr External (S (S (S (S Z))))
-> Expr External (S (S (S (S (S Z)))))
ExprAdd (forall level. Expr Internal level -> Expr External level
toExternal (Expr Internal (S (S (S (S Z))))
-> [(AddSub, Expr Internal (S (S (S (S Z)))))]
-> Expr Internal (S (S (S (S (S Z)))))
ExprInternalAddSub Expr Internal (S (S (S (S Z))))
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
init [(AddSub, Expr Internal (S (S (S (S Z)))))]
es)) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S Z))))
e')
  (AddSub
Sub, Expr Internal (S (S (S (S Z))))
e') -> Expr External (S (S (S (S (S Z)))))
-> Expr External (S (S (S (S Z))))
-> Expr External (S (S (S (S (S Z)))))
ExprSub (forall level. Expr Internal level -> Expr External level
toExternal (Expr Internal (S (S (S (S Z))))
-> [(AddSub, Expr Internal (S (S (S (S Z)))))]
-> Expr Internal (S (S (S (S (S Z)))))
ExprInternalAddSub Expr Internal (S (S (S (S Z))))
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
init [(AddSub, Expr Internal (S (S (S (S Z)))))]
es)) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S Z))))
e')
toExternal (ExprEQ Expr Internal (S (S (S (S (S Z)))))
e1 Expr Internal (S (S (S (S (S Z)))))
e2) = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprEQ (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e1) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e2)
toExternal (ExprNEQ Expr Internal (S (S (S (S (S Z)))))
e1 Expr Internal (S (S (S (S (S Z)))))
e2) = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprNEQ (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e1) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e2)
toExternal (ExprGT Expr Internal (S (S (S (S (S Z)))))
e1 Expr Internal (S (S (S (S (S Z)))))
e2) = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprGT (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e1) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e2)
toExternal (ExprGE Expr Internal (S (S (S (S (S Z)))))
e1 Expr Internal (S (S (S (S (S Z)))))
e2) = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprGE (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e1) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e2)
toExternal (ExprLT Expr Internal (S (S (S (S (S Z)))))
e1 Expr Internal (S (S (S (S (S Z)))))
e2) = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprLT (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e1) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e2)
toExternal (ExprLE Expr Internal (S (S (S (S (S Z)))))
e1 Expr Internal (S (S (S (S (S Z)))))
e2) = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprLE (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e1) (forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S Z)))))
e2)
toExternal (ExprInternalAnd Expr Internal (S (S (S (S (S (S Z))))))
e []) = forall visibility lv. Expr visibility lv -> Expr visibility (S lv)
ExprLift forall a b. (a -> b) -> a -> b
$ forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S (S Z))))))
e
toExternal (ExprInternalAnd Expr Internal (S (S (S (S (S (S Z))))))
e [Expr Internal (S (S (S (S (S (S Z))))))]
es) = Expr External (S (S (S (S (S (S (S Z)))))))
-> Expr External (S (S (S (S (S (S Z))))))
-> Expr External (S (S (S (S (S (S (S Z)))))))
ExprAnd (forall level. Expr Internal level -> Expr External level
toExternal (Expr Internal (S (S (S (S (S (S Z))))))
-> [Expr Internal (S (S (S (S (S (S Z))))))]
-> Expr Internal (S (S (S (S (S (S (S Z)))))))
ExprInternalAnd Expr Internal (S (S (S (S (S (S Z))))))
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
init [Expr Internal (S (S (S (S (S (S Z))))))]
es)) (forall level. Expr Internal level -> Expr External level
toExternal forall a b. (a -> b) -> a -> b
$ forall a. [a] -> a
last [Expr Internal (S (S (S (S (S (S Z))))))]
es)
toExternal (ExprInternalOr Expr Internal (S (S (S (S (S (S (S Z)))))))
e []) = forall visibility lv. Expr visibility lv -> Expr visibility (S lv)
ExprLift forall a b. (a -> b) -> a -> b
$ forall level. Expr Internal level -> Expr External level
toExternal Expr Internal (S (S (S (S (S (S (S Z)))))))
e
toExternal (ExprInternalOr Expr Internal (S (S (S (S (S (S (S Z)))))))
e [Expr Internal (S (S (S (S (S (S (S Z)))))))]
es) = Expr External LevelMax
-> Expr External (S (S (S (S (S (S (S Z)))))))
-> Expr External LevelMax
ExprOr (forall level. Expr Internal level -> Expr External level
toExternal (Expr Internal (S (S (S (S (S (S (S Z)))))))
-> [Expr Internal (S (S (S (S (S (S (S Z)))))))]
-> Expr Internal LevelMax
ExprInternalOr Expr Internal (S (S (S (S (S (S (S Z)))))))
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
init [Expr Internal (S (S (S (S (S (S (S Z)))))))]
es)) (forall level. Expr Internal level -> Expr External level
toExternal forall a b. (a -> b) -> a -> b
$ forall a. [a] -> a
last [Expr Internal (S (S (S (S (S (S (S Z)))))))]
es)

deriving instance Eq (Expr visibility level)

instance Show (Expr visibility phase) where
  show :: Expr visibility phase -> String
show (ExprLift Expr visibility lv
e) = forall a. Show a => a -> String
show Expr visibility lv
e
  show (ExprIntegerLiteral Integer
n) = forall a. Show a => a -> String
show Integer
n
  show (ExprStringLiteral StringLiteral
n) = forall a. Show a => a -> String
show StringLiteral
n
  show (ExprBooleanLiteral Bool
b) = if Bool
b then String
"true" else String
"false"
  show (ExprVariable Identifier
v) = forall a. Show a => a -> String
show Identifier
v
  show (ExprParen Expr visibility LevelMax
e) = Char
'(' forall a. a -> [a] -> [a]
: forall a. Show a => a -> ShowS
shows Expr visibility LevelMax
e String
")"
  show (ExprRange [Expr visibility LevelMax]
args) = String
"range(" forall a. [a] -> [a] -> [a]
++ forall a. [a] -> [[a]] -> [a]
intercalate String
", " [ forall a. Show a => a -> String
show Expr visibility LevelMax
e | Expr visibility LevelMax
e <- [Expr visibility LevelMax]
args ] forall a. [a] -> [a] -> [a]
++ String
")"
  show (ExprAttributed Expr visibility Z
e [Identifier]
attrs) = forall a. Show a => a -> ShowS
shows Expr visibility Z
e forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ Char
'.' forall a. a -> [a] -> [a]
: forall a. Show a => a -> String
show Identifier
a | Identifier
a <- [Identifier]
attrs ]
  show (ExprFiltered Expr visibility (S Z)
v [Filter]
filters) = forall a. Show a => a -> ShowS
shows Expr visibility (S Z)
v forall a b. (a -> b) -> a -> b
$ [Filter]
filters forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a. Show a => a -> String
show
  show (ExprInternalPow Expr Internal (S (S Z))
e [Expr Internal (S (S Z))]
es) = forall a. [a] -> [[a]] -> [a]
intercalate String
" ** " forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Expr Internal (S (S Z))
eforall a. a -> [a] -> [a]
:[Expr Internal (S (S Z))]
es
  show (ExprPow Expr External (S (S (S Z)))
e1 Expr External (S (S Z))
e2) = forall a. Show a => a -> ShowS
shows Expr External (S (S (S Z)))
e1 String
" ** " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr External (S (S Z))
e2
  show (ExprInternalMulDiv Expr Internal (S (S (S Z)))
e [(MulDiv, Expr Internal (S (S (S Z))))]
es) = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show Expr Internal (S (S (S Z)))
e forall a. a -> [a] -> [a]
: forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ [ Char
' ' forall a. a -> [a] -> [a]
: forall a. Show a => a -> ShowS
shows MulDiv
op String
" ", forall a. Show a => a -> String
show Expr Internal (S (S (S Z)))
e' ] | (MulDiv
op, Expr Internal (S (S (S Z)))
e') <- [(MulDiv, Expr Internal (S (S (S Z))))]
es ]
  show (ExprMul Expr External (S (S (S (S Z))))
e1 Expr External (S (S (S Z)))
e2) = forall a. Show a => a -> ShowS
shows Expr External (S (S (S (S Z))))
e1 String
" * " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr External (S (S (S Z)))
e2
  show (ExprDivF Expr External (S (S (S (S Z))))
e1 Expr External (S (S (S Z)))
e2) = forall a. Show a => a -> ShowS
shows Expr External (S (S (S (S Z))))
e1 String
" / " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr External (S (S (S Z)))
e2
  show (ExprDivI Expr External (S (S (S (S Z))))
e1 Expr External (S (S (S Z)))
e2) = forall a. Show a => a -> ShowS
shows Expr External (S (S (S (S Z))))
e1 String
" // " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr External (S (S (S Z)))
e2
  show (ExprMod Expr External (S (S (S (S Z))))
e1 Expr External (S (S (S Z)))
e2) = forall a. Show a => a -> ShowS
shows Expr External (S (S (S (S Z))))
e1 String
" % " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr External (S (S (S Z)))
e2
  show (ExprInternalAddSub Expr Internal (S (S (S (S Z))))
e [(AddSub, Expr Internal (S (S (S (S Z)))))]
es) = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show Expr Internal (S (S (S (S Z))))
e forall a. a -> [a] -> [a]
: forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ [ Char
' ' forall a. a -> [a] -> [a]
: forall a. Show a => a -> ShowS
shows AddSub
op String
" ", forall a. Show a => a -> String
show Expr Internal (S (S (S (S Z))))
e' ] | (AddSub
op, Expr Internal (S (S (S (S Z))))
e') <- [(AddSub, Expr Internal (S (S (S (S Z)))))]
es ]
  show (ExprAdd Expr External (S (S (S (S (S Z)))))
e1 Expr External (S (S (S (S Z))))
e2) = forall a. Show a => a -> ShowS
shows Expr External (S (S (S (S (S Z)))))
e1 String
" + " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr External (S (S (S (S Z))))
e2
  show (ExprSub Expr External (S (S (S (S (S Z)))))
e1 Expr External (S (S (S (S Z))))
e2) = forall a. Show a => a -> ShowS
shows Expr External (S (S (S (S (S Z)))))
e1 String
" - " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr External (S (S (S (S Z))))
e2
  show (ExprEQ Expr visibility (S (S (S (S (S Z)))))
e1 Expr visibility (S (S (S (S (S Z)))))
e2) = forall a. Show a => a -> ShowS
shows Expr visibility (S (S (S (S (S Z)))))
e1 String
" == " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr visibility (S (S (S (S (S Z)))))
e2
  show (ExprNEQ Expr visibility (S (S (S (S (S Z)))))
e1 Expr visibility (S (S (S (S (S Z)))))
e2) = forall a. Show a => a -> ShowS
shows Expr visibility (S (S (S (S (S Z)))))
e1 String
" != " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr visibility (S (S (S (S (S Z)))))
e2
  show (ExprGT Expr visibility (S (S (S (S (S Z)))))
e1 Expr visibility (S (S (S (S (S Z)))))
e2) = forall a. Show a => a -> ShowS
shows Expr visibility (S (S (S (S (S Z)))))
e1 String
" > " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr visibility (S (S (S (S (S Z)))))
e2
  show (ExprGE Expr visibility (S (S (S (S (S Z)))))
e1 Expr visibility (S (S (S (S (S Z)))))
e2) = forall a. Show a => a -> ShowS
shows Expr visibility (S (S (S (S (S Z)))))
e1 String
" >= " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr visibility (S (S (S (S (S Z)))))
e2
  show (ExprLT Expr visibility (S (S (S (S (S Z)))))
e1 Expr visibility (S (S (S (S (S Z)))))
e2) = forall a. Show a => a -> ShowS
shows Expr visibility (S (S (S (S (S Z)))))
e1 String
" < " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr visibility (S (S (S (S (S Z)))))
e2
  show (ExprLE Expr visibility (S (S (S (S (S Z)))))
e1 Expr visibility (S (S (S (S (S Z)))))
e2) = forall a. Show a => a -> ShowS
shows Expr visibility (S (S (S (S (S Z)))))
e1 String
" <= " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr visibility (S (S (S (S (S Z)))))
e2
  show (ExprInternalAnd Expr Internal (S (S (S (S (S (S Z))))))
e [Expr Internal (S (S (S (S (S (S Z))))))]
es) = forall a. [a] -> [[a]] -> [a]
intercalate String
" and " forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Expr Internal (S (S (S (S (S (S Z))))))
eforall a. a -> [a] -> [a]
:[Expr Internal (S (S (S (S (S (S Z))))))]
es
  show (ExprAnd Expr External (S (S (S (S (S (S (S Z)))))))
e1 Expr External (S (S (S (S (S (S Z))))))
e2) = forall a. Show a => a -> ShowS
shows Expr External (S (S (S (S (S (S (S Z)))))))
e1 String
" and " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr External (S (S (S (S (S (S Z))))))
e2
  show (ExprInternalOr Expr Internal (S (S (S (S (S (S (S Z)))))))
e [Expr Internal (S (S (S (S (S (S (S Z)))))))]
es) = forall a. [a] -> [[a]] -> [a]
intercalate String
" or " forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Expr Internal (S (S (S (S (S (S (S Z)))))))
eforall a. a -> [a] -> [a]
:[Expr Internal (S (S (S (S (S (S (S Z)))))))]
es
  show (ExprOr Expr External LevelMax
e1 Expr External (S (S (S (S (S (S (S Z)))))))
e2) = forall a. Show a => a -> ShowS
shows Expr External LevelMax
e1 String
" or " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Expr External (S (S (S (S (S (S (S Z)))))))
e2

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprIntegerLiteral
-- >>> eval "1"
-- Right 1
-- >>> eval "2"
-- Right 2
exprIntegerLiteral :: Parser (Expr Internal Level0)
exprIntegerLiteral :: Parser (Expr Internal Z)
exprIntegerLiteral = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a. HasCallStack => String -> a
error forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Show a => a -> String
show :: Double -> String)) forall visibility. Integer -> Expr visibility Z
ExprIntegerLiteral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Scientific
Data.Attoparsec.Text.scientific

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprStringLiteral
-- >>> eval "'test'"
-- Right 'test'
-- >>> eval "\"test\""
-- Right "test"
exprStringLiteral :: Parser (Expr Internal Level0)
exprStringLiteral :: Parser (Expr Internal Z)
exprStringLiteral = forall visibility. StringLiteral -> Expr visibility Z
ExprStringLiteral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser StringLiteral
stringLiteral

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprBooleanLiteral
-- >>> eval "true"
-- Right true
-- >>> eval "false"
-- Right false
exprBooleanLiteral :: Parser (Expr Internal Level0)
exprBooleanLiteral :: Parser (Expr Internal Z)
exprBooleanLiteral = forall visibility. Bool -> Expr visibility Z
ExprBooleanLiteral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Text -> Parser Text
string Text
"true" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True, Text -> Parser Text
string Text
"false" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False ]

exprVariable :: Parser (Expr Internal Level0)
exprVariable :: Parser (Expr Internal Z)
exprVariable = forall visibility. Identifier -> Expr visibility Z
ExprVariable forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
identifier

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprParen
-- >>> eval "(1)"
-- Right (1)
-- >>> eval "(foo)"
-- Right (foo)
-- >>> eval "(true)"
-- Right (true)
-- >>> eval "(foo )"
-- Right (foo)
-- >>> eval "( foo)"
-- Right (foo)
exprParen :: Parser (Expr Internal Level0)
exprParen :: Parser (Expr Internal Z)
exprParen = forall visibility. Expr visibility LevelMax -> Expr visibility Z
ExprParen forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Char -> Parser Char
char Char
'(' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text (Expr Internal LevelMax)
exprLevelMax forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> Parser Char
char Char
')')

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprRange
-- >>> eval "range(1)"
-- Right range(1)
-- >>> eval "range (1)"
-- Right range(1)
-- >>> eval "range(1, 2)"
-- Right range(1, 2)
-- >>> eval "range (1,2)"
-- Right range(1, 2)
-- >>> eval "range(1 ,2 , 3)"
-- Right range(1, 2, 3)
exprRange :: Parser (Expr Internal Level0)
exprRange :: Parser (Expr Internal Z)
exprRange = forall visibility. [Expr visibility LevelMax] -> Expr visibility Z
ExprRange forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text [Expr Internal LevelMax]
args where
  args :: Parser Text [Expr Internal LevelMax]
args = do
    [Expr Internal LevelMax]
es <- Text -> Parser Text
string Text
"range" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Char -> Parser Char
char Char
'(' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Parser Text (Expr Internal LevelMax)
exprLevelMax forall (f :: * -> *) a s. Alternative f => f a -> f s -> f [a]
`sepBy1` (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Char -> Parser Char
char Char
',' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace)) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> Parser Char
char Char
')'
    forall a. a -> a -> Bool -> a
bool (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"too many args") (forall (m :: * -> *) a. Monad m => a -> m a
return [Expr Internal LevelMax]
es) forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr Internal LevelMax]
es forall a. Ord a => a -> a -> Bool
< Int
4

exprLevel0 :: Parser (Expr Internal Level0)
exprLevel0 :: Parser (Expr Internal Z)
exprLevel0 = forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Parser (Expr Internal Z)
exprIntegerLiteral
                    , Parser (Expr Internal Z)
exprStringLiteral
                    , Parser (Expr Internal Z)
exprBooleanLiteral
                    , Parser (Expr Internal Z)
exprRange
                    , Parser (Expr Internal Z)
exprVariable
                    , Parser (Expr Internal Z)
exprParen
                    ]

exprAttributed :: Parser (Expr Internal Level1)
exprAttributed :: Parser (Expr Internal (S Z))
exprAttributed = forall visibility.
Expr visibility Z -> [Identifier] -> Expr visibility (S Z)
ExprAttributed forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal Z)
exprLevel0 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many' (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Char -> Parser Char
char Char
'.' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Identifier
identifier)

exprLevel1 :: Parser (Expr Internal Level1)
exprLevel1 :: Parser (Expr Internal (S Z))
exprLevel1 = forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Parser (Expr Internal (S Z))
exprAttributed
                    ]

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprFiltered
-- >>> eval "foo|abs"
-- Right foo|abs
-- >>> eval "foo| abs"
-- Right foo|abs
-- >>> eval "foo |abs"
-- Right foo|abs
-- >>> eval "foo | abs"
-- Right foo|abs
exprFiltered :: Parser (Expr Internal Level2)
exprFiltered :: Parser (Expr Internal (S (S Z)))
exprFiltered = forall visibility.
Expr visibility (S Z) -> [Filter] -> Expr visibility (S (S Z))
ExprFiltered forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S Z))
exprLevel1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many' (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text Filter
filter)

exprLevel2 :: Parser (Expr Internal Level2)
exprLevel2 :: Parser (Expr Internal (S (S Z)))
exprLevel2 = forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Parser (Expr Internal (S (S Z)))
exprFiltered
                    ]

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprPow
-- >>> eval "1**2"
-- Right 1 ** 2
-- >>> eval "1**  2"
-- Right 1 ** 2
-- >>> eval "1  **2"
-- Right 1 ** 2
exprPow :: Parser (Expr Internal Level3)
exprPow :: Parser (Expr Internal (S (S (S Z))))
exprPow = Expr Internal (S (S Z))
-> [Expr Internal (S (S Z))] -> Expr Internal (S (S (S Z)))
ExprInternalPow forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S Z)))
exprLevel2 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many' (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> Parser Text
string Text
"**" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Expr Internal (S (S Z)))
exprLevel2)

exprLevel3 :: Parser (Expr Internal Level3)
exprLevel3 :: Parser (Expr Internal (S (S (S Z))))
exprLevel3 = forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Parser (Expr Internal (S (S (S Z))))
exprPow
                    ]

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprMulDiv
-- >>> eval "1*2//3"
-- Right 1 * 2 // 3
-- >>> eval "1 * 2 // 3"
-- Right 1 * 2 // 3
-- >>> eval "1//2*3"
-- Right 1 // 2 * 3
-- >>> eval "1*2/3"
-- Right 1 * 2 / 3
-- >>> eval "1 * 2 % 3"
-- Right 1 * 2 % 3
-- >>> eval "1%2*3"
-- Right 1 % 2 * 3
exprMulDiv :: Parser (Expr Internal Level4)
exprMulDiv :: Parser (Expr Internal (S (S (S (S Z)))))
exprMulDiv = Expr Internal (S (S (S Z)))
-> [(MulDiv, Expr Internal (S (S (S Z))))]
-> Expr Internal (S (S (S (S Z))))
ExprInternalMulDiv forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S Z))))
exprLevel3 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many' ((,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text MulDiv
op) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Expr Internal (S (S (S Z))))
exprLevel3)) where
  op :: Parser Text MulDiv
op = forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Text -> Parser Text
string Text
"//" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. Monad m => a -> m a
return MulDiv
DivI
              , Text -> Parser Text
string Text
"/" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. Monad m => a -> m a
return MulDiv
DivF
              , Text -> Parser Text
string Text
"*" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. Monad m => a -> m a
return MulDiv
Mul
              , Text -> Parser Text
string Text
"%" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. Monad m => a -> m a
return MulDiv
Mod
              ]

exprLevel4 :: Parser (Expr Internal Level4)
exprLevel4 :: Parser (Expr Internal (S (S (S (S Z)))))
exprLevel4 = forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Parser (Expr Internal (S (S (S (S Z)))))
exprMulDiv
                    ]

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprAddSub
-- >>> eval "1+2-3"
-- Right 1 + 2 - 3
-- >>> eval "1 + 2 - 3"
-- Right 1 + 2 - 3
-- >>> eval "1-2+3"
-- Right 1 - 2 + 3
exprAddSub :: Parser (Expr Internal Level5)
exprAddSub :: Parser (Expr Internal (S (S (S (S (S Z))))))
exprAddSub = Expr Internal (S (S (S (S Z))))
-> [(AddSub, Expr Internal (S (S (S (S Z)))))]
-> Expr Internal (S (S (S (S (S Z)))))
ExprInternalAddSub forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S Z)))))
exprLevel4 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many' ((,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text AddSub
op) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Expr Internal (S (S (S (S Z)))))
exprLevel4)) where
  op :: Parser Text AddSub
op = forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Text -> Parser Text
string Text
"+" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. Monad m => a -> m a
return AddSub
Add
              , Text -> Parser Text
string Text
"-" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. Monad m => a -> m a
return AddSub
Sub
              ]

exprLevel5 :: Parser (Expr Internal Level5)
exprLevel5 :: Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5 = forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Parser (Expr Internal (S (S (S (S (S Z))))))
exprAddSub
                    ]

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprEQ
-- >>> eval "1==1"
-- Right 1 == 1
-- >>> eval "1== 1"
-- Right 1 == 1
-- >>> eval "1 ==1"
-- Right 1 == 1
exprEQ :: Parser (Expr Internal Level6)
exprEQ :: Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprEQ = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprEQ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> Parser Text
string Text
"==" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5)

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprNEQ
-- >>> eval "1!=1"
-- Right 1 != 1
-- >>> eval "1!= 1"
-- Right 1 != 1
-- >>> eval "1 !=1"
-- Right 1 != 1
exprNEQ :: Parser (Expr Internal Level6)
exprNEQ :: Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprNEQ = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprNEQ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> Parser Text
string Text
"!=" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5)

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprGT
-- >>> eval "1>1"
-- Right 1 > 1
-- >>> eval "1> 1"
-- Right 1 > 1
-- >>> eval "1 >1"
-- Right 1 > 1
exprGT :: Parser (Expr Internal Level6)
exprGT :: Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprGT = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprGT forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> Parser Text
string Text
">" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5)

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprGE
-- >>> eval "1>=1"
-- Right 1 >= 1
-- >>> eval "1>= 1"
-- Right 1 >= 1
-- >>> eval "1 >=1"
-- Right 1 >= 1
exprGE :: Parser (Expr Internal Level6)
exprGE :: Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprGE = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprGE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> Parser Text
string Text
">=" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5)

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprLT
-- >>> eval "1<1"
-- Right 1 < 1
-- >>> eval "1< 1"
-- Right 1 < 1
-- >>> eval "1 <1"
-- Right 1 < 1
exprLT :: Parser (Expr Internal Level6)
exprLT :: Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprLT = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprLT forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> Parser Text
string Text
"<" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5)

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprLE
-- >>> eval "1<=1"
-- Right 1 <= 1
-- >>> eval "1<= 1"
-- Right 1 <= 1
-- >>> eval "1 <=1"
-- Right 1 <= 1
exprLE :: Parser (Expr Internal Level6)
exprLE :: Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprLE = forall visibility.
Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S Z)))))
-> Expr visibility (S (S (S (S (S (S Z))))))
ExprLE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> Parser Text
string Text
"<=" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5)

exprLevel6 :: Parser (Expr Internal Level6)
exprLevel6 :: Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprLevel6 = forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprEQ
                    , Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprNEQ
                    , Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprGE
                    , Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprGT
                    , Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprLE
                    , Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprLT
                    , forall visibility lv. Expr visibility lv -> Expr visibility (S lv)
ExprLift forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S (S Z))))))
exprLevel5
                    ]

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprAnd
-- >>> eval "true and false"
-- Right true and false
exprAnd :: Parser (Expr Internal Level7)
exprAnd :: Parser (Expr Internal (S (S (S (S (S (S (S Z))))))))
exprAnd = Expr Internal (S (S (S (S (S (S Z))))))
-> [Expr Internal (S (S (S (S (S (S Z))))))]
-> Expr Internal (S (S (S (S (S (S (S Z)))))))
ExprInternalAnd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprLevel6 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many' (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> Parser Text
string Text
"and" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprLevel6)

exprLevel7 :: Parser (Expr Internal Level7)
exprLevel7 :: Parser (Expr Internal (S (S (S (S (S (S (S Z))))))))
exprLevel7 = forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Parser (Expr Internal (S (S (S (S (S (S (S Z))))))))
exprAnd
                    , forall visibility lv. Expr visibility lv -> Expr visibility (S lv)
ExprLift forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S (S (S Z)))))))
exprLevel6
                    ]

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly exprOr
-- >>> eval "true or false"
-- Right true or false
exprOr :: Parser (Expr Internal Level8)
exprOr :: Parser Text (Expr Internal LevelMax)
exprOr = Expr Internal (S (S (S (S (S (S (S Z)))))))
-> [Expr Internal (S (S (S (S (S (S (S Z)))))))]
-> Expr Internal LevelMax
ExprInternalOr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S (S (S (S Z))))))))
exprLevel7 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many' (Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> Parser Text
string Text
"or" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Text ()
skipSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Expr Internal (S (S (S (S (S (S (S Z))))))))
exprLevel7)

exprLevel8 :: Parser (Expr Internal Level8)
exprLevel8 :: Parser Text (Expr Internal LevelMax)
exprLevel8 = forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Parser Text (Expr Internal LevelMax)
exprOr
                    , forall visibility lv. Expr visibility lv -> Expr visibility (S lv)
ExprLift forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Expr Internal (S (S (S (S (S (S (S Z))))))))
exprLevel7
                    ]

exprLevelMax :: Parser (Expr Internal LevelMax)
exprLevelMax :: Parser Text (Expr Internal LevelMax)
exprLevelMax = Parser Text (Expr Internal LevelMax)
exprLevel8

newtype Expression = Expression (Expr External LevelMax) deriving Expression -> Expression -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Expression -> Expression -> Bool
$c/= :: Expression -> Expression -> Bool
== :: Expression -> Expression -> Bool
$c== :: Expression -> Expression -> Bool
Eq

instance Show Expression where
  show :: Expression -> String
show (Expression Expr External LevelMax
e) = forall a. Show a => a -> String
show Expr External LevelMax
e

-- |
--
-- >>> let eval = left (const "parse error") . parseOnly expression
-- >>> eval "foo"
-- Right foo
-- >>> eval "(foo)"
-- Right (foo)
-- >>> eval "1"
-- Right 1
-- >>> eval "true"
-- Right true
-- >>> eval "false"
-- Right false
-- >>> eval "foo.bar"
-- Right foo.bar
-- >>> eval "(foo).bar"
-- Right (foo).bar
-- >>> eval "(foo.bar)"
-- Right (foo.bar)
-- >>> eval "foo.b}}ar"
-- Right foo.b
-- >>> eval "foo.b ar"
-- Right foo.b
-- >>> eval "foo.b }ar"
-- Right foo.b
-- >>> eval " foo.bar"
-- Left "parse error"
-- >>> eval "foo.  bar"
-- Right foo.bar
-- >>> eval "foo  .bar"
-- Right foo.bar
-- >>> eval "foo.bar  "
-- Right foo.bar
-- >>> eval "foo.bar  "
-- Right foo.bar
-- >>> eval "foo.bar.baz"
-- Right foo.bar.baz
--
expression :: Parser Expression
expression :: Parser Expression
expression = Expr External LevelMax -> Expression
Expression forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall level. Expr Internal level -> Expr External level
toExternal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text (Expr Internal LevelMax)
exprLevelMax