{-#LANGUAGE DerivingStrategies #-}
{-#LANGUAGE FlexibleContexts #-}
{-#LANGUAGE FlexibleInstances #-}
{-#LANGUAGE GeneralizedNewtypeDeriving #-}
{-#LANGUAGE OverloadedStrings #-}
{-#LANGUAGE TupleSections #-}
{-#LANGUAGE TypeSynonymInstances #-}
{-#LANGUAGE MultiParamTypeClasses #-}
{-#LANGUAGE ScopedTypeVariables #-}
{-#LANGUAGE LambdaCase #-}
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)
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
| 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
| 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] ->
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
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"
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
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 #-}