{-#LANGUAGE FlexibleContexts #-}
{-#LANGUAGE FlexibleInstances #-}
{-#LANGUAGE OverloadedStrings #-}
{-#LANGUAGE TupleSections #-}
{-#LANGUAGE TypeSynonymInstances #-}
{-#LANGUAGE MultiParamTypeClasses #-}
{-#LANGUAGE ScopedTypeVariables #-}
{-#LANGUAGE LambdaCase #-}
-- | Execute Ginger templates in an arbitrary monad.
--
-- Usage example:
--
-- > render :: Template -> Text -> Text -> Text
-- > render template username imageURL = do
-- >    let contextLookup varName =
-- >            case varName of
-- >                "username" -> toGVal username
-- >                "imageURL" -> toGVal imageURL
-- >                _ -> def -- def for GVal is equivalent to a NULL value
-- >        context = makeContextHtml contextLookup
-- >    in htmlSource $ runGinger context template
module Text.Ginger.Run
(
-- * The \"easy\" interface
-- | Provides a straightforward way of rendering templates monadically
-- as well as purely.
  easyRenderM
, easyRender
, easyContext
-- * The \"direct\" interface
-- | This interface gives more control than the easy interface, at the
-- expense of requiring more yak shaving.
, runGingerT
, runGinger
, makeContext
, makeContextM
, makeContext'
, makeContextM'
, makeContextExM'
, makeContextHtml
, makeContextHtmlM
, makeContextHtmlExM
, makeContextText
, makeContextTextM
, makeContextTextExM
-- * The context type
, GingerContext
-- * The Run monad
, Run, liftRun, liftRun2
-- * Helper functions for interpreting argument lists
, extractArgs, extractArgsT, extractArgsL, extractArgsDefL
-- * Hoisting
, hoistContext
, hoistRun
, hoistNewlines
, hoistRunState
-- * Errors
, RuntimeError (..)
, runtimeErrorWhat
, runtimeErrorWhere
, runtimeErrorMessage
)
where

import Prelude ( (.), ($), (==), (/=)
               , (>), (<), (>=), (<=)
               , (+), (-), (*), (/), div, (**), (^)
               , (||), (&&)
               , (++)
               , Show, show
               , undefined, otherwise
               , Maybe (..)
               , Bool (..)
               , Int, Integer, String
               , fromIntegral, floor, round
               , not
               , show
               , uncurry
               , seq
               , fst, snd
               , maybe
               , Either (..)
               , id
               )
import qualified Prelude
import Data.Maybe (fromMaybe, isJust, isNothing)
import qualified Data.List as List
import Text.Ginger.AST
import Text.Ginger.Html
import Text.Ginger.GVal
import Text.Ginger.Run.Type
import Text.Ginger.Run.Builtins
import Text.Ginger.Run.FuncUtils
import Text.Ginger.Run.VM
import Text.Printf
import Text.PrintfA
import Text.Ginger.Parse (parseGinger, ParserError)
import Control.Monad.Trans.Except (runExceptT, catchE)

import Data.Text (Text)
import Data.String (fromString)
import qualified Data.Text as Text
import qualified Data.ByteString.UTF8 as UTF8
import Control.Monad
import Control.Monad.Identity
import Control.Monad.Writer
import Control.Monad.Reader
import Control.Monad.State
import Control.Applicative
import qualified Data.HashMap.Strict as HashMap
import Data.HashMap.Strict (HashMap)
import qualified Data.Map.Strict as Map
import Data.Map.Strict (Map)
import Data.Scientific (Scientific, formatScientific)
import qualified Data.Scientific as Scientific
import Data.Default (def)
import Safe (readMay, lastDef, headMay)
import Network.HTTP.Types (urlEncode)
import Debug.Trace (trace)
import Data.List (lookup, zipWith, unzip)
import Data.Monoid (Monoid (..), (<>))
import Data.Aeson as JSON

defaultScope :: forall m h p
              . ( Monoid h
                , Monad m
                , ToGVal (Run p m h) h
                , ToGVal (Run p m h) p
                )
             => [(Text, GVal (Run p m h))]
defaultScope :: forall (m :: * -> *) h p.
(Monoid h, Monad m, ToGVal (Run p m h) h, ToGVal (Run p m h) p) =>
[(Text, GVal (Run p m h))]
defaultScope =
    [ (Text
"raw", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnRawHtml)
    , (Text
"abs", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> ((Scientific -> Scientific) -> Function (Run p m h))
-> (Scientific -> Scientific)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> (Scientific -> Scientific) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
Scientific
-> (Scientific -> Scientific)
-> [(Maybe Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
unaryNumericFunc Scientific
0 ((Scientific -> Scientific) -> GVal (Run p m h))
-> (Scientific -> Scientific) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Scientific -> Scientific
forall a. Num a => a -> a
Prelude.abs)
    , (Text
"any", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnAny)
    , (Text
"all", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnAll)
    , (Text
"apply", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnApply)
    -- TODO: batch
    , (Text
"capitalize", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> (([Text] -> Text) -> Function (Run p m h))
-> ([Text] -> Text)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Text) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
([Text] -> Text)
-> [(Maybe Text, GVal (Run p m h))] -> Run p m h (GVal (Run p m h))
variadicStringFunc (([Text] -> Text) -> GVal (Run p m h))
-> ([Text] -> Text) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ [Text] -> Text
forall a. Monoid a => [a] -> a
mconcat ([Text] -> Text) -> ([Text] -> [Text]) -> [Text] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Text) -> [Text] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map Text -> Text
capitalize)
    , (Text
"ceil", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> ((Scientific -> Scientific) -> Function (Run p m h))
-> (Scientific -> Scientific)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> (Scientific -> Scientific) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
Scientific
-> (Scientific -> Scientific)
-> [(Maybe Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
unaryNumericFunc Scientific
0 ((Scientific -> Scientific) -> GVal (Run p m h))
-> (Scientific -> Scientific) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Integer -> Scientific
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral (Integer -> Scientific)
-> (Scientific -> Integer) -> Scientific -> Scientific
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> Integer
forall b. Integral b => Scientific -> b
forall a b. (RealFrac a, Integral b) => a -> b
Prelude.ceiling)
    , (Text
"center", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnCenter)
    , (Text
"compose", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnCompose)
    , (Text
"concat", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnConcat)
    , (Text
"contains", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnContains)
    , (Text
"d", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnDefault)
    , (Text
"date", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnDateFormat)
    , (Text
"dateformat", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnDateFormat)
    , (Text
"default", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnDefault)
    , (Text
"dictsort", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnDictsort)
    , (Text
"difference", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> (([Scientific] -> Scientific) -> Function (Run p m h))
-> ([Scientific] -> Scientific)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> ([Scientific] -> Scientific) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
Scientific
-> ([Scientific] -> Scientific)
-> [(Maybe Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
variadicNumericFunc Scientific
0 (([Scientific] -> Scientific) -> GVal (Run p m h))
-> ([Scientific] -> Scientific) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ [Scientific] -> Scientific
forall a. Num a => [a] -> a
difference)
    , (Text
"divisibleby", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnDivisibleBy)
    , (Text
"e", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnEscape)
    , (Text
"eq", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnEquals)
    , (Text
"equals", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnEquals)
    , (Text
"equalto", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnEquals)
    , (Text
"escape", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnEscape)
    , (Text
"eval", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) h p.
(Monad m, Monoid h, ToGVal (Run p m h) h, ToGVal (Run p m h) p) =>
Function (Run p m h)
gfnEval)
    , (Text
"even", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnEven)
    , (Text
"filesizeformat", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnFileSizeFormat)
    , (Text
"filter", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnFilter)
    , (Text
"floor", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> ((Scientific -> Scientific) -> Function (Run p m h))
-> (Scientific -> Scientific)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> (Scientific -> Scientific) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
Scientific
-> (Scientific -> Scientific)
-> [(Maybe Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
unaryNumericFunc Scientific
0 ((Scientific -> Scientific) -> GVal (Run p m h))
-> (Scientific -> Scientific) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Integer -> Scientific
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral (Integer -> Scientific)
-> (Scientific -> Integer) -> Scientific -> Scientific
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> Integer
forall b. Integral b => Scientific -> b
forall a b. (RealFrac a, Integral b) => a -> b
Prelude.floor)
    , (Text
"format", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnPrintf)
    , (Text
"ge", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnGreaterEquals)
    , (Text
"gt", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnGreater)
    , (Text
"greater", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnGreater)
    , (Text
"greaterthan", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnGreater)
    , (Text
"greaterEquals", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnGreaterEquals)
    , (Text
"int", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> ((GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h))
-> (GVal (Run p m h) -> GVal (Run p m h))
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
forall (m :: * -> *) h p.
Monad m =>
(GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
unaryFunc ((GVal (Run p m h) -> GVal (Run p m h)) -> GVal (Run p m h))
-> (GVal (Run p m h) -> GVal (Run p m h)) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Maybe Int -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Maybe Int -> GVal (Run p m h))
-> (GVal (Run p m h) -> Maybe Int)
-> GVal (Run p m h)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Scientific -> Int) -> Maybe Scientific -> Maybe Int
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Scientific -> Int
forall b. Integral b => Scientific -> b
forall a b. (RealFrac a, Integral b) => a -> b
Prelude.truncate :: Scientific -> Int) (Maybe Scientific -> Maybe Int)
-> (GVal (Run p m h) -> Maybe Scientific)
-> GVal (Run p m h)
-> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GVal (Run p m h) -> Maybe Scientific
forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber)
    , (Text
"int_ratio", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> (([Scientific] -> Scientific) -> Function (Run p m h))
-> ([Scientific] -> Scientific)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> ([Scientific] -> Scientific) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
Scientific
-> ([Scientific] -> Scientific)
-> [(Maybe Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
variadicNumericFunc Scientific
1 (([Scientific] -> Scientific) -> GVal (Run p m h))
-> ([Scientific] -> Scientific) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Integer -> Scientific
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Scientific)
-> ([Scientific] -> Integer) -> [Scientific] -> Scientific
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Integer] -> Integer
forall a. (Integral a, Num a) => [a] -> a
intRatio ([Integer] -> Integer)
-> ([Scientific] -> [Integer]) -> [Scientific] -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Scientific -> Integer) -> [Scientific] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map Scientific -> Integer
forall b. Integral b => Scientific -> b
forall a b. (RealFrac a, Integral b) => a -> b
Prelude.floor)
    , (Text
"is_lt", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnLess)
    , (Text
"iterable", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> ((GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h))
-> (GVal (Run p m h) -> GVal (Run p m h))
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
forall (m :: * -> *) h p.
Monad m =>
(GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
unaryFunc ((GVal (Run p m h) -> GVal (Run p m h)) -> GVal (Run p m h))
-> (GVal (Run p m h) -> GVal (Run p m h)) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Bool -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Bool -> GVal (Run p m h))
-> (GVal (Run p m h) -> Bool)
-> GVal (Run p m h)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\GVal (Run p m h)
x -> GVal (Run p m h) -> Bool
forall (m :: * -> *). GVal m -> Bool
isList GVal (Run p m h)
x Bool -> Bool -> Bool
|| GVal (Run p m h) -> Bool
forall (m :: * -> *). GVal m -> Bool
isDict GVal (Run p m h)
x))
    , (Text
"json", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnJSON)
    , (Text
"length", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnLength)
    , (Text
"le", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnLessEquals)
    , (Text
"less", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnLess)
    , (Text
"lessthan", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnLess)
    , (Text
"lessEquals", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnLessEquals)
    , (Text
"lt", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnLess)
    , (Text
"map", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) a.
(Monad m, MonadError (RuntimeError a) m) =>
Function m
gfnMap)
    , (Text
"modulo", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> (([Scientific] -> Scientific) -> Function (Run p m h))
-> ([Scientific] -> Scientific)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> ([Scientific] -> Scientific) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
Scientific
-> ([Scientific] -> Scientific)
-> [(Maybe Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
variadicNumericFunc Scientific
1 (([Scientific] -> Scientific) -> GVal (Run p m h))
-> ([Scientific] -> Scientific) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Integer -> Scientific
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Scientific)
-> ([Scientific] -> Integer) -> [Scientific] -> Scientific
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Integer] -> Integer
forall a. (Integral a, Num a) => [a] -> a
modulo ([Integer] -> Integer)
-> ([Scientific] -> [Integer]) -> [Scientific] -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Scientific -> Integer) -> [Scientific] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map Scientific -> Integer
forall b. Integral b => Scientific -> b
forall a b. (RealFrac a, Integral b) => a -> b
Prelude.floor)
    , (Text
"ne", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnNEquals)
    , (Text
"nequals", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnNEquals)
    , (Text
"num", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> ((GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h))
-> (GVal (Run p m h) -> GVal (Run p m h))
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
forall (m :: * -> *) h p.
Monad m =>
(GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
unaryFunc ((GVal (Run p m h) -> GVal (Run p m h)) -> GVal (Run p m h))
-> (GVal (Run p m h) -> GVal (Run p m h)) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Maybe Scientific -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Maybe Scientific -> GVal (Run p m h))
-> (GVal (Run p m h) -> Maybe Scientific)
-> GVal (Run p m h)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GVal (Run p m h) -> Maybe Scientific
forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber)
    , (Text
"odd", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnOdd)
    , (Text
"partial", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnPartial)
    , (Text
"printf", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnPrintf)
    , (Text
"product", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> (([Scientific] -> Scientific) -> Function (Run p m h))
-> ([Scientific] -> Scientific)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> ([Scientific] -> Scientific) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
Scientific
-> ([Scientific] -> Scientific)
-> [(Maybe Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
variadicNumericFunc Scientific
1 (([Scientific] -> Scientific) -> GVal (Run p m h))
-> ([Scientific] -> Scientific) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ [Scientific] -> Scientific
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
Prelude.product)
    , (Text
"ratio", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> (([Scientific] -> Scientific) -> Function (Run p m h))
-> ([Scientific] -> Scientific)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> ([Scientific] -> Scientific) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
Scientific
-> ([Scientific] -> Scientific)
-> [(Maybe Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
variadicNumericFunc Scientific
1 (([Scientific] -> Scientific) -> GVal (Run p m h))
-> ([Scientific] -> Scientific) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Double -> Scientific
forall a. RealFloat a => a -> Scientific
Scientific.fromFloatDigits (Double -> Scientific)
-> ([Scientific] -> Double) -> [Scientific] -> Scientific
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Double] -> Double
forall a. (Show a, Fractional a, Num a) => [a] -> a
ratio ([Double] -> Double)
-> ([Scientific] -> [Double]) -> [Scientific] -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Scientific -> Double) -> [Scientific] -> [Double]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map Scientific -> Double
forall a. RealFloat a => Scientific -> a
Scientific.toRealFloat)
    , (Text
"replace", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnReplace)
    , (Text
"reverse", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall p (m :: * -> *) h. Monad m => Function (Run p m h)
gfnReverse)
    , (Text
"round", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> ((Scientific -> Scientific) -> Function (Run p m h))
-> (Scientific -> Scientific)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> (Scientific -> Scientific) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
Scientific
-> (Scientific -> Scientific)
-> [(Maybe Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
unaryNumericFunc Scientific
0 ((Scientific -> Scientific) -> GVal (Run p m h))
-> (Scientific -> Scientific) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Integer -> Scientific
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral (Integer -> Scientific)
-> (Scientific -> Integer) -> Scientific -> Scientific
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> Integer
forall b. Integral b => Scientific -> b
forall a b. (RealFrac a, Integral b) => a -> b
Prelude.round)
    , (Text
"show", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> ((GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h))
-> (GVal (Run p m h) -> GVal (Run p m h))
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
forall (m :: * -> *) h p.
Monad m =>
(GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
unaryFunc ((GVal (Run p m h) -> GVal (Run p m h)) -> GVal (Run p m h))
-> (GVal (Run p m h) -> GVal (Run p m h)) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ String -> GVal (Run p m h)
forall a. IsString a => String -> a
fromString (String -> GVal (Run p m h))
-> (GVal (Run p m h) -> String)
-> GVal (Run p m h)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GVal (Run p m h) -> String
forall a. Show a => a -> String
show)
    , (Text
"slice", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnSlice)
    , (Text
"sort", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall p (m :: * -> *) h. Monad m => Function (Run p m h)
gfnSort)
    , (Text
"split", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnSplit)
    , (Text
"str", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> ((GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h))
-> (GVal (Run p m h) -> GVal (Run p m h))
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
forall (m :: * -> *) h p.
Monad m =>
(GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
unaryFunc ((GVal (Run p m h) -> GVal (Run p m h)) -> GVal (Run p m h))
-> (GVal (Run p m h) -> GVal (Run p m h)) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Text -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Text -> GVal (Run p m h))
-> (GVal (Run p m h) -> Text)
-> GVal (Run p m h)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GVal (Run p m h) -> Text
forall (m :: * -> *). GVal m -> Text
asText)
    , (Text
"sum", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> (([Scientific] -> Scientific) -> Function (Run p m h))
-> ([Scientific] -> Scientific)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> ([Scientific] -> Scientific) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
Scientific
-> ([Scientific] -> Scientific)
-> [(Maybe Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
variadicNumericFunc Scientific
0 (([Scientific] -> Scientific) -> GVal (Run p m h))
-> ([Scientific] -> Scientific) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ [Scientific] -> Scientific
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
Prelude.sum)
    , (Text
"truncate", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> ((Scientific -> Scientific) -> Function (Run p m h))
-> (Scientific -> Scientific)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> (Scientific -> Scientific) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
Scientific
-> (Scientific -> Scientific)
-> [(Maybe Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
unaryNumericFunc Scientific
0 ((Scientific -> Scientific) -> GVal (Run p m h))
-> (Scientific -> Scientific) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ Integer -> Scientific
forall a b. (Integral a, Num b) => a -> b
Prelude.fromIntegral (Integer -> Scientific)
-> (Scientific -> Integer) -> Scientific -> Scientific
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> Integer
forall b. Integral b => Scientific -> b
forall a b. (RealFrac a, Integral b) => a -> b
Prelude.truncate)
    , (Text
"urlencode", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnUrlEncode)
    , (Text
"upper", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> (([Text] -> Text) -> Function (Run p m h))
-> ([Text] -> Text)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Text) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
([Text] -> Text)
-> [(Maybe Text, GVal (Run p m h))] -> Run p m h (GVal (Run p m h))
variadicStringFunc (([Text] -> Text) -> GVal (Run p m h))
-> ([Text] -> Text) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ [Text] -> Text
forall a. Monoid a => [a] -> a
mconcat ([Text] -> Text) -> ([Text] -> [Text]) -> [Text] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Text) -> [Text] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map Text -> Text
Text.toUpper)
    , (Text
"lower", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Function (Run p m h) -> GVal (Run p m h))
-> (([Text] -> Text) -> Function (Run p m h))
-> ([Text] -> Text)
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Text) -> Function (Run p m h)
forall (m :: * -> *) p h.
Monad m =>
([Text] -> Text)
-> [(Maybe Text, GVal (Run p m h))] -> Run p m h (GVal (Run p m h))
variadicStringFunc (([Text] -> Text) -> GVal (Run p m h))
-> ([Text] -> Text) -> GVal (Run p m h)
forall a b. (a -> b) -> a -> b
$ [Text] -> Text
forall a. Monoid a => [a] -> a
mconcat ([Text] -> Text) -> ([Text] -> [Text]) -> [Text] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Text) -> [Text] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map Text -> Text
Text.toLower)
    , (Text
"throw", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) h p.
(Monad m, Monoid h, ToGVal (Run p m h) h, ToGVal (Run p m h) p) =>
Function (Run p m h)
gfnThrow)
    , (Text
"zip", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnZip)
    , (Text
"zipwith", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnZipWith)

    -- Tests/predicates

    , (Text
"in", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnIn)
    , (Text
"escaped", Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall (m :: * -> *). Monad m => Function m
gfnEscaped)

    , (Text
"regex", GVal (Run p m h)
forall (m :: * -> *) p h. Monad m => GVal (Run p m h)
gfoRegex)

    -- TODO: sameas (predicate)
    -- NOTE that this test doesn't make sense in a host language where pointers
    -- are transparent - in Haskell, we simply don't care whether two values
    -- share a memory location or not, and whether they do or not might even
    -- depend on build flags.

    -- TODO: mapping (predicate)
    -- TODO: none (predicate)
    -- TODO: number (predicate)
    -- TODO: sequence (predicate)
    -- TODO: string (predicate)
    -- TODO: callable

    -- TODO: defined (predicate)
    -- TODO: undefined (predicate)
    -- NOTE that @defined@ cannot actually be written as a function. See
    -- issue #33.

    -- TODO: lower (predicate)
    -- TODO: upper (predicate)
    ]

-- | Simplified interface to render a ginger template \"into\" a monad.
--
-- @easyRenderM emit context template@ renders the @template@ with the
-- given @context@ object (which should represent some sort of
-- dictionary-like object) by feeding any output to the @emit@ function.
easyRenderM :: ( Monad m
               , ContextEncodable h
               , Monoid h
               , ToGVal (Run p m h) v
               , ToGVal (Run p m h) h
               , ToGVal (Run p m h) p
               )
            => (h -> m ())
            -> v
            -> Template p
            -> m (Either (RuntimeError p) (GVal (Run p m h)))
easyRenderM :: forall (m :: * -> *) h p v.
(Monad m, ContextEncodable h, Monoid h, ToGVal (Run p m h) v,
 ToGVal (Run p m h) h, ToGVal (Run p m h) p) =>
(h -> m ())
-> v
-> Template p
-> m (Either (RuntimeError p) (GVal (Run p m h)))
easyRenderM h -> m ()
emit v
context Template p
template =
    GingerContext p m h
-> Template p -> m (Either (RuntimeError p) (GVal (Run p m h)))
forall p (m :: * -> *) h.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
GingerContext p m h
-> Template p -> m (Either (RuntimeError p) (GVal (Run p m h)))
runGingerT ((h -> m ()) -> v -> GingerContext p m h
forall (m :: * -> *) h p v.
(Monad m, ContextEncodable h, ToGVal (Run p m h) v) =>
(h -> m ()) -> v -> GingerContext p m h
easyContext h -> m ()
emit v
context) Template p
template

-- | Simplified interface to render a ginger template in a pure fashion.
--
-- @easyRender context template@ renders the @template@ with the
-- given @context@ object (which should represent some sort of
-- dictionary-like object) by returning the concatenated output.
easyRender :: ( ContextEncodable h
              , Monoid h
              , ToGVal (Run p (Writer h) h) v
              , ToGVal (Run p (Writer h) h) h
              , ToGVal (Run p (Writer h) h) p
              )
           => v
           -> Template p
           -> h
easyRender :: forall h p v.
(ContextEncodable h, Monoid h, ToGVal (Run p (Writer h) h) v,
 ToGVal (Run p (Writer h) h) h, ToGVal (Run p (Writer h) h) p) =>
v -> Template p -> h
easyRender v
context Template p
template =
    Writer h (Either (RuntimeError p) (GVal (Run p (Writer h) h))) -> h
forall w a. Writer w a -> w
execWriter (Writer h (Either (RuntimeError p) (GVal (Run p (Writer h) h)))
 -> h)
-> Writer h (Either (RuntimeError p) (GVal (Run p (Writer h) h)))
-> h
forall a b. (a -> b) -> a -> b
$ (h -> WriterT h Identity ())
-> v
-> Template p
-> Writer h (Either (RuntimeError p) (GVal (Run p (Writer h) h)))
forall (m :: * -> *) h p v.
(Monad m, ContextEncodable h, Monoid h, ToGVal (Run p m h) v,
 ToGVal (Run p m h) h, ToGVal (Run p m h) p) =>
(h -> m ())
-> v
-> Template p
-> m (Either (RuntimeError p) (GVal (Run p m h)))
easyRenderM h -> WriterT h Identity ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell v
context Template p
template

-- | Purely expand a Ginger template. The underlying carrier monad is 'Writer'
-- 'h', which is used to collect the output and render it into a 'h'
-- value.
runGinger :: ( ToGVal (Run p (Writer h) h) h
             , ToGVal (Run p (Writer h) h) p
             , Monoid h
             )
          => GingerContext p (Writer h) h
          -> Template p
          -> h
runGinger :: forall p h.
(ToGVal (Run p (Writer h) h) h, ToGVal (Run p (Writer h) h) p,
 Monoid h) =>
GingerContext p (Writer h) h -> Template p -> h
runGinger GingerContext p (Writer h) h
context Template p
template =
    Writer h (Either (RuntimeError p) (GVal (Run p (Writer h) h))) -> h
forall w a. Writer w a -> w
execWriter (Writer h (Either (RuntimeError p) (GVal (Run p (Writer h) h)))
 -> h)
-> Writer h (Either (RuntimeError p) (GVal (Run p (Writer h) h)))
-> h
forall a b. (a -> b) -> a -> b
$ GingerContext p (Writer h) h
-> Template p
-> Writer h (Either (RuntimeError p) (GVal (Run p (Writer h) h)))
forall p (m :: * -> *) h.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
GingerContext p m h
-> Template p -> m (Either (RuntimeError p) (GVal (Run p m h)))
runGingerT GingerContext p (Writer h) h
context Template p
template

-- | Monadically run a Ginger template. The @m@ parameter is the carrier monad.
runGingerT :: ( ToGVal (Run p m h) h
              , ToGVal (Run p m h) p
              , Monoid h
              , Monad m
              )
           => GingerContext p m h
           -> Template p
           -> m (Either (RuntimeError p) (GVal (Run p m h)))
runGingerT :: forall p (m :: * -> *) h.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
GingerContext p m h
-> Template p -> m (Either (RuntimeError p) (GVal (Run p m h)))
runGingerT GingerContext p m h
context Template p
tpl =
    ReaderT
  (GingerContext p m h)
  m
  (Either (RuntimeError p) (GVal (Run p m h)))
-> GingerContext p m h
-> m (Either (RuntimeError p) (GVal (Run p m h)))
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (StateT
  (RunState p m h)
  (ReaderT (GingerContext p m h) m)
  (Either (RuntimeError p) (GVal (Run p m h)))
-> RunState p m h
-> ReaderT
     (GingerContext p m h)
     m
     (Either (RuntimeError p) (GVal (Run p m h)))
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT (ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
-> StateT
     (RunState p m h)
     (ReaderT (GingerContext p m h) m)
     (Either (RuntimeError p) (GVal (Run p m h)))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (Template p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall p (m :: * -> *) h.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Template p -> Run p m h (GVal (Run p m h))
runTemplate Template p
tpl)) (Template p -> RunState p m h
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Template p -> RunState p m h
defRunState Template p
tpl)) GingerContext p m h
context

-- | Find the effective base template of an inheritance chain
baseTemplate :: Template p -> Template p
baseTemplate :: forall p. Template p -> Template p
baseTemplate Template p
t =
    case Template p -> Maybe (Template p)
forall a. Template a -> Maybe (Template a)
templateParent Template p
t of
        Maybe (Template p)
Nothing -> Template p
t
        Just Template p
p -> Template p -> Template p
forall p. Template p -> Template p
baseTemplate Template p
p

-- | Run a template.
runTemplate :: ( ToGVal (Run p m h) h
               , ToGVal (Run p m h) p
               , Monoid h
               , Monad m
               )
            => Template p
            -> Run p m h (GVal (Run p m h))
runTemplate :: forall p (m :: * -> *) h.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Template p -> Run p m h (GVal (Run p m h))
runTemplate =
    Statement p -> Run p m h (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement (Statement p -> Run p m h (GVal (Run p m h)))
-> (Template p -> Statement p)
-> Template p
-> Run p m h (GVal (Run p m h))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Template p -> Statement p
forall a. Template a -> Statement a
templateBody (Template p -> Statement p)
-> (Template p -> Template p) -> Template p -> Statement p
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Template p -> Template p
forall p. Template p -> Template p
baseTemplate

-- | Run an action within a different template context.
withTemplate :: Monad m
             => Template p
             -> Run p m h a
             -> Run p m h a
withTemplate :: forall (m :: * -> *) p h a.
Monad m =>
Template p -> Run p m h a -> Run p m h a
withTemplate Template p
tpl Run p m h a
a = do
    Template p
oldTpl <- (RunState p m h -> Template p)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Template p)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets RunState p m h -> Template p
forall p (m :: * -> *) h. RunState p m h -> Template p
rsCurrentTemplate
    Maybe Text
oldBlockName <- (RunState p m h -> Maybe Text)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Maybe Text)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets RunState p m h -> Maybe Text
forall p (m :: * -> *) h. RunState p m h -> Maybe Text
rsCurrentBlockName
    (RunState p m h -> RunState p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\RunState p m h
s -> RunState p m h
s { rsCurrentTemplate = tpl, rsCurrentBlockName = Nothing })
    a
result <- p -> Run p m h a -> Run p m h a
forall (m :: * -> *) p h a.
Monad m =>
p -> Run p m h a -> Run p m h a
withSourcePos (Template p -> p
forall p. Template p -> p
forall (f :: * -> *) p. Annotated f => f p -> p
annotation Template p
tpl) Run p m h a
a
    (RunState p m h -> RunState p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\RunState p m h
s -> RunState p m h
s { rsCurrentTemplate = oldTpl, rsCurrentBlockName = oldBlockName })
    a -> Run p m h a
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return a
result

-- | Run an action within a block context
withBlockName :: Monad m
              => VarName
              -> Run p m h a
              -> Run p m h a
withBlockName :: forall (m :: * -> *) p h a.
Monad m =>
Text -> Run p m h a -> Run p m h a
withBlockName Text
blockName Run p m h a
a = do
    Maybe Text
oldBlockName <- (RunState p m h -> Maybe Text)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Maybe Text)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets RunState p m h -> Maybe Text
forall p (m :: * -> *) h. RunState p m h -> Maybe Text
rsCurrentBlockName
    (RunState p m h -> RunState p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\RunState p m h
s -> RunState p m h
s { rsCurrentBlockName = Just blockName })
    a
result <- Run p m h a
a
    (RunState p m h -> RunState p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\RunState p m h
s -> RunState p m h
s { rsCurrentBlockName = oldBlockName })
    a -> Run p m h a
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return a
result

lookupBlock :: Monad m => VarName -> Run p m h (Block p)
lookupBlock :: forall (m :: * -> *) p h. Monad m => Text -> Run p m h (Block p)
lookupBlock Text
blockName = do
    Template p
tpl <- (RunState p m h -> Template p)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Template p)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets RunState p m h -> Template p
forall p (m :: * -> *) h. RunState p m h -> Template p
rsCurrentTemplate
    let blockMay :: Maybe (Block p)
blockMay = Text -> Template p -> Maybe (Block p)
forall p. Text -> Template p -> Maybe (Block p)
resolveBlock Text
blockName Template p
tpl
    case Maybe (Block p)
blockMay of
        Maybe (Block p)
Nothing -> RuntimeError p -> Run p m h (Block p)
forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere (RuntimeError p -> Run p m h (Block p))
-> RuntimeError p -> Run p m h (Block p)
forall a b. (a -> b) -> a -> b
$ Text -> RuntimeError p
forall p. Text -> RuntimeError p
UndefinedBlockError Text
blockName
        Just Block p
block -> Block p -> Run p m h (Block p)
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return Block p
block
    where
        resolveBlock :: VarName -> Template p -> Maybe (Block p)
        resolveBlock :: forall p. Text -> Template p -> Maybe (Block p)
resolveBlock Text
name Template p
tpl =
            case Text -> HashMap Text (Block p) -> Maybe (Block p)
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HashMap.lookup Text
name (Template p -> HashMap Text (Block p)
forall a. Template a -> HashMap Text (Block a)
templateBlocks Template p
tpl) of
                Just Block p
block ->
                    Block p -> Maybe (Block p)
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return Block p
block -- Found it!
                Maybe (Block p)
Nothing ->
                    Template p -> Maybe (Template p)
forall a. Template a -> Maybe (Template a)
templateParent Template p
tpl Maybe (Template p)
-> (Template p -> Maybe (Block p)) -> Maybe (Block p)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> Template p -> Maybe (Block p)
forall p. Text -> Template p -> Maybe (Block p)
resolveBlock Text
name

-- | Run one statement.
runStatement :: forall m h p
              . ( ToGVal (Run p m h) h
                , ToGVal (Run p m h) p
                , Monoid h
                , Monad m
                )
             => Statement p
             -> Run p m h (GVal (Run p m h))
runStatement :: forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement Statement p
stmt =
    p -> Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h))
forall (m :: * -> *) p h a.
Monad m =>
p -> Run p m h a -> Run p m h a
withSourcePos
        (Statement p -> p
forall p. Statement p -> p
forall (f :: * -> *) p. Annotated f => f p -> p
annotation Statement p
stmt)
        (Statement p -> Run p m h (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement' Statement p
stmt)

runStatement' :: forall m h p
              . ( ToGVal (Run p m h) h
                , ToGVal (Run p m h) p
                , Monoid h
                , Monad m
                )
             => Statement p
             -> Run p m h (GVal (Run p m h))
runStatement' :: forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement' (NullS p
_) =
    GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal (Run p m h)
forall a. Default a => a
def
runStatement' (MultiS p
_ [Statement p]
xs) =
    [Statement p]
-> (Statement p
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [GVal (Run p m h)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Statement p]
xs Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  [GVal (Run p m h)]
-> ([GVal (Run p m h)]
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b.
ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  a
-> (a
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         b)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        [] -> GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal (Run p m h)
forall a. Default a => a
def
        [GVal (Run p m h)]
rvals -> GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return (GVal (Run p m h)
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ [GVal (Run p m h)] -> GVal (Run p m h)
forall a. HasCallStack => [a] -> a
List.last [GVal (Run p m h)]
rvals
runStatement' (LiteralS p
_ Html
html) =
    GVal (Run p m h) -> Run p m h ()
forall (m :: * -> *) h p.
(Monad m, Monoid h) =>
GVal (Run p m h) -> Run p m h ()
echo (Html -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Html
html) Run p m h ()
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b.
ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal (Run p m h)
forall a. Default a => a
def
runStatement' (InterpolationS p
_ Expression p
expr) =
    Expression p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall {p} {m :: * -> *} {h}.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
expr ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
-> (GVal (Run p m h) -> Run p m h ()) -> Run p m h ()
forall a b.
ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  a
-> (a
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         b)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= GVal (Run p m h) -> Run p m h ()
forall (m :: * -> *) h p.
(Monad m, Monoid h) =>
GVal (Run p m h) -> Run p m h ()
echo Run p m h ()
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b.
ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal (Run p m h)
forall a. Default a => a
def
runStatement' (ExpressionS p
_ Expression p
expr) =
    Expression p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall {p} {m :: * -> *} {h}.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
expr
runStatement' (IfS p
_ Expression p
condExpr Statement p
true Statement p
false) = do
    GVal (Run p m h)
cond <- Expression p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall {p} {m :: * -> *} {h}.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
condExpr
    Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement (Statement p
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ if GVal (Run p m h) -> Bool
forall (m :: * -> *). GVal m -> Bool
toBoolean GVal (Run p m h)
cond then Statement p
true else Statement p
false

runStatement' (IndentS p
_ Expression p
expr Statement p
body) = do
    GVal (Run p m h)
i <- Expression p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall {p} {m :: * -> *} {h}.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
expr
    GVal (Run p m h) -> h
encode <- (GingerContext p m h -> GVal (Run p m h) -> h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h) -> h)
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks GingerContext p m h -> GVal (Run p m h) -> h
forall p (m :: * -> *) h.
GingerContext p m h -> GVal (Run p m h) -> h
contextEncode
    let istr :: h
istr = GVal (Run p m h) -> h
encode GVal (Run p m h)
i
    h
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p a.
(Monad m, Monoid h) =>
h -> Run p m h a -> Run p m h a
indented h
istr (ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement Statement p
body

runStatement' (SwitchS p
_ Expression p
pivotExpr [(Expression p, Statement p)]
cases Statement p
defBranch) = do
    GVal (Run p m h)
pivot <- Expression p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall {p} {m :: * -> *} {h}.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
pivotExpr
    let branches :: [ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))]
branches =
            [ \ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
cont -> do
                GVal (Run p m h)
cond <- Expression p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall {p} {m :: * -> *} {h}.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
condExpr
                if GVal (Run p m h)
pivot GVal (Run p m h) -> GVal (Run p m h) -> Bool
forall (m :: * -> *). GVal m -> GVal m -> Bool
`looseEquals` GVal (Run p m h)
cond
                    then Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement Statement p
body
                    else ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
cont
            | (Expression p
condExpr, Statement p
body)
            <- [(Expression p, Statement p)]
cases
            ] [ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))]
-> [ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (GVal (Run p m h))]
-> [ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (GVal (Run p m h))]
forall a. [a] -> [a] -> [a]
++
            [ ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b. a -> b -> a
Prelude.const (ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement Statement p
defBranch ]
    [ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
go [ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))]
branches
    where
        go :: [ Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h)) ]
           -> Run p m h (GVal (Run p m h))
        go :: [ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
go [] = GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal (Run p m h)
forall a. Default a => a
def
        go (ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
x:[ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))]
xs) = ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
x ([ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
go [ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))]
xs)

runStatement' (SetVarS p
_ Text
name Expression p
valExpr) = do
    GVal (Run p m h)
val <- Expression p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall {p} {m :: * -> *} {h}.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
valExpr
    Text -> GVal (Run p m h) -> Run p m h ()
forall (m :: * -> *) p h.
Monad m =>
Text -> GVal (Run p m h) -> Run p m h ()
setVar Text
name GVal (Run p m h)
val
    GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal (Run p m h)
forall a. Default a => a
def

runStatement' (DefMacroS p
_ Text
name Macro p
macro) = do
    let val :: GVal (Run p m h)
val = Macro p -> GVal (Run p m h)
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Macro p -> GVal (Run p m h)
macroToGVal Macro p
macro
    Text -> GVal (Run p m h) -> Run p m h ()
forall (m :: * -> *) p h.
Monad m =>
Text -> GVal (Run p m h) -> Run p m h ()
setVar Text
name GVal (Run p m h)
val
    GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal (Run p m h)
forall a. Default a => a
def

runStatement' (BlockRefS p
_ Text
blockName) = do
    Block p
block <- Text -> Run p m h (Block p)
forall (m :: * -> *) p h. Monad m => Text -> Run p m h (Block p)
lookupBlock Text
blockName
    Text
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) p h a.
Monad m =>
Text -> Run p m h a -> Run p m h a
withBlockName Text
blockName (ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$
        Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement (Block p -> Statement p
forall a. Block a -> Statement a
blockBody Block p
block)

runStatement' (ScopedS p
_ Statement p
body) = ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) p h a. Monad m => Run p m h a -> Run p m h a
withLocalScope ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
Monad m =>
ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
runInner
    where
        runInner :: Monad m => Run p m h (GVal (Run p m h))
        runInner :: Monad m =>
ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
runInner = Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement Statement p
body

runStatement' (ForS p
_ Maybe Text
varNameIndex Text
varNameValue Expression p
itereeExpr Statement p
body) = do
    let go :: Int -> GVal (Run p m h) -> Run p m h (GVal (Run p m h))
        go :: Int
-> GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
go Int
recursionDepth GVal (Run p m h)
iteree = do
            [(GVal (Run p m h), GVal (Run p m h))]
iterPairs <- if Maybe [(Text, GVal (Run p m h))] -> Bool
forall a. Maybe a -> Bool
isJust (GVal (Run p m h) -> Maybe [(Text, GVal (Run p m h))]
forall (m :: * -> *). GVal m -> Maybe [(Text, GVal m)]
asDictItems GVal (Run p m h)
iteree)
                then [(GVal (Run p m h), GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [(GVal (Run p m h), GVal (Run p m h))]
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return [ (Text -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Text
k, GVal (Run p m h)
v) | (Text
k, GVal (Run p m h)
v) <- [(Text, GVal (Run p m h))]
-> Maybe [(Text, GVal (Run p m h))] -> [(Text, GVal (Run p m h))]
forall a. a -> Maybe a -> a
fromMaybe [] (GVal (Run p m h) -> Maybe [(Text, GVal (Run p m h))]
forall (m :: * -> *). GVal m -> Maybe [(Text, GVal m)]
asDictItems GVal (Run p m h)
iteree) ]
                else case GVal (Run p m h) -> Maybe [GVal (Run p m h)]
forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList GVal (Run p m h)
iteree of
                  Just [GVal (Run p m h)]
items -> [(GVal (Run p m h), GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [(GVal (Run p m h), GVal (Run p m h))]
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return ([(GVal (Run p m h), GVal (Run p m h))]
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      [(GVal (Run p m h), GVal (Run p m h))])
-> [(GVal (Run p m h), GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [(GVal (Run p m h), GVal (Run p m h))]
forall a b. (a -> b) -> a -> b
$ [GVal (Run p m h)]
-> [GVal (Run p m h)] -> [(GVal (Run p m h), GVal (Run p m h))]
forall a b. [a] -> [b] -> [(a, b)]
Prelude.zip ((Int -> GVal (Run p m h)) -> [Int] -> [GVal (Run p m h)]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map Int -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal ([Int
0..] :: [Int])) [GVal (Run p m h)]
items
                  Maybe [GVal (Run p m h)]
Nothing -> do
                    RuntimeError p -> Run p m h ()
forall (m :: * -> *) p h. Monad m => RuntimeError p -> Run p m h ()
warn (RuntimeError p -> Run p m h ()) -> RuntimeError p -> Run p m h ()
forall a b. (a -> b) -> a -> b
$ [Text] -> Maybe Text -> RuntimeError p
forall p. [Text] -> Maybe Text -> RuntimeError p
TypeError [Text
"list", Text
"dictionary"] (Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Text -> Maybe Text
forall a b. (a -> b) -> a -> b
$ GVal (Run p m h) -> Text
forall a. Show a => a -> Text
tshow GVal (Run p m h)
iteree)
                    [(GVal (Run p m h), GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [(GVal (Run p m h), GVal (Run p m h))]
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return []
            let numItems :: Int
                numItems :: Int
numItems = [(GVal (Run p m h), GVal (Run p m h))] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
Prelude.length [(GVal (Run p m h), GVal (Run p m h))]
iterPairs
                cycle :: Int -> [(Maybe Text, GVal (Run p m h))] -> Run p m h (GVal (Run p m h))
                cycle :: Int
-> [(Maybe Text, GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
cycle Int
index [(Maybe Text, GVal (Run p m h))]
args = GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return
                                 (GVal (Run p m h)
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> ([(Maybe Text, GVal (Run p m h))] -> GVal (Run p m h))
-> [(Maybe Text, GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GVal (Run p m h) -> Maybe (GVal (Run p m h)) -> GVal (Run p m h)
forall a. a -> Maybe a -> a
fromMaybe GVal (Run p m h)
forall a. Default a => a
def
                                 (Maybe (GVal (Run p m h)) -> GVal (Run p m h))
-> ([(Maybe Text, GVal (Run p m h))] -> Maybe (GVal (Run p m h)))
-> [(Maybe Text, GVal (Run p m h))]
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [GVal (Run p m h)] -> Maybe (GVal (Run p m h))
forall a. [a] -> Maybe a
headMay
                                 ([GVal (Run p m h)] -> Maybe (GVal (Run p m h)))
-> ([(Maybe Text, GVal (Run p m h))] -> [GVal (Run p m h)])
-> [(Maybe Text, GVal (Run p m h))]
-> Maybe (GVal (Run p m h))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [GVal (Run p m h)] -> [GVal (Run p m h)]
forall a. Int -> [a] -> [a]
Prelude.drop (Int
index Int -> Int -> Int
forall a. Integral a => a -> a -> a
`Prelude.mod` [(Maybe Text, GVal (Run p m h))] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
Prelude.length [(Maybe Text, GVal (Run p m h))]
args)
                                 ([GVal (Run p m h)] -> [GVal (Run p m h)])
-> ([(Maybe Text, GVal (Run p m h))] -> [GVal (Run p m h)])
-> [(Maybe Text, GVal (Run p m h))]
-> [GVal (Run p m h)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Maybe Text, GVal (Run p m h)) -> GVal (Run p m h))
-> [(Maybe Text, GVal (Run p m h))] -> [GVal (Run p m h)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Maybe Text, GVal (Run p m h)) -> GVal (Run p m h)
forall a b. (a, b) -> b
snd
                                 ([(Maybe Text, GVal (Run p m h))]
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> [(Maybe Text, GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ [(Maybe Text, GVal (Run p m h))]
args
                loop :: [(Maybe Text, GVal (Run p m h))] -> Run p m h (GVal (Run p m h))
                loop :: [(Maybe Text, GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
loop [] = RuntimeError p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere (RuntimeError p
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> RuntimeError p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ Maybe Text -> Text -> RuntimeError p
forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"loop") Text
"at least one argument is required"
                loop ((Maybe Text
_, GVal (Run p m h)
loopee):[(Maybe Text, GVal (Run p m h))]
_) = Int
-> GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
go (Int -> Int
forall a. Enum a => a -> a
Prelude.succ Int
recursionDepth) GVal (Run p m h)
loopee
                iteration :: (Int, (GVal (Run p m h), GVal (Run p m h)))
                          -> Run p m h (GVal (Run p m h))
                iteration :: (Int, (GVal (Run p m h), GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
iteration (Int
index, (GVal (Run p m h)
key, GVal (Run p m h)
value)) = do
                    Text -> GVal (Run p m h) -> Run p m h ()
forall (m :: * -> *) p h.
Monad m =>
Text -> GVal (Run p m h) -> Run p m h ()
setVar Text
varNameValue GVal (Run p m h)
value
                    Text -> GVal (Run p m h) -> Run p m h ()
forall (m :: * -> *) p h.
Monad m =>
Text -> GVal (Run p m h) -> Run p m h ()
setVar Text
"loop" (GVal (Run p m h) -> Run p m h ())
-> GVal (Run p m h) -> Run p m h ()
forall a b. (a -> b) -> a -> b
$
                        ([(Text, GVal (Run p m h))] -> GVal (Run p m h)
forall (m :: * -> *). [Pair m] -> GVal m
dict [ Text
"index" Text -> Int -> (Text, GVal (Run p m h))
forall (m :: * -> *) a. ToGVal m a => Text -> a -> Pair m
~> Int -> Int
forall a. Enum a => a -> a
Prelude.succ Int
index
                             , Text
"index0" Text -> Int -> (Text, GVal (Run p m h))
forall (m :: * -> *) a. ToGVal m a => Text -> a -> Pair m
~> Int
index
                             , Text
"revindex" Text -> Int -> (Text, GVal (Run p m h))
forall (m :: * -> *) a. ToGVal m a => Text -> a -> Pair m
~> (Int
numItems Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
index)
                             , Text
"revindex0" Text -> Int -> (Text, GVal (Run p m h))
forall (m :: * -> *) a. ToGVal m a => Text -> a -> Pair m
~> (Int
numItems Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
index Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
                             , Text
"depth" Text -> Int -> (Text, GVal (Run p m h))
forall (m :: * -> *) a. ToGVal m a => Text -> a -> Pair m
~> Int -> Int
forall a. Enum a => a -> a
Prelude.succ Int
recursionDepth
                             , Text
"depth0" Text -> Int -> (Text, GVal (Run p m h))
forall (m :: * -> *) a. ToGVal m a => Text -> a -> Pair m
~> Int
recursionDepth
                             , Text
"first" Text -> Bool -> (Text, GVal (Run p m h))
forall (m :: * -> *) a. ToGVal m a => Text -> a -> Pair m
~> (Int
index Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0)
                             , Text
"last" Text -> Bool -> (Text, GVal (Run p m h))
forall (m :: * -> *) a. ToGVal m a => Text -> a -> Pair m
~> (Int -> Int
forall a. Enum a => a -> a
Prelude.succ Int
index Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
numItems)
                             , Text
"length" Text -> Int -> (Text, GVal (Run p m h))
forall (m :: * -> *) a. ToGVal m a => Text -> a -> Pair m
~> Int
numItems
                             , Text
"cycle" Text -> GVal (Run p m h) -> (Text, GVal (Run p m h))
forall (m :: * -> *) a. ToGVal m a => Text -> a -> Pair m
~> ([(Maybe Text, GVal (Run p m h))]
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction (Int
-> [(Maybe Text, GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
cycle Int
index)
                             ])
                             { asFunction = Just loop }
                    case Maybe Text
varNameIndex of
                        Maybe Text
Nothing -> () -> Run p m h ()
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
forall a. Default a => a
def
                        Just Text
n -> Text -> GVal (Run p m h) -> Run p m h ()
forall (m :: * -> *) p h.
Monad m =>
Text -> GVal (Run p m h) -> Run p m h ()
setVar Text
n GVal (Run p m h)
key
                    Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement Statement p
body
            (ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  [GVal (Run p m h)]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [GVal (Run p m h)]
forall (m :: * -> *) p h a. Monad m => Run p m h a -> Run p m h a
withLocalScope (ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   [GVal (Run p m h)]
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      [GVal (Run p m h)])
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [GVal (Run p m h)]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [GVal (Run p m h)]
forall a b. (a -> b) -> a -> b
$ [(Int, (GVal (Run p m h), GVal (Run p m h)))]
-> ((Int, (GVal (Run p m h), GVal (Run p m h)))
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [GVal (Run p m h)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM ([Int]
-> [(GVal (Run p m h), GVal (Run p m h))]
-> [(Int, (GVal (Run p m h), GVal (Run p m h)))]
forall a b. [a] -> [b] -> [(a, b)]
Prelude.zip [Int
0..] [(GVal (Run p m h), GVal (Run p m h))]
iterPairs) (Int, (GVal (Run p m h), GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
iteration) ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  [GVal (Run p m h)]
-> ([GVal (Run p m h)]
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b.
ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  a
-> (a
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         b)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
                [] -> GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal (Run p m h)
forall a. Default a => a
def
                [GVal (Run p m h)]
rvals -> GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return (GVal (Run p m h)
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ [GVal (Run p m h)] -> GVal (Run p m h)
forall a. HasCallStack => [a] -> a
List.last [GVal (Run p m h)]
rvals
    Expression p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall {p} {m :: * -> *} {h}.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
itereeExpr ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
-> (GVal (Run p m h)
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b.
ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  a
-> (a
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         b)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int
-> GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
go Int
0

runStatement' (PreprocessedIncludeS p
_ Template p
tpl) =
    Template p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) p h a.
Monad m =>
Template p -> Run p m h a -> Run p m h a
withTemplate Template p
tpl (ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ Template p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall p (m :: * -> *) h.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Template p -> Run p m h (GVal (Run p m h))
runTemplate Template p
tpl

runStatement' (TryCatchS p
_ Statement p
tryS [CatchBlock p]
catchesS Statement p
finallyS) = do
    GVal (Run p m h)
result <- (Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement Statement p
tryS) ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
-> (RuntimeError p
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) e a e'.
Monad m =>
ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a
`catchE` [CatchBlock p]
-> RuntimeError p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall {m :: * -> *} {p} {h} {p}.
(Monad m,
 ToGVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
   p,
 ToGVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
   h,
 ToGVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
   p,
 Monoid h) =>
[CatchBlock p]
-> RuntimeError p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
handle [CatchBlock p]
catchesS
    Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement Statement p
finallyS
    GVal (Run p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal (Run p m h)
result
    where
        handle :: [CatchBlock p]
-> RuntimeError p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
handle [] RuntimeError p
e = GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
forall a. Default a => a
def
        handle ((Catch Maybe Text
whatMay Maybe Text
varNameMay Statement p
catchS):[CatchBlock p]
catches) RuntimeError p
e = do
            let what :: Text
what = RuntimeError p -> Text
forall p. RuntimeError p -> Text
runtimeErrorWhat RuntimeError p
e
            if Maybe Text
whatMay Maybe Text -> Maybe Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Maybe Text
forall a. a -> Maybe a
Just Text
what Bool -> Bool -> Bool
|| Maybe Text
whatMay Maybe Text -> Maybe Text -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Text
forall a. Maybe a
Nothing
                then
                    ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
forall (m :: * -> *) p h a. Monad m => Run p m h a -> Run p m h a
withLocalScope (ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal
         (ExceptT
            (RuntimeError p)
            (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
forall a b. (a -> b) -> a -> b
$ do
                        case Maybe Text
varNameMay of
                            Maybe Text
Nothing -> ()
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     ()
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
                            Just Text
varName -> Text
-> GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     ()
forall (m :: * -> *) p h.
Monad m =>
Text -> GVal (Run p m h) -> Run p m h ()
setVar Text
varName (RuntimeError p
-> GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal RuntimeError p
e)
                        Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement Statement p
catchS
                else
                    [CatchBlock p]
-> RuntimeError p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
handle [CatchBlock p]
catches RuntimeError p
e

-- | Deeply magical function that converts a 'Macro' into a Function.
macroToGVal :: forall m h p
             . ( ToGVal (Run p m h) h
               , ToGVal (Run p m h) p
               , Monoid h
               , Monad m
               ) => Macro p -> GVal (Run p m h)
macroToGVal :: forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Macro p -> GVal (Run p m h)
macroToGVal (Macro [Text]
argNames Statement p
body) =
    Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
f
    where
        f :: Function (Run p m h)
        -- Establish a local state to not contaminate the parent scope
        -- with function arguments and local variables, and;
        -- Establish a local context, where we override the HTML writer,
        -- rewiring it to append any output to the state's capture.
        f :: Function (Run p m h)
f [(Maybe Text, GVal (Run p m h))]
args =
            ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) s a. (Monad m, MonadState s m) => m a -> m a
withLocalState (ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h))
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GingerContext p m h -> GingerContext p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a.
(GingerContext p m h -> GingerContext p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (\GingerContext p m h
c -> GingerContext p m h
c { contextWrite = appendCapture }) (ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (GVal (Run p m h))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ do
                Run p m h ()
forall h (m :: * -> *) p. (Monoid h, Monad m) => Run p m h ()
clearCapture
                [(Text, GVal (Run p m h))]
-> ((Text, GVal (Run p m h)) -> Run p m h ()) -> Run p m h ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ (HashMap Text (GVal (Run p m h)) -> [(Text, GVal (Run p m h))]
forall k v. HashMap k v -> [(k, v)]
HashMap.toList HashMap Text (GVal (Run p m h))
matchedArgs) ((Text -> GVal (Run p m h) -> Run p m h ())
-> (Text, GVal (Run p m h)) -> Run p m h ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Text -> GVal (Run p m h) -> Run p m h ()
forall (m :: * -> *) p h.
Monad m =>
Text -> GVal (Run p m h) -> Run p m h ()
setVar)
                Text -> GVal (Run p m h) -> Run p m h ()
forall (m :: * -> *) p h.
Monad m =>
Text -> GVal (Run p m h) -> Run p m h ()
setVar Text
"varargs" (GVal (Run p m h) -> Run p m h ())
-> ([GVal (Run p m h)] -> GVal (Run p m h))
-> [GVal (Run p m h)]
-> Run p m h ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [GVal (Run p m h)] -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal ([GVal (Run p m h)] -> Run p m h ())
-> [GVal (Run p m h)] -> Run p m h ()
forall a b. (a -> b) -> a -> b
$ [GVal (Run p m h)]
positionalArgs
                Text -> GVal (Run p m h) -> Run p m h ()
forall (m :: * -> *) p h.
Monad m =>
Text -> GVal (Run p m h) -> Run p m h ()
setVar Text
"kwargs" (GVal (Run p m h) -> Run p m h ())
-> (HashMap Text (GVal (Run p m h)) -> GVal (Run p m h))
-> HashMap Text (GVal (Run p m h))
-> Run p m h ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap Text (GVal (Run p m h)) -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (HashMap Text (GVal (Run p m h)) -> Run p m h ())
-> HashMap Text (GVal (Run p m h)) -> Run p m h ()
forall a b. (a -> b) -> a -> b
$ HashMap Text (GVal (Run p m h))
namedArgs
                Statement p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement Statement p
body
                -- At this point, we're still inside the local state, so the
                -- capture contains the macro's output; we now simply return
                -- the capture as the function's return value.
                h -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (h -> GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     h
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal (Run p m h))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  h
forall (m :: * -> *) p h. Monad m => Run p m h h
fetchCapture
                where
                    matchArgs' :: [(Maybe Text, GVal (Run p m h))] -> (HashMap Text (GVal (Run p m h)), [GVal (Run p m h)], HashMap Text (GVal (Run p m h)))
                    matchArgs' :: [(Maybe Text, GVal (Run p m h))]
-> (HashMap Text (GVal (Run p m h)), [GVal (Run p m h)],
    HashMap Text (GVal (Run p m h)))
matchArgs' = [Text]
-> [(Maybe Text, GVal (Run p m h))]
-> (HashMap Text (GVal (Run p m h)), [GVal (Run p m h)],
    HashMap Text (GVal (Run p m h)))
forall (m :: * -> *).
[Text]
-> [(Maybe Text, GVal m)]
-> (HashMap Text (GVal m), [GVal m], HashMap Text (GVal m))
matchFuncArgs [Text]
argNames
                    (HashMap Text (GVal (Run p m h))
matchedArgs, [GVal (Run p m h)]
positionalArgs, HashMap Text (GVal (Run p m h))
namedArgs) = [(Maybe Text, GVal (Run p m h))]
-> (HashMap Text (GVal (Run p m h)), [GVal (Run p m h)],
    HashMap Text (GVal (Run p m h)))
matchArgs' [(Maybe Text, GVal (Run p m h))]
args

-- | Run p (evaluate) an expression and return its value into the Run p monad
runExpression :: Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
expr =
    p -> Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h))
forall (m :: * -> *) p h a.
Monad m =>
p -> Run p m h a -> Run p m h a
withSourcePos
        (Expression p -> p
forall p. Expression p -> p
forall (f :: * -> *) p. Annotated f => f p -> p
annotation Expression p
expr)
        (Expression p -> Run p m h (GVal (Run p m h))
runExpression' Expression p
expr)

runExpression' :: Expression p -> Run p m h (GVal (Run p m h))
runExpression' (StringLiteralE p
_ Text
str) = GVal (Run p m h) -> Run p m h (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return (GVal (Run p m h) -> Run p m h (GVal (Run p m h)))
-> (Text -> GVal (Run p m h))
-> Text
-> Run p m h (GVal (Run p m h))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Text -> Run p m h (GVal (Run p m h)))
-> Text -> Run p m h (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ Text
str
runExpression' (NumberLiteralE p
_ Scientific
n) = GVal (Run p m h) -> Run p m h (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return (GVal (Run p m h) -> Run p m h (GVal (Run p m h)))
-> (Scientific -> GVal (Run p m h))
-> Scientific
-> Run p m h (GVal (Run p m h))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Scientific -> Run p m h (GVal (Run p m h)))
-> Scientific -> Run p m h (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ Scientific
n
runExpression' (BoolLiteralE p
_ Bool
b) = GVal (Run p m h) -> Run p m h (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return (GVal (Run p m h) -> Run p m h (GVal (Run p m h)))
-> (Bool -> GVal (Run p m h))
-> Bool
-> Run p m h (GVal (Run p m h))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Bool -> Run p m h (GVal (Run p m h)))
-> Bool -> Run p m h (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ Bool
b
runExpression' (NullLiteralE p
_) = GVal (Run p m h) -> Run p m h (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal (Run p m h)
forall a. Default a => a
def
runExpression' (VarE p
_ Text
key) = Text -> Run p m h (GVal (Run p m h))
forall (m :: * -> *) p h.
Monad m =>
Text -> Run p m h (GVal (Run p m h))
getVar Text
key
runExpression' (ListE p
_ [Expression p]
xs) = [GVal (Run p m h)] -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal ([GVal (Run p m h)] -> GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [GVal (Run p m h)]
-> Run p m h (GVal (Run p m h))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Expression p]
-> (Expression p -> Run p m h (GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [GVal (Run p m h)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Expression p]
xs Expression p -> Run p m h (GVal (Run p m h))
runExpression
runExpression' (ObjectE p
_ [(Expression p, Expression p)]
xs) = do
    [(Text, GVal (Run p m h))]
items <- [(Expression p, Expression p)]
-> ((Expression p, Expression p)
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (Text, GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [(Text, GVal (Run p m h))]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(Expression p, Expression p)]
xs (((Expression p, Expression p)
  -> ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
       (Text, GVal (Run p m h)))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      [(Text, GVal (Run p m h))])
-> ((Expression p, Expression p)
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (Text, GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [(Text, GVal (Run p m h))]
forall a b. (a -> b) -> a -> b
$ \(Expression p
a, Expression p
b) -> do
        Text
l <- GVal (Run p m h) -> Text
forall (m :: * -> *). GVal m -> Text
asText (GVal (Run p m h) -> Text)
-> Run p m h (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
a
        GVal (Run p m h)
r <- Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
b
        (Text, GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Text, GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
l, GVal (Run p m h)
r)
    GVal (Run p m h) -> Run p m h (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return (GVal (Run p m h) -> Run p m h (GVal (Run p m h)))
-> ([(Text, GVal (Run p m h))] -> GVal (Run p m h))
-> [(Text, GVal (Run p m h))]
-> Run p m h (GVal (Run p m h))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Text (GVal (Run p m h)) -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Map Text (GVal (Run p m h)) -> GVal (Run p m h))
-> ([(Text, GVal (Run p m h))] -> Map Text (GVal (Run p m h)))
-> [(Text, GVal (Run p m h))]
-> GVal (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Text, GVal (Run p m h))] -> Map Text (GVal (Run p m h))
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(Text, GVal (Run p m h))] -> Run p m h (GVal (Run p m h)))
-> [(Text, GVal (Run p m h))] -> Run p m h (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ [(Text, GVal (Run p m h))]
items
runExpression' (MemberLookupE p
_ Expression p
baseExpr Expression p
indexExpr) = do
    GVal (Run p m h)
base <- Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
baseExpr
    GVal (Run p m h)
index <- Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
indexExpr
    RuntimeError p
-> GVal (Run p m h)
-> Maybe (GVal (Run p m h))
-> Run p m h (GVal (Run p m h))
forall (m :: * -> *) p a h.
Monad m =>
RuntimeError p -> a -> Maybe a -> Run p m h a
warnFromMaybe (Text -> RuntimeError p
forall p. Text -> RuntimeError p
IndexError (Text -> RuntimeError p) -> Text -> RuntimeError p
forall a b. (a -> b) -> a -> b
$ Text -> Text
forall a. Show a => a -> Text
tshow (GVal (Run p m h) -> Text
forall (m :: * -> *). GVal m -> Text
asText GVal (Run p m h)
index)) GVal (Run p m h)
forall a. Default a => a
def (Maybe (GVal (Run p m h)) -> Run p m h (GVal (Run p m h)))
-> Maybe (GVal (Run p m h)) -> Run p m h (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$
        GVal (Run p m h) -> GVal (Run p m h) -> Maybe (GVal (Run p m h))
forall (m :: * -> *). GVal m -> GVal m -> Maybe (GVal m)
lookupLoose GVal (Run p m h)
index GVal (Run p m h)
base
runExpression' (CallE p
_ Expression p
funcE [(Maybe Text, Expression p)]
argsEs) = do
    [(Maybe Text, GVal (Run p m h))]
args <- [(Maybe Text, Expression p)]
-> ((Maybe Text, Expression p)
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (Maybe Text, GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [(Maybe Text, GVal (Run p m h))]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(Maybe Text, Expression p)]
argsEs (((Maybe Text, Expression p)
  -> ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
       (Maybe Text, GVal (Run p m h)))
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      [(Maybe Text, GVal (Run p m h))])
-> ((Maybe Text, Expression p)
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (Maybe Text, GVal (Run p m h)))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [(Maybe Text, GVal (Run p m h))]
forall a b. (a -> b) -> a -> b
$
        \(Maybe Text
argName, Expression p
argE) -> (Maybe Text
argName,) (GVal (Run p m h) -> (Maybe Text, GVal (Run p m h)))
-> Run p m h (GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Maybe Text, GVal (Run p m h))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
argE
    GVal (Run p m h)
e <- Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
funcE
    let func :: Maybe (Function (Run p m h))
func = GVal (Run p m h) -> Maybe (Function (Run p m h))
forall (m :: * -> *). GVal m -> Maybe (Function m)
toFunction GVal (Run p m h)
e
    case Maybe (Function (Run p m h))
func of
        Maybe (Function (Run p m h))
Nothing -> do
            RuntimeError p -> Run p m h ()
forall (m :: * -> *) p h. Monad m => RuntimeError p -> Run p m h ()
warn RuntimeError p
forall p. RuntimeError p
NotAFunctionError
            GVal (Run p m h) -> Run p m h (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return GVal (Run p m h)
forall a. Default a => a
def
        Just Function (Run p m h)
f -> Function (Run p m h)
f [(Maybe Text, GVal (Run p m h))]
args
runExpression' (LambdaE p
_ [Text]
argNames Expression p
body) = do
    let fn :: [(a, GVal (Run p m h))] -> Run p m h (GVal (Run p m h))
fn [(a, GVal (Run p m h))]
args = Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h))
forall (m :: * -> *) p h a. Monad m => Run p m h a -> Run p m h a
withLocalScope (Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h)))
-> Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ do
            [(Text, GVal (Run p m h))]
-> ((Text, GVal (Run p m h)) -> Run p m h ()) -> Run p m h ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ ([Text] -> [GVal (Run p m h)] -> [(Text, GVal (Run p m h))]
forall a b. [a] -> [b] -> [(a, b)]
Prelude.zip [Text]
argNames (((a, GVal (Run p m h)) -> GVal (Run p m h))
-> [(a, GVal (Run p m h))] -> [GVal (Run p m h)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a, GVal (Run p m h)) -> GVal (Run p m h)
forall a b. (a, b) -> b
snd [(a, GVal (Run p m h))]
args)) (((Text, GVal (Run p m h)) -> Run p m h ()) -> Run p m h ())
-> ((Text, GVal (Run p m h)) -> Run p m h ()) -> Run p m h ()
forall a b. (a -> b) -> a -> b
$ (Text -> GVal (Run p m h) -> Run p m h ())
-> (Text, GVal (Run p m h)) -> Run p m h ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Text -> GVal (Run p m h) -> Run p m h ()
forall (m :: * -> *) p h.
Monad m =>
Text -> GVal (Run p m h) -> Run p m h ()
setVar
            Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
body
    GVal (Run p m h) -> Run p m h (GVal (Run p m h))
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return (GVal (Run p m h) -> Run p m h (GVal (Run p m h)))
-> GVal (Run p m h) -> Run p m h (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ Function (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). Function m -> GVal m
fromFunction Function (Run p m h)
forall {a}. [(a, GVal (Run p m h))] -> Run p m h (GVal (Run p m h))
fn
runExpression' (TernaryE p
_ Expression p
condition Expression p
yes Expression p
no) = do
    GVal (Run p m h)
condVal <- Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
condition
    let expr :: Expression p
expr = if GVal (Run p m h) -> Bool
forall (m :: * -> *). GVal m -> Bool
asBoolean GVal (Run p m h)
condVal then Expression p
yes else Expression p
no
    Expression p -> Run p m h (GVal (Run p m h))
runExpression Expression p
expr
runExpression' (DoE p
_ Statement p
stmt) =
    Statement p -> Run p m h (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement Statement p
stmt

-- | Helper function to output a HTML value using whatever print function the
-- context provides.
echo :: (Monad m, Monoid h)
     => GVal (Run p m h) -> Run p m h ()
echo :: forall (m :: * -> *) h p.
(Monad m, Monoid h) =>
GVal (Run p m h) -> Run p m h ()
echo GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
src = do
    GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> h
e <- (GingerContext p m h
 -> GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
 -> h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
      -> h)
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks GingerContext p m h
-> GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> h
forall p (m :: * -> *) h.
GingerContext p m h -> GVal (Run p m h) -> h
contextEncode
    h -> Run p m h ()
p <- (GingerContext p m h -> h -> Run p m h ())
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (h -> Run p m h ())
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks GingerContext p m h -> h -> Run p m h ()
forall p (m :: * -> *) h. GingerContext p m h -> h -> Run p m h ()
contextWrite
    (GingerContext p m h -> Maybe (Newlines h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Maybe (Newlines h))
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks GingerContext p m h -> Maybe (Newlines h)
forall p (m :: * -> *) h. GingerContext p m h -> Maybe (Newlines h)
contextNewlines ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (Maybe (Newlines h))
-> (Maybe (Newlines h) -> Run p m h ()) -> Run p m h ()
forall a b.
ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  a
-> (a
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         b)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        Maybe (Newlines h)
Nothing ->
            h -> Run p m h ()
p (h -> Run p m h ())
-> (GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
    -> h)
-> GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> Run p m h ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> h
e (GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
 -> Run p m h ())
-> GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> Run p m h ()
forall a b. (a -> b) -> a -> b
$ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
src
        Just Newlines h
newlines -> do
            [h]
indentation <- [h] -> Maybe [h] -> [h]
forall a. a -> Maybe a -> a
fromMaybe [] (Maybe [h] -> [h])
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Maybe [h])
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     [h]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (RunState p m h -> Maybe [h])
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Maybe [h])
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets RunState p m h -> Maybe [h]
forall p (m :: * -> *) h. RunState p m h -> Maybe [h]
rsIndentation
            let ls :: [h]
ls = Newlines h -> h -> [h]
forall h. Newlines h -> h -> [h]
splitLines Newlines h
newlines (h -> [h]) -> h -> [h]
forall a b. (a -> b) -> a -> b
$ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> h
e GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
src
                indent :: h
indent = [h] -> h
forall a. Monoid a => [a] -> a
mconcat ([h] -> h) -> ([h] -> [h]) -> [h] -> h
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [h] -> [h]
forall a. [a] -> [a]
List.reverse ([h] -> h) -> [h] -> h
forall a b. (a -> b) -> a -> b
$ [h]
indentation
            [h] -> (h -> Run p m h ()) -> Run p m h ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ [h]
ls ((h -> Run p m h ()) -> Run p m h ())
-> (h -> Run p m h ()) -> Run p m h ()
forall a b. (a -> b) -> a -> b
$ \h
l -> do
                Bool
atLineStart <- (RunState p m h -> Bool)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets RunState p m h -> Bool
forall p (m :: * -> *) h. RunState p m h -> Bool
rsAtLineStart
                if Bool
atLineStart
                    then h -> Run p m h ()
p (h -> Run p m h ()) -> h -> Run p m h ()
forall a b. (a -> b) -> a -> b
$ h
indent h -> h -> h
forall a. Semigroup a => a -> a -> a
<> h
l
                    else h -> Run p m h ()
p h
l
                (RunState p m h -> RunState p m h) -> Run p m h ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((RunState p m h -> RunState p m h) -> Run p m h ())
-> (RunState p m h -> RunState p m h) -> Run p m h ()
forall a b. (a -> b) -> a -> b
$ \RunState p m h
state -> RunState p m h
state {
                    rsAtLineStart = endsWithNewline newlines l
                }

indented :: (Monad m, Monoid h)
         => h
         -> Run p m h a
         -> Run p m h a
indented :: forall (m :: * -> *) h p a.
(Monad m, Monoid h) =>
h -> Run p m h a -> Run p m h a
indented h
i Run p m h a
action = do
    h -> Run p m h ()
forall (m :: * -> *) h p. (Monad m, Monoid h) => h -> Run p m h ()
pushIndent h
i Run p m h () -> Run p m h a -> Run p m h a
forall a b.
ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Run p m h a
action Run p m h a -> Run p m h () -> Run p m h a
forall a b.
ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     b
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Run p m h ()
forall (m :: * -> *) h p. (Monad m, Monoid h) => Run p m h ()
popIndent

pushIndent :: (Monad m, Monoid h)
           => h
           -> Run p m h ()
pushIndent :: forall (m :: * -> *) h p. (Monad m, Monoid h) => h -> Run p m h ()
pushIndent h
i =
    (RunState p m h -> RunState p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((RunState p m h -> RunState p m h)
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      ())
-> (RunState p m h -> RunState p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     ()
forall a b. (a -> b) -> a -> b
$ \RunState p m h
state ->
        RunState p m h
state { rsIndentation = increaseIndent i (rsIndentation state) }
popIndent :: (Monad m, Monoid h)
           => Run p m h ()
popIndent :: forall (m :: * -> *) h p. (Monad m, Monoid h) => Run p m h ()
popIndent =
    (RunState p m h -> RunState p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((RunState p m h -> RunState p m h)
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      ())
-> (RunState p m h -> RunState p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     ()
forall a b. (a -> b) -> a -> b
$ \RunState p m h
state ->
        RunState p m h
state { rsIndentation = decreaseIndent (rsIndentation state) }

increaseIndent :: a -> Maybe [a] -> Maybe [a]
increaseIndent :: forall a. a -> Maybe [a] -> Maybe [a]
increaseIndent a
_ Maybe [a]
Nothing = [a] -> Maybe [a]
forall a. a -> Maybe a
Just []
increaseIndent a
x (Just [a]
xs) = [a] -> Maybe [a]
forall a. a -> Maybe a
Just (a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
xs)

decreaseIndent :: Maybe [a] -> Maybe [a]
decreaseIndent :: forall a. Maybe [a] -> Maybe [a]
decreaseIndent Maybe [a]
Nothing = Maybe [a]
forall a. Maybe a
Nothing
decreaseIndent (Just []) = Maybe [a]
forall a. Maybe a
Nothing
decreaseIndent (Just (a
x:[a]
xs)) = [a] -> Maybe [a]
forall a. a -> Maybe a
Just [a]
xs

defRunState :: forall m h p
             . ( ToGVal (Run p m h) h
               , ToGVal (Run p m h) p
               , Monoid h
               , Monad m
               )
            => Template p
            -> RunState p m h
defRunState :: forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Template p -> RunState p m h
defRunState Template p
tpl =
    RunState
        { rsScope :: HashMap Text (GVal (Run p m h))
rsScope = [(Text, GVal (Run p m h))] -> HashMap Text (GVal (Run p m h))
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HashMap.fromList [(Text, GVal (Run p m h))]
forall (m :: * -> *) h p.
(Monoid h, Monad m, ToGVal (Run p m h) h, ToGVal (Run p m h) p) =>
[(Text, GVal (Run p m h))]
defaultScope
        , rsCapture :: h
rsCapture = h
forall a. Monoid a => a
mempty
        , rsCurrentTemplate :: Template p
rsCurrentTemplate = Template p
tpl
        , rsCurrentBlockName :: Maybe Text
rsCurrentBlockName = Maybe Text
forall a. Maybe a
Nothing
        , rsIndentation :: Maybe [h]
rsIndentation = Maybe [h]
forall a. Maybe a
Nothing
        , rsAtLineStart :: Bool
rsAtLineStart = Bool
True
        , rsCurrentSourcePos :: p
rsCurrentSourcePos = Template p -> p
forall p. Template p -> p
forall (f :: * -> *) p. Annotated f => f p -> p
annotation Template p
tpl
        }

gfnThrow :: ( Monad m
            , Monoid h
            , ToGVal (Run p m h) h
            , ToGVal (Run p m h) p
            )
         => Function (Run p m h)
gfnThrow :: forall (m :: * -> *) h p.
(Monad m, Monoid h, ToGVal (Run p m h) h, ToGVal (Run p m h) p) =>
Function (Run p m h)
gfnThrow [(Maybe Text, GVal (Run p m h))]
args =
    RuntimeError p -> Run p m h (GVal (Run p m h))
forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere (Text -> RuntimeError p
forall p. Text -> RuntimeError p
RuntimeError (Text -> RuntimeError p)
-> ([(Maybe Text, GVal (Run p m h))] -> Text)
-> [(Maybe Text, GVal (Run p m h))]
-> RuntimeError p
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Text] -> Text
forall a. Monoid a => [a] -> a
mconcat ([Text] -> Text)
-> ([(Maybe Text, GVal (Run p m h))] -> [Text])
-> [(Maybe Text, GVal (Run p m h))]
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Maybe Text, GVal (Run p m h)) -> Text)
-> [(Maybe Text, GVal (Run p m h))] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (GVal (Run p m h) -> Text
forall (m :: * -> *). GVal m -> Text
asText (GVal (Run p m h) -> Text)
-> ((Maybe Text, GVal (Run p m h)) -> GVal (Run p m h))
-> (Maybe Text, GVal (Run p m h))
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Text, GVal (Run p m h)) -> GVal (Run p m h)
forall a b. (a, b) -> b
snd) ([(Maybe Text, GVal (Run p m h))] -> RuntimeError p)
-> [(Maybe Text, GVal (Run p m h))] -> RuntimeError p
forall a b. (a -> b) -> a -> b
$ [(Maybe Text, GVal (Run p m h))]
args)

gfnEval :: ( Monad m
           , Monoid h
           , ToGVal (Run p m h) h
           , ToGVal (Run p m h) p
           )
        => Function (Run p m h)
gfnEval :: forall (m :: * -> *) h p.
(Monad m, Monoid h, ToGVal (Run p m h) h, ToGVal (Run p m h) p) =>
Function (Run p m h)
gfnEval [(Maybe Text, GVal (Run p m h))]
args =
    let extracted :: Either
  ([GVal (Run p m h)], HashMap Text (GVal (Run p m h)), [Text])
  [GVal (Run p m h)]
extracted =
            [(Text, GVal (Run p m h))]
-> [(Maybe Text, GVal (Run p m h))]
-> Either
     ([GVal (Run p m h)], HashMap Text (GVal (Run p m h)), [Text])
     [GVal (Run p m h)]
forall a.
[(Text, a)]
-> [(Maybe Text, a)] -> Either ([a], HashMap Text a, [Text]) [a]
extractArgsDefL
                [ (Text
"src", GVal (Run p m h)
forall a. Default a => a
def)
                , (Text
"context", GVal (Run p m h)
forall a. Default a => a
def)
                ]
                [(Maybe Text, GVal (Run p m h))]
args
    in case Either
  ([GVal (Run p m h)], HashMap Text (GVal (Run p m h)), [Text])
  [GVal (Run p m h)]
extracted of
        Left ([GVal (Run p m h)], HashMap Text (GVal (Run p m h)), [Text])
_ -> RuntimeError p -> Run p m h (GVal (Run p m h))
forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere (RuntimeError p -> Run p m h (GVal (Run p m h)))
-> RuntimeError p -> Run p m h (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ Maybe Text -> Text -> RuntimeError p
forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"eval") Text
"expected: (src, context)"
        Right [GVal (Run p m h)
gSrc, GVal (Run p m h)
gContext] -> do
            Either ParserError (Template SourcePos)
result' <- IncludeResolver (Run p m h)
-> Maybe String
-> String
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Either ParserError (Template SourcePos))
forall (m :: * -> *).
Monad m =>
IncludeResolver m
-> Maybe String
-> String
-> m (Either ParserError (Template SourcePos))
parseGinger
                (ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  (Maybe String)
-> IncludeResolver (Run p m h)
forall a b. a -> b -> a
Prelude.const (ExceptT
   (RuntimeError p)
   (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
   (Maybe String)
 -> IncludeResolver (Run p m h))
-> (Maybe String
    -> ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
         (Maybe String))
-> Maybe String
-> IncludeResolver (Run p m h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe String
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Maybe String)
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe String -> IncludeResolver (Run p m h))
-> Maybe String -> IncludeResolver (Run p m h)
forall a b. (a -> b) -> a -> b
$ Maybe String
forall a. Maybe a
Nothing) -- include resolver
                Maybe String
forall a. Maybe a
Nothing -- source name
                (Text -> String
Text.unpack (Text -> String)
-> (GVal (Run p m h) -> Text) -> GVal (Run p m h) -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GVal (Run p m h) -> Text
forall (m :: * -> *). GVal m -> Text
asText (GVal (Run p m h) -> String) -> GVal (Run p m h) -> String
forall a b. (a -> b) -> a -> b
$ GVal (Run p m h)
gSrc) -- source code
            p
pos <- (RunState p m h -> p)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     p
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets RunState p m h -> p
forall p (m :: * -> *) h. RunState p m h -> p
rsCurrentSourcePos
            let result :: Either ParserError (Template p)
result = (SourcePos -> p) -> Template SourcePos -> Template p
forall a b. (a -> b) -> Template a -> Template b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (p -> SourcePos -> p
forall a b. a -> b -> a
Prelude.const p
pos) (Template SourcePos -> Template p)
-> Either ParserError (Template SourcePos)
-> Either ParserError (Template p)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Either ParserError (Template SourcePos)
result'
            Template p
tpl <- case Either ParserError (Template p)
result of
                Left ParserError
err -> RuntimeError p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Template p)
forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere (RuntimeError p
 -> ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
      (Template p))
-> RuntimeError p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Template p)
forall a b. (a -> b) -> a -> b
$ ParserError -> RuntimeError p
forall p. ParserError -> RuntimeError p
EvalParseError ParserError
err
                Right Template p
t -> Template p
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     (Template p)
forall a.
a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall (m :: * -> *) a. Monad m => a -> m a
return Template p
t
            let localLookup :: a -> m (GVal (Run p m h))
localLookup a
varName = GVal (Run p m h) -> m (GVal (Run p m h))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (GVal (Run p m h) -> m (GVal (Run p m h)))
-> GVal (Run p m h) -> m (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$
                    GVal (Run p m h)
-> GVal (Run p m h) -> GVal (Run p m h) -> GVal (Run p m h)
forall (m :: * -> *). GVal m -> GVal m -> GVal m -> GVal m
lookupLooseDef GVal (Run p m h)
forall a. Default a => a
def (a -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal a
varName) GVal (Run p m h)
gContext
                localContext :: GingerContext p m h -> GingerContext p m h
localContext GingerContext p m h
c = GingerContext p m h
c
                    { contextWrite = appendCapture
                    , contextLookup = localLookup
                    }
            Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h))
forall (m :: * -> *) s a. (Monad m, MonadState s m) => m a -> m a
withLocalState (Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h)))
-> Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ do
                RunState p m h -> Run p m h ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (RunState p m h -> Run p m h ()) -> RunState p m h -> Run p m h ()
forall a b. (a -> b) -> a -> b
$ Template p -> RunState p m h
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Template p -> RunState p m h
defRunState Template p
tpl
                (GingerContext p m h -> GingerContext p m h)
-> Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h))
forall a.
(GingerContext p m h -> GingerContext p m h)
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local GingerContext p m h -> GingerContext p m h
localContext (Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h)))
-> Run p m h (GVal (Run p m h)) -> Run p m h (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ do
                    Run p m h ()
forall h (m :: * -> *) p. (Monoid h, Monad m) => Run p m h ()
clearCapture
                    Statement p -> Run p m h (GVal (Run p m h))
forall (m :: * -> *) h p.
(ToGVal (Run p m h) h, ToGVal (Run p m h) p, Monoid h, Monad m) =>
Statement p -> Run p m h (GVal (Run p m h))
runStatement (Statement p -> Run p m h (GVal (Run p m h)))
-> Statement p -> Run p m h (GVal (Run p m h))
forall a b. (a -> b) -> a -> b
$ Template p -> Statement p
forall a. Template a -> Statement a
templateBody Template p
tpl
                    -- At this point, we're still inside the local state, so the
                    -- capture contains the macro's output; we now simply return
                    -- the capture as the function's return value.
                    h -> GVal (Run p m h)
forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (h -> GVal (Run p m h))
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     h
-> Run p m h (GVal (Run p m h))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ExceptT
  (RuntimeError p)
  (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
  h
forall (m :: * -> *) p h. Monad m => Run p m h h
fetchCapture