{-#LANGUAGE DerivingStrategies #-}
{-#LANGUAGE FlexibleContexts #-}
{-#LANGUAGE FlexibleInstances #-}
{-#LANGUAGE GeneralizedNewtypeDeriving #-}
{-#LANGUAGE OverloadedStrings #-}
{-#LANGUAGE TupleSections #-}
{-#LANGUAGE TypeSynonymInstances #-}
{-#LANGUAGE MultiParamTypeClasses #-}
{-#LANGUAGE ScopedTypeVariables #-}
{-#LANGUAGE LambdaCase #-}

-- | Implementations of the default template context functions and values. You
-- will not normally need to import this module, unless you want to provide
-- your own context with things that reuse functionality from the default
-- ones.
module Text.Ginger.Run.Builtins
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
               , flip
               , const
               , either
               )
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.FuncUtils
import Text.Ginger.Run.VM
import Text.Printf
import Text.PrintfA

import Data.Text (Text)
import Data.String (fromString)
import qualified Data.Text as Text
import qualified Data.ByteString.UTF8 as UTF8
import qualified Data.ByteString.Lazy as LBS
import Control.Monad
import Control.Monad.Writer
import Control.Monad.Reader
import Control.Monad.State
import Control.Monad.Except (throwError, MonadError)
import Control.Applicative
import qualified Data.HashMap.Strict as HashMap
import Data.HashMap.Strict (HashMap)
import Data.Scientific (Scientific, formatScientific, FPFormat (Fixed) )
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, foldl')
import Data.Monoid (Monoid (..), (<>))
import Data.Time ( defaultTimeLocale
                 , formatTime
                 , LocalTime (..)
                 , ZonedTime (..)
                 , utc
                 , utcToZonedTime
                 , zonedTimeToUTC
                 , TimeOfDay (..)
                 , fromGregorian
                 , Day (..)
                 , parseTimeM
                 , TimeLocale (..)
                 , TimeZone (..)
                 )
import Data.Foldable (asum, toList)
import qualified Data.Aeson as JSON
import qualified Data.Aeson.Encode.Pretty as JSON
import qualified Text.Regex.TDFA as RE

tshow :: Show a => a -> Text
tshow :: forall a. Show a => a -> Text
tshow = [Char] -> Text
Text.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> [Char]
show

gfnRawHtml :: Monad m => Function (Run p m h)
gfnRawHtml :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnRawHtml = forall (m :: * -> *) h p.
Monad m =>
(GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
unaryFunc (forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Html
unsafeRawHtml forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Text
asText)

gfnUrlEncode :: Monad m => Function (Run p m h)
gfnUrlEncode :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnUrlEncode =
    forall (m :: * -> *) h p.
Monad m =>
(GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
unaryFunc
        ( forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Text
Text.pack
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Char]
UTF8.toString
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> ByteString -> ByteString
urlEncode Bool
True
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ByteString
UTF8.fromString
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
Text.unpack
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Text
asText
        )

gfnDefault :: Monad m => Function m
gfnDefault :: forall (m :: * -> *). Monad m => Function m
gfnDefault [] = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Default a => a
def
gfnDefault ((Maybe Text
_, GVal m
x):[(Maybe Text, GVal m)]
xs)
    | forall (m :: * -> *). GVal m -> Bool
asBoolean GVal m
x = forall (m :: * -> *) a. Monad m => a -> m a
return GVal m
x
    | Bool
otherwise = forall (m :: * -> *). Monad m => Function m
gfnDefault [(Maybe Text, GVal m)]
xs

gfnEscape :: Monad m => Function m
gfnEscape :: forall (m :: * -> *). Monad m => Function m
gfnEscape = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Html
html forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Monoid a => [a] -> a
mconcat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (m :: * -> *). GVal m -> Text
asText forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd)

-- Check if all arguments are HTML-\"escaped\" (sic!) NOTE that this doesn't
-- really make much sense considering the way Ginger works - every GVal is, by
-- construction, both escaped in its 'asGVal' representation and not escaped in
-- its 'asText' representation, at the same time.
-- So what we check instead is whether the current 'asHtml'representation of
-- the value is exactly the same as what explicitly HTML-encoding the 'asText'
-- representation would give. In other words, we check whether the HTML
-- representations of @{{ v }}@ and @{{ v|escape }}@ match.
gfnEscaped :: Monad m => Function m
gfnEscaped :: forall (m :: * -> *). Monad m => Function m
gfnEscaped = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.all (forall (m :: * -> *). GVal m -> Bool
isEscaped forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd)
  where
    isEscaped :: GVal m -> Bool
isEscaped GVal m
v =
      (forall (m :: * -> *). GVal m -> Html
asHtml forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Html
html forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Text
asText forall a b. (a -> b) -> a -> b
$ GVal m
v) forall a. Eq a => a -> a -> Bool
==
      (forall (m :: * -> *). GVal m -> Html
asHtml GVal m
v)

gfnAny :: Monad m => Function m
gfnAny :: forall (m :: * -> *). Monad m => Function m
gfnAny [(Maybe Text, GVal m)]
xs = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Prelude.any (forall (m :: * -> *). GVal m -> Bool
asBoolean forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) [(Maybe Text, GVal m)]
xs

gfnAll :: Monad m => Function m
gfnAll :: forall (m :: * -> *). Monad m => Function m
gfnAll [(Maybe Text, GVal m)]
xs = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Prelude.all (forall (m :: * -> *). GVal m -> Bool
asBoolean forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) [(Maybe Text, GVal m)]
xs

gfnIn :: Monad m => Function m
gfnIn :: forall (m :: * -> *). Monad m => Function m
gfnIn [] =
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Default a => a
def
gfnIn [(Maybe Text, GVal m)
needle] =
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Bool
False
gfnIn [(Maybe Text
_, GVal m
needle),(Maybe Text
_, GVal m
haystack)] =
  forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). GVal m -> GVal m -> Bool
inDict GVal m
needle GVal m
haystack Bool -> Bool -> Bool
|| forall (m :: * -> *). GVal m -> GVal m -> Bool
inList GVal m
needle GVal m
haystack

inList :: GVal m -> GVal m -> Bool
inList :: forall (m :: * -> *). GVal m -> GVal m -> Bool
inList GVal m
needle GVal m
haystack =
  forall b a. b -> (a -> b) -> Maybe a -> b
maybe
    Bool
False
    (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.any (forall (m :: * -> *). GVal m -> GVal m -> Bool
looseEquals GVal m
needle))
    (forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList GVal m
haystack)

inDict :: GVal m -> GVal m -> Bool
inDict :: forall (m :: * -> *). GVal m -> GVal m -> Bool
inDict GVal m
needle GVal m
haystack =
  forall a. Maybe a -> Bool
isJust forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Text -> GVal m -> Maybe (GVal m)
lookupKey (forall (m :: * -> *). GVal m -> Text
asText GVal m
needle) GVal m
haystack

gfnApply :: Monad m => Function (Run p m h)
gfnApply :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnApply [] = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Default a => a
def
gfnApply [(Maybe Text,
 GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
_] = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Default a => a
def
gfnApply ((Maybe Text
_, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fg):(Maybe Text
_,GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
a):[(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
xs) =
  case forall (m :: * -> *). GVal m -> Maybe (Function m)
asFunction GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fg of
    Maybe
  (Function
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
Nothing -> forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"apply") Text
"Tried to call something that isn't a function"
    Just Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f ->
      let args :: [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args = (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. Maybe a
Nothing,) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe [] forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList forall a b. (a -> b) -> a -> b
$ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
a) forall a. [a] -> [a] -> [a]
++ [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
xs
      in Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args

gfnEquals :: Monad m => Function m
gfnEquals :: forall (m :: * -> *). Monad m => Function m
gfnEquals [] = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Bool
True
gfnEquals [(Maybe Text, GVal m)
x] = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Bool
True
gfnEquals ((Maybe Text, GVal m)
x:[(Maybe Text, GVal m)]
xs) =
    forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Prelude.all ((forall a b. (a, b) -> b
snd (Maybe Text, GVal m)
x forall (m :: * -> *). GVal m -> GVal m -> Bool
`looseEquals`) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) [(Maybe Text, GVal m)]
xs

gfnNEquals :: Monad m => Function m
gfnNEquals :: forall (m :: * -> *). Monad m => Function m
gfnNEquals [] = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Bool
True
gfnNEquals [(Maybe Text, GVal m)
x] = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Bool
True
gfnNEquals ((Maybe Text, GVal m)
x:[(Maybe Text, GVal m)]
xs) =
    forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Prelude.any (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (a, b) -> b
snd (Maybe Text, GVal m)
x forall (m :: * -> *). GVal m -> GVal m -> Bool
`looseEquals`) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) [(Maybe Text, GVal m)]
xs

gfnContains :: Monad m => Function (Run p m h)
gfnContains :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnContains [] = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Bool
False
gfnContains ((Maybe Text,
 GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
list:[(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
elems) = do
    [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
rawList <- forall (m :: * -> *) p a h.
Monad m =>
RuntimeError p -> a -> Maybe a -> Run p m h a
warnFromMaybe (forall p. [Text] -> Maybe Text -> RuntimeError p
TypeError [Text
"list"] (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> Text
tshow (Maybe Text,
 GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
list)) [] forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ (Maybe Text,
 GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
list
    let rawElems :: [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
rawElems = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
elems
        GVal m
e isInList :: GVal m -> t (GVal m) -> Bool
`isInList` t (GVal m)
xs = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Prelude.any (forall (m :: * -> *). GVal m -> GVal m -> Bool
looseEquals GVal m
e) t (GVal m)
xs
        t (GVal m)
es areInList :: t (GVal m) -> t (GVal m) -> Bool
`areInList` t (GVal m)
xs = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Prelude.all (forall {t :: * -> *} {m :: * -> *}.
Foldable t =>
GVal m -> t (GVal m) -> Bool
`isInList` t (GVal m)
xs) t (GVal m)
es
    forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
rawElems forall {t :: * -> *} {t :: * -> *} {m :: * -> *}.
(Foldable t, Foldable t) =>
t (GVal m) -> t (GVal m) -> Bool
`areInList` [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
rawList

gfnConcat :: Monad m => Function m
gfnConcat :: forall (m :: * -> *). Monad m => Function m
gfnConcat [] =
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Bool
False
gfnConcat [(Maybe Text, GVal m)
x] =
  forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (a, b) -> b
snd (Maybe Text, GVal m)
x)
gfnConcat ((Maybe Text, GVal m)
x:[(Maybe Text, GVal m)]
xs) =
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' forall (m :: * -> *). GVal m -> GVal m -> GVal m
gappend (forall a b. (a, b) -> b
snd (Maybe Text, GVal m)
x) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd [(Maybe Text, GVal m)]
xs)

looseEquals :: GVal m -> GVal m -> Bool
looseEquals :: forall (m :: * -> *). GVal m -> GVal m -> Bool
looseEquals GVal m
a GVal m
b
    | forall a. Maybe a -> Bool
isJust (forall (m :: * -> *). GVal m -> Maybe (Function m)
asFunction GVal m
a) Bool -> Bool -> Bool
|| forall a. Maybe a -> Bool
isJust (forall (m :: * -> *). GVal m -> Maybe (Function m)
asFunction GVal m
b) = Bool
False
    | forall a. Maybe a -> Bool
isJust (forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList GVal m
a) forall a. Eq a => a -> a -> Bool
/= forall a. Maybe a -> Bool
isJust (forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList GVal m
b) = Bool
False
    | forall a. Maybe a -> Bool
isJust (forall (m :: * -> *). GVal m -> Maybe [(Text, GVal m)]
asDictItems GVal m
a) forall a. Eq a => a -> a -> Bool
/= forall a. Maybe a -> Bool
isJust (forall (m :: * -> *). GVal m -> Maybe [(Text, GVal m)]
asDictItems GVal m
b) = Bool
False
    -- Both numbers: do numeric comparison
    | forall a. Maybe a -> Bool
isJust (forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
a) Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isJust (forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
b) = forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
a forall a. Eq a => a -> a -> Bool
== forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
b
    -- If either is NULL, the other must be falsy
    | forall (m :: * -> *). GVal m -> Bool
isNull GVal m
a Bool -> Bool -> Bool
|| forall (m :: * -> *). GVal m -> Bool
isNull GVal m
b = forall (m :: * -> *). GVal m -> Bool
asBoolean GVal m
a forall a. Eq a => a -> a -> Bool
== forall (m :: * -> *). GVal m -> Bool
asBoolean GVal m
b
    | Bool
otherwise = forall (m :: * -> *). GVal m -> Text
asText GVal m
a forall a. Eq a => a -> a -> Bool
== forall (m :: * -> *). GVal m -> Text
asText GVal m
b

gfnLess :: Monad m => Function m
gfnLess :: forall (m :: * -> *). Monad m => Function m
gfnLess [] = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ Bool
False
gfnLess [(Maybe Text, GVal m)]
xs' =
    let xs :: [GVal m]
xs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd [(Maybe Text, GVal m)]
xs'
    in forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$
        forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Prelude.all (forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just Bool
True) (forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
Prelude.zipWith forall (m :: * -> *). Monad m => GVal m -> GVal m -> Maybe Bool
less [GVal m]
xs (forall a. [a] -> [a]
Prelude.tail [GVal m]
xs))

gfnGreater :: Monad m => Function m
gfnGreater :: forall (m :: * -> *). Monad m => Function m
gfnGreater [] = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ Bool
False
gfnGreater [(Maybe Text, GVal m)]
xs' =
    let xs :: [GVal m]
xs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd [(Maybe Text, GVal m)]
xs'
    in forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$
        forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Prelude.all (forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just Bool
True) (forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
Prelude.zipWith forall (m :: * -> *). Monad m => GVal m -> GVal m -> Maybe Bool
greater [GVal m]
xs (forall a. [a] -> [a]
Prelude.tail [GVal m]
xs))

gfnLessEquals :: Monad m => Function m
gfnLessEquals :: forall (m :: * -> *). Monad m => Function m
gfnLessEquals [] = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ Bool
False
gfnLessEquals [(Maybe Text, GVal m)]
xs' =
    let xs :: [GVal m]
xs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd [(Maybe Text, GVal m)]
xs'
    in forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$
        forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Prelude.all (forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just Bool
True) (forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
Prelude.zipWith forall (m :: * -> *). Monad m => GVal m -> GVal m -> Maybe Bool
lessEq [GVal m]
xs (forall a. [a] -> [a]
Prelude.tail [GVal m]
xs))

gfnGreaterEquals :: Monad m => Function m
gfnGreaterEquals :: forall (m :: * -> *). Monad m => Function m
gfnGreaterEquals [] = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ Bool
False
gfnGreaterEquals [(Maybe Text, GVal m)]
xs' =
    let xs :: [GVal m]
xs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd [(Maybe Text, GVal m)]
xs'
    in forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$
        forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Prelude.all (forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just Bool
True) (forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
Prelude.zipWith forall (m :: * -> *). Monad m => GVal m -> GVal m -> Maybe Bool
greaterEq [GVal m]
xs (forall a. [a] -> [a]
Prelude.tail [GVal m]
xs))

less :: Monad m => GVal m -> GVal m -> Maybe Bool
less :: forall (m :: * -> *). Monad m => GVal m -> GVal m -> Maybe Bool
less GVal m
a GVal m
b = forall a. Ord a => a -> a -> Bool
(<) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
a forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
b

greater :: Monad m => GVal m -> GVal m -> Maybe Bool
greater :: forall (m :: * -> *). Monad m => GVal m -> GVal m -> Maybe Bool
greater GVal m
a GVal m
b = forall a. Ord a => a -> a -> Bool
(>) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
a forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
b

lessEq :: Monad m => GVal m -> GVal m -> Maybe Bool
lessEq :: forall (m :: * -> *). Monad m => GVal m -> GVal m -> Maybe Bool
lessEq GVal m
a GVal m
b = forall a. Ord a => a -> a -> Bool
(<=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
a forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
b

greaterEq :: Monad m => GVal m -> GVal m -> Maybe Bool
greaterEq :: forall (m :: * -> *). Monad m => GVal m -> GVal m -> Maybe Bool
greaterEq GVal m
a GVal m
b = forall a. Ord a => a -> a -> Bool
(>=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
a forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
b

difference :: Prelude.Num a => [a] -> a
difference :: forall a. Num a => [a] -> a
difference (a
x:[a]
xs) = a
x forall a. Num a => a -> a -> a
- forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
Prelude.sum [a]
xs
difference [] = a
0

ratio :: (Show a, Prelude.Fractional a, Prelude.Num a) => [a] -> a
ratio :: forall a. (Show a, Fractional a, Num a) => [a] -> a
ratio (a
x:[a]
xs) = a
x forall a. Fractional a => a -> a -> a
/ forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
Prelude.product [a]
xs
ratio [] = a
0

intRatio :: (Prelude.Integral a, Prelude.Num a) => [a] -> a
intRatio :: forall a. (Integral a, Num a) => [a] -> a
intRatio (a
x:[a]
xs) = a
x forall a. Integral a => a -> a -> a
`Prelude.div` forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
Prelude.product [a]
xs
intRatio [] = a
0

modulo :: (Prelude.Integral a, Prelude.Num a) => [a] -> a
modulo :: forall a. (Integral a, Num a) => [a] -> a
modulo (a
x:[a]
xs) = a
x forall a. Integral a => a -> a -> a
`Prelude.mod` forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
Prelude.product [a]
xs
modulo [] = a
0

capitalize :: Text -> Text
capitalize :: Text -> Text
capitalize Text
txt = Text -> Text
Text.toUpper (Int -> Text -> Text
Text.take Int
1 Text
txt) forall a. Semigroup a => a -> a -> a
<> Int -> Text -> Text
Text.drop Int
1 Text
txt

gfnCenter :: Monad m => Function m
gfnCenter :: forall (m :: * -> *). Monad m => Function m
gfnCenter [] = forall (m :: * -> *). Monad m => Function m
gfnCenter [(forall a. Maybe a
Nothing, forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Text
"" :: Text))]
gfnCenter [(Maybe Text, GVal m)
x] = forall (m :: * -> *). Monad m => Function m
gfnCenter [(Maybe Text, GVal m)
x, (forall a. Maybe a
Nothing, forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Int
80 :: Int))]
gfnCenter [(Maybe Text, GVal m)
x,(Maybe Text, GVal m)
y] = forall (m :: * -> *). Monad m => Function m
gfnCenter [(Maybe Text, GVal m)
x, (Maybe Text, GVal m)
y, (forall a. Maybe a
Nothing, forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Text
" " :: Text))]
gfnCenter ((Maybe Text
_, GVal m
s):(Maybe Text
_, GVal m
w):(Maybe Text
_, GVal m
pad):[(Maybe Text, GVal m)]
_) =
    forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ Text -> Int -> Text -> Text
center (forall (m :: * -> *). GVal m -> Text
asText GVal m
s) (forall a. a -> Maybe a -> a
fromMaybe Int
80 forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
Prelude.truncate forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
w) (forall (m :: * -> *). GVal m -> Text
asText GVal m
pad)

gfnLength :: Monad m => Function (Run p m h)
gfnLength :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnLength [] =
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Default a => a
def
gfnLength ((Maybe Text
_,GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
x):[(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
_) =
  case (forall (m :: * -> *). GVal m -> Maybe [(Text, GVal m)]
asDictItems GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
x, forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
x) of
    (Maybe
  [(Text,
    GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
Nothing, Maybe
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
Nothing) ->
      forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Int
Text.length forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Text
asText forall a b. (a -> b) -> a -> b
$ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
x
    (Just [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
items, Maybe
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
_) ->
      forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> Int
Prelude.length forall a b. (a -> b) -> a -> b
$ [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
items
    (Maybe
  [(Text,
    GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
_, Just [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
items) ->
      forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> Int
Prelude.length forall a b. (a -> b) -> a -> b
$ [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
items

gfnSlice :: Monad m => Function (Run p m h)
gfnSlice :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnSlice [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args =
    let argValues :: Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
argValues =
            forall a.
[(Text, a)]
-> [(Maybe Text, a)] -> Either ([a], HashMap Text a, [Text]) [a]
extractArgsDefL
                [ (Text
"slicee", forall a. Default a => a
def)
                , (Text
"start", forall a. Default a => a
def)
                , (Text
"length", forall a. Default a => a
def)
                ]
                [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args
    in case Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
argValues of
        Right [GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
slicee, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
startPos, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
length] -> do
            let startInt :: Int
                startInt :: Int
startInt = forall b a. b -> (a -> b) -> Maybe a -> b
maybe Int
0 forall a b. (RealFrac a, Integral b) => a -> b
Prelude.round forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber forall a b. (a -> b) -> a -> b
$ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
startPos

                lengthInt :: Maybe Int
                lengthInt :: Maybe Int
lengthInt = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (RealFrac a, Integral b) => a -> b
Prelude.round forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber forall a b. (a -> b) -> a -> b
$ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
length

                slice :: [a] -> Int -> Maybe Int -> [a]
                slice :: forall a. [a] -> Int -> Maybe Int -> [a]
slice [a]
xs Int
start Maybe Int
Nothing
                    | Int
start forall a. Ord a => a -> a -> Bool
< Int
0 =
                        forall a. Int -> [a] -> [a]
Prelude.drop (forall (t :: * -> *) a. Foldable t => t a -> Int
Prelude.length [a]
xs forall a. Num a => a -> a -> a
+ Int
start) [a]
xs
                    | Bool
otherwise =
                        forall a. Int -> [a] -> [a]
Prelude.drop Int
start [a]
xs
                slice [a]
xs Int
start (Just Int
length) =
                    forall a. Int -> [a] -> [a]
Prelude.take Int
length forall a b. (a -> b) -> a -> b
$ forall a. [a] -> Int -> Maybe Int -> [a]
slice [a]
xs Int
start forall a. Maybe a
Nothing
            case forall (m :: * -> *). GVal m -> Maybe [(Text, GVal m)]
asDictItems GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
slicee of
                Just [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
items -> do
                    let slicedItems :: [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
slicedItems = forall a. [a] -> Int -> Maybe Int -> [a]
slice [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
items Int
startInt Maybe Int
lengthInt
                    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). [Pair m] -> GVal m
dict [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
slicedItems
                Maybe
  [(Text,
    GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
Nothing ->
                    case forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
slicee of
                    Just [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
items ->
                        forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ forall a. [a] -> Int -> Maybe Int -> [a]
slice [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
items Int
startInt Maybe Int
lengthInt
                    Maybe
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
Nothing ->
                        forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Text
Text.pack forall a b. (a -> b) -> a -> b
$
                            forall a. [a] -> Int -> Maybe Int -> [a]
slice (Text -> [Char]
Text.unpack forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). GVal m -> Text
asText GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
slicee) Int
startInt Maybe Int
lengthInt
        Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
_ -> forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"slice") Text
"expected: (slicee, start=0, length=null)"

gfnReplace :: Monad m => Function (Run p m h)
gfnReplace :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnReplace [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args =
    let argValues :: Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
argValues =
            forall a.
[(Text, a)]
-> [(Maybe Text, a)] -> Either ([a], HashMap Text a, [Text]) [a]
extractArgsDefL
                [ (Text
"str", forall a. Default a => a
def)
                , (Text
"search", forall a. Default a => a
def)
                , (Text
"replace", forall a. Default a => a
def)
                ]
                [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args
    in case Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
argValues of
        Right [GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
strG, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
searchG, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
replaceG] -> do
            let str :: Text
str = forall (m :: * -> *). GVal m -> Text
asText GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
strG
                search :: Text
search = forall (m :: * -> *). GVal m -> Text
asText GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
searchG
                replace :: Text
replace = forall (m :: * -> *). GVal m -> Text
asText GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
replaceG
            forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ Text -> Text -> Text -> Text
Text.replace Text
search Text
replace Text
str
        Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
_ -> forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"replace") Text
"expected: (str, search, replace)"

gfnSplit :: Monad m => Function (Run p m h)
gfnSplit :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnSplit [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args =
    let argValues :: Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
argValues =
            forall a.
[(Text, a)]
-> [(Maybe Text, a)] -> Either ([a], HashMap Text a, [Text]) [a]
extractArgsDefL
                [ (Text
"str", forall a. Default a => a
def)
                , (Text
"sep", forall a. Default a => a
def)
                ]
                [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args
    in case Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
argValues of
        Right [GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
strG, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sepG] -> do
            let search :: Text
search = forall (m :: * -> *). GVal m -> Text
asText GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
strG
                split :: Text -> [Text]
split = case forall (m :: * -> *). GVal m -> Text
asText GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sepG of
                    Text
"" -> Text -> [Text]
Text.words
                    Text
sep -> Text -> Text -> [Text]
Text.splitOn Text
sep
            forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text]
split forall a b. (a -> b) -> a -> b
$ Text
search
        Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
_ -> forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"split") Text
"expected: (str, sep=null)"

gfnCompose :: forall m p h. Monad m => Function (Run p m h)
gfnCompose :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnCompose [] = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"compose") Text
""
gfnCompose [(Maybe Text
_, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fG)] = forall (m :: * -> *) a. Monad m => a -> m a
return GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fG
gfnCompose ((Maybe Text
_, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fG):[(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
xs) = do
  GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gG <- forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnCompose [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
xs
  case (forall (m :: * -> *). GVal m -> Maybe (Function m)
asFunction GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fG, forall (m :: * -> *). GVal m -> Maybe (Function m)
asFunction GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gG) of
    (Maybe
  (Function
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
Nothing, Maybe
  (Function
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
_) -> forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall p. RuntimeError p
NotAFunctionError
    (Maybe
  (Function
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
_, Maybe
  (Function
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
Nothing) -> forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall p. RuntimeError p
NotAFunctionError
    (Just Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f, Just Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
g) -> do
      let h :: Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
h [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args = do
              GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
arg' <- Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
g [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args
              Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f [(forall a. Maybe a
Nothing, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
arg')]
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Function m -> GVal m
fromFunction Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
h

gfnPartial :: forall m p h. Monad m => Function (Run p m h)
gfnPartial :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnPartial [] = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"partial") Text
""
gfnPartial ((Maybe Text
_, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fG):[(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args) = do
  case forall (m :: * -> *). GVal m -> Maybe (Function m)
asFunction GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fG of
    Maybe
  (Function
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
Nothing -> forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"partial") Text
"Argument must be a function"
    Just Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f -> do
      let h :: Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
h [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args' = do
            Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f ([(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args forall a. [a] -> [a] -> [a]
++ [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args')
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Function m -> GVal m
fromFunction Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
h

gfnZip :: forall m p h. Monad m => Function (Run p m h)
gfnZip :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnZip [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args = do
  forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[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)))]
go (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. a -> Maybe a -> a
fromMaybe [] forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args)
  where
    go :: [[GVal (Run p m h)]] -> Run p m h [GVal (Run p m h)]
    go :: [[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)))]
go [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    go [[GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]]
args = do
      let heads :: [Maybe
   (GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
heads = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. [a] -> Maybe a
headMay [[GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]]
args
          tails :: [[GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]]
tails = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. Int -> [a] -> [a]
List.drop Int
1) [[GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]]
args
      if forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.any forall a. Maybe a -> Bool
isNothing [Maybe
   (GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
heads then
        forall (m :: * -> *) a. Monad m => a -> m a
return []
      else do
        let currentVal :: GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
currentVal = forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. a -> Maybe a -> a
fromMaybe forall a. Default a => a
def) [Maybe
   (GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
heads)
        [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
tailVals <- [[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)))]
go [[GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]]
tails
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
currentVal forall a. a -> [a] -> [a]
: [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
tailVals


gfnZipWith :: forall m p h. Monad m => Function (Run p m h)
gfnZipWith :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnZipWith ((Maybe Text
Nothing, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gfn):[(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args) = do
  Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
zipFunction <- case forall (m :: * -> *). GVal m -> Maybe (Function m)
asFunction GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gfn of
    Maybe
  (Function
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
Nothing -> forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"zipwith") Text
""
    Just Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fn -> forall (m :: * -> *) a. Monad m => a -> m a
return Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fn
  forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> [Maybe Text]
-> [[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)))]
go Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
zipFunction (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> a
fst [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. a -> Maybe a -> a
fromMaybe [] forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args)
  where
    go :: Function (Run p m h) -> [Maybe Text] -> [[GVal (Run p m h)]] -> Run p m h [GVal (Run p m h)]
    go :: Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> [Maybe Text]
-> [[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)))]
go Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f [Maybe Text]
_ [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    go Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f [Maybe Text]
argNames [[GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]]
args = do
      let heads :: [Maybe
   (GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
heads = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. [a] -> Maybe a
headMay [[GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]]
args
          tails :: [[GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]]
tails = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. Int -> [a] -> [a]
List.drop Int
1) [[GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]]
args
      if forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.any forall a. Maybe a -> Bool
isNothing [Maybe
   (GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
heads then
        forall (m :: * -> *) a. Monad m => a -> m a
return []
      else do
        GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
currentVal <- Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f (forall a b. [a] -> [b] -> [(a, b)]
List.zip [Maybe Text]
argNames (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. a -> Maybe a -> a
fromMaybe forall a. Default a => a
def) [Maybe
   (GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
heads))
        [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
tailVals <- Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> [Maybe Text]
-> [[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)))]
go Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f [Maybe Text]
argNames [[GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]]
tails
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
currentVal forall a. a -> [a] -> [a]
: [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
tailVals


gfnMap :: (Monad m, MonadError (RuntimeError a) m) => Function m
gfnMap :: forall (m :: * -> *) a.
(Monad m, MonadError (RuntimeError a) m) =>
Function m
gfnMap [(Maybe Text, GVal m)]
args = do
    let parsedArgs :: Either ([GVal m], HashMap Text (GVal m), [Text]) [GVal m]
parsedArgs = forall a.
[(Text, a)]
-> [(Maybe Text, a)] -> Either ([a], HashMap Text a, [Text]) [a]
extractArgsDefL
            [ (Text
"collection", forall a. Default a => a
def)
            , (Text
"function", forall a. Default a => a
def)
            , (Text
"attribute", forall a. Default a => a
def)
            ]
            [(Maybe Text, GVal m)]
args
    (Maybe [(Text, GVal m)]
dictMay, Maybe [GVal m]
listMay, Maybe (Function m)
functionMay, Maybe Text
attributeMay) <- case Either ([GVal m], HashMap Text (GVal m), [Text]) [GVal m]
parsedArgs of
        Right [GVal m
collection, GVal m
function, GVal m
attribute] ->
            forall (m :: * -> *) a. Monad m => a -> m a
return ( forall (m :: * -> *). GVal m -> Maybe [(Text, GVal m)]
asDictItems GVal m
collection
                   , forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList GVal m
collection
                   , forall (m :: * -> *). GVal m -> Maybe (Function m)
asFunction GVal m
function
                   , forall a. a -> Maybe a
Just (forall (m :: * -> *). GVal m -> Text
asText GVal m
attribute)
                   )
        Either ([GVal m], HashMap Text (GVal m), [Text]) [GVal m]
_ ->
            forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"map") Text
""
    Function m
mapFunction <- case (Maybe (Function m)
functionMay, Maybe Text
attributeMay) of
        (Just Function m
f, Maybe Text
_) -> forall (m :: * -> *) a. Monad m => a -> m a
return Function m
f
        (Maybe (Function m)
Nothing, Just Text
key) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \case
            (Maybe Text
_, GVal m
item):[(Maybe Text, GVal m)]
_ ->
                forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). GVal m -> GVal m -> GVal m -> GVal m
lookupLooseDef forall a. Default a => a
def (forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Text
key) GVal m
item
            [(Maybe Text, GVal m)]
_ ->
                forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Default a => a
def
        (Maybe (Function m), Maybe Text)
_ -> forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"map") Text
"You have to pass a function or an attribute"
    case (Maybe [(Text, GVal m)]
dictMay, Maybe [GVal m]
listMay) of
        (Just [(Text, GVal m)]
items, Maybe [GVal m]
_) ->
            forall (m :: * -> *). [Pair m] -> GVal m
dict forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(Text, GVal m)]
items
                (\(Text
key, GVal m
value) -> (Text
key,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Function m
mapFunction [(forall a. Maybe a
Nothing, GVal m
value)])
        (Maybe [(Text, GVal m)]
Nothing, Just [GVal m]
items) ->
            forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Function m
mapFunction forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[]) forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Maybe a
Nothing,)) [GVal m]
items
        (Maybe [(Text, GVal m)]
Nothing, Maybe [GVal m]
Nothing) ->
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Default a => a
def


gfnSort :: forall p m h. Monad m => Function (Run p m h)
gfnSort :: forall p (m :: * -> *) h. Monad m => Function (Run p m h)
gfnSort [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args = do
    let parsedArgs :: Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
parsedArgs = forall a.
[(Text, a)]
-> [(Maybe Text, a)] -> Either ([a], HashMap Text a, [Text]) [a]
extractArgsDefL
            [ (Text
"sortee", forall a. Default a => a
def)
            , (Text
"by", forall a. Default a => a
def)
            , (Text
"reverse", forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Bool
False)
            ]
            [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args
    (GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortee, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortKey, Bool
sortReverse) <- case Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
parsedArgs of
        Right [GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortee, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortKey, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
reverseG] ->
            forall (m :: * -> *) a. Monad m => a -> m a
return ( GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortee
                   , GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortKey
                   , forall (m :: * -> *). GVal m -> Bool
asBoolean GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
reverseG
                   )
        Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
_ -> forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"sort") Text
"expected: (sortee, by, reverse)"
    let extractByFunc :: Maybe ((Text, GVal (Run p m h)) -> Run p m h (GVal (Run p m h)))
        extractByFunc :: Maybe
  ((Text,
    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)))))
extractByFunc = do
            Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f <- forall (m :: * -> *). GVal m -> Maybe (Function m)
asFunction GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortKey
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \(Text,
 GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
g ->
                Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
f [(forall a. Maybe a
Nothing, forall a b. (a, b) -> b
snd (Text,
 GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
g)]

    let extractByPath :: Maybe ((Text, GVal (Run p m h)) -> Run p m h (GVal (Run p m h)))
        extractByPath :: Maybe
  ((Text,
    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)))))
extractByPath = do
            [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
keys <- forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortKey
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \(Text,
 GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
g ->
                forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (forall a b c. (a -> b -> c) -> b -> a -> c
flip (forall (m :: * -> *). GVal m -> GVal m -> GVal m -> GVal m
lookupLooseDef forall a. Default a => a
def)) (forall a b. (a, b) -> b
snd (Text,
 GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
g) [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
keys

        extractByKey :: Monad m => Maybe ((Text, a) -> Run p m h (GVal (Run p m h)))
        extractByKey :: forall a.
Monad m =>
Maybe
  ((Text, a)
   -> Run
        p
        m
        h
        (GVal
           (ExceptT
              (RuntimeError p)
              (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))))
extractByKey =
            if forall (m :: * -> *). GVal m -> Text
asText GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortKey forall a. Eq a => a -> a -> Bool
== Text
"__key"
                then forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst
                else forall a. Maybe a
Nothing

        extractByProp :: Maybe
  ((a,
    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)))))
extractByProp =
            if forall (m :: * -> *). GVal m -> Bool
isNull GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortKey
                then forall a. Maybe a
Nothing
                else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> GVal m -> GVal m -> GVal m
lookupLooseDef forall a. Default a => a
def GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd

        extractFunc :: (Text,
 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))))
extractFunc = forall a. a -> Maybe a -> a
fromMaybe (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) forall a b. (a -> b) -> a -> b
$
            Maybe
  ((Text,
    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)))))
extractByFunc forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
            Maybe
  ((Text,
    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)))))
extractByPath forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
            forall a.
Monad m =>
Maybe
  ((Text, a)
   -> Run
        p
        m
        h
        (GVal
           (ExceptT
              (RuntimeError p)
              (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))))
extractByKey forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
            forall {a}.
Maybe
  ((a,
    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)))))
extractByProp

        ([Pair m] -> GVal m
pack, [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
unpacked) =
            case (forall (m :: * -> *). GVal m -> Maybe [(Text, GVal m)]
asDictItems GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortee, forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sortee) of
                (Just [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
dictItems, Maybe
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
_) ->
                    (forall (m :: * -> *). [Pair m] -> GVal m
orderedDict, [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
dictItems)
                (Maybe
  [(Text,
    GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
Nothing, Just [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
listItems) ->
                    (forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd, forall a. [a] -> [(Text, a)]
listToIndexedDict [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
listItems)
                (Maybe
  [(Text,
    GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
Nothing, Maybe
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
Nothing) ->
                    (forall a b. a -> b -> a
Prelude.const forall a. Default a => a
def, [])

    [(Text,
  (Text,
   GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))))]
tagged <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
unpacked forall a b. (a -> b) -> a -> b
$ \(Text,
 GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
item -> do
        GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
extracted <- (Text,
 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))))
extractFunc (Text,
 GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
item
        forall (m :: * -> *) a. Monad m => a -> m a
return (forall (m :: * -> *). GVal m -> Text
asText GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
extracted, (Text,
 GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
item)
    let compare :: (Text, c) -> (Text, d) -> Ordering
compare =
            forall a b c d. (a -> a -> b) -> (a, c) -> (a, d) -> b
onFst forall a b. (a -> b) -> a -> b
$ if Bool
sortReverse
                then forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a. Ord a => a -> a -> Ordering
Prelude.compare
                else forall a. Ord a => a -> a -> Ordering
Prelude.compare

    let sorted :: GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sorted = forall (m :: * -> *). [Pair m] -> GVal m
pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a. (a -> a -> Ordering) -> [a] -> [a]
List.sortBy forall {c} {d}. (Text, c) -> (Text, d) -> Ordering
compare [(Text,
  (Text,
   GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))))]
tagged

    forall (m :: * -> *) a. Monad m => a -> m a
return GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
sorted

onFst :: (a -> a -> b) -> (a, c) -> (a, d) -> b
onFst :: forall a b c d. (a -> a -> b) -> (a, c) -> (a, d) -> b
onFst a -> a -> b
f (a
x, c
_) (a
y, d
_) = a -> a -> b
f a
x a
y

listToIndexedDict :: [a] -> [(Text, a)]
listToIndexedDict :: forall a. [a] -> [(Text, a)]
listToIndexedDict [a]
values =
    let indexes :: [Text]
indexes = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. Show a => a -> Text
tshow) [Integer
0..]
    in forall a b. [a] -> [b] -> [(a, b)]
List.zip [Text]
indexes [a]
values

center :: Text -> Prelude.Int -> Text -> Text
center :: Text -> Int -> Text -> Text
center Text
str Int
width Text
pad =
    if Text -> Int
Text.length Text
str forall a. Ord a => a -> a -> Bool
Prelude.>= Int
width
        then Text
str
        else Text
paddingL forall a. Semigroup a => a -> a -> a
<> Text
str forall a. Semigroup a => a -> a -> a
<> Text
paddingR
    where
        chars :: Int
chars = Int
width forall a. Num a => a -> a -> a
- Text -> Int
Text.length Text
str
        charsL :: Int
charsL = Int
chars forall a. Integral a => a -> a -> a
`div` Int
2
        charsR :: Int
charsR = Int
chars forall a. Num a => a -> a -> a
- Int
charsL
        repsL :: Int
repsL = forall a. Enum a => a -> a
Prelude.succ Int
charsL forall a. Integral a => a -> a -> a
`div` Text -> Int
Text.length Text
pad
        paddingL :: Text
paddingL = Int -> Text -> Text
Text.take Int
charsL forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text -> Text
Text.replicate Int
repsL forall a b. (a -> b) -> a -> b
$ Text
pad
        repsR :: Int
repsR = forall a. Enum a => a -> a
Prelude.succ Int
charsR forall a. Integral a => a -> a -> a
`div` Text -> Int
Text.length Text
pad
        paddingR :: Text
paddingR = Int -> Text -> Text
Text.take Int
charsR forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text -> Text
Text.replicate Int
repsR forall a b. (a -> b) -> a -> b
$ Text
pad

gfnFileSizeFormat :: Monad m => Function m
gfnFileSizeFormat :: forall (m :: * -> *). Monad m => Function m
gfnFileSizeFormat [(Maybe Text
_, GVal m
sizeG)] =
    forall (m :: * -> *). Monad m => Function m
gfnFileSizeFormat [(forall a. Maybe a
Nothing, GVal m
sizeG), (forall a. Maybe a
Nothing, forall a. Default a => a
def)]
gfnFileSizeFormat [(Maybe Text
_, GVal m
sizeG), (Maybe Text
_, GVal m
binaryG)] = do
    let sizeM :: Maybe Integer
sizeM = forall a b. (RealFrac a, Integral b) => a -> b
Prelude.round forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). GVal m -> Maybe Scientific
asNumber GVal m
sizeG
        binary :: Bool
binary = forall (m :: * -> *). GVal m -> Bool
asBoolean GVal m
binaryG
    forall b a. b -> (a -> b) -> Maybe a -> b
Prelude.maybe
        (forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Default a => a
def)
        (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Integer -> [Char]
formatFileSize Bool
binary)
        Maybe Integer
sizeM
gfnFileSizeFormat [(Maybe Text, GVal m)]
_ = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Default a => a
def

formatFileSize :: Bool -> Integer -> String
formatFileSize :: Bool -> Integer -> [Char]
formatFileSize Bool
binary Integer
size =
    let units :: [(Integer, [Char])]
units =
            if Bool
binary
                then
                    [ (Integer
1, [Char]
"B")
                    , (Integer
1024, [Char]
"kiB")
                    , (Integer
1024 forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
2, [Char]
"MiB")
                    , (Integer
1024 forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
3, [Char]
"GiB")
                    , (Integer
1024 forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
4, [Char]
"TiB")
                    , (Integer
1024 forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
5, [Char]
"PiB")
                    ]
                else
                    [ (Integer
1, [Char]
"B")
                    , (Integer
1000, [Char]
"kB")
                    , (Integer
1000000, [Char]
"MB")
                    , (Integer
1000000000, [Char]
"GB")
                    , (Integer
1000000000000, [Char]
"TB")
                    , (Integer
1000000000000000, [Char]
"PB")
                    ]
        (Integer
divisor, [Char]
unitName) =
            forall a. a -> [a] -> a
lastDef (Integer
1, [Char]
"B") [ (Integer
d, [Char]
u) | (Integer
d, [Char]
u) <- [(Integer, [Char])]
units, Integer
d forall a. Ord a => a -> a -> Bool
<= Integer
size ]
        dividedSize :: Scientific
        dividedSize :: Scientific
dividedSize = forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
size forall a. Fractional a => a -> a -> a
/ forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
divisor
        formattedSize :: [Char]
formattedSize =
            if Scientific -> Bool
Scientific.isInteger Scientific
dividedSize
                then FPFormat -> Maybe Int -> Scientific -> [Char]
formatScientific FPFormat
Fixed (forall a. a -> Maybe a
Just Int
0) Scientific
dividedSize
                else FPFormat -> Maybe Int -> Scientific -> [Char]
formatScientific FPFormat
Fixed (forall a. a -> Maybe a
Just Int
1) Scientific
dividedSize
    in [Char]
formattedSize forall a. [a] -> [a] -> [a]
++ [Char]
" " forall a. [a] -> [a] -> [a]
++ [Char]
unitName

gfnPrintf :: Monad m => Function (Run p m h)
gfnPrintf :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnPrintf [] = do
    forall (m :: * -> *) p h. Monad m => RuntimeError p -> Run p m h ()
warn forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"printf") Text
"No format string provided"
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Default a => a
def
gfnPrintf [(Maybe Text
_, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fmtStrG)] = forall (m :: * -> *) a. Monad m => a -> m a
return GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fmtStrG
gfnPrintf ((Maybe Text
_, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fmtStrG):[(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args) = do
    forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). [Char] -> [GVal m] -> [Char]
printfG [Char]
fmtStr (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args)
    where
        fmtStr :: [Char]
fmtStr = Text -> [Char]
Text.unpack forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). GVal m -> Text
asText GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
fmtStrG

gvalToDate :: TimeZone -> GVal m -> Maybe ZonedTime
gvalToDate :: forall (m :: * -> *). TimeZone -> GVal m -> Maybe ZonedTime
gvalToDate TimeZone
tz GVal m
g = forall (m :: * -> *). TimeZone -> GVal m -> Maybe ZonedTime
gvalDictToDate TimeZone
tz GVal m
g
             forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). TimeZone -> GVal m -> Maybe ZonedTime
gvalListToDate TimeZone
tz GVal m
g
             forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). TimeZone -> GVal m -> Maybe ZonedTime
gvalAutoParseDate TimeZone
tz GVal m
g

gvalDictToDate :: TimeZone -> GVal m -> Maybe ZonedTime
gvalDictToDate :: forall (m :: * -> *). TimeZone -> GVal m -> Maybe ZonedTime
gvalDictToDate TimeZone
defTZ GVal m
g = do
    let datePartMay :: Maybe Day
datePartMay = do
            Integer
year <- forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Int -> Integer) forall a b. (a -> b) -> a -> b
$ GVal m
g forall (m :: * -> *) v. FromGVal m v => GVal m -> GVal m -> Maybe v
~! GVal m
"year"
            Int
month <- GVal m
g forall (m :: * -> *) v. FromGVal m v => GVal m -> GVal m -> Maybe v
~! GVal m
"month"
            Int
day <- GVal m
g forall (m :: * -> *) v. FromGVal m v => GVal m -> GVal m -> Maybe v
~! GVal m
"day"
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Integer -> Int -> Int -> Day
fromGregorian Integer
year Int
month Int
day
        timePartMay :: Maybe TimeOfDay
timePartMay = do
            Int
hours <- GVal m
g forall (m :: * -> *) v. FromGVal m v => GVal m -> GVal m -> Maybe v
~! GVal m
"hours"
            Int
minutes <- GVal m
g forall (m :: * -> *) v. FromGVal m v => GVal m -> GVal m -> Maybe v
~! GVal m
"minutes"
            Pico
seconds <- forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Scientific -> Pico
scientificToPico forall a b. (a -> b) -> a -> b
$ GVal m
g forall (m :: * -> *) v. FromGVal m v => GVal m -> GVal m -> Maybe v
~! GVal m
"seconds"
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int -> Int -> Pico -> TimeOfDay
TimeOfDay Int
hours Int
minutes Pico
seconds
        tzPartMay :: Maybe TimeZone
tzPartMay = GVal m
g forall (m :: * -> *) v. FromGVal m v => GVal m -> GVal m -> Maybe v
~! GVal m
"tz"
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall a. Maybe a -> Bool
isNothing Maybe Day
datePartMay Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isNothing Maybe TimeOfDay
timePartMay) forall a. Maybe a
Nothing
    let datePart :: Day
datePart = forall a. a -> Maybe a -> a
fromMaybe (Integer -> Int -> Int -> Day
fromGregorian Integer
1970 Int
1 Int
1) Maybe Day
datePartMay
        timePart :: TimeOfDay
timePart = forall a. a -> Maybe a -> a
fromMaybe (Int -> Int -> Pico -> TimeOfDay
TimeOfDay Int
12 Int
0 Pico
0) Maybe TimeOfDay
timePartMay
        tz :: TimeZone
tz = forall a. a -> Maybe a -> a
fromMaybe TimeZone
defTZ Maybe TimeZone
tzPartMay
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ LocalTime -> TimeZone -> ZonedTime
ZonedTime (Day -> TimeOfDay -> LocalTime
LocalTime Day
datePart TimeOfDay
timePart) TimeZone
tz

gvalListToDate :: TimeZone -> GVal m -> Maybe ZonedTime
gvalListToDate :: forall (m :: * -> *). TimeZone -> GVal m -> Maybe ZonedTime
gvalListToDate TimeZone
defTZ GVal m
g = forall (m :: * -> *). [GVal m] -> Maybe ZonedTime
go forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList GVal m
g
    where
        go :: [GVal m] -> Maybe ZonedTime
        go :: forall (m :: * -> *). [GVal m] -> Maybe ZonedTime
go [GVal m]
parts = case [GVal m]
parts of
            [GVal m
yearG, GVal m
monthG, GVal m
dayG, GVal m
hoursG, GVal m
minutesG, GVal m
secondsG, GVal m
tzG] -> do
                Day
datePart <-
                    Integer -> Int -> Int -> Day
fromGregorian
                        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). GVal m -> Maybe Int
toInt GVal m
yearG)
                        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). GVal m -> Maybe Int
toInt GVal m
monthG
                        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). GVal m -> Maybe Int
toInt GVal m
dayG
                TimeOfDay
timePart <-
                    Int -> Int -> Pico -> TimeOfDay
TimeOfDay
                        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). GVal m -> Maybe Int
toInt GVal m
hoursG
                        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). GVal m -> Maybe Int
toInt GVal m
minutesG
                        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). GVal m -> Maybe Int
toInt GVal m
secondsG)
                TimeZone
tzPart <- forall (m :: * -> *) a. FromGVal m a => GVal m -> Maybe a
fromGVal GVal m
tzG
                forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ LocalTime -> TimeZone -> ZonedTime
ZonedTime (Day -> TimeOfDay -> LocalTime
LocalTime Day
datePart TimeOfDay
timePart) TimeZone
tzPart
            [GVal m
yearG, GVal m
monthG, GVal m
dayG, GVal m
hoursG, GVal m
minutesG, GVal m
secondsG] ->
                forall (m :: * -> *). [GVal m] -> Maybe ZonedTime
go [GVal m
yearG, GVal m
monthG, GVal m
dayG, GVal m
hoursG, GVal m
minutesG, GVal m
secondsG, forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal TimeZone
defTZ]
            [GVal m
yearG, GVal m
monthG, GVal m
dayG, GVal m
hoursG, GVal m
minutesG] ->
                forall (m :: * -> *). [GVal m] -> Maybe ZonedTime
go [GVal m
yearG, GVal m
monthG, GVal m
dayG, GVal m
hoursG, GVal m
minutesG, forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Int
0 :: Int)]
            [GVal m
yearG, GVal m
monthG, GVal m
dayG] ->
                forall (m :: * -> *). [GVal m] -> Maybe ZonedTime
go [GVal m
yearG, GVal m
monthG, GVal m
dayG, forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Int
12 :: Int), forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal (Int
0 :: Int)]
            [GVal m]
_ -> forall a. Maybe a
Nothing

gvalAutoParseDate :: TimeZone -> GVal m -> Maybe ZonedTime
gvalAutoParseDate :: forall (m :: * -> *). TimeZone -> GVal m -> Maybe ZonedTime
gvalAutoParseDate TimeZone
defTZ = [Char] -> Maybe ZonedTime
go forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
Text.unpack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Text
asText
    where
        go :: [Char] -> Maybe ZonedTime
go [Char]
input = forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum [ [Char] -> [Char] -> Maybe ZonedTime
parse [Char]
t [Char]
input | ([Char] -> [Char] -> Maybe ZonedTime
parse, [Char]
t) <- [([Char] -> [Char] -> Maybe ZonedTime, [Char])]
formats ]
        ztparse :: String -> String -> Maybe ZonedTime
        ztparse :: [Char] -> [Char] -> Maybe ZonedTime
ztparse [Char]
fmt = forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> [Char] -> [Char] -> m t
parseTimeM Bool
True TimeLocale
defaultTimeLocale [Char]
fmt
        utcparse :: String -> String -> Maybe ZonedTime
        utcparse :: [Char] -> [Char] -> Maybe ZonedTime
utcparse [Char]
fmt [Char]
input = do
            LocalTime
lt <- forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> [Char] -> [Char] -> m t
parseTimeM Bool
True TimeLocale
defaultTimeLocale [Char]
fmt [Char]
input
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ LocalTime -> TimeZone -> ZonedTime
ZonedTime LocalTime
lt TimeZone
defTZ
        formats :: [([Char] -> [Char] -> Maybe ZonedTime, [Char])]
formats =
            [ ([Char] -> [Char] -> Maybe ZonedTime
ztparse, [Char]
"%Y-%m-%dT%H:%M:%S%Q%Z")
            , ([Char] -> [Char] -> Maybe ZonedTime
utcparse, [Char]
"%Y-%m-%d %H:%M:%S%Q")
            , ([Char] -> [Char] -> Maybe ZonedTime
ztparse, [Char]
"%Y-%m-%d %H:%M:%S%Q%z")
            , ([Char] -> [Char] -> Maybe ZonedTime
ztparse, [Char]
"%Y-%m-%d %H:%M:%S%Q%Z")
            , ([Char] -> [Char] -> Maybe ZonedTime
utcparse, [Char]
"%Y-%m-%d")
            ]

gvalToTZ :: GVal m -> Maybe TimeZone
gvalToTZ :: forall (m :: * -> *). GVal m -> Maybe TimeZone
gvalToTZ GVal m
g =
    forall (m :: * -> *) a. FromGVal m a => GVal m -> Maybe a
fromGVal GVal m
g forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> Maybe TimeZone
parseTZ forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
Text.unpack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Text
asText forall a b. (a -> b) -> a -> b
$ GVal m
g)

parseTZ :: String -> Maybe TimeZone
parseTZ :: [Char] -> Maybe TimeZone
parseTZ = forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> [Char] -> [Char] -> m t
parseTimeM Bool
True TimeLocale
defaultTimeLocale [Char]
"%z"

gfnDateFormat :: Monad m => Function (Run p m h)
gfnDateFormat :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnDateFormat [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args =
    let extracted :: Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
extracted =
            forall a.
[(Text, a)]
-> [(Maybe Text, a)] -> Either ([a], HashMap Text a, [Text]) [a]
extractArgsDefL
                [ (Text
"date", forall a. Default a => a
def)
                , (Text
"format", forall a. Default a => a
def)
                , (Text
"tz", forall a. Default a => a
def)
                , (Text
"locale", forall a. Default a => a
def)
                ]
                [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args
    in case Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
extracted of
        Right [GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gDate, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gFormat, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gTimeZone, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gLocale] ->
                -- The desired target timezone; Nothing means keep original timezone
            let tzMay :: Maybe TimeZone
tzMay = forall (m :: * -> *). GVal m -> Maybe TimeZone
gvalToTZ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gTimeZone
                -- The default timezone used when the input doesn't include timezone
                -- information; if a target timezone is given, then it is also used as
                -- the default, otherwise, UTC is assumed. The underlying assumptions
                -- are:
                --
                -- * If the input does not include timezone information, then it is a
                --   local time; hence, if the user explicitly passes a time zone for
                --   formatting, it is assumed that this means the original local time
                --   is in that time zone.
                -- * If the input does not include timezone information, and no
                --   explicit timezone is given, the only sane time zone to pick is
                --   UTC. In this situation, the incoming dates either originate from
                --   a system that doesn't track timezone information but implicitly
                --   stores everything in UTC (which is fine), or the formatting
                --   doesn't use timezone information anyway (in which case it doesn't
                --   matter), or the originator of the data uses another timezone but
                --   fails to report it (in which case it is impossible to do the right
                --   thing)
                -- * If the input *does* include timezone information, it should be
                --   respected; explicitly passing timezone information in the date()
                --   call means the user wants to represent the same zoned time in a
                --   different time zone, which means time zone conversion is required.
                defTZ :: TimeZone
defTZ = forall a. a -> Maybe a -> a
fromMaybe TimeZone
utc Maybe TimeZone
tzMay
                dateMay :: Maybe ZonedTime
dateMay = forall (m :: * -> *). TimeZone -> GVal m -> Maybe ZonedTime
gvalToDate TimeZone
defTZ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gDate
                fmtMay :: Maybe [Char]
fmtMay = Text -> [Char]
Text.unpack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. FromGVal m a => GVal m -> Maybe a
fromGVal GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gFormat
            in case Maybe [Char]
fmtMay of
                Just [Char]
fmt -> do
                    TimeLocale
locale <- forall b a. b -> (a -> b) -> Maybe a -> b
maybe
                        (forall (m :: * -> *) p h.
Monad m =>
GVal (Run p m h) -> Run p m h TimeLocale
getTimeLocale GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gLocale)
                        forall (m :: * -> *) a. Monad m => a -> m a
return
                        (forall (m :: * -> *) a. FromGVal m a => GVal m -> Maybe a
fromGVal GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gLocale)
                    forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ forall t. FormatTime t => TimeLocale -> [Char] -> t -> [Char]
formatTime TimeLocale
locale [Char]
fmt forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe TimeZone -> ZonedTime -> ZonedTime
convertTZ Maybe TimeZone
tzMay forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ZonedTime
dateMay
                Maybe [Char]
Nothing -> do
                    forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ Maybe TimeZone -> ZonedTime -> ZonedTime
convertTZ Maybe TimeZone
tzMay forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ZonedTime
dateMay
        Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
_ -> forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"date") Text
"expected: (date, format, tz=null, locale=null)"
    where
        convertTZ :: Maybe TimeZone -> ZonedTime -> ZonedTime
        convertTZ :: Maybe TimeZone -> ZonedTime -> ZonedTime
convertTZ Maybe TimeZone
Nothing = forall a. a -> a
id
        convertTZ (Just TimeZone
tz) = TimeZone -> UTCTime -> ZonedTime
utcToZonedTime TimeZone
tz forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> UTCTime
zonedTimeToUTC

getTimeLocale :: Monad m => GVal (Run p m h) -> Run p m h TimeLocale
getTimeLocale :: forall (m :: * -> *) p h.
Monad m =>
GVal (Run p m h) -> Run p m h TimeLocale
getTimeLocale GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
localeName = do
    forall (m :: * -> *). GVal m -> Maybe (Function m)
toFunction forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) p h.
Monad m =>
Text -> Run p m h (GVal (Run p m h))
getVar Text
"getlocale" forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        Maybe
  (Function
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))
Nothing ->
            forall (m :: * -> *) a. Monad m => a -> m a
return TimeLocale
defaultTimeLocale
        Just Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
getlocale -> do
            let args :: [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args = [ (forall a. a -> Maybe a
Just Text
"category", GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
"LC_TIME")
                       , (forall a. a -> Maybe a
Just Text
"locale", GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
localeName)
                       ]
            forall a. a -> Maybe a -> a
fromMaybe TimeLocale
defaultTimeLocale forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. FromGVal m a => GVal m -> Maybe a
fromGVal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
getlocale [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args


gfnFilter :: Monad m => Function (Run p m h)
gfnFilter :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnFilter [] = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Default a => a
def
gfnFilter [(Maybe Text
_, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
xs)] = forall (m :: * -> *) a. Monad m => a -> m a
return GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
xs
gfnFilter ((Maybe Text
_, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
xs):(Maybe Text
_, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
p):[(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args) = do
    Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
pfnG <- forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall p. RuntimeError p
NotAFunctionError) forall (m :: * -> *) a. Monad m => a -> m a
return (forall (m :: * -> *). GVal m -> Maybe (Function m)
asFunction GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
p)
    let pfn :: GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> Run p m h Bool
pfn GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
x = forall (m :: * -> *). GVal m -> Bool
asBoolean forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Function
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
pfnG ((forall a. Maybe a
Nothing, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
x)forall a. a -> [a] -> [a]
:[(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args)
        xsl :: [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
xsl = forall a. a -> Maybe a -> a
fromMaybe [] (forall (m :: * -> *). GVal m -> Maybe [GVal m]
asList GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
xs)
    [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
filtered <- forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> Run p m h Bool
pfn [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
xsl
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal [GVal
   (ExceptT
      (RuntimeError p)
      (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
filtered

printfG :: String -> [GVal m] -> String
printfG :: forall (m :: * -> *). [Char] -> [GVal m] -> [Char]
printfG [Char]
fmt [GVal m]
args = forall t. PrintfType t => [Char] -> [PrintfArgT] -> t
printfa [Char]
fmt (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. PrintfArg a => a -> PrintfArgT
P [GVal m]
args)


gfnDictsort :: Monad m => Function (Run p m h)
gfnDictsort :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnDictsort [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args =
    let extracted :: Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
extracted =
            forall a.
[(Text, a)]
-> [(Maybe Text, a)] -> Either ([a], HashMap Text a, [Text]) [a]
extractArgsDefL
                [ (Text
"dict", forall a. Default a => a
def)
                , (Text
"case_sensitive", forall a. Default a => a
def)
                , (Text
"by", GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
"key")
                ]
                [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args
    in case Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
extracted of
        Right [GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gDict, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gCaseSensitive, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gSortBy] -> do
            let caseSensitive :: Bool
caseSensitive = forall (m :: * -> *). GVal m -> Bool
asBoolean GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gCaseSensitive
            Bool
sortByKey <- case forall (m :: * -> *). GVal m -> Text
asText GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gSortBy of
                Text
"key" -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
                Text
"value" -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
                Text
"val" -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
                Text
x -> forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"dictsort")
                        ( Text
"argument 'by' must be one of 'key', 'value', 'val', " forall a. Semigroup a => a -> a -> a
<>
                          Text
"but found '" forall a. Semigroup a => a -> a -> a
<>
                          Text
x forall a. Semigroup a => a -> a -> a
<> Text
"'"
                        )
            let items :: [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
items = forall a. a -> Maybe a -> a
fromMaybe [] forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). GVal m -> Maybe [(Text, GVal m)]
asDictItems GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gDict
            let projection :: (Text, GVal m) -> Text
projection =
                    (if Bool
caseSensitive then forall a. a -> a
id else Text -> Text
Text.toUpper) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                    (if Bool
sortByKey then forall a b. (a, b) -> a
fst else (forall (m :: * -> *). GVal m -> Text
asText forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd))
            forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). [Pair m] -> GVal m
orderedDict forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. Ord b => (a -> b) -> [a] -> [a]
List.sortOn forall {m :: * -> *}. (Text, GVal m) -> Text
projection forall a b. (a -> b) -> a -> b
$ [(Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
items
        Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
_ -> forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"dictsort") Text
"expected: (dict, case_sensitive=false, by=null)"

gfnJSON :: Monad m => Function (Run p m h)
gfnJSON :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnJSON [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args =
  let extracted :: Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
extracted =
          forall a.
[(Text, a)]
-> [(Maybe Text, a)] -> Either ([a], HashMap Text a, [Text]) [a]
extractArgsDefL
            [ (Text
"val", forall a. Default a => a
def)
            , (Text
"pretty", forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal Bool
True)
            ]
            [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args
  in case Either
  ([GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
   HashMap
     Text
     (GVal
        (ExceptT
           (RuntimeError p)
           (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
   [Text])
  [GVal
     (ExceptT
        (RuntimeError p)
        (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))]
extracted of
      Right [ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gVal, GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gPretty ] -> do
          let encoder :: GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
-> ByteString
encoder =
                if forall (m :: * -> *). GVal m -> Bool
asBoolean GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gPretty then
                    forall a. ToJSON a => a -> ByteString
JSON.encodePretty
                else
                    forall a. ToJSON a => a -> ByteString
JSON.encode
          forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
.
            forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
.
            [Char] -> Text
Text.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
.
            ByteString -> [Char]
UTF8.toString forall b c a. (b -> c) -> (a -> b) -> a -> c
.
            ByteString -> ByteString
LBS.toStrict 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)))
-> ByteString
encoder forall a b. (a -> b) -> a -> b
$
            GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
gVal
      Left ([GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))],
 HashMap
   Text
   (GVal
      (ExceptT
         (RuntimeError p)
         (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))),
 [Text])
_ -> forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"json") Text
"expected: one argument"


-- Built-in tests
--gfnDefined :: Monad m => Function (Run p m h)
--gfnDefined = unaryFunc $ toGVal . isJust . fmap getVar . fromGVal

gfnDivisibleBy :: Monad m => Function (Run p m h)
gfnDivisibleBy :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnDivisibleBy = forall (m :: * -> *) h p.
Monad m =>
(GVal (Run p m h) -> GVal (Run p m h) -> GVal (Run p m h))
-> Function (Run p m h)
binaryFunc forall a b. (a -> b) -> a -> b
$ \GVal (Run p m h)
x GVal (Run p m h)
y -> forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall a b. (a -> b) -> a -> b
$ forall {a}. Integral a => a -> a -> Bool
divisibleBy forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *). GVal m -> Maybe Integer
toInteger GVal (Run p m h)
x) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall (m :: * -> *). GVal m -> Maybe Integer
toInteger GVal (Run p m h)
y)
  where divisibleBy :: a -> a -> Bool
divisibleBy a
x a
y = a
x forall a. Integral a => a -> a -> a
`Prelude.mod` a
y forall a. Eq a => a -> a -> Bool
== a
0

gfnEven :: Monad m => Function (Run p m h)
gfnEven :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnEven = forall (m :: * -> *) h p.
Monad m =>
(GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
unaryFunc forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Integral a => a -> Bool
Prelude.even forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Maybe Integer
toInteger

gfnOdd :: Monad m => Function (Run p m h)
gfnOdd :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnOdd = forall (m :: * -> *) h p.
Monad m =>
(GVal (Run p m h) -> GVal (Run p m h)) -> Function (Run p m h)
unaryFunc forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Integral a => a -> Bool
Prelude.odd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Maybe Integer
toInteger

gfoRegex :: Monad m => GVal (Run p m h)
gfoRegex :: forall (m :: * -> *) p h. Monad m => GVal (Run p m h)
gfoRegex =
  forall (m :: * -> *). [Pair m] -> GVal m
dict
    [ (Text
"match", forall (m :: * -> *). Function m -> GVal m
fromFunction forall p (m :: * -> *) h. Monad m => Function (Run p m h)
gfnReMatchOne)
    , (Text
"matches", forall (m :: * -> *). Function m -> GVal m
fromFunction forall p (m :: * -> *) h. Monad m => Function (Run p m h)
gfnReMatch)
    , (Text
"test", forall (m :: * -> *). Function m -> GVal m
fromFunction forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnReTest)
    ]

gfnReMatchOne :: forall p m h. Monad m => Function (Run p m h)
gfnReMatchOne :: forall p (m :: * -> *) h. Monad m => Function (Run p m h)
gfnReMatchOne [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args =
  forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\([Char]
_, MatchText [Char]
m, [Char]
_) -> forall (m :: * -> *). Monad m => MatchText [Char] -> GVal m
matchTextToGVal MatchText [Char]
m :: GVal (Run p m h)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {m :: * -> *} {a} {p} {h}.
Monad m =>
(Regex -> [Char] -> a)
-> [(Maybe Text, GVal (Run p m h))] -> Run p m h a
fnReMatch forall regex source.
RegexLike regex source =>
regex -> source -> Maybe (source, MatchText source, source)
RE.matchOnceText [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args

gfnReMatch :: forall p m h. Monad m => Function (Run p m h)
gfnReMatch :: forall p (m :: * -> *) h. Monad m => Function (Run p m h)
gfnReMatch [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args =
  forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (m :: * -> *). Monad m => MatchText [Char] -> GVal m
matchTextToGVal :: RE.MatchText String -> GVal (Run p m h)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {m :: * -> *} {a} {p} {h}.
Monad m =>
(Regex -> [Char] -> a)
-> [(Maybe Text, GVal (Run p m h))] -> Run p m h a
fnReMatch forall regex source.
RegexLike regex source =>
regex -> source -> [MatchText source]
RE.matchAllText [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args

gfnReTest :: Monad m => Function (Run p m h)
gfnReTest :: forall (m :: * -> *) p h. Monad m => Function (Run p m h)
gfnReTest [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args =
  forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {m :: * -> *} {a} {p} {h}.
Monad m =>
(Regex -> [Char] -> a)
-> [(Maybe Text, GVal (Run p m h))] -> Run p m h a
fnReMatch forall regex source.
RegexLike regex source =>
regex -> source -> Bool
RE.matchTest [(Maybe Text,
  GVal
    (ExceptT
       (RuntimeError p)
       (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))))]
args

matchTextToGVal :: Monad m => RE.MatchText String -> GVal m
matchTextToGVal :: forall (m :: * -> *). Monad m => MatchText [Char] -> GVal m
matchTextToGVal MatchText [Char]
matchArr =
  let base :: GVal m
base = forall (m :: * -> *) a. ToGVal m a => a -> GVal m
toGVal forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Char] -> Text
Text.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) forall a b. (a -> b) -> a -> b
$ MatchText [Char]
matchArr
      textRepr :: Text
textRepr = forall a. a -> Maybe a -> a
fromMaybe Text
"" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Char] -> Text
Text.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe a
headMay forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList forall a b. (a -> b) -> a -> b
$ MatchText [Char]
matchArr
  in forall {m :: * -> *}. GVal m
base
      { asText :: Text
asText = Text
textRepr
      , asHtml :: Html
asHtml = Text -> Html
html Text
textRepr
      }

fnReMatch :: (Regex -> [Char] -> a)
-> [(Maybe Text, GVal (Run p m h))] -> Run p m h a
fnReMatch Regex -> [Char] -> a
matchFunc [(Maybe Text, GVal (Run p m h))]
args =
  let gArgs :: Either
  ([GVal (Run p m h)], HashMap Text (GVal (Run p m h)), [Text])
  [Maybe (GVal (Run p m h))]
gArgs = forall a.
[Text]
-> [(Maybe Text, a)]
-> Either ([a], HashMap Text a, [Text]) [Maybe a]
extractArgsL [Text
"re", Text
"haystack", Text
"opts"] [(Maybe Text, GVal (Run p m h))]
args
  in forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const forall {p} {h} {a}. Run p m h a
barf) forall {p} {h}.
[Maybe (GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
go Either
  ([GVal (Run p m h)], HashMap Text (GVal (Run p m h)), [Text])
  [Maybe (GVal (Run p m h))]
gArgs
  where
    go :: [Maybe (GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
go = \case
      [Maybe (GVal (Run p m h))
r, Maybe (GVal (Run p m h))
h, Maybe (GVal (Run p m h))
Nothing] ->
        [Maybe (GVal (Run p m h))]
-> ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m))
     a
go [Maybe (GVal (Run p m h))
r, Maybe (GVal (Run p m h))
h, forall a. a -> Maybe a
Just forall a. Default a => a
def]
      [Just GVal (Run p m h)
reG, Just GVal (Run p m h)
haystackG, Just GVal (Run p m h)
optsG] -> do
        CompOption
opts <- forall (m :: * -> *) p h.
Monad m =>
GVal (Run p m h) -> Run p m h CompOption
parseCompOpts GVal (Run p m h)
optsG
        let reM :: Either [Char] Regex
reM = forall a. FailToEither a -> Either [Char] a
runFailToEither forall a b. (a -> b) -> a -> b
$
                      forall regex compOpt execOpt source (m :: * -> *).
(RegexMaker regex compOpt execOpt source, MonadFail m) =>
compOpt -> execOpt -> source -> m regex
RE.makeRegexOptsM CompOption
opts forall regex compOpt execOpt.
RegexOptions regex compOpt execOpt =>
execOpt
RE.defaultExecOpt (Text -> [Char]
Text.unpack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Text
asText forall a b. (a -> b) -> a -> b
$ GVal (Run p m h)
reG)
            haystack :: [Char]
haystack = Text -> [Char]
Text.unpack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Text
asText forall a b. (a -> b) -> a -> b
$ GVal (Run p m h)
haystackG
        case Either [Char] Regex
reM of
            Left [Char]
err ->
                forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"re.match") forall a b. (a -> b) -> a -> b
$ Text
"invalid regex: " forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
Text.pack [Char]
err
            Right Regex
re ->
                forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Regex -> [Char] -> a
matchFunc Regex
re [Char]
haystack
      [Maybe (GVal (Run p m h))]
_ -> forall {p} {h} {a}. Run p m h a
barf
    barf :: Run p m h a
barf = do
      forall (m :: * -> *) p h a.
Monad m =>
RuntimeError p -> Run p m h a
throwHere forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError (forall a. a -> Maybe a
Just Text
"re.match") Text
"expected: regex, haystack, [opts]"

parseCompOpts :: Monad m => GVal (Run p m h) -> Run p m h RE.CompOption
parseCompOpts :: forall (m :: * -> *) p h.
Monad m =>
GVal (Run p m h) -> Run p m h CompOption
parseCompOpts GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
g = do
  let str :: [Char]
str = Text -> [Char]
Text.unpack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). GVal m -> Text
asText forall a b. (a -> b) -> a -> b
$ GVal
  (ExceptT
     (RuntimeError p)
     (StateT (RunState p m h) (ReaderT (GingerContext p m h) m)))
g
  forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM
    (\CompOption
x ->
      \case
        Char
'i' -> forall (m :: * -> *) a. Monad m => a -> m a
return CompOption
x { caseSensitive :: Bool
RE.caseSensitive = Bool
False }
        Char
'm' -> forall (m :: * -> *) a. Monad m => a -> m a
return CompOption
x { multiline :: Bool
RE.multiline = Bool
True }
        Char
c -> do
          forall (m :: * -> *) p h. Monad m => RuntimeError p -> Run p m h ()
warn forall a b. (a -> b) -> a -> b
$ forall p. Maybe Text -> Text -> RuntimeError p
ArgumentsError forall a. Maybe a
Nothing forall a b. (a -> b) -> a -> b
$ Text
"unexpected regex modifier: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> Text
tshow Char
c
          forall (m :: * -> *) a. Monad m => a -> m a
return CompOption
x
    )
    forall regex compOpt execOpt.
RegexOptions regex compOpt execOpt =>
compOpt
RE.blankCompOpt
    [Char]
str

-- | This type provides an easy way to use 'RE.makeRegexOptsM' without having
-- to add a new dependency.
newtype FailToEither a
  = FailToEither
      { forall a. FailToEither a -> Either [Char] a
runFailToEither :: Either String a
      }
  deriving newtype (Functor FailToEither
forall a. a -> FailToEither a
forall a b. FailToEither a -> FailToEither b -> FailToEither a
forall a b. FailToEither a -> FailToEither b -> FailToEither b
forall a b.
FailToEither (a -> b) -> FailToEither a -> FailToEither b
forall a b c.
(a -> b -> c) -> FailToEither a -> FailToEither b -> FailToEither c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: forall a b. FailToEither a -> FailToEither b -> FailToEither a
$c<* :: forall a b. FailToEither a -> FailToEither b -> FailToEither a
*> :: forall a b. FailToEither a -> FailToEither b -> FailToEither b
$c*> :: forall a b. FailToEither a -> FailToEither b -> FailToEither b
liftA2 :: forall a b c.
(a -> b -> c) -> FailToEither a -> FailToEither b -> FailToEither c
$cliftA2 :: forall a b c.
(a -> b -> c) -> FailToEither a -> FailToEither b -> FailToEither c
<*> :: forall a b.
FailToEither (a -> b) -> FailToEither a -> FailToEither b
$c<*> :: forall a b.
FailToEither (a -> b) -> FailToEither a -> FailToEither b
pure :: forall a. a -> FailToEither a
$cpure :: forall a. a -> FailToEither a
Applicative, forall a b. a -> FailToEither b -> FailToEither a
forall a b. (a -> b) -> FailToEither a -> FailToEither b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> FailToEither b -> FailToEither a
$c<$ :: forall a b. a -> FailToEither b -> FailToEither a
fmap :: forall a b. (a -> b) -> FailToEither a -> FailToEither b
$cfmap :: forall a b. (a -> b) -> FailToEither a -> FailToEither b
Functor, Applicative FailToEither
forall a. a -> FailToEither a
forall a b. FailToEither a -> FailToEither b -> FailToEither b
forall a b.
FailToEither a -> (a -> FailToEither b) -> FailToEither b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: forall a. a -> FailToEither a
$creturn :: forall a. a -> FailToEither a
>> :: forall a b. FailToEither a -> FailToEither b -> FailToEither b
$c>> :: forall a b. FailToEither a -> FailToEither b -> FailToEither b
>>= :: forall a b.
FailToEither a -> (a -> FailToEither b) -> FailToEither b
$c>>= :: forall a b.
FailToEither a -> (a -> FailToEither b) -> FailToEither b
Monad)

instance MonadFail FailToEither where
  fail :: forall a. [Char] -> FailToEither a
fail = forall a. Either [Char] a -> FailToEither a
FailToEither forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> Either a b
Left
  {-# INLINE fail #-}

-- vim: sw=4 ts=4 expandtab