{-# LANGUAGE DataKinds #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE CPP #-}
-- |
-- Module      : Text.Haiji.Runtime
-- Copyright   : 2015 Noriyuki OHKAWA
-- License     : BSD3
--
-- Maintainer  : n.ohkawa@gmail.com
-- Stability   : experimental
-- Portability : portable
module Text.Haiji.Runtime
       ( readTemplateFile
       ) where

#if MIN_VERSION_base(4,8,0)
#else
import Control.Applicative
#endif
import Control.Monad.Trans.Reader
import qualified Data.Aeson as JSON
import qualified Data.Aeson.Types as JSON
import Data.Maybe
import Data.Scientific
import qualified Data.Text as T
import qualified Data.Text.Lazy as LT
import qualified Data.Vector as V
import Text.Haiji.Parse
import Text.Haiji.Syntax
import Text.Haiji.Types
import Text.Haiji.Utils

-- | Dynamically template loader (for template development use)
readTemplateFile :: Environment -> FilePath -> IO (Template JSON.Value)
readTemplateFile :: Environment -> FilePath -> IO (Template Value)
readTemplateFile Environment
env FilePath
file = Environment -> Jinja2 -> Template Value
unsafeTemplate Environment
env forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (q :: * -> *). QuasiWithFile q => FilePath -> q Jinja2
parseFile FilePath
file

unsafeTemplate :: Environment -> Jinja2 -> Template JSON.Value
unsafeTemplate :: Environment -> Jinja2 -> Template Value
unsafeTemplate Environment
env Jinja2
tmpl = forall dict. Reader dict Text -> Template dict
Template forall a b. (a -> b) -> a -> b
$ Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> [AST 'Fully]
-> Reader Value Text
haijiASTs Environment
env forall a. Maybe a
Nothing (Jinja2 -> [AST 'Fully]
jinja2Child Jinja2
tmpl) (Jinja2 -> [AST 'Fully]
jinja2Base Jinja2
tmpl)

haijiASTs :: Environment -> Maybe [AST 'Fully] -> [AST 'Fully] -> [AST 'Fully] -> Reader JSON.Value LT.Text
haijiASTs :: Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> [AST 'Fully]
-> Reader Value Text
haijiASTs Environment
env Maybe [AST 'Fully]
parentBlock [AST 'Fully]
children [AST 'Fully]
asts = [Text] -> Text
LT.concat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> AST 'Fully
-> Reader Value Text
haijiAST Environment
env Maybe [AST 'Fully]
parentBlock [AST 'Fully]
children) [AST 'Fully]
asts

haijiAST :: Environment -> Maybe [AST 'Fully] -> [AST 'Fully] -> AST 'Fully -> Reader JSON.Value LT.Text
haijiAST :: Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> AST 'Fully
-> Reader Value Text
haijiAST Environment
_env Maybe [AST 'Fully]
_parentBlock [AST 'Fully]
_children (Literal Text
l) =
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> Text
LT.fromStrict Text
l
haijiAST  Environment
env Maybe [AST 'Fully]
_parentBlock [AST 'Fully]
_children (Eval Expression
x) =
  do let esc :: Escape
esc = if Environment -> Bool
autoEscape Environment
env then Escape
htmlEscape else Escape
rawEscape
     Value
obj <- Expression -> Reader Value Value
eval Expression
x
     case Value
obj of
       JSON.Bool Bool
b   -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (Text -> Escape -> Text
`escapeBy` Escape
esc) forall a b. (a -> b) -> a -> b
$ forall a. ToLT a => a -> Text
toLT Bool
b
       JSON.String Text
s -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (Text -> Escape -> Text
`escapeBy` Escape
esc) forall a b. (a -> b) -> a -> b
$ forall a. ToLT a => a -> Text
toLT Text
s
       JSON.Number Scientific
n -> case forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger (Scientific
n :: Scientific) of
         Left  Double
r -> let Double
_ = (Double
r :: Double) in forall a. HasCallStack => FilePath -> a
error FilePath
"invalid value type"
         Right Integer
i -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (Text -> Escape -> Text
`escapeBy` Escape
esc) forall a b. (a -> b) -> a -> b
$ forall a. ToLT a => a -> Text
toLT (Integer
i :: Integer)
       Value
_ -> forall a. HasCallStack => a
undefined
haijiAST  Environment
env  Maybe [AST 'Fully]
parentBlock  [AST 'Fully]
children (Condition Expression
p [AST 'Fully]
ts Maybe [AST 'Fully]
fs) =
  do Value
b <- Expression -> Reader Value Value
eval Expression
p
     case Value
b of
       JSON.Bool Bool
True  -> Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> [AST 'Fully]
-> Reader Value Text
haijiASTs Environment
env Maybe [AST 'Fully]
parentBlock [AST 'Fully]
children [AST 'Fully]
ts
       JSON.Bool Bool
False -> forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. Monad m => a -> m a
return Text
"") (Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> [AST 'Fully]
-> Reader Value Text
haijiASTs Environment
env Maybe [AST 'Fully]
parentBlock [AST 'Fully]
children) Maybe [AST 'Fully]
fs
       Value
_               -> forall a. HasCallStack => FilePath -> a
error FilePath
"invalid condition type"
haijiAST  Environment
env  Maybe [AST 'Fully]
parentBlock  [AST 'Fully]
children (Foreach Identifier
k Expression
xs [AST 'Fully]
loopBody Maybe [AST 'Fully]
elseBody) =
  do Value
arr <- Expression -> Reader Value Value
eval Expression
xs
     case Value
arr of
       JSON.Array Array
dicts -> do
         Value
p <- forall (m :: * -> *) r. Monad m => ReaderT r m r
ask
         let len :: Integer
len = forall a. Integral a => a -> Integer
toInteger forall a b. (a -> b) -> a -> b
$ forall a. Vector a -> Int
V.length Array
dicts
         if Integer
0 forall a. Ord a => a -> a -> Bool
< Integer
len
         then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Text] -> Text
LT.concat
              [ forall r a. Reader r a -> r -> a
runReader (Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> [AST 'Fully]
-> Reader Value Text
haijiASTs Environment
env Maybe [AST 'Fully]
parentBlock [AST 'Fully]
children [AST 'Fully]
loopBody)
                          (let JSON.Object Object
obj = Value
p
                           in  Object -> Value
JSON.Object
                               forall a b. (a -> b) -> a -> b
$ Key -> Value -> Object -> Object
insertValue Key
"loop" (Integer -> Integer -> Value
loopVariables Integer
len Integer
ix)
                               forall a b. (a -> b) -> a -> b
$ Key -> Value -> Object -> Object
insertValue (FilePath -> Key
toKey forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> FilePath
show Identifier
k) Value
x Object
obj)
              | (Integer
ix, Value
x) <- forall a b. [a] -> [b] -> [(a, b)]
zip [Integer
0..] (forall a. Vector a -> [a]
V.toList Array
dicts)
              ]
         else forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. Monad m => a -> m a
return Text
"") (Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> [AST 'Fully]
-> Reader Value Text
haijiASTs Environment
env Maybe [AST 'Fully]
parentBlock [AST 'Fully]
children) Maybe [AST 'Fully]
elseBody
       Value
_                -> forall a. HasCallStack => FilePath -> a
error FilePath
"invalid array type"
haijiAST Environment
_env Maybe [AST 'Fully]
_parentBlock [AST 'Fully]
_children (Raw FilePath
raw) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ FilePath -> Text
LT.pack FilePath
raw
haijiAST Environment
_env Maybe [AST 'Fully]
_parentBlock [AST 'Fully]
_children (Base [AST 'Fully]
_asts) = forall a. HasCallStack => a
undefined
haijiAST  Environment
env  Maybe [AST 'Fully]
parentBlock  [AST 'Fully]
children (Block Bool
_base Identifier
name Bool
_scoped [AST 'Fully]
body) =
  case forall a. [a] -> Maybe a
listToMaybe [ [AST 'Fully]
b | Block Bool
_ Identifier
n Bool
_ [AST 'Fully]
b <- [AST 'Fully]
children, Identifier
n forall a. Eq a => a -> a -> Bool
== Identifier
name ] of
    Maybe [AST 'Fully]
Nothing    -> Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> [AST 'Fully]
-> Reader Value Text
haijiASTs Environment
env Maybe [AST 'Fully]
parentBlock [AST 'Fully]
children [AST 'Fully]
body
    Just [AST 'Fully]
child -> Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> [AST 'Fully]
-> Reader Value Text
haijiASTs Environment
env (forall a. a -> Maybe a
Just [AST 'Fully]
body) [AST 'Fully]
children [AST 'Fully]
child
haijiAST  Environment
env  Maybe [AST 'Fully]
parentBlock  [AST 'Fully]
children AST 'Fully
Super = forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall a. HasCallStack => FilePath -> a
error FilePath
"invalid super()") (Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> [AST 'Fully]
-> Reader Value Text
haijiASTs Environment
env forall a. Maybe a
Nothing [AST 'Fully]
children) Maybe [AST 'Fully]
parentBlock
haijiAST Environment
_env Maybe [AST 'Fully]
_parentBlock [AST 'Fully]
_children (Comment FilePath
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Text
""
haijiAST  Environment
env  Maybe [AST 'Fully]
parentBlock  [AST 'Fully]
children (Set Identifier
lhs Expression
rhs [AST 'Fully]
scopes) =
  do Value
val <- Expression -> Reader Value Value
eval Expression
rhs
     Value
p <- forall (m :: * -> *) r. Monad m => ReaderT r m r
ask
     forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall r a. Reader r a -> r -> a
runReader (Environment
-> Maybe [AST 'Fully]
-> [AST 'Fully]
-> [AST 'Fully]
-> Reader Value Text
haijiASTs Environment
env Maybe [AST 'Fully]
parentBlock [AST 'Fully]
children [AST 'Fully]
scopes)
       (let JSON.Object Object
obj = Value
p in  Object -> Value
JSON.Object forall a b. (a -> b) -> a -> b
$ Key -> Value -> Object -> Object
insertValue (FilePath -> Key
toKey forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> FilePath
show Identifier
lhs) Value
val Object
obj)

loopVariables :: Integer -> Integer -> JSON.Value
loopVariables :: Integer -> Integer -> Value
loopVariables Integer
len Integer
ix = [Pair] -> Value
JSON.object [ Key
"first"     forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
JSON..= (Integer
ix forall a. Eq a => a -> a -> Bool
== Integer
0)
                                   , Key
"index"     forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
JSON..= (Integer
ix forall a. Num a => a -> a -> a
+ Integer
1)
                                   , Key
"index0"    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
JSON..= Integer
ix
                                   , Key
"last"      forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
JSON..= (Integer
ix forall a. Eq a => a -> a -> Bool
== Integer
len forall a. Num a => a -> a -> a
- Integer
1)
                                   , Key
"length"    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
JSON..= Integer
len
                                   , Key
"revindex"  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
JSON..= (Integer
len forall a. Num a => a -> a -> a
- Integer
ix)
                                   , Key
"revindex0" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
JSON..= (Integer
len forall a. Num a => a -> a -> a
- Integer
ix forall a. Num a => a -> a -> a
- Integer
1)
                                   ]

eval :: Expression -> Reader JSON.Value JSON.Value
eval :: Expression -> Reader Value Value
eval (Expression Expr External LevelMax
expression) = forall level. Expr External level -> Reader Value Value
go Expr External LevelMax
expression where
  go :: Expr External level -> Reader JSON.Value JSON.Value
  go :: forall level. Expr External level -> Reader Value Value
go (ExprLift Expr External lv
e) = forall level. Expr External level -> Reader Value Value
go Expr External lv
e
  go (ExprIntegerLiteral Integer
n) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Scientific -> Value
JSON.Number forall a b. (a -> b) -> a -> b
$ Integer -> Int -> Scientific
scientific Integer
n Int
0
  go (ExprStringLiteral StringLiteral
s) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> Value
JSON.String forall a b. (a -> b) -> a -> b
$ FilePath -> Text
T.pack forall a b. (a -> b) -> a -> b
$ StringLiteral -> FilePath
unwrap StringLiteral
s
  go (ExprBooleanLiteral Bool
b) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool Bool
b
  go (ExprVariable Identifier
v) = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Object -> Parser a) -> Value -> Parser a
JSON.withObject (forall a. Show a => a -> FilePath
show Identifier
v) (forall a. FromJSON a => Object -> Key -> Parser a
JSON..: (FilePath -> Key
toKey forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> FilePath
show Identifier
v))) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) r. Monad m => ReaderT r m r
ask
  go (ExprParen Expr External LevelMax
e) = forall level. Expr External level -> Reader Value Value
go Expr External LevelMax
e
  go (ExprRange [Expr External LevelMax
stop]) = do
    Scientific
sstop <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"range" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External LevelMax
stop
    case forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
sstop :: Either Float Integer of
      (Right Integer
istop) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Array -> Value
JSON.Array forall a b. (a -> b) -> a -> b
$ forall a. [a] -> Vector a
V.fromList forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (Scientific -> Value
JSON.Number forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip Integer -> Int -> Scientific
scientific Int
0) [Integer
0..Integer
istopforall a. Num a => a -> a -> a
-Integer
1]
      Either Float Integer
_             -> forall a. HasCallStack => FilePath -> a
error FilePath
"range"
  go (ExprRange [Expr External LevelMax
start, Expr External LevelMax
stop]) = do
    Scientific
sstart <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"range" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External LevelMax
start
    Scientific
sstop <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"range" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External LevelMax
stop
    case (forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
sstart :: Either Float Integer, forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
sstop :: Either Float Integer) of
      (Right Integer
istart, Right Integer
istop) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Array -> Value
JSON.Array forall a b. (a -> b) -> a -> b
$ forall a. [a] -> Vector a
V.fromList forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (Scientific -> Value
JSON.Number forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip Integer -> Int -> Scientific
scientific Int
0) [Integer
istart..Integer
istopforall a. Num a => a -> a -> a
-Integer
1]
      (Either Float Integer, Either Float Integer)
_             -> forall a. HasCallStack => FilePath -> a
error FilePath
"range"
  go (ExprRange [Expr External LevelMax
start, Expr External LevelMax
stop, Expr External LevelMax
step]) = do
    Scientific
sstart <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"range" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External LevelMax
start
    Scientific
sstop <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"range" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External LevelMax
stop
    Scientific
sstep <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"range" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External LevelMax
step
    case (forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
sstart :: Either Float Integer, forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
sstop :: Either Float Integer, forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
sstep :: Either Float Integer) of
      (Right Integer
istart, Right Integer
istop, Right Integer
istep) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Array -> Value
JSON.Array forall a b. (a -> b) -> a -> b
$ forall a. [a] -> Vector a
V.fromList forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (Scientific -> Value
JSON.Number forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip Integer -> Int -> Scientific
scientific Int
0) [Integer
istart,Integer
istartforall a. Num a => a -> a -> a
+Integer
istep..Integer
istopforall a. Num a => a -> a -> a
-Integer
1]
      (Either Float Integer, Either Float Integer, Either Float Integer)
_             -> forall a. HasCallStack => FilePath -> a
error FilePath
"range"
  go (ExprRange [Expr External LevelMax]
_) = forall a. HasCallStack => FilePath -> a
error FilePath
"unreachable"
  go (ExprAttributed Expr External Z
e []) = forall level. Expr External level -> Reader Value Value
go Expr External Z
e
  go (ExprAttributed Expr External Z
e [Identifier]
attrs) = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Object -> Parser a) -> Value -> Parser a
JSON.withObject (forall a. Show a => a -> FilePath
show forall a b. (a -> b) -> a -> b
$ forall a. [a] -> a
last [Identifier]
attrs) (forall a. FromJSON a => Object -> Key -> Parser a
JSON..: (FilePath -> Key
toKey forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> FilePath
show forall a b. (a -> b) -> a -> b
$ forall a. [a] -> a
last [Identifier]
attrs))) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go (forall visibility.
Expr visibility Z -> [Identifier] -> Expr visibility (S Z)
ExprAttributed Expr External Z
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
init [Identifier]
attrs)
  go (ExprFiltered Expr External (S Z)
e []) = forall level. Expr External level -> Reader Value Value
go Expr External (S Z)
e
  go (ExprFiltered Expr External (S Z)
e [Filter]
filters) = forall {level}. Filter -> Expr External level -> Reader Value Value
applyFilter (forall a. [a] -> a
last [Filter]
filters) forall a b. (a -> b) -> a -> b
$ forall visibility.
Expr visibility (S Z) -> [Filter] -> Expr visibility (S (S Z))
ExprFiltered Expr External (S Z)
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
init [Filter]
filters where
    applyFilter :: Filter -> Expr External level -> Reader Value Value
applyFilter Filter
FilterAbs Expr External level
e' = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"abs" (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> Value
JSON.Number forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Num a => a -> a
abs)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External level
e'
    applyFilter Filter
FilterLength Expr External level
e' = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Array -> Parser a) -> Value -> Parser a
JSON.withArray FilePath
"length" (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> Value
JSON.Number forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip Integer -> Int -> Scientific
scientific Int
0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Integral a => a -> Integer
toInteger forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Vector a -> Int
V.length)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External level
e'

  go (ExprPow Expr External (S (S (S Z)))
e1 Expr External (S (S Z))
e2) = do
    Scientific
v1 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"lhs of (**)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S Z)))
e1
    Scientific
v2 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"rhs of (**)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S Z))
e2
    case (forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
v1 :: Either Float Integer, forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
v2 :: Either Float Integer) of
      (Right Integer
l, Right Integer
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Scientific -> Value
JSON.Number forall a b. (a -> b) -> a -> b
$ Integer -> Int -> Scientific
scientific (Integer
l forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
r) Int
0
      (Either Float Integer, Either Float Integer)
_                  -> forall a. HasCallStack => FilePath -> a
error FilePath
"(**)"
  go (ExprMul Expr External (S (S (S (S Z))))
e1 Expr External (S (S (S Z)))
e2) = do
    Scientific
v1 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"lhs of (*)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S Z))))
e1
    Scientific
v2 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"rhs of (*)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S Z)))
e2
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Scientific -> Value
JSON.Number forall a b. (a -> b) -> a -> b
$ Scientific
v1 forall a. Num a => a -> a -> a
* Scientific
v2
  go (ExprDivF Expr External (S (S (S (S Z))))
e1 Expr External (S (S (S Z)))
e2) = do
    Scientific
v1 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"lhs of (/)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S Z))))
e1
    Scientific
v2 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"rhs of (/)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S Z)))
e2
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Scientific -> Value
JSON.Number forall a b. (a -> b) -> a -> b
$ Scientific
v1 forall a. Fractional a => a -> a -> a
/ Scientific
v2
  go (ExprDivI Expr External (S (S (S (S Z))))
e1 Expr External (S (S (S Z)))
e2) = do
    Scientific
v1 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"lhs of (//)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S Z))))
e1
    Scientific
v2 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"rhs of (//)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S Z)))
e2
    case (forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
v1 :: Either Float Integer, forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
v2 :: Either Float Integer) of
      (Right Integer
l, Right Integer
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Scientific -> Value
JSON.Number forall a b. (a -> b) -> a -> b
$ Integer -> Int -> Scientific
scientific (Integer
l forall a. Integral a => a -> a -> a
`div` Integer
r) Int
0
      (Either Float Integer, Either Float Integer)
_                  -> forall a. HasCallStack => FilePath -> a
error FilePath
"(//)"
  go (ExprMod Expr External (S (S (S (S Z))))
e1 Expr External (S (S (S Z)))
e2) = do
    Scientific
v1 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"lhs of (%)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S Z))))
e1
    Scientific
v2 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"rhs of (%)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S Z)))
e2
    case (forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
v1 :: Either Float Integer, forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
v2 :: Either Float Integer) of
      (Right Integer
l, Right Integer
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Scientific -> Value
JSON.Number forall a b. (a -> b) -> a -> b
$ Integer -> Int -> Scientific
scientific (Integer
l forall a. Integral a => a -> a -> a
`mod` Integer
r) Int
0
      (Either Float Integer, Either Float Integer)
_                  -> forall a. HasCallStack => FilePath -> a
error FilePath
"(%)"
  go (ExprAdd Expr External (S (S (S (S (S Z)))))
e1 Expr External (S (S (S (S Z))))
e2) = do
    Scientific
v1 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"lhs of (/)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e1
    Scientific
v2 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"rhs of (/)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S Z))))
e2
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Scientific -> Value
JSON.Number forall a b. (a -> b) -> a -> b
$ Scientific
v1 forall a. Num a => a -> a -> a
+ Scientific
v2
  go (ExprSub Expr External (S (S (S (S (S Z)))))
e1 Expr External (S (S (S (S Z))))
e2) = do
    Scientific
v1 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"lhs of (/)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e1
    Scientific
v2 <- forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => FilePath -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Parser b) -> a -> Either FilePath b
JSON.parseEither (forall a. FilePath -> (Scientific -> Parser a) -> Value -> Parser a
JSON.withScientific FilePath
"rhs of (/)" forall (m :: * -> *) a. Monad m => a -> m a
return) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S Z))))
e2
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Scientific -> Value
JSON.Number forall a b. (a -> b) -> a -> b
$ Scientific
v1 forall a. Num a => a -> a -> a
- Scientific
v2
  go (ExprEQ Expr External (S (S (S (S (S Z)))))
e1 Expr External (S (S (S (S (S Z)))))
e2) = Bool -> Value
JSON.Bool forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a. Eq a => a -> a -> Bool
(==) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e2)
  go (ExprNEQ Expr External (S (S (S (S (S Z)))))
e1 Expr External (S (S (S (S (S Z)))))
e2) = Bool -> Value
JSON.Bool forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a. Eq a => a -> a -> Bool
(/=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e2)
  go (ExprGT Expr External (S (S (S (S (S Z)))))
e1 Expr External (S (S (S (S (S Z)))))
e2) = do
    Value
v1 <- forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e1
    Value
v2 <- forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e2
    case (Value
v1, Value
v2) of
      (JSON.Number Scientific
l, JSON.Number Scientific
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Scientific
l forall a. Ord a => a -> a -> Bool
> Scientific
r
      (JSON.String Text
l, JSON.String Text
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Text
l forall a. Ord a => a -> a -> Bool
> Text
r
      (JSON.Bool   Bool
l, JSON.Bool   Bool
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Bool
l forall a. Ord a => a -> a -> Bool
> Bool
r
      (Value, Value)
_ -> forall a. HasCallStack => FilePath -> a
error FilePath
"(>)"
  go (ExprGE Expr External (S (S (S (S (S Z)))))
e1 Expr External (S (S (S (S (S Z)))))
e2) = do
    Value
v1 <- forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e1
    Value
v2 <- forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e2
    case (Value
v1, Value
v2) of
      (JSON.Number Scientific
l, JSON.Number Scientific
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Scientific
l forall a. Ord a => a -> a -> Bool
>= Scientific
r
      (JSON.String Text
l, JSON.String Text
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Text
l forall a. Ord a => a -> a -> Bool
>= Text
r
      (JSON.Bool   Bool
l, JSON.Bool   Bool
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Bool
l forall a. Ord a => a -> a -> Bool
>= Bool
r
      (Value, Value)
_ -> forall a. HasCallStack => FilePath -> a
error FilePath
"(>=)"
  go (ExprLT Expr External (S (S (S (S (S Z)))))
e1 Expr External (S (S (S (S (S Z)))))
e2) = do
    Value
v1 <- forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e1
    Value
v2 <- forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e2
    case (Value
v1, Value
v2) of
      (JSON.Number Scientific
l, JSON.Number Scientific
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Scientific
l forall a. Ord a => a -> a -> Bool
< Scientific
r
      (JSON.String Text
l, JSON.String Text
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Text
l forall a. Ord a => a -> a -> Bool
< Text
r
      (JSON.Bool   Bool
l, JSON.Bool   Bool
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Bool
l forall a. Ord a => a -> a -> Bool
< Bool
r
      (Value, Value)
_ -> forall a. HasCallStack => FilePath -> a
error FilePath
"(<)"
  go (ExprLE Expr External (S (S (S (S (S Z)))))
e1 Expr External (S (S (S (S (S Z)))))
e2) = do
    Value
v1 <- forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e1
    Value
v2 <- forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S Z)))))
e2
    case (Value
v1, Value
v2) of
      (JSON.Number Scientific
l, JSON.Number Scientific
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Scientific
l forall a. Ord a => a -> a -> Bool
<= Scientific
r
      (JSON.String Text
l, JSON.String Text
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Text
l forall a. Ord a => a -> a -> Bool
<= Text
r
      (JSON.Bool   Bool
l, JSON.Bool   Bool
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Bool
l forall a. Ord a => a -> a -> Bool
<= Bool
r
      (Value, Value)
_ -> forall a. HasCallStack => FilePath -> a
error FilePath
"(<=)"
  go (ExprAnd Expr External (S (S (S (S (S (S (S Z)))))))
e1 Expr External (S (S (S (S (S (S Z))))))
e2) = do
    Value
v1 <- forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S (S (S Z)))))))
e1
    Value
v2 <- forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S (S Z))))))
e2
    case (Value
v1, Value
v2) of
      (JSON.Bool   Bool
l, JSON.Bool   Bool
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Bool
l Bool -> Bool -> Bool
&& Bool
r
      (Value, Value)
_ -> forall a. HasCallStack => FilePath -> a
error FilePath
"(<=)"
  go (ExprOr Expr External LevelMax
e1 Expr External (S (S (S (S (S (S (S Z)))))))
e2) = do
    Value
v1 <- forall level. Expr External level -> Reader Value Value
go Expr External LevelMax
e1
    Value
v2 <- forall level. Expr External level -> Reader Value Value
go Expr External (S (S (S (S (S (S (S Z)))))))
e2
    case (Value
v1, Value
v2) of
      (JSON.Bool   Bool
l, JSON.Bool   Bool
r) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Value
JSON.Bool forall a b. (a -> b) -> a -> b
$ Bool
l Bool -> Bool -> Bool
|| Bool
r
      (Value, Value)
_ -> forall a. HasCallStack => FilePath -> a
error FilePath
"(<=)"