{-# LANGUAGE CPP #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedLists #-}
module Language.Ginger.Interpret.Builtins
where
import Language.Ginger.AST
import Language.Ginger.Interpret.Type
import Language.Ginger.Render (renderSyntaxText)
import Language.Ginger.RuntimeError
import Language.Ginger.Value
import Control.Applicative ( (<|>) )
import Control.Monad.Except
import Control.Monad.Trans (lift)
import qualified Data.Aeson as JSON
import qualified Data.Array as Array
import Data.Bits (popCount)
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as LBS
import Data.Char (isUpper, isLower, isAlphaNum, isPrint, isSpace, isAlpha, isDigit, ord)
import Data.Foldable (asum)
#if MIN_VERSION_base(4,20,0)
import Data.List (sortBy, minimumBy, maximumBy)
#else
import Data.List (sortBy, minimumBy, maximumBy, foldl')
#endif
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.Maybe (fromMaybe, listToMaybe, catMaybes, isJust)
import Data.Text (Text)
import qualified Data.Text as Text
import qualified Data.Text.Encoding as Text
import Data.Time
( TimeZone (..)
, ZonedTime (..)
, TimeOfDay (..)
, LocalTime (..)
, parseTimeM
, defaultTimeLocale
, utc
, fromGregorian
, utcToZonedTime
, zonedTimeToUTC
, formatTime
)
import Data.Vector (Vector)
import qualified Data.Vector as V
import System.Random (uniformR)
import Text.Printf (printf)
import Text.Read (readMaybe)
import qualified Text.Regex.TDFA as RE
type BuiltinAttribs a m = Map Identifier (a -> m (Either RuntimeError (Value m)))
builtinGlobals :: forall m. Monad m
=> (Expr -> GingerT m (Value m))
-> Map Identifier (Value m)
builtinGlobals :: forall (m :: * -> *).
Monad m =>
(Expr -> GingerT m (Value m)) -> Map Identifier (Value m)
builtinGlobals Expr -> GingerT m (Value m)
evalE = [(Identifier, Value m)] -> Map Identifier (Value m)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(Identifier, Value m)] -> Map Identifier (Value m))
-> [(Identifier, Value m)] -> Map Identifier (Value m)
forall a b. (a -> b) -> a -> b
$
[ (Identifier
"abs", ObjectID
-> Maybe ProcedureDoc
-> (Integer -> Integer)
-> (Double -> Double)
-> Value m
forall (m :: * -> *).
Monad m =>
ObjectID
-> Maybe ProcedureDoc
-> (Integer -> Integer)
-> (Double -> Double)
-> Value m
numericBuiltin
ObjectID
"builtin:abs"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"abs"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"value"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"number")
Maybe Text
forall a. Maybe a
Nothing
Text
""
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"number")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Absolute of a number."
}
)
Integer -> Integer
forall a. Num a => a -> a
abs Double -> Double
forall a. Num a => a -> a
abs)
, (Identifier
"attr", ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Value m -> m (Either RuntimeError (Value m)))
-> Value m
forall a (m :: * -> *).
FnToValue a m =>
ObjectID -> Maybe ProcedureDoc -> a -> Value m
fnToValue ObjectID
"builtin:attr"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"attr"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"value"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"dict")
Maybe Text
forall a. Maybe a
Nothing
Text
""
, Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"attrName"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
Maybe Text
forall a. Maybe a
Nothing
Text
""
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny)
, procedureDocDescription :: Text
procedureDocDescription = [Text] -> Text
Text.unlines
[ Text
Item [Text]
"Get a named attribute from a `dict` or dict-like object."
, Text
"Unlike `[]` or dot member access, this will only look " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"at attributes, not items."
]
}
)
((Value m -> Value m -> m (Either RuntimeError (Value m)))
-> Value m)
-> (Value m -> Value m -> m (Either RuntimeError (Value m)))
-> Value m
forall a b. (a -> b) -> a -> b
$ \Value m
x Value m
y -> case Value m
y :: Value m of
StringV Text
yStr ->
(Maybe (Value m) -> Value m)
-> Either RuntimeError (Maybe (Value m))
-> Either RuntimeError (Value m)
forall a b.
(a -> b) -> Either RuntimeError a -> Either RuntimeError b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Value m -> Maybe (Value m) -> Value m
forall a. a -> Maybe a -> a
fromMaybe Value m
forall (m :: * -> *). Value m
NoneV) (Either RuntimeError (Maybe (Value m))
-> Either RuntimeError (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
-> m (Either RuntimeError (Value m))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *).
Monad m =>
Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
getAttrRaw @m Value m
x (Text -> Identifier
Identifier Text
yStr)
Value m
_ ->
Either RuntimeError (Value m) -> m (Either RuntimeError (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Value m)
-> m (Either RuntimeError (Value m)))
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> m (Either RuntimeError (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> Either RuntimeError (Value m)
forall a b. b -> Either a b
Right (Value m -> m (Either RuntimeError (Value m)))
-> Value m -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Value m
forall (m :: * -> *). Value m
NoneV)
, (Identifier
"batch", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnBatch)
, (Identifier
"capitalize", ObjectID -> Maybe ProcedureDoc -> (Text -> Text) -> Value m
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID -> Maybe ProcedureDoc -> (Text -> a) -> Value m
textBuiltin
ObjectID
"builtin:capitalize"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"capitalize"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"value"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
Maybe Text
forall a. Maybe a
Nothing
Text
""
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Convert `value` to title case."
}
)
Text -> Text
Text.toTitle)
, (Identifier
"center", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnCenter)
, (Identifier
"count", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnLength)
, (Identifier
"dictsort", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnDictsort)
, (Identifier
"e", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnEscape)
, (Identifier
"escape", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnEscape)
, (Identifier
"even", ObjectID -> Maybe ProcedureDoc -> (Integer -> Bool) -> Value m
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID -> Maybe ProcedureDoc -> (Integer -> a) -> Value m
intBuiltin
ObjectID
"builtin:even"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"even"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"value"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int")
Maybe Text
forall a. Maybe a
Nothing
Text
""
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Check if `value` is an even number"
}
)
Integer -> Bool
forall a. Integral a => a -> Bool
even)
, (Identifier
"filesizeformat", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnFilesizeFormat)
, (Identifier
"first", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnFirst)
, (Identifier
"float", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnToFloat)
, (Identifier
"groupby", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnGroupBy)
, (Identifier
"int", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnToInt)
, (Identifier
"items", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnItems)
, (Identifier
"join", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnJoin)
, (Identifier
"json", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnToJSON)
, (Identifier
"last", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnLast)
, (Identifier
"length", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnLength)
, (Identifier
"list", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnToList)
, (Identifier
"lower", ObjectID -> Maybe ProcedureDoc -> (Text -> Text) -> Value m
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID -> Maybe ProcedureDoc -> (Text -> a) -> Value m
textBuiltin
ObjectID
"builtin:lower"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"lower"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"value"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
Maybe Text
forall a. Maybe a
Nothing
Text
""
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Convert `value` to lowercase."
}
)
Text -> Text
Text.toLower)
, (Identifier
"map", Filter m -> Value m
forall (m :: * -> *). Filter m -> Value m
FilterV (Filter m -> Value m) -> Filter m -> Value m
forall a b. (a -> b) -> a -> b
$ (Expr -> GingerT m (Value m)) -> Filter m
forall (m :: * -> *).
Monad m =>
(Expr -> GingerT m (Value m)) -> Filter m
fnMap Expr -> GingerT m (Value m)
evalE)
, (Identifier
"max", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnMax)
, (Identifier
"min", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnMin)
, (Identifier
"namespace", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Procedure m
NamespaceProcedure)
, (Identifier
"odd", ObjectID -> Maybe ProcedureDoc -> (Integer -> Bool) -> Value m
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID -> Maybe ProcedureDoc -> (Integer -> a) -> Value m
intBuiltin
ObjectID
"builtin:odd"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"odd"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"value"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int")
Maybe Text
forall a. Maybe a
Nothing
Text
""
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Checks if `value` is an odd number."
}
)
Integer -> Bool
forall a. Integral a => a -> Bool
odd)
, (Identifier
"random", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnRandom)
, (Identifier
"reject", Filter m -> Value m
forall (m :: * -> *). Filter m -> Value m
FilterV (Filter m -> Value m) -> Filter m -> Value m
forall a b. (a -> b) -> a -> b
$ (Expr -> GingerT m (Value m)) -> Filter m
forall (m :: * -> *).
Monad m =>
(Expr -> GingerT m (Value m)) -> Filter m
fnReject Expr -> GingerT m (Value m)
evalE)
, (Identifier
"replace", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrReplace)
, (Identifier
"reverse", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnReverse)
, (Identifier
"round", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnRound)
, (Identifier
"safe", ObjectID -> Maybe ProcedureDoc -> (Text -> Value m) -> Value m
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID -> Maybe ProcedureDoc -> (Text -> a) -> Value m
textBuiltin
ObjectID
"builtin:safe"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"safe"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"value"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
Maybe Text
forall a. Maybe a
Nothing
Text
""
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"encoded")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Mark `value` as pre-encoded HTML."
}
)
(forall (m :: * -> *). Encoded -> Value m
EncodedV @m (Encoded -> Value m) -> (Text -> Encoded) -> Text -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Encoded
Encoded)
)
, (Identifier
"select", Filter m -> Value m
forall (m :: * -> *). Filter m -> Value m
FilterV (Filter m -> Value m) -> Filter m -> Value m
forall a b. (a -> b) -> a -> b
$ (Expr -> GingerT m (Value m)) -> Filter m
forall (m :: * -> *).
Monad m =>
(Expr -> GingerT m (Value m)) -> Filter m
fnSelect Expr -> GingerT m (Value m)
evalE)
, (Identifier
"sort", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnSort)
, (Identifier
"split", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrSplit)
, (Identifier
"string", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnToString)
, (Identifier
"sum", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnSum)
, (Identifier
"title", ObjectID -> Maybe ProcedureDoc -> (Text -> Text) -> Value m
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID -> Maybe ProcedureDoc -> (Text -> a) -> Value m
textBuiltin
ObjectID
"builtin:title"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"title"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"value"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
Maybe Text
forall a. Maybe a
Nothing
Text
""
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Convert `value` to title case."
}
)
Text -> Text
Text.toTitle)
, (Identifier
"tojson", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnToJSON)
, (Identifier
"upper", ObjectID -> Maybe ProcedureDoc -> (Text -> Text) -> Value m
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID -> Maybe ProcedureDoc -> (Text -> a) -> Value m
textBuiltin
ObjectID
"builtin:upper"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"upper"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"value"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
Maybe Text
forall a. Maybe a
Nothing
Text
""
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Convert `value` to uppercase."
}
)
Text -> Text
Text.toUpper)
, (Identifier
"wordcount", ObjectID -> Maybe ProcedureDoc -> (Text -> Int) -> Value m
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID -> Maybe ProcedureDoc -> (Text -> a) -> Value m
textBuiltin
ObjectID
"builtin:wordcount"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"wordcount"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"value"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
Maybe Text
forall a. Maybe a
Nothing
Text
""
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Counts words in value."
}
)
([Text] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Text] -> Int) -> (Text -> [Text]) -> Text -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text]
Text.words))
]
builtinGlobalsNonJinja :: forall m. Monad m
=> (Expr -> GingerT m (Value m))
-> Map Identifier (Value m)
builtinGlobalsNonJinja :: forall (m :: * -> *).
Monad m =>
(Expr -> GingerT m (Value m)) -> Map Identifier (Value m)
builtinGlobalsNonJinja Expr -> GingerT m (Value m)
_evalE = [(Identifier, Value m)] -> Map Identifier (Value m)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(Identifier, Value m)] -> Map Identifier (Value m))
-> [(Identifier, Value m)] -> Map Identifier (Value m)
forall a b. (a -> b) -> a -> b
$
[ (Identifier
"strip", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrStrip)
, (Identifier
"regex", Value m
forall (m :: * -> *). Monad m => Value m
regexModule)
, (Identifier
"date", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnDateFormat)
, (Identifier
"dateformat", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnDateFormat)
, (Identifier
"help", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnHelp)
]
builtinIntAttribs :: forall m. Monad m => BuiltinAttribs Integer m
builtinIntAttribs :: forall (m :: * -> *). Monad m => BuiltinAttribs Integer m
builtinIntAttribs = [(Identifier, Integer -> m (Either RuntimeError (Value m)))]
-> Map Identifier (Integer -> m (Either RuntimeError (Value m)))
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
[ (Identifier
"denominator", (Integer -> Integer)
-> Integer -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Integer -> a) -> Integer -> m (Either RuntimeError (Value m))
intProp (Integer -> Integer -> Integer
forall a b. a -> b -> a
const (Integer
1 :: Integer)))
, (Identifier
"bit_count", ObjectID
-> Maybe ProcedureDoc
-> (Integer -> Int)
-> Integer
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Integer -> a)
-> Integer
-> m (Either RuntimeError (Value m))
intAttrib
ObjectID
"builtin:int:bit_count"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"int.bit_count"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int")
, procedureDocDescription :: Text
procedureDocDescription =
[Text] -> Text
Text.unlines
[ Text
Item [Text]
"Bit count (popcount)."
, Text
Item [Text]
"Counts the number of set bits in an integer."
]
}
)
Integer -> Int
forall a. Bits a => a -> Int
popCount)
, (Identifier
"imag", (Integer -> Integer)
-> Integer -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Integer -> a) -> Integer -> m (Either RuntimeError (Value m))
intProp (Integer -> Integer -> Integer
forall a b. a -> b -> a
const (Integer
0 :: Integer)))
, (Identifier
"numerator", (Integer -> Integer)
-> Integer -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Integer -> a) -> Integer -> m (Either RuntimeError (Value m))
intProp Integer -> Integer
forall a. a -> a
id)
, (Identifier
"real", (Integer -> Integer)
-> Integer -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Integer -> a) -> Integer -> m (Either RuntimeError (Value m))
intProp Integer -> Integer
forall a. a -> a
id)
]
builtinFloatAttribs :: Monad m => BuiltinAttribs Double m
builtinFloatAttribs :: forall (m :: * -> *). Monad m => BuiltinAttribs Double m
builtinFloatAttribs = [(Identifier, Double -> m (Either RuntimeError (Value m)))]
-> Map Identifier (Double -> m (Either RuntimeError (Value m)))
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
[ (Identifier
"imag", (Double -> Double) -> Double -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Double -> a) -> Double -> m (Either RuntimeError (Value m))
floatProp (Double -> Double -> Double
forall a b. a -> b -> a
const (Double
0 :: Double)))
, (Identifier
"real", (Double -> Double) -> Double -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Double -> a) -> Double -> m (Either RuntimeError (Value m))
floatProp Double -> Double
forall a. a -> a
id)
]
builtinBoolAttribs :: Monad m => BuiltinAttribs Bool m
builtinBoolAttribs :: forall (m :: * -> *). Monad m => BuiltinAttribs Bool m
builtinBoolAttribs = [(Identifier, Bool -> m (Either RuntimeError (Value m)))]
-> Map Identifier (Bool -> m (Either RuntimeError (Value m)))
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
[ (Identifier
"denominator", (Bool -> Integer) -> Bool -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Bool -> a) -> Bool -> m (Either RuntimeError (Value m))
boolProp (Integer -> Bool -> Integer
forall a b. a -> b -> a
const (Integer
1 :: Integer)))
, (Identifier
"bit_count", ObjectID
-> Maybe ProcedureDoc
-> (Bool -> Int)
-> Bool
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Bool -> a)
-> Bool
-> m (Either RuntimeError (Value m))
boolAttrib
ObjectID
"builtin:bool:bit_count"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"bool.bit_count"
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int")
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocDescription :: Text
procedureDocDescription =
[Text] -> Text
Text.unlines
[ Text
Item [Text]
"Bit count (popcount)."
, Text
Item [Text]
"Counts the number of set bits."
, Text
"Since a boolean only has one bit, this will " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"always be either 0 or 1."
]
}
)
Bool -> Int
forall a. Bits a => a -> Int
popCount)
, (Identifier
"to_bytes", (Bool -> ByteString) -> Bool -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Bool -> a) -> Bool -> m (Either RuntimeError (Value m))
boolProp (Word8 -> ByteString
BS.singleton (Word8 -> ByteString) -> (Bool -> Word8) -> Bool -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> (Bool -> Int) -> Bool -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum))
, (Identifier
"imag", (Bool -> Integer) -> Bool -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Bool -> a) -> Bool -> m (Either RuntimeError (Value m))
boolProp (Integer -> Bool -> Integer
forall a b. a -> b -> a
const (Integer
0 :: Integer)))
, (Identifier
"numerator", (Bool -> Int) -> Bool -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Bool -> a) -> Bool -> m (Either RuntimeError (Value m))
boolProp Bool -> Int
forall a. Enum a => a -> Int
fromEnum)
, (Identifier
"real", (Bool -> Int) -> Bool -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Bool -> a) -> Bool -> m (Either RuntimeError (Value m))
boolProp Bool -> Int
forall a. Enum a => a -> Int
fromEnum)
]
builtinStringAttribs :: forall m. Monad m => BuiltinAttribs Text m
builtinStringAttribs :: forall (m :: * -> *). Monad m => BuiltinAttribs Text m
builtinStringAttribs = [(Identifier, Text -> m (Either RuntimeError (Value m)))]
-> Map Identifier (Text -> m (Either RuntimeError (Value m)))
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
[ (Identifier
"length", (Text -> Int) -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Text -> a) -> Text -> m (Either RuntimeError (Value m))
textProp Text -> Int
Text.length)
, (Identifier
"capitalize", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Text)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:string:capitalize"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.capitalize"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Convert `value` to title case."
}
)
Text -> Text
Text.toTitle)
, (Identifier
"casefold", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Text)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:string:casefold"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.casefold"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
, procedureDocDescription :: Text
procedureDocDescription =
Text
"Convert `value` to canonical case for " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"case-insensitive comparison"
}
)
Text -> Text
Text.toCaseFold)
, (Identifier
"center", Procedure m -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnCenter)
, (Identifier
"count", Procedure m -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrCount)
, (Identifier
"encode", Procedure m -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrEncode)
, (Identifier
"endswith", Procedure m -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrEndswith)
, (Identifier
"isalnum", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Bool)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:string:isalnum"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.isalnum"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Check whether a string is alpha-numeric (a letter or a digit)."
}
)
((Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isAlphaNum)
)
, (Identifier
"isalpha", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Bool)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:string:isalpha"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.isalpha"
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocDescription :: Text
procedureDocDescription = Text
"Check whether a string is alphabetic (consists solely of letters)."
}
)
((Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isAlpha))
, (Identifier
"isascii", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Bool)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:string:isascii"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.isascii"
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocDescription :: Text
procedureDocDescription = Text
"Check whether a string consists solely of 7-bit ASCII characters."
}
)
((Char -> Bool) -> Text -> Bool
Text.all ((Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
128) (Int -> Bool) -> (Char -> Int) -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord)))
, (Identifier
"isdecimal", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Bool)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:string:isdecimal"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.isdecimal"
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocDescription :: Text
procedureDocDescription = Text
"Check whether a string is a decimal number"
}
)
Text -> Bool
isDecimal)
, (Identifier
"isdigit", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Bool)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:string:isdigit"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.isdigit"
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocDescription :: Text
procedureDocDescription = Text
"Check whether a string consists solely of digits."
}
)
((Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isDigit))
, (Identifier
"islower", ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Value m)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToNativeProcedure m a) =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Text
-> m (Either RuntimeError (Value m))
textNProcAttrib
ObjectID
"builtin:string:islower"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.islower"
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocDescription :: Text
procedureDocDescription = Text
"Check whether a string is all-lowercase"
}
)
Value m -> Value m
forall (m :: * -> *). Value m -> Value m
isLowerVal)
, (Identifier
"isprintable", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Bool)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:string:isprintable"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.isprintable"
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocDescription :: Text
procedureDocDescription = Text
"Check whether a string contains only printable characters."
}
)
((Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isPrint))
, (Identifier
"isspace", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Bool)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:string:isspace"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.isspace"
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocDescription :: Text
procedureDocDescription = Text
"Check whether a string contains only whitespace."
}
)
((Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isSpace))
, (Identifier
"isupper", ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Value m)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToNativeProcedure m a) =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Text
-> m (Either RuntimeError (Value m))
textNProcAttrib
ObjectID
"builtin:string:isupper"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.isupper"
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocDescription :: Text
procedureDocDescription = Text
"Check whether a string is all-uppercase."
}
)
Value m -> Value m
forall (m :: * -> *). Value m -> Value m
isUpperVal)
, (Identifier
"join", Procedure m -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrJoin)
, (Identifier
"lower", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Text)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:lower"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.lower"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Convert `value` to lowercase."
}
)
Text -> Text
Text.toLower)
, (Identifier
"lstrip", Procedure m -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrLStrip)
, (Identifier
"replace", Procedure m -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrReplace)
, (Identifier
"rstrip", Procedure m -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrRStrip)
, (Identifier
"split", Procedure m -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrSplit)
, (Identifier
"splitlines", ObjectID
-> Maybe ProcedureDoc
-> (Text -> [Text])
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:string:splitlines()"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.splitlines"
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocDescription :: Text
procedureDocDescription = Text
"Split a string into lines."
}
)
Text -> [Text]
Text.lines)
, (Identifier
"startswith", Procedure m -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrStartswith)
, (Identifier
"strip", Procedure m -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnStrStrip)
, (Identifier
"title", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Text)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:title"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.title"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Convert `value` to title case."
}
)
Text -> Text
Text.toTitle)
, (Identifier
"upper", ObjectID
-> Maybe ProcedureDoc
-> (Text -> Text)
-> Text
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib
ObjectID
"builtin:upper"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"string.upper"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Convert `value` to uppercase."
}
)
Text -> Text
Text.toUpper)
]
builtinListAttribs :: Monad m => BuiltinAttribs (Vector (Value m)) m
builtinListAttribs :: forall (m :: * -> *).
Monad m =>
BuiltinAttribs (Vector (Value m)) m
builtinListAttribs = [(Identifier,
Vector (Value m) -> m (Either RuntimeError (Value m)))]
-> Map
Identifier (Vector (Value m) -> m (Either RuntimeError (Value m)))
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
[
]
builtinDictAttribs :: Monad m => BuiltinAttribs (Map Scalar (Value m)) m
builtinDictAttribs :: forall (m :: * -> *).
Monad m =>
BuiltinAttribs (Map Scalar (Value m)) m
builtinDictAttribs = [(Identifier,
Map Scalar (Value m) -> m (Either RuntimeError (Value m)))]
-> Map
Identifier
(Map Scalar (Value m) -> m (Either RuntimeError (Value m)))
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
[ (Identifier
"items", ObjectID
-> Maybe ProcedureDoc
-> (Map Scalar (Value m) -> [(Scalar, Value m)])
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Map Scalar (Value m) -> a)
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
dictAttrib
ObjectID
"builtin:dict:items"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"dict.items"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Get a list of key/value pairs from dictionary `value` as a list"
}
)
Map Scalar (Value m) -> [(Scalar, Value m)]
forall k a. Map k a -> [(k, a)]
Map.toList)
, (Identifier
"values", ObjectID
-> Maybe ProcedureDoc
-> (Map Scalar (Value m) -> [Value m])
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Map Scalar (Value m) -> a)
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
dictAttrib
ObjectID
"builtin:dict:values"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"dict.values"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Extract the values from dictionary `value` as a list"
}
)
Map Scalar (Value m) -> [Value m]
forall k a. Map k a -> [a]
Map.elems)
, (Identifier
"keys", ObjectID
-> Maybe ProcedureDoc
-> (Map Scalar (Value m) -> [Scalar])
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Map Scalar (Value m) -> a)
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
dictAttrib
ObjectID
"builtin:dict:keys"
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"dict.keys"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
, procedureDocDescription :: Text
procedureDocDescription = Text
"Get a list of all keys in dict `value`"
}
)
Map Scalar (Value m) -> [Scalar]
forall k a. Map k a -> [k]
Map.keys)
, (Identifier
"get", Procedure m
-> Map Scalar (Value m) -> m (Either RuntimeError (Value m))
forall (m :: * -> *).
Monad m =>
Procedure m
-> Map Scalar (Value m) -> m (Either RuntimeError (Value m))
dictProcAttrib
Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnDictGet)
]
regexModule :: forall m. Monad m => Value m
regexModule :: forall (m :: * -> *). Monad m => Value m
regexModule = [(Scalar, Value m)] -> Value m
forall (m :: * -> *). [(Scalar, Value m)] -> Value m
dictV
[ (Scalar
"match", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnReMatch)
, (Scalar
"matches", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnReMatches)
, (Scalar
"test", Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV Procedure m
forall (m :: * -> *). Monad m => Procedure m
fnReTest)
]
runReWith :: forall a m. Monad m
=> (RE.Regex -> Text -> a)
-> Text
-> Text
-> Text
-> ExceptT RuntimeError m a
runReWith :: forall a (m :: * -> *).
Monad m =>
(Regex -> Text -> a)
-> Text -> Text -> Text -> ExceptT RuntimeError m a
runReWith Regex -> Text -> a
matchFunc Text
regexText Text
haystack Text
optsText = do
let opts :: CompOption
opts = Text -> CompOption
parseCompOpts Text
optsText
let regex :: Regex
regex = CompOption -> ExecOption -> String -> Regex
forall regex compOpt execOpt source.
RegexMaker regex compOpt execOpt source =>
compOpt -> execOpt -> source -> regex
RE.makeRegexOpts CompOption
opts ExecOption
forall regex compOpt execOpt.
RegexOptions regex compOpt execOpt =>
execOpt
RE.defaultExecOpt (Text -> String
Text.unpack Text
regexText)
a -> ExceptT RuntimeError m a
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> ExceptT RuntimeError m a) -> a -> ExceptT RuntimeError m a
forall a b. (a -> b) -> a -> b
$ Regex -> Text -> a
matchFunc Regex
regex Text
haystack
fnReMatch :: forall m. Monad m => Procedure m
fnReMatch :: forall (m :: * -> *). Monad m => Procedure m
fnReMatch = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text -> Text -> Text -> ExceptT RuntimeError m (Maybe [Text]))
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"regex.match"
([Text] -> Text
Text.unlines
[ Text
Item [Text]
"Match a regular expression against a string."
, Text
"Returns an array where the first element is the entire " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"match, and subsequent elements are matches on " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"subexpressions (capture groups)."
]
)
( Identifier
"regex"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"haystack"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"opts"
, Text -> Maybe Text
forall a. a -> Maybe a
Just Text
""
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
((Text -> Text -> Text -> ExceptT RuntimeError m (Maybe [Text]))
-> Procedure m)
-> (Text -> Text -> Text -> ExceptT RuntimeError m (Maybe [Text]))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ (Regex -> Text -> Maybe [Text])
-> Text -> Text -> Text -> ExceptT RuntimeError m (Maybe [Text])
forall a (m :: * -> *).
Monad m =>
(Regex -> Text -> a)
-> Text -> Text -> Text -> ExceptT RuntimeError m a
runReWith (\Regex
r Text
h -> Maybe (Text, MatchText Text, Text) -> Maybe [Text]
convertMatchOnceText (Maybe (Text, MatchText Text, Text) -> Maybe [Text])
-> Maybe (Text, MatchText Text, Text) -> Maybe [Text]
forall a b. (a -> b) -> a -> b
$ Regex -> Text -> Maybe (Text, MatchText Text, Text)
forall regex source.
RegexLike regex source =>
regex -> source -> Maybe (source, MatchText source, source)
RE.matchOnceText Regex
r Text
h)
fnReMatches :: forall m. Monad m => Procedure m
fnReMatches :: forall (m :: * -> *). Monad m => Procedure m
fnReMatches = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text -> Text -> Text -> ExceptT RuntimeError m [[Text]])
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"regex.matches"
([Text] -> Text
Text.unlines
[ Text
Item [Text]
"Match a regular expression against a string."
, Text
"Returns an array of matches, where each match is an " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"array where the first element is the entire match, and " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"subsequent elements are matches on subexpressions " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"(capture groups)."
]
)
( Identifier
"regex"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"haystack"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"opts"
, Text -> Maybe Text
forall a. a -> Maybe a
Just Text
""
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
((Text -> Text -> Text -> ExceptT RuntimeError m [[Text]])
-> Procedure m)
-> (Text -> Text -> Text -> ExceptT RuntimeError m [[Text]])
-> Procedure m
forall a b. (a -> b) -> a -> b
$ (Regex -> Text -> [[Text]])
-> Text -> Text -> Text -> ExceptT RuntimeError m [[Text]]
forall a (m :: * -> *).
Monad m =>
(Regex -> Text -> a)
-> Text -> Text -> Text -> ExceptT RuntimeError m a
runReWith (\Regex
r Text
h -> (MatchText Text -> [Text]) -> [MatchText Text] -> [[Text]]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MatchText Text -> [Text]
convertMatchText ([MatchText Text] -> [[Text]]) -> [MatchText Text] -> [[Text]]
forall a b. (a -> b) -> a -> b
$ Regex -> Text -> [MatchText Text]
forall regex source.
RegexLike regex source =>
regex -> source -> [MatchText source]
RE.matchAllText Regex
r Text
h)
fnReTest :: forall m. Monad m => Procedure m
fnReTest :: forall (m :: * -> *). Monad m => Procedure m
fnReTest = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text -> Text -> Text -> ExceptT RuntimeError m Bool)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"regex.test"
([Text] -> Text
Text.unlines
[ Text
Item [Text]
"Match a regular expression against a string."
, Text
Item [Text]
"Returns true if at least one match exists, false otherwise."
]
)
( Identifier
"regex"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"haystack"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"opts"
, Text -> Maybe Text
forall a. a -> Maybe a
Just Text
""
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
((Text -> Text -> Text -> ExceptT RuntimeError m Bool)
-> Procedure m)
-> (Text -> Text -> Text -> ExceptT RuntimeError m Bool)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ (Regex -> Text -> Bool)
-> Text -> Text -> Text -> ExceptT RuntimeError m Bool
forall a (m :: * -> *).
Monad m =>
(Regex -> Text -> a)
-> Text -> Text -> Text -> ExceptT RuntimeError m a
runReWith (\Regex
r Text
h -> Maybe (Text, MatchText Text, Text) -> Bool
forall a. Maybe a -> Bool
isJust (Maybe (Text, MatchText Text, Text) -> Bool)
-> Maybe (Text, MatchText Text, Text) -> Bool
forall a b. (a -> b) -> a -> b
$ Regex -> Text -> Maybe (Text, MatchText Text, Text)
forall regex source.
RegexLike regex source =>
regex -> source -> Maybe (source, MatchText source, source)
RE.matchOnceText Regex
r Text
h)
parseCompOpts :: Text -> RE.CompOption
parseCompOpts :: Text -> CompOption
parseCompOpts = do
(CompOption -> Char -> CompOption)
-> CompOption -> Text -> CompOption
forall a. (a -> Char -> a) -> a -> Text -> a
Text.foldl'
(\CompOption
x ->
\case
Char
'i' -> CompOption
x { RE.caseSensitive = False }
Char
'm' -> CompOption
x { RE.multiline = True }
Char
_ -> CompOption
x
)
CompOption
forall regex compOpt execOpt.
RegexOptions regex compOpt execOpt =>
compOpt
RE.blankCompOpt
convertMatchOnceText :: Maybe (Text, RE.MatchText Text, Text) -> Maybe [Text]
convertMatchOnceText :: Maybe (Text, MatchText Text, Text) -> Maybe [Text]
convertMatchOnceText Maybe (Text, MatchText Text, Text)
Nothing = Maybe [Text]
forall a. Maybe a
Nothing
convertMatchOnceText (Just (Text
_, MatchText Text
m, Text
_)) = [Text] -> Maybe [Text]
forall a. a -> Maybe a
Just (MatchText Text -> [Text]
convertMatchText MatchText Text
m)
convertMatchText :: RE.MatchText Text -> [Text]
convertMatchText :: MatchText Text -> [Text]
convertMatchText MatchText Text
matches =
((Text, (Int, Int)) -> Text) -> [(Text, (Int, Int))] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (Text, (Int, Int)) -> Text
forall a b. (a, b) -> a
fst ([(Text, (Int, Int))] -> [Text]) -> [(Text, (Int, Int))] -> [Text]
forall a b. (a -> b) -> a -> b
$ MatchText Text -> [(Text, (Int, Int))]
forall i e. Array i e -> [e]
Array.elems MatchText Text
matches
fnLength :: forall m. Monad m => Procedure m
fnLength :: forall (m :: * -> *). Monad m => Procedure m
fnLength = Text
-> Text
-> (Identifier, Maybe (Value m), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Value m -> ExceptT RuntimeError m Int)
-> Procedure m
forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1 Text
"length"
([Text] -> Text
Text.unlines
[ Text
Item [Text]
"Get the length of a string, list, or dictionary."
]
)
( Identifier
"value"
, Maybe (Value m)
forall a. Maybe a
Nothing :: Maybe (Value m)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Vector Text -> TypeDoc
TypeDocAlternatives [ Text
Item (Vector Text)
"string", Text
Item (Vector Text)
"list", Text
Item (Vector Text)
"dict" ]
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int")
((Value m -> ExceptT RuntimeError m Int) -> Procedure m)
-> (Value m -> ExceptT RuntimeError m Int) -> Procedure m
forall a b. (a -> b) -> a -> b
$ \case
StringV Text
s -> Int -> ExceptT RuntimeError m Int
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> ExceptT RuntimeError m Int)
-> Int -> ExceptT RuntimeError m Int
forall a b. (a -> b) -> a -> b
$ Text -> Int
Text.length Text
s
ListV Vector (Value m)
xs -> Int -> ExceptT RuntimeError m Int
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> ExceptT RuntimeError m Int)
-> Int -> ExceptT RuntimeError m Int
forall a b. (a -> b) -> a -> b
$ Vector (Value m) -> Int
forall a. Vector a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length Vector (Value m)
xs
DictV Map Scalar (Value m)
xs -> Int -> ExceptT RuntimeError m Int
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> ExceptT RuntimeError m Int)
-> Int -> ExceptT RuntimeError m Int
forall a b. (a -> b) -> a -> b
$ Map Scalar (Value m) -> Int
forall k a. Map k a -> Int
Map.size Map Scalar (Value m)
xs
Value m
x ->
RuntimeError -> ExceptT RuntimeError m Int
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m Int)
-> RuntimeError -> ExceptT RuntimeError m Int
forall a b. (a -> b) -> a -> b
$
Text -> Text -> Text -> Text -> RuntimeError
ArgumentError
Text
"length"
Text
"value"
Text
"iterable"
(Value m -> Text
forall (m :: * -> *). Value m -> Text
tagNameOf Value m
x)
fnEscape :: forall m. Monad m => Procedure m
fnEscape :: forall (m :: * -> *). Monad m => Procedure m
fnEscape = Text
-> Text
-> (Identifier, Maybe (Value m), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m
-> SomePRNG -> Value m -> ExceptT RuntimeError m (Value m))
-> Procedure m
forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1' Text
"escape"
([Text] -> Text
Text.unlines
[ Text
Item [Text]
"Escape the argument."
]
)
( Identifier
"value"
, Maybe (Value m)
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"encoded")
((Context m
-> SomePRNG -> Value m -> ExceptT RuntimeError m (Value m))
-> Procedure m)
-> (Context m
-> SomePRNG -> Value m -> ExceptT RuntimeError m (Value m))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Context m
ctx SomePRNG
_ Value m
value ->
(forall (m :: * -> *). Encoded -> Value m
EncodedV @m) (Encoded -> Value m)
-> ExceptT RuntimeError m Encoded
-> ExceptT RuntimeError m (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
Context m -> Value m -> ExceptT RuntimeError m Encoded
forall (m :: * -> *) (t :: (* -> *) -> * -> *).
(Monad m, MonadError RuntimeError (t m), MonadTrans t) =>
Context m -> Value m -> t m Encoded
encodeWith Context m
ctx Value m
value
fnToList :: forall m. Monad m => Procedure m
fnToList :: forall (m :: * -> *). Monad m => Procedure m
fnToList = Text
-> Text
-> (Identifier, Maybe (Value m), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Value m -> ExceptT RuntimeError m (Vector (Value m)))
-> Procedure m
forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1 Text
"list"
([Text] -> Text
Text.unlines
[ Text
Item [Text]
"Convert `value` to a list, if possible"
]
)
( Identifier
"value"
, Maybe (Value m)
forall a. Maybe a
Nothing :: Maybe (Value m)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
((Value m -> ExceptT RuntimeError m (Vector (Value m)))
-> Procedure m)
-> (Value m -> ExceptT RuntimeError m (Vector (Value m)))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \case
ListV Vector (Value m)
xs ->
Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector (Value m)
xs
DictV Map Scalar (Value m)
xs ->
Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Value m] -> Vector (Value m)
forall a. [a] -> Vector a
V.fromList ([Value m] -> Vector (Value m)) -> [Value m] -> Vector (Value m)
forall a b. (a -> b) -> a -> b
$ Map Scalar (Value m) -> [Value m]
forall k a. Map k a -> [a]
Map.elems Map Scalar (Value m)
xs)
StringV Text
txt ->
Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m)))
-> Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall a b. (a -> b) -> a -> b
$ (Char -> Value m) -> Vector Char -> Vector (Value m)
forall a b. (a -> b) -> Vector a -> Vector b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (Text -> Value m) -> (Char -> Text) -> Char -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Text
Text.singleton) (Vector Char -> Vector (Value m))
-> (String -> Vector Char) -> String -> Vector (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Vector Char
forall a. [a] -> Vector a
V.fromList (String -> Vector (Value m)) -> String -> Vector (Value m)
forall a b. (a -> b) -> a -> b
$ Text -> String
Text.unpack Text
txt
EncodedV (Encoded Text
txt) ->
Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m)))
-> Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall a b. (a -> b) -> a -> b
$ (Char -> Value m) -> Vector Char -> Vector (Value m)
forall a b. (a -> b) -> Vector a -> Vector b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (Text -> Value m) -> (Char -> Text) -> Char -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Text
Text.singleton) (Vector Char -> Vector (Value m))
-> (String -> Vector Char) -> String -> Vector (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Vector Char
forall a. [a] -> Vector a
V.fromList (String -> Vector (Value m)) -> String -> Vector (Value m)
forall a b. (a -> b) -> a -> b
$ Text -> String
Text.unpack Text
txt
NativeV NativeObject m
obj ->
m (Either RuntimeError (Maybe (Vector (Value m))))
-> ExceptT RuntimeError m (Maybe (Vector (Value m)))
forall (m :: * -> *) (t :: (* -> *) -> * -> *) a.
(Monad m, MonadTrans t, MonadError RuntimeError (t m)) =>
m (Either RuntimeError a) -> t m a
native (Maybe (Vector (Value m))
-> Either RuntimeError (Maybe (Vector (Value m)))
forall a b. b -> Either a b
Right (Maybe (Vector (Value m))
-> Either RuntimeError (Maybe (Vector (Value m))))
-> m (Maybe (Vector (Value m)))
-> m (Either RuntimeError (Maybe (Vector (Value m))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NativeObject m -> m (Maybe (Vector (Value m)))
forall (m :: * -> *).
NativeObject m -> m (Maybe (Vector (Value m)))
nativeObjectAsList NativeObject m
obj) ExceptT RuntimeError m (Maybe (Vector (Value m)))
-> (Maybe (Vector (Value m))
-> ExceptT RuntimeError m (Vector (Value m)))
-> ExceptT RuntimeError m (Vector (Value m))
forall a b.
ExceptT RuntimeError m a
-> (a -> ExceptT RuntimeError m b) -> ExceptT RuntimeError m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
ExceptT RuntimeError m (Vector (Value m))
-> (Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m)))
-> Maybe (Vector (Value m))
-> ExceptT RuntimeError m (Vector (Value m))
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(RuntimeError -> ExceptT RuntimeError m (Vector (Value m))
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m (Vector (Value m)))
-> RuntimeError -> ExceptT RuntimeError m (Vector (Value m))
forall a b. (a -> b) -> a -> b
$
Text -> Text -> Text -> Text -> RuntimeError
ArgumentError
Text
"list"
Text
"value"
Text
"iterable"
Text
"non-iterable native object"
)
Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
BytesV ByteString
bytes ->
Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m)))
-> Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall a b. (a -> b) -> a -> b
$ (Word8 -> Value m) -> Vector Word8 -> Vector (Value m)
forall a b. (a -> b) -> Vector a -> Vector b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word8 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (Vector Word8 -> Vector (Value m))
-> ([Word8] -> Vector Word8) -> [Word8] -> Vector (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> Vector Word8
forall a. [a] -> Vector a
V.fromList ([Word8] -> Vector (Value m)) -> [Word8] -> Vector (Value m)
forall a b. (a -> b) -> a -> b
$ ByteString -> [Word8]
BS.unpack ByteString
bytes
Value m
x -> RuntimeError -> ExceptT RuntimeError m (Vector (Value m))
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m (Vector (Value m)))
-> RuntimeError -> ExceptT RuntimeError m (Vector (Value m))
forall a b. (a -> b) -> a -> b
$
Text -> Text -> Text -> Text -> RuntimeError
ArgumentError
Text
"list"
Text
"value"
Text
"iterable"
(Value m -> Text
forall (m :: * -> *). Value m -> Text
tagNameOf Value m
x)
fnToFloat :: forall m. Monad m => Procedure m
fnToFloat :: forall (m :: * -> *). Monad m => Procedure m
fnToFloat = Text
-> Text
-> (Identifier, Maybe (Value m), Maybe TypeDoc, Text)
-> (Identifier, Maybe Double, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Value m -> Double -> ExceptT RuntimeError m Double)
-> Procedure m
forall (m :: * -> *) a1 a2 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2 Text
"float"
([Text] -> Text
Text.unlines
[ Text
Item [Text]
"Convert `value` to float."
, Text
"If `default` is given, values that cannot be converted " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
" to floats will be replaced with this default value."
]
)
( Identifier
"value"
, Maybe (Value m)
forall a. Maybe a
Nothing :: Maybe (Value m)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"default"
, Double -> Maybe Double
forall a. a -> Maybe a
Just Double
0
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"float")
((Value m -> Double -> ExceptT RuntimeError m Double)
-> Procedure m)
-> (Value m -> Double -> ExceptT RuntimeError m Double)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Value m
value Double
def ->
case Value m
value of
IntV Integer
i -> Double -> ExceptT RuntimeError m Double
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> ExceptT RuntimeError m Double)
-> Double -> ExceptT RuntimeError m Double
forall a b. (a -> b) -> a -> b
$ Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i
BoolV Bool
b -> Double -> ExceptT RuntimeError m Double
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> ExceptT RuntimeError m Double)
-> Double -> ExceptT RuntimeError m Double
forall a b. (a -> b) -> a -> b
$ Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Double) -> Int -> Double
forall a b. (a -> b) -> a -> b
$ Bool -> Int
forall a. Enum a => a -> Int
fromEnum Bool
b
FloatV Double
f -> Double -> ExceptT RuntimeError m Double
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Double
f
Value m
NoneV -> Double -> ExceptT RuntimeError m Double
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Double
0
StringV Text
s ->
Double -> ExceptT RuntimeError m Double
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> ExceptT RuntimeError m Double)
-> (Maybe Double -> Double)
-> Maybe Double
-> ExceptT RuntimeError m Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Maybe Double -> Double
forall a. a -> Maybe a -> a
fromMaybe Double
def (Maybe Double -> ExceptT RuntimeError m Double)
-> Maybe Double -> ExceptT RuntimeError m Double
forall a b. (a -> b) -> a -> b
$ String -> Maybe Double
forall a. Read a => String -> Maybe a
readMaybe (Text -> String
Text.unpack Text
s)
Value m
_ -> Double -> ExceptT RuntimeError m Double
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Double
def
fnToInt :: forall m. Monad m => Procedure m
fnToInt :: forall (m :: * -> *). Monad m => Procedure m
fnToInt = Text
-> Text
-> (Identifier, Maybe (Value m), Maybe TypeDoc, Text)
-> (Identifier, Maybe Integer, Maybe TypeDoc, Text)
-> (Identifier, Maybe Integer, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Value m
-> Integer -> Integer -> ExceptT RuntimeError m Integer)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"int"
([Text] -> Text
Text.unlines
[ Text
Item [Text]
"Convert `value` to int."
, Text
"If `default` is given, values that cannot be converted " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
" to integers will be replaced with this default value."
]
)
( Identifier
"value"
, Maybe (Value m)
forall a. Maybe a
Nothing :: Maybe (Value m)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"default"
, Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
0
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"base"
, Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
10 :: Maybe Integer
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int")
((Value m -> Integer -> Integer -> ExceptT RuntimeError m Integer)
-> Procedure m)
-> (Value m
-> Integer -> Integer -> ExceptT RuntimeError m Integer)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Value m
value Integer
def Integer
_base ->
case Value m
value of
IntV Integer
i -> Integer -> ExceptT RuntimeError m Integer
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Integer
i
BoolV Bool
b -> Integer -> ExceptT RuntimeError m Integer
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Integer -> ExceptT RuntimeError m Integer)
-> Integer -> ExceptT RuntimeError m Integer
forall a b. (a -> b) -> a -> b
$ Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Integer) -> Int -> Integer
forall a b. (a -> b) -> a -> b
$ Bool -> Int
forall a. Enum a => a -> Int
fromEnum Bool
b
FloatV Double
f -> Integer -> ExceptT RuntimeError m Integer
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Integer -> ExceptT RuntimeError m Integer)
-> Integer -> ExceptT RuntimeError m Integer
forall a b. (a -> b) -> a -> b
$ Double -> Integer
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Double
f
Value m
NoneV -> Integer -> ExceptT RuntimeError m Integer
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Integer
0
StringV Text
s ->
Integer -> ExceptT RuntimeError m Integer
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Integer -> ExceptT RuntimeError m Integer)
-> (Maybe Integer -> Integer)
-> Maybe Integer
-> ExceptT RuntimeError m Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Maybe Integer -> Integer
forall a. a -> Maybe a -> a
fromMaybe Integer
def (Maybe Integer -> ExceptT RuntimeError m Integer)
-> Maybe Integer -> ExceptT RuntimeError m Integer
forall a b. (a -> b) -> a -> b
$ String -> Maybe Integer
forall a. Read a => String -> Maybe a
readMaybe (Text -> String
Text.unpack Text
s)
Value m
_ -> Integer -> ExceptT RuntimeError m Integer
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Integer
def
fnToString :: forall m. Monad m => Procedure m
fnToString :: forall (m :: * -> *). Monad m => Procedure m
fnToString = Text
-> Text
-> (Identifier, Maybe (Value m), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Value m -> ExceptT RuntimeError m Text)
-> Procedure m
forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1 Text
"string"
Text
"Convert argument to string"
( Identifier
"value"
, Maybe (Value m)
forall a. Maybe a
Nothing :: Maybe (Value m)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
((Value m -> ExceptT RuntimeError m Text) -> Procedure m)
-> (Value m -> ExceptT RuntimeError m Text) -> Procedure m
forall a b. (a -> b) -> a -> b
$ \Value m
value ->
Value m -> ExceptT RuntimeError m Text
forall (m :: * -> *) (t :: (* -> *) -> * -> *).
(Monad m, MonadError RuntimeError (t m), MonadTrans t) =>
Value m -> t m Text
stringify Value m
value
fnMin :: forall m. Monad m => Procedure m
fnMin :: forall (m :: * -> *). Monad m => Procedure m
fnMin = Text
-> Text
-> (Identifier, Maybe (Vector (Value m)), Maybe TypeDoc, Text)
-> (Identifier, Maybe Bool, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Text), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Vector (Value m)
-> Bool -> Maybe Text -> ExceptT RuntimeError m (Value m))
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"min"
Text
"Get the minimum value from a list"
( Identifier
"value"
, Maybe (Vector (Value m))
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list"
, Text
""
)
( Identifier
"case_sensitive"
, Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool"
, Text
"Treat upper and lowercase strings as distinct."
)
( Identifier
"attr"
, Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just (Maybe Text
forall a. Maybe a
Nothing :: Maybe Text)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
"Get the object with the min value of this attribute."
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just TypeDoc
TypeDocAny)
((Vector (Value m)
-> Bool -> Maybe Text -> ExceptT RuntimeError m (Value m))
-> Procedure m)
-> (Vector (Value m)
-> Bool -> Maybe Text -> ExceptT RuntimeError m (Value m))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Vector (Value m)
xs Bool
caseSensitive Maybe Text
attrMay -> do
let caseProjection :: Value m -> Value m
caseProjection =
if Bool
caseSensitive then
Value m -> Value m
forall a. a -> a
id
else
Value m -> Value m
forall (m :: * -> *). Value m -> Value m
caseFoldValue
attrProjection :: Value m -> ExceptT RuntimeError m (Value m)
attrProjection =
case Maybe Text
attrMay of
Maybe Text
Nothing -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
Just Text
attr -> (Maybe (Value m) -> Value m)
-> ExceptT RuntimeError m (Maybe (Value m))
-> ExceptT RuntimeError m (Value m)
forall a b.
(a -> b) -> ExceptT RuntimeError m a -> ExceptT RuntimeError m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Value m -> Maybe (Value m) -> Value m
forall a. a -> Maybe a -> a
fromMaybe Value m
forall (m :: * -> *). Value m
NoneV) (ExceptT RuntimeError m (Maybe (Value m))
-> ExceptT RuntimeError m (Value m))
-> (Value m -> ExceptT RuntimeError m (Maybe (Value m)))
-> Value m
-> ExceptT RuntimeError m (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m)))
-> (Value m -> m (Either RuntimeError (Maybe (Value m))))
-> Value m
-> ExceptT RuntimeError m (Maybe (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value m
-> Identifier -> m (Either RuntimeError (Maybe (Value m))))
-> Identifier
-> Value m
-> m (Either RuntimeError (Maybe (Value m)))
forall a b c. (a -> b -> c) -> b -> a -> c
flip Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
forall (m :: * -> *).
Monad m =>
Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
getAttrOrItemRaw (Text -> Identifier
Identifier Text
attr)
[Value m]
xs' <- (Value m -> ExceptT RuntimeError m (Value m))
-> [Value m] -> ExceptT RuntimeError m [Value m]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((Value m -> Value m)
-> ExceptT RuntimeError m (Value m)
-> ExceptT RuntimeError m (Value m)
forall a b.
(a -> b) -> ExceptT RuntimeError m a -> ExceptT RuntimeError m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value m -> Value m
forall (m :: * -> *). Value m -> Value m
caseProjection (ExceptT RuntimeError m (Value m)
-> ExceptT RuntimeError m (Value m))
-> (Value m -> ExceptT RuntimeError m (Value m))
-> Value m
-> ExceptT RuntimeError m (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> ExceptT RuntimeError m (Value m)
attrProjection) ([Value m] -> ExceptT RuntimeError m [Value m])
-> [Value m] -> ExceptT RuntimeError m [Value m]
forall a b. (a -> b) -> a -> b
$ Vector (Value m) -> [Value m]
forall a. Vector a -> [a]
V.toList Vector (Value m)
xs
if [Value m] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Value m]
xs' then
Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value m
forall (m :: * -> *). Value m
NoneV
else
Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> ([(Value m, Value m)] -> Value m)
-> [(Value m, Value m)]
-> ExceptT RuntimeError m (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value m, Value m) -> Value m
forall a b. (a, b) -> b
snd ((Value m, Value m) -> Value m)
-> ([(Value m, Value m)] -> (Value m, Value m))
-> [(Value m, Value m)]
-> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Value m, Value m) -> (Value m, Value m) -> Ordering)
-> [(Value m, Value m)] -> (Value m, Value m)
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
minimumBy (\(Value m, Value m)
a (Value m, Value m)
b -> Value m -> Value m -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ((Value m, Value m) -> Value m
forall a b. (a, b) -> a
fst (Value m, Value m)
a) ((Value m, Value m) -> Value m
forall a b. (a, b) -> a
fst (Value m, Value m)
b)) ([(Value m, Value m)] -> ExceptT RuntimeError m (Value m))
-> [(Value m, Value m)] -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ [Value m] -> [Value m] -> [(Value m, Value m)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Value m]
xs' (Vector (Value m) -> [Value m]
forall a. Vector a -> [a]
V.toList Vector (Value m)
xs)
fnMax :: forall m. Monad m => Procedure m
fnMax :: forall (m :: * -> *). Monad m => Procedure m
fnMax = Text
-> Text
-> (Identifier, Maybe (Vector (Value m)), Maybe TypeDoc, Text)
-> (Identifier, Maybe Bool, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Identifier), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Vector (Value m)
-> Bool -> Maybe Identifier -> ExceptT RuntimeError m (Value m))
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"max"
Text
"Get the maximum value from a list"
( Identifier
"value"
, Maybe (Vector (Value m))
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list"
, Text
""
)
( Identifier
"case_sensitive"
, Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool"
, Text
"Treat upper and lowercase strings as distinct."
)
( Identifier
"attr"
, Maybe Identifier -> Maybe (Maybe Identifier)
forall a. a -> Maybe a
Just (Maybe Identifier
forall a. Maybe a
Nothing :: Maybe Identifier)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
"Get the object with the max value of this attribute."
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just TypeDoc
TypeDocAny)
((Vector (Value m)
-> Bool -> Maybe Identifier -> ExceptT RuntimeError m (Value m))
-> Procedure m)
-> (Vector (Value m)
-> Bool -> Maybe Identifier -> ExceptT RuntimeError m (Value m))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Vector (Value m)
xs Bool
caseSensitive Maybe Identifier
attrMay -> do
let caseProjection :: Value m -> Value m
caseProjection =
if Bool
caseSensitive then
Value m -> Value m
forall a. a -> a
id
else
Value m -> Value m
forall (m :: * -> *). Value m -> Value m
caseFoldValue
attrProjection :: Value m -> ExceptT RuntimeError m (Value m)
attrProjection =
case Maybe Identifier
attrMay of
Maybe Identifier
Nothing -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
Just Identifier
attr -> (Maybe (Value m) -> Value m)
-> ExceptT RuntimeError m (Maybe (Value m))
-> ExceptT RuntimeError m (Value m)
forall a b.
(a -> b) -> ExceptT RuntimeError m a -> ExceptT RuntimeError m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Value m -> Maybe (Value m) -> Value m
forall a. a -> Maybe a -> a
fromMaybe Value m
forall (m :: * -> *). Value m
NoneV) (ExceptT RuntimeError m (Maybe (Value m))
-> ExceptT RuntimeError m (Value m))
-> (Value m -> ExceptT RuntimeError m (Maybe (Value m)))
-> Value m
-> ExceptT RuntimeError m (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m)))
-> (Value m -> m (Either RuntimeError (Maybe (Value m))))
-> Value m
-> ExceptT RuntimeError m (Maybe (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value m
-> Identifier -> m (Either RuntimeError (Maybe (Value m))))
-> Identifier
-> Value m
-> m (Either RuntimeError (Maybe (Value m)))
forall a b c. (a -> b -> c) -> b -> a -> c
flip Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
forall (m :: * -> *).
Monad m =>
Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
getAttrOrItemRaw Identifier
attr
[Value m]
xs' <- (Value m -> ExceptT RuntimeError m (Value m))
-> [Value m] -> ExceptT RuntimeError m [Value m]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((Value m -> Value m)
-> ExceptT RuntimeError m (Value m)
-> ExceptT RuntimeError m (Value m)
forall a b.
(a -> b) -> ExceptT RuntimeError m a -> ExceptT RuntimeError m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value m -> Value m
forall (m :: * -> *). Value m -> Value m
caseProjection (ExceptT RuntimeError m (Value m)
-> ExceptT RuntimeError m (Value m))
-> (Value m -> ExceptT RuntimeError m (Value m))
-> Value m
-> ExceptT RuntimeError m (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> ExceptT RuntimeError m (Value m)
attrProjection) ([Value m] -> ExceptT RuntimeError m [Value m])
-> [Value m] -> ExceptT RuntimeError m [Value m]
forall a b. (a -> b) -> a -> b
$ Vector (Value m) -> [Value m]
forall a. Vector a -> [a]
V.toList Vector (Value m)
xs
if [Value m] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Value m]
xs' then
Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value m
forall (m :: * -> *). Value m
NoneV
else
Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> ([(Value m, Value m)] -> Value m)
-> [(Value m, Value m)]
-> ExceptT RuntimeError m (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value m, Value m) -> Value m
forall a b. (a, b) -> b
snd ((Value m, Value m) -> Value m)
-> ([(Value m, Value m)] -> (Value m, Value m))
-> [(Value m, Value m)]
-> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Value m, Value m) -> (Value m, Value m) -> Ordering)
-> [(Value m, Value m)] -> (Value m, Value m)
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
maximumBy (\(Value m, Value m)
a (Value m, Value m)
b -> Value m -> Value m -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ((Value m, Value m) -> Value m
forall a b. (a, b) -> a
fst (Value m, Value m)
a) ((Value m, Value m) -> Value m
forall a b. (a, b) -> a
fst (Value m, Value m)
b)) ([(Value m, Value m)] -> ExceptT RuntimeError m (Value m))
-> [(Value m, Value m)] -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ [Value m] -> [Value m] -> [(Value m, Value m)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Value m]
xs' (Vector (Value m) -> [Value m]
forall a. Vector a -> [a]
V.toList Vector (Value m)
xs)
fnSum :: forall m. Monad m => Procedure m
fnSum :: forall (m :: * -> *). Monad m => Procedure m
fnSum = Text
-> Text
-> (Identifier, Maybe (Vector (Value m)), Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Identifier), Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Int), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Vector (Value m)
-> Maybe Identifier
-> Maybe Int
-> ExceptT RuntimeError m (Value m))
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"sum"
Text
"Get the sum of the values in a list"
( Identifier
"value"
, Maybe (Vector (Value m))
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list"
, Text
""
)
( Identifier
"attr"
, Maybe Identifier -> Maybe (Maybe Identifier)
forall a. a -> Maybe a
Just (Maybe Identifier
forall a. Maybe a
Nothing :: Maybe Identifier)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
"Use this attribute from each object in the list"
)
( Identifier
"start"
, Maybe Int -> Maybe (Maybe Int)
forall a. a -> Maybe a
Just (Maybe Int
forall a. Maybe a
Nothing :: Maybe Int)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int"
, Text
"Start at this offset into the list"
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just TypeDoc
TypeDocAny)
((Vector (Value m)
-> Maybe Identifier
-> Maybe Int
-> ExceptT RuntimeError m (Value m))
-> Procedure m)
-> (Vector (Value m)
-> Maybe Identifier
-> Maybe Int
-> ExceptT RuntimeError m (Value m))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Vector (Value m)
xs Maybe Identifier
attrMay Maybe Int
startMay -> do
let startTransform :: Vector a -> Vector a
startTransform =
case Maybe Int
startMay of
Maybe Int
Nothing -> Vector a -> Vector a
forall a. a -> a
id
Just Int
start -> Int -> Vector a -> Vector a
forall a. Int -> Vector a -> Vector a
V.drop Int
start
attrProjection :: Value m -> ExceptT RuntimeError m (Value m)
attrProjection =
case Maybe Identifier
attrMay of
Maybe Identifier
Nothing -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
Just Identifier
attr -> (Maybe (Value m) -> Value m)
-> ExceptT RuntimeError m (Maybe (Value m))
-> ExceptT RuntimeError m (Value m)
forall a b.
(a -> b) -> ExceptT RuntimeError m a -> ExceptT RuntimeError m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Value m -> Maybe (Value m) -> Value m
forall a. a -> Maybe a -> a
fromMaybe Value m
forall (m :: * -> *). Value m
NoneV) (ExceptT RuntimeError m (Maybe (Value m))
-> ExceptT RuntimeError m (Value m))
-> (Value m -> ExceptT RuntimeError m (Maybe (Value m)))
-> Value m
-> ExceptT RuntimeError m (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m)))
-> (Value m -> m (Either RuntimeError (Maybe (Value m))))
-> Value m
-> ExceptT RuntimeError m (Maybe (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value m
-> Identifier -> m (Either RuntimeError (Maybe (Value m))))
-> Identifier
-> Value m
-> m (Either RuntimeError (Maybe (Value m)))
forall a b c. (a -> b -> c) -> b -> a -> c
flip Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
forall (m :: * -> *).
Monad m =>
Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
getAttrOrItemRaw Identifier
attr
[Value m]
xs' <- (Value m -> ExceptT RuntimeError m (Value m))
-> [Value m] -> ExceptT RuntimeError m [Value m]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Value m -> ExceptT RuntimeError m (Value m)
attrProjection ([Value m] -> ExceptT RuntimeError m [Value m])
-> (Vector (Value m) -> [Value m])
-> Vector (Value m)
-> ExceptT RuntimeError m [Value m]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector (Value m) -> [Value m]
forall a. Vector a -> [a]
V.toList (Vector (Value m) -> [Value m])
-> (Vector (Value m) -> Vector (Value m))
-> Vector (Value m)
-> [Value m]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector (Value m) -> Vector (Value m)
forall {a}. Vector a -> Vector a
startTransform (Vector (Value m) -> ExceptT RuntimeError m [Value m])
-> Vector (Value m) -> ExceptT RuntimeError m [Value m]
forall a b. (a -> b) -> a -> b
$ Vector (Value m)
xs
Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> ([Value m] -> Value m)
-> [Value m]
-> ExceptT RuntimeError m (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Value m] -> Value m
forall (m :: * -> *). [Value m] -> Value m
valueSum ([Value m] -> ExceptT RuntimeError m (Value m))
-> [Value m] -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ [Value m]
xs'
valueSum :: [Value m] -> Value m
valueSum :: forall (m :: * -> *). [Value m] -> Value m
valueSum = (Value m -> Value m -> Value m) -> Value m -> [Value m] -> Value m
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' Value m -> Value m -> Value m
forall (m :: * -> *). Value m -> Value m -> Value m
valueAdd Value m
forall (m :: * -> *). Value m
NoneV
valueAdd :: Value m -> Value m -> Value m
valueAdd :: forall (m :: * -> *). Value m -> Value m -> Value m
valueAdd (IntV Integer
a) (IntV Integer
b) = Integer -> Value m
forall (m :: * -> *). Integer -> Value m
IntV (Integer
a Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
b)
valueAdd Value m
NoneV Value m
x = Value m
x
valueAdd Value m
x Value m
NoneV = Value m
x
valueAdd (FloatV Double
x) (FloatV Double
y) = Double -> Value m
forall (m :: * -> *). Double -> Value m
FloatV (Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
y)
valueAdd Value m
x Value m
y = Double -> Value m
forall (m :: * -> *). Double -> Value m
FloatV (Double -> Value m -> Double
forall (m :: * -> *). Double -> Value m -> Double
asFloatValLenient Double
0 Value m
x Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double -> Value m -> Double
forall (m :: * -> *). Double -> Value m -> Double
asFloatValLenient Double
0 Value m
y)
caseFoldValue :: Value m -> Value m
caseFoldValue :: forall (m :: * -> *). Value m -> Value m
caseFoldValue (StringV Text
t) = Text -> Value m
forall (m :: * -> *). Text -> Value m
StringV (Text -> Text
Text.toCaseFold Text
t)
caseFoldValue (EncodedV (Encoded Text
t)) = Encoded -> Value m
forall (m :: * -> *). Encoded -> Value m
EncodedV (Text -> Encoded
Encoded (Text -> Text
Text.toCaseFold Text
t))
caseFoldValue Value m
x = Value m
x
fnRandom :: forall m. Monad m => Procedure m
fnRandom :: forall (m :: * -> *). Monad m => Procedure m
fnRandom = Text
-> Text
-> (Identifier, Maybe (Vector (Value m)), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m
-> SomePRNG
-> Vector (Value m)
-> ExceptT RuntimeError m (Value m))
-> Procedure m
forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1' Text
"random"
Text
"Pick a random element from a list"
( Identifier
"value"
, Maybe (Vector (Value m))
forall a. Maybe a
Nothing :: Maybe (Vector (Value m))
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list"
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny)
((Context m
-> SomePRNG
-> Vector (Value m)
-> ExceptT RuntimeError m (Value m))
-> Procedure m)
-> (Context m
-> SomePRNG
-> Vector (Value m)
-> ExceptT RuntimeError m (Value m))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Context m
_ctx SomePRNG
rng Vector (Value m)
xs -> do
if Vector (Value m) -> Bool
forall a. Vector a -> Bool
V.null Vector (Value m)
xs then
Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value m
forall (m :: * -> *). Value m
NoneV
else do
let (Int
i, SomePRNG
_) = (Int, Int) -> SomePRNG -> (Int, SomePRNG)
forall a g. (UniformRange a, RandomGen g) => (a, a) -> g -> (a, g)
uniformR (Int
0, Vector (Value m) -> Int
forall a. Vector a -> Int
V.length Vector (Value m)
xs Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) SomePRNG
rng
Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> Value m -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ Vector (Value m)
xs Vector (Value m) -> Int -> Value m
forall a. Vector a -> Int -> a
V.! Int
i
fnReverse :: forall m. Monad m => Procedure m
fnReverse :: forall (m :: * -> *). Monad m => Procedure m
fnReverse = Text
-> Text
-> (Identifier, Maybe (Either Text (Vector (Value m))),
Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Either Text (Vector (Value m))
-> ExceptT RuntimeError m (Value m))
-> Procedure m
forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1 Text
"reverse"
Text
"Reverse a list or string"
( Identifier
"value"
, Maybe (Either Text (Vector (Value m)))
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Vector Text -> TypeDoc
TypeDocAlternatives [ Text
Item (Vector Text)
"list", Text
Item (Vector Text)
"string" ]
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Vector Text -> TypeDoc
TypeDocAlternatives [ Text
Item (Vector Text)
"list", Text
Item (Vector Text)
"string" ])
((Either Text (Vector (Value m))
-> ExceptT RuntimeError m (Value m))
-> Procedure m)
-> (Either Text (Vector (Value m))
-> ExceptT RuntimeError m (Value m))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \case
Left Text
t -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> Value m -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ Text -> Value m
forall (m :: * -> *). Text -> Value m
StringV (Text -> Text
Text.reverse Text
t)
Right Vector (Value m)
xs -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> Value m -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ Vector (Value m) -> Value m
forall (m :: * -> *). Vector (Value m) -> Value m
ListV (Vector (Value m) -> Vector (Value m)
forall {a}. Vector a -> Vector a
V.reverse (Vector (Value m)
xs :: Vector (Value m)))
fnItems :: forall m. Monad m => Procedure m
fnItems :: forall (m :: * -> *). Monad m => Procedure m
fnItems = Text
-> Text
-> (Identifier, Maybe (Map Scalar (Value m)), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Map Scalar (Value m)
-> ExceptT RuntimeError m [(Scalar, Value m)])
-> Procedure m
forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1 Text
"items"
Text
"Convert a dict to a list of its elements without the keys."
( Identifier
"value"
, Maybe (Map Scalar (Value m))
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"dict"
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
((Map Scalar (Value m)
-> ExceptT RuntimeError m [(Scalar, Value m)])
-> Procedure m)
-> (Map Scalar (Value m)
-> ExceptT RuntimeError m [(Scalar, Value m)])
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Map Scalar (Value m)
value ->
[(Scalar, Value m)] -> ExceptT RuntimeError m [(Scalar, Value m)]
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Map Scalar (Value m) -> [(Scalar, Value m)]
forall k a. Map k a -> [(k, a)]
Map.toAscList Map Scalar (Value m)
value :: [(Scalar, Value m)])
data DictSortBy
= ByKey
| ByValue
deriving (Int -> DictSortBy -> ShowS
[DictSortBy] -> ShowS
DictSortBy -> String
(Int -> DictSortBy -> ShowS)
-> (DictSortBy -> String)
-> ([DictSortBy] -> ShowS)
-> Show DictSortBy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DictSortBy -> ShowS
showsPrec :: Int -> DictSortBy -> ShowS
$cshow :: DictSortBy -> String
show :: DictSortBy -> String
$cshowList :: [DictSortBy] -> ShowS
showList :: [DictSortBy] -> ShowS
Show, ReadPrec [DictSortBy]
ReadPrec DictSortBy
Int -> ReadS DictSortBy
ReadS [DictSortBy]
(Int -> ReadS DictSortBy)
-> ReadS [DictSortBy]
-> ReadPrec DictSortBy
-> ReadPrec [DictSortBy]
-> Read DictSortBy
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DictSortBy
readsPrec :: Int -> ReadS DictSortBy
$creadList :: ReadS [DictSortBy]
readList :: ReadS [DictSortBy]
$creadPrec :: ReadPrec DictSortBy
readPrec :: ReadPrec DictSortBy
$creadListPrec :: ReadPrec [DictSortBy]
readListPrec :: ReadPrec [DictSortBy]
Read, DictSortBy -> DictSortBy -> Bool
(DictSortBy -> DictSortBy -> Bool)
-> (DictSortBy -> DictSortBy -> Bool) -> Eq DictSortBy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DictSortBy -> DictSortBy -> Bool
== :: DictSortBy -> DictSortBy -> Bool
$c/= :: DictSortBy -> DictSortBy -> Bool
/= :: DictSortBy -> DictSortBy -> Bool
Eq, Eq DictSortBy
Eq DictSortBy =>
(DictSortBy -> DictSortBy -> Ordering)
-> (DictSortBy -> DictSortBy -> Bool)
-> (DictSortBy -> DictSortBy -> Bool)
-> (DictSortBy -> DictSortBy -> Bool)
-> (DictSortBy -> DictSortBy -> Bool)
-> (DictSortBy -> DictSortBy -> DictSortBy)
-> (DictSortBy -> DictSortBy -> DictSortBy)
-> Ord DictSortBy
DictSortBy -> DictSortBy -> Bool
DictSortBy -> DictSortBy -> Ordering
DictSortBy -> DictSortBy -> DictSortBy
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DictSortBy -> DictSortBy -> Ordering
compare :: DictSortBy -> DictSortBy -> Ordering
$c< :: DictSortBy -> DictSortBy -> Bool
< :: DictSortBy -> DictSortBy -> Bool
$c<= :: DictSortBy -> DictSortBy -> Bool
<= :: DictSortBy -> DictSortBy -> Bool
$c> :: DictSortBy -> DictSortBy -> Bool
> :: DictSortBy -> DictSortBy -> Bool
$c>= :: DictSortBy -> DictSortBy -> Bool
>= :: DictSortBy -> DictSortBy -> Bool
$cmax :: DictSortBy -> DictSortBy -> DictSortBy
max :: DictSortBy -> DictSortBy -> DictSortBy
$cmin :: DictSortBy -> DictSortBy -> DictSortBy
min :: DictSortBy -> DictSortBy -> DictSortBy
Ord, Int -> DictSortBy
DictSortBy -> Int
DictSortBy -> [DictSortBy]
DictSortBy -> DictSortBy
DictSortBy -> DictSortBy -> [DictSortBy]
DictSortBy -> DictSortBy -> DictSortBy -> [DictSortBy]
(DictSortBy -> DictSortBy)
-> (DictSortBy -> DictSortBy)
-> (Int -> DictSortBy)
-> (DictSortBy -> Int)
-> (DictSortBy -> [DictSortBy])
-> (DictSortBy -> DictSortBy -> [DictSortBy])
-> (DictSortBy -> DictSortBy -> [DictSortBy])
-> (DictSortBy -> DictSortBy -> DictSortBy -> [DictSortBy])
-> Enum DictSortBy
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: DictSortBy -> DictSortBy
succ :: DictSortBy -> DictSortBy
$cpred :: DictSortBy -> DictSortBy
pred :: DictSortBy -> DictSortBy
$ctoEnum :: Int -> DictSortBy
toEnum :: Int -> DictSortBy
$cfromEnum :: DictSortBy -> Int
fromEnum :: DictSortBy -> Int
$cenumFrom :: DictSortBy -> [DictSortBy]
enumFrom :: DictSortBy -> [DictSortBy]
$cenumFromThen :: DictSortBy -> DictSortBy -> [DictSortBy]
enumFromThen :: DictSortBy -> DictSortBy -> [DictSortBy]
$cenumFromTo :: DictSortBy -> DictSortBy -> [DictSortBy]
enumFromTo :: DictSortBy -> DictSortBy -> [DictSortBy]
$cenumFromThenTo :: DictSortBy -> DictSortBy -> DictSortBy -> [DictSortBy]
enumFromThenTo :: DictSortBy -> DictSortBy -> DictSortBy -> [DictSortBy]
Enum, DictSortBy
DictSortBy -> DictSortBy -> Bounded DictSortBy
forall a. a -> a -> Bounded a
$cminBound :: DictSortBy
minBound :: DictSortBy
$cmaxBound :: DictSortBy
maxBound :: DictSortBy
Bounded)
instance ToValue DictSortBy m where
toValue :: DictSortBy -> Value m
toValue DictSortBy
ByKey = Text -> Value m
forall (m :: * -> *). Text -> Value m
StringV Text
"key"
toValue DictSortBy
ByValue = Text -> Value m
forall (m :: * -> *). Text -> Value m
StringV Text
"value"
instance (Monad m) => FromValue DictSortBy m where
fromValue :: Value m -> m (Either RuntimeError DictSortBy)
fromValue (StringV Text
"key") = Either RuntimeError DictSortBy
-> m (Either RuntimeError DictSortBy)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError DictSortBy
-> m (Either RuntimeError DictSortBy))
-> (DictSortBy -> Either RuntimeError DictSortBy)
-> DictSortBy
-> m (Either RuntimeError DictSortBy)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DictSortBy -> Either RuntimeError DictSortBy
forall a b. b -> Either a b
Right (DictSortBy -> m (Either RuntimeError DictSortBy))
-> DictSortBy -> m (Either RuntimeError DictSortBy)
forall a b. (a -> b) -> a -> b
$ DictSortBy
ByKey
fromValue (StringV Text
"value") = Either RuntimeError DictSortBy
-> m (Either RuntimeError DictSortBy)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError DictSortBy
-> m (Either RuntimeError DictSortBy))
-> (DictSortBy -> Either RuntimeError DictSortBy)
-> DictSortBy
-> m (Either RuntimeError DictSortBy)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DictSortBy -> Either RuntimeError DictSortBy
forall a b. b -> Either a b
Right (DictSortBy -> m (Either RuntimeError DictSortBy))
-> DictSortBy -> m (Either RuntimeError DictSortBy)
forall a b. (a -> b) -> a -> b
$ DictSortBy
ByValue
fromValue (StringV Text
x) = Either RuntimeError DictSortBy
-> m (Either RuntimeError DictSortBy)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError DictSortBy
-> m (Either RuntimeError DictSortBy))
-> (RuntimeError -> Either RuntimeError DictSortBy)
-> RuntimeError
-> m (Either RuntimeError DictSortBy)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RuntimeError -> Either RuntimeError DictSortBy
forall a b. a -> Either a b
Left (RuntimeError -> m (Either RuntimeError DictSortBy))
-> RuntimeError -> m (Either RuntimeError DictSortBy)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Text -> RuntimeError
TagError Text
"conversion to dictsort target" Text
"'key' or 'value'" (Text
"string " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text -> Text
forall a. Show a => a -> Text
Text.show Text
x)
fromValue Value m
x = Either RuntimeError DictSortBy
-> m (Either RuntimeError DictSortBy)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError DictSortBy
-> m (Either RuntimeError DictSortBy))
-> (RuntimeError -> Either RuntimeError DictSortBy)
-> RuntimeError
-> m (Either RuntimeError DictSortBy)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RuntimeError -> Either RuntimeError DictSortBy
forall a b. a -> Either a b
Left (RuntimeError -> m (Either RuntimeError DictSortBy))
-> RuntimeError -> m (Either RuntimeError DictSortBy)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Text -> RuntimeError
TagError Text
"conversion to dictsort target" Text
"string" (Value m -> Text
forall (m :: * -> *). Value m -> Text
tagNameOf Value m
x)
fnSort :: forall m. Monad m => Procedure m
fnSort :: forall (m :: * -> *). Monad m => Procedure m
fnSort = Text
-> Text
-> (Identifier, Maybe [Value m], Maybe TypeDoc, Text)
-> (Identifier, Maybe Bool, Maybe TypeDoc, Text)
-> (Identifier, Maybe Bool, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe (Value m)), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> ([Value m]
-> Bool
-> Bool
-> Maybe (Value m)
-> ExceptT RuntimeError m [Value m])
-> Procedure m
forall (m :: * -> *) a1 a2 a3 a4 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue a4 m,
FromValue a4 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4 Text
"sort"
Text
""
( Identifier
"value"
, Maybe [Value m]
forall a. Maybe a
Nothing :: Maybe [Value m]
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list"
, Text
""
)
( Identifier
"reverse"
, Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool"
, Text
""
)
( Identifier
"case_sensitive"
, Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool"
, Text
""
)
( Identifier
"attribute"
, Maybe (Value m) -> Maybe (Maybe (Value m))
forall a. a -> Maybe a
Just Maybe (Value m)
forall a. Maybe a
Nothing :: Maybe (Maybe (Value m))
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
(([Value m]
-> Bool
-> Bool
-> Maybe (Value m)
-> ExceptT RuntimeError m [Value m])
-> Procedure m)
-> ([Value m]
-> Bool
-> Bool
-> Maybe (Value m)
-> ExceptT RuntimeError m [Value m])
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \[Value m]
value Bool
reverseSort Bool
caseSensitive Maybe (Value m)
attributeMay -> do
let cmp :: (Text, b) -> (Text, b) -> Ordering
cmp (Text, b)
a (Text, b)
b = if Bool
caseSensitive then
Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ((Text, b) -> Text
forall a b. (a, b) -> a
fst (Text, b)
a) ((Text, b) -> Text
forall a b. (a, b) -> a
fst (Text, b)
b)
else
Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Text -> Text
Text.toCaseFold ((Text, b) -> Text
forall a b. (a, b) -> a
fst (Text, b)
a)) (Text -> Text
Text.toCaseFold ((Text, b) -> Text
forall a b. (a, b) -> a
fst (Text, b)
b))
cmp' :: (Text, b) -> (Text, b) -> Ordering
cmp' = if Bool
reverseSort then ((Text, b) -> (Text, b) -> Ordering)
-> (Text, b) -> (Text, b) -> Ordering
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Text, b) -> (Text, b) -> Ordering
forall {b} {b}. (Text, b) -> (Text, b) -> Ordering
cmp else (Text, b) -> (Text, b) -> Ordering
forall {b} {b}. (Text, b) -> (Text, b) -> Ordering
cmp
proj :: Value m -> t m (Text, Value m)
proj Value m
x = do
Text
sk <- case Maybe (Value m)
attributeMay of
Maybe (Value m)
Nothing ->
Value m -> t m Text
forall (m :: * -> *) (t :: (* -> *) -> * -> *).
(Monad m, MonadError RuntimeError (t m), MonadTrans t) =>
Value m -> t m Text
stringify Value m
x
Just Value m
a -> do
Value m
v <- (Maybe (Value m) -> Value m)
-> t m (Maybe (Value m)) -> t m (Value m)
forall a b. (a -> b) -> t m a -> t m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Value m -> Maybe (Value m) -> Value m
forall a. a -> Maybe a -> a
fromMaybe Value m
forall (m :: * -> *). Value m
NoneV) (t m (Maybe (Value m)) -> t m (Value m))
-> t m (Maybe (Value m)) -> t m (Value m)
forall a b. (a -> b) -> a -> b
$ m (Either RuntimeError (Maybe (Value m))) -> t m (Maybe (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Maybe (Value m)))
-> t m (Maybe (Value m)))
-> m (Either RuntimeError (Maybe (Value m)))
-> t m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> Value m -> m (Either RuntimeError (Maybe (Value m)))
forall (m :: * -> *).
Monad m =>
Value m -> Value m -> m (Either RuntimeError (Maybe (Value m)))
getItemOrAttrRaw Value m
x Value m
a
Value m -> t m Text
forall (m :: * -> *) (t :: (* -> *) -> * -> *).
(Monad m, MonadError RuntimeError (t m), MonadTrans t) =>
Value m -> t m Text
stringify Value m
v
(Text, Value m) -> t m (Text, Value m)
forall a. a -> t m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text
sk, Value m
x)
([(Text, Value m)]
items' :: [(Text, Value m)]) <- (Value m -> ExceptT RuntimeError m (Text, Value m))
-> [Value m] -> ExceptT RuntimeError m [(Text, Value m)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Value m -> ExceptT RuntimeError m (Text, Value m)
forall {t :: (* -> *) -> * -> *}.
(MonadError RuntimeError (t m), MonadTrans t) =>
Value m -> t m (Text, Value m)
proj [Value m]
value
[Value m] -> ExceptT RuntimeError m [Value m]
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Value m] -> ExceptT RuntimeError m [Value m])
-> [Value m] -> ExceptT RuntimeError m [Value m]
forall a b. (a -> b) -> a -> b
$ ((Text, Value m) -> Value m) -> [(Text, Value m)] -> [Value m]
forall a b. (a -> b) -> [a] -> [b]
map (Text, Value m) -> Value m
forall a b. (a, b) -> b
snd ([(Text, Value m)] -> [Value m]) -> [(Text, Value m)] -> [Value m]
forall a b. (a -> b) -> a -> b
$ ((Text, Value m) -> (Text, Value m) -> Ordering)
-> [(Text, Value m)] -> [(Text, Value m)]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (Text, Value m) -> (Text, Value m) -> Ordering
forall {b} {b}. (Text, b) -> (Text, b) -> Ordering
cmp' [(Text, Value m)]
items'
fnDictsort :: forall m. Monad m => Procedure m
fnDictsort :: forall (m :: * -> *). Monad m => Procedure m
fnDictsort = Text
-> Text
-> (Identifier, Maybe (Map Scalar (Value m)), Maybe TypeDoc, Text)
-> (Identifier, Maybe Bool, Maybe TypeDoc, Text)
-> (Identifier, Maybe DictSortBy, Maybe TypeDoc, Text)
-> (Identifier, Maybe Bool, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Map Scalar (Value m)
-> Bool
-> DictSortBy
-> Bool
-> ExceptT RuntimeError m [(Scalar, Value m)])
-> Procedure m
forall (m :: * -> *) a1 a2 a3 a4 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue a4 m,
FromValue a4 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4 Text
"dictsort"
Text
"Sort a dict, returning a list of key-value pairs."
( Identifier
"value"
, Maybe (Map Scalar (Value m))
forall a. Maybe a
Nothing :: Maybe (Map Scalar (Value m))
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"dict"
, Text
""
)
( Identifier
"case_sensitive"
, Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool"
, Text
""
)
( Identifier
"by"
, DictSortBy -> Maybe DictSortBy
forall a. a -> Maybe a
Just DictSortBy
ByKey
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
"One of 'key', 'value'"
)
( Identifier
"reverse"
, Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool"
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
((Map Scalar (Value m)
-> Bool
-> DictSortBy
-> Bool
-> ExceptT RuntimeError m [(Scalar, Value m)])
-> Procedure m)
-> (Map Scalar (Value m)
-> Bool
-> DictSortBy
-> Bool
-> ExceptT RuntimeError m [(Scalar, Value m)])
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Map Scalar (Value m)
value Bool
caseSensitive DictSortBy
by Bool
reverseSort -> do
let cmp :: (Text, b) -> (Text, b) -> Ordering
cmp (Text, b)
a (Text, b)
b = if Bool
caseSensitive then
Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ((Text, b) -> Text
forall a b. (a, b) -> a
fst (Text, b)
a) ((Text, b) -> Text
forall a b. (a, b) -> a
fst (Text, b)
b)
else
Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Text -> Text
Text.toCaseFold ((Text, b) -> Text
forall a b. (a, b) -> a
fst (Text, b)
a)) (Text -> Text
Text.toCaseFold ((Text, b) -> Text
forall a b. (a, b) -> a
fst (Text, b)
b))
cmp' :: (Text, b) -> (Text, b) -> Ordering
cmp' = if Bool
reverseSort then ((Text, b) -> (Text, b) -> Ordering)
-> (Text, b) -> (Text, b) -> Ordering
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Text, b) -> (Text, b) -> Ordering
forall {b} {b}. (Text, b) -> (Text, b) -> Ordering
cmp else (Text, b) -> (Text, b) -> Ordering
forall {b} {b}. (Text, b) -> (Text, b) -> Ordering
cmp
proj :: (Scalar, Value m) -> t m (Text, (Scalar, Value m))
proj (Scalar
k, Value m
v) = do
Text
sk <- case DictSortBy
by of
DictSortBy
ByKey ->
case Scalar
k of
StringScalar Text
s -> Text -> t m Text
forall a. a -> t m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
s
IntScalar Integer
i -> Text -> t m Text
forall a. a -> t m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> t m Text) -> Text -> t m Text
forall a b. (a -> b) -> a -> b
$ Integer -> Text
forall a. Show a => a -> Text
Text.show Integer
i
FloatScalar Double
f -> Text -> t m Text
forall a. a -> t m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> t m Text) -> Text -> t m Text
forall a b. (a -> b) -> a -> b
$ Double -> Text
forall a. Show a => a -> Text
Text.show Double
f
Scalar
NoneScalar -> Text -> t m Text
forall a. a -> t m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
""
BoolScalar Bool
b -> Text -> t m Text
forall a. a -> t m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> t m Text) -> (Text -> Text) -> Text -> t m Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
Text.toLower (Text -> t m Text) -> Text -> t m Text
forall a b. (a -> b) -> a -> b
$ Bool -> Text
forall a. Show a => a -> Text
Text.show Bool
b
EncodedScalar (Encoded Text
e) -> Text -> t m Text
forall a. a -> t m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
e
BytesScalar ByteString
bs -> Text -> t m Text
forall a. a -> t m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> t m Text) -> Text -> t m Text
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
Text.decodeUtf8 ByteString
bs
DictSortBy
ByValue ->
Value m -> t m Text
forall (m :: * -> *) (t :: (* -> *) -> * -> *).
(Monad m, MonadError RuntimeError (t m), MonadTrans t) =>
Value m -> t m Text
stringify Value m
v
(Text, (Scalar, Value m)) -> t m (Text, (Scalar, Value m))
forall a. a -> t m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text
sk, (Scalar
k, Value m
v))
itemsRaw :: [(Scalar, Value m)]
itemsRaw = Map Scalar (Value m) -> [(Scalar, Value m)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Scalar (Value m)
value
[(Text, (Scalar, Value m))]
items' <- ((Scalar, Value m)
-> ExceptT RuntimeError m (Text, (Scalar, Value m)))
-> [(Scalar, Value m)]
-> ExceptT RuntimeError m [(Text, (Scalar, Value m))]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (Scalar, Value m)
-> ExceptT RuntimeError m (Text, (Scalar, Value m))
forall {m :: * -> *} {t :: (* -> *) -> * -> *}.
(Monad m, MonadError RuntimeError (t m), MonadTrans t) =>
(Scalar, Value m) -> t m (Text, (Scalar, Value m))
proj [(Scalar, Value m)]
itemsRaw
[(Scalar, Value m)] -> ExceptT RuntimeError m [(Scalar, Value m)]
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([(Scalar, Value m)] -> ExceptT RuntimeError m [(Scalar, Value m)])
-> [(Scalar, Value m)]
-> ExceptT RuntimeError m [(Scalar, Value m)]
forall a b. (a -> b) -> a -> b
$ ((Text, (Scalar, Value m)) -> (Scalar, Value m))
-> [(Text, (Scalar, Value m))] -> [(Scalar, Value m)]
forall a b. (a -> b) -> [a] -> [b]
map (Text, (Scalar, Value m)) -> (Scalar, Value m)
forall a b. (a, b) -> b
snd ([(Text, (Scalar, Value m))] -> [(Scalar, Value m)])
-> [(Text, (Scalar, Value m))] -> [(Scalar, Value m)]
forall a b. (a -> b) -> a -> b
$ ((Text, (Scalar, Value m))
-> (Text, (Scalar, Value m)) -> Ordering)
-> [(Text, (Scalar, Value m))] -> [(Text, (Scalar, Value m))]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (Text, (Scalar, Value m)) -> (Text, (Scalar, Value m)) -> Ordering
forall {b} {b}. (Text, b) -> (Text, b) -> Ordering
cmp' [(Text, (Scalar, Value m))]
items'
fnSelect :: forall m. Monad m
=> (Expr -> GingerT m (Value m))
-> Filter m
fnSelect :: forall (m :: * -> *).
Monad m =>
(Expr -> GingerT m (Value m)) -> Filter m
fnSelect = Bool -> Text -> Text -> (Expr -> GingerT m (Value m)) -> Filter m
forall (m :: * -> *).
Monad m =>
Bool -> Text -> Text -> (Expr -> GingerT m (Value m)) -> Filter m
fnSelectReject Bool
False Text
"select" Text
"select"
fnReject :: forall m. Monad m
=> (Expr -> GingerT m (Value m))
-> Filter m
fnReject :: forall (m :: * -> *).
Monad m =>
(Expr -> GingerT m (Value m)) -> Filter m
fnReject = Bool -> Text -> Text -> (Expr -> GingerT m (Value m)) -> Filter m
forall (m :: * -> *).
Monad m =>
Bool -> Text -> Text -> (Expr -> GingerT m (Value m)) -> Filter m
fnSelectReject Bool
True Text
"reject" Text
"reject"
fnSelectReject :: forall m. Monad m
=> Bool
-> Text
-> Text
-> (Expr -> GingerT m (Value m))
-> Filter m
fnSelectReject :: forall (m :: * -> *).
Monad m =>
Bool -> Text -> Text -> (Expr -> GingerT m (Value m)) -> Filter m
fnSelectReject Bool
invert Text
procName Text
procDescName Expr -> GingerT m (Value m)
evalE =
Maybe ProcedureDoc -> FilterFunc m -> Filter m
forall (m :: * -> *).
Maybe ProcedureDoc -> FilterFunc m -> Filter m
NativeFilter
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName =
Text
procName
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"value"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
Maybe Text
forall a. Maybe a
Nothing
Text
""
, Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"filter"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Vector Text -> TypeDoc
TypeDocAlternatives [ Text
Item (Vector Text)
"string", Text
Item (Vector Text)
"filter", Text
Item (Vector Text)
"test", Text
Item (Vector Text)
"procedure" ])
(Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"none")
( Text
"A filter or test to apply to each element to determine " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"whether to " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
procDescName Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" it or not."
)
, Text -> Maybe TypeDoc -> Maybe Text -> Text -> ArgumentDoc
ArgumentDoc
Text
"attribute"
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Vector Text -> TypeDoc
TypeDocAlternatives [ Text
Item (Vector Text)
"string", Text
Item (Vector Text)
"none" ])
(Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"none")
( Text
"If specified, the name of an attribute to extract from each " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"element for testing.\n" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"This argument can only be passed by keyword, not positionally."
)
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = (TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
, procedureDocDescription :: Text
procedureDocDescription = [Text] -> Text
Text.unlines
[ Text -> Text
Text.toTitle Text
procDescName Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" by a test or filter, and/or an attribute."
]
}
) (FilterFunc m -> Filter m) -> FilterFunc m -> Filter m
forall a b. (a -> b) -> a -> b
$
\Expr
scrutineeE [(Maybe Identifier, Value m)]
args Context m
ctx Env m
env SomePRNG
rng -> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m)))
-> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ do
let funcName :: Text
funcName = Text
"select"
Map Identifier (Value m)
argValues <- Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m)))
-> Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall a b. (a -> b) -> a -> b
$
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
forall (m :: * -> *).
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
resolveArgs
Text
funcName
[]
[(Maybe Identifier, Value m)]
args
[Value m]
varargs <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m [Value m]
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
"varargs" Map Identifier (Value m)
argValues
(Map Scalar (Value m)
kwargs :: Map Scalar (Value m)) <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m (Map Scalar (Value m))
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
"kwargs" Map Identifier (Value m)
argValues
(Value m
scrutinee :: Value m) <- m (Either RuntimeError (Value m))
-> ExceptT RuntimeError m (Value m)
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Value m))
-> ExceptT RuntimeError m (Value m))
-> m (Either RuntimeError (Value m))
-> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$
GingerT m (Value m)
-> Context m
-> Env m
-> SomePRNG
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) g a.
(Monad m, SplitGen g) =>
GingerT m a -> Context m -> Env m -> g -> m (Either RuntimeError a)
runGingerT (Expr -> GingerT m (Value m)
evalE Expr
scrutineeE) Context m
ctx Env m
env SomePRNG
rng
(Vector (Value m)
xs :: Vector (Value m)) <- m (Either RuntimeError (Vector (Value m)))
-> ExceptT RuntimeError m (Vector (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Vector (Value m)))
-> ExceptT RuntimeError m (Vector (Value m)))
-> m (Either RuntimeError (Vector (Value m)))
-> ExceptT RuntimeError m (Vector (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> m (Either RuntimeError (Vector (Value m)))
forall a (m :: * -> *).
FromValue a m =>
Value m -> m (Either RuntimeError a)
fromValue Value m
scrutinee
case [Value m]
varargs of
[] ->
RuntimeError -> ExceptT RuntimeError m (Value m)
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m (Value m))
-> RuntimeError -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$
Text -> Text -> Text -> Text -> RuntimeError
ArgumentError
Text
funcName
Text
"attribute/callee"
Text
"attribute=identifier or callable"
Text
"no argument"
(Value m
test:[Value m]
varargs') -> do
let args' :: [(Maybe Identifier, Value m)]
args' = [Maybe Identifier] -> [Value m] -> [(Maybe Identifier, Value m)]
forall a b. [a] -> [b] -> [(a, b)]
zip (Maybe Identifier -> [Maybe Identifier]
forall a. a -> [a]
repeat Maybe Identifier
forall a. Maybe a
Nothing) [Value m]
varargs' [(Maybe Identifier, Value m)]
-> [(Maybe Identifier, Value m)] -> [(Maybe Identifier, Value m)]
forall a. [a] -> [a] -> [a]
++
Map (Maybe Identifier) (Value m) -> [(Maybe Identifier, Value m)]
forall k a. Map k a -> [(k, a)]
Map.toList ((Scalar -> Maybe Identifier)
-> Map Scalar (Value m) -> Map (Maybe Identifier) (Value m)
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Scalar -> Maybe Identifier
toIdentifier Map Scalar (Value m)
kwargs)
let apply' :: Value m -> Value m -> t m Bool
apply' Value m
testV Value m
x =
case Value m
testV of
StringV Text
name -> do
Value m
testV' <- m (Either RuntimeError (Value m)) -> t m (Value m)
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Value m)) -> t m (Value m))
-> m (Either RuntimeError (Value m)) -> t m (Value m)
forall a b. (a -> b) -> a -> b
$
GingerT m (Value m)
-> Context m
-> Env m
-> SomePRNG
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) g a.
(Monad m, SplitGen g) =>
GingerT m a -> Context m -> Env m -> g -> m (Either RuntimeError a)
runGingerT
(GingerT m (Value m) -> GingerT m (Value m)
forall (m :: * -> *) a. Monad m => GingerT m a -> GingerT m a
withJinjaTests (GingerT m (Value m) -> GingerT m (Value m))
-> GingerT m (Value m) -> GingerT m (Value m)
forall a b. (a -> b) -> a -> b
$ Expr -> GingerT m (Value m)
evalE (Identifier -> Expr
VarE (Identifier -> Expr) -> Identifier -> Expr
forall a b. (a -> b) -> a -> b
$ Text -> Identifier
Identifier Text
name))
Context m
ctx Env m
env SomePRNG
rng
Value m -> Value m -> t m Bool
apply' Value m
testV' Value m
x
DictV Map Scalar (Value m)
m -> do
case Scalar -> Map Scalar (Value m) -> Maybe (Value m)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Scalar
"__call__" Map Scalar (Value m)
m of
Maybe (Value m)
Nothing -> RuntimeError -> t m Bool
forall a. RuntimeError -> t m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> t m Bool) -> RuntimeError -> t m Bool
forall a b. (a -> b) -> a -> b
$
Text -> RuntimeError
NonCallableObjectError
(Value m -> Text
forall (m :: * -> *). Value m -> Text
tagNameOf Value m
test Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Value m -> Text
forall a. Show a => a -> Text
Text.show Value m
testV)
Just Value m
v -> Value m -> Value m -> t m Bool
apply' Value m
v Value m
x
NativeV NativeObject m
obj -> do
case NativeObject m
-> Maybe
(NativeObject m
-> [(Maybe Identifier, Value m)]
-> m (Either RuntimeError (Value m)))
forall (m :: * -> *).
NativeObject m
-> Maybe
(NativeObject m
-> [(Maybe Identifier, Value m)]
-> m (Either RuntimeError (Value m)))
nativeObjectCall NativeObject m
obj of
Maybe
(NativeObject m
-> [(Maybe Identifier, Value m)]
-> m (Either RuntimeError (Value m)))
Nothing -> RuntimeError -> t m Bool
forall a. RuntimeError -> t m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> t m Bool) -> RuntimeError -> t m Bool
forall a b. (a -> b) -> a -> b
$
Text -> RuntimeError
NonCallableObjectError
Text
"non-callable native object"
Just NativeObject m
-> [(Maybe Identifier, Value m)]
-> m (Either RuntimeError (Value m))
f -> m (Either RuntimeError (Value m)) -> t m (Value m)
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (NativeObject m
-> [(Maybe Identifier, Value m)]
-> m (Either RuntimeError (Value m))
f NativeObject m
obj [(Maybe Identifier, Value m)]
args') t m (Value m) -> (Value m -> t m Bool) -> t m Bool
forall a b. t m a -> (a -> t m b) -> t m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
Either RuntimeError Bool -> t m Bool
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError Bool -> t m Bool)
-> (Value m -> Either RuntimeError Bool) -> Value m -> t m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Value m -> Either RuntimeError Bool
forall (m :: * -> *). Text -> Value m -> Either RuntimeError Bool
asTruthVal Text
"native object to bool conversion"
TestV Test m
f -> do
let env' :: Env m
env' = Env m
env { envVars = Map.insert "@" x $ envVars env }
m (Either RuntimeError Bool) -> t m Bool
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError Bool) -> t m Bool)
-> m (Either RuntimeError Bool) -> t m Bool
forall a b. (a -> b) -> a -> b
$ Test m -> TestFunc m
forall (m :: * -> *). Test m -> TestFunc m
runTest Test m
f (Identifier -> Expr
VarE Identifier
"@") [(Maybe Identifier, Value m)]
args' Context m
ctx Env m
env' SomePRNG
rng
ProcedureV (NativeProcedure ObjectID
_ Maybe ProcedureDoc
_ [(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m))
f) -> do
m (Either RuntimeError (Value m)) -> t m (Value m)
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m))
f ((Maybe Identifier
forall a. Maybe a
Nothing, Value m
x)(Maybe Identifier, Value m)
-> [(Maybe Identifier, Value m)] -> [(Maybe Identifier, Value m)]
forall a. a -> [a] -> [a]
:[(Maybe Identifier, Value m)]
args') Context m
ctx SomePRNG
rng) t m (Value m) -> (Value m -> t m Bool) -> t m Bool
forall a b. t m a -> (a -> t m b) -> t m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
Either RuntimeError Bool -> t m Bool
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError Bool -> t m Bool)
-> (Value m -> Either RuntimeError Bool) -> Value m -> t m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Value m -> Either RuntimeError Bool
forall (m :: * -> *). Text -> Value m -> Either RuntimeError Bool
asTruthVal Text
"native procedure"
ProcedureV (GingerProcedure Env m
env' [(Identifier, Maybe (Value m))]
argSpecs Expr
body) -> do
Map Identifier (Value m)
args'' <- Either RuntimeError (Map Identifier (Value m))
-> t m (Map Identifier (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError (Map Identifier (Value m))
-> t m (Map Identifier (Value m)))
-> Either RuntimeError (Map Identifier (Value m))
-> t m (Map Identifier (Value m))
forall a b. (a -> b) -> a -> b
$
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
forall (m :: * -> *).
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
resolveArgs
Text
"select callback"
[(Identifier, Maybe (Value m))]
argSpecs
((Maybe Identifier
forall a. Maybe a
Nothing, Value m
x)(Maybe Identifier, Value m)
-> [(Maybe Identifier, Value m)] -> [(Maybe Identifier, Value m)]
forall a. a -> [a] -> [a]
:[(Maybe Identifier, Value m)]
args')
m (Either RuntimeError (Value m)) -> t m (Value m)
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (GingerT m (Value m)
-> Context m
-> Env m
-> SomePRNG
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) g a.
(Monad m, SplitGen g) =>
GingerT m a -> Context m -> Env m -> g -> m (Either RuntimeError a)
runGingerT (Map Identifier (Value m) -> GingerT m ()
forall (m :: * -> *).
Monad m =>
Map Identifier (Value m) -> GingerT m ()
setVars Map Identifier (Value m)
args'' GingerT m () -> GingerT m (Value m) -> GingerT m (Value m)
forall a b. GingerT m a -> GingerT m b -> GingerT m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Expr -> GingerT m (Value m)
evalE Expr
body) Context m
ctx Env m
env' SomePRNG
rng) t m (Value m) -> (Value m -> t m Bool) -> t m Bool
forall a b. t m a -> (a -> t m b) -> t m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
Either RuntimeError Bool -> t m Bool
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError Bool -> t m Bool)
-> (Value m -> Either RuntimeError Bool) -> Value m -> t m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Value m -> Either RuntimeError Bool
forall (m :: * -> *). Text -> Value m -> Either RuntimeError Bool
asTruthVal Text
"ginger procedure"
Value m
_ ->
RuntimeError -> t m Bool
forall a. RuntimeError -> t m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> t m Bool) -> RuntimeError -> t m Bool
forall a b. (a -> b) -> a -> b
$
Text -> RuntimeError
NonCallableObjectError
(Value m -> Text
forall (m :: * -> *). Value m -> Text
tagNameOf Value m
test Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Value m -> Text
forall a. Show a => a -> Text
Text.show Value m
testV)
invertFun :: Bool -> Bool
invertFun = if Bool
invert then Bool -> Bool
not else Bool -> Bool
forall a. a -> a
id
apply :: Value m -> ExceptT RuntimeError m Bool
apply = (Bool -> Bool)
-> ExceptT RuntimeError m Bool -> ExceptT RuntimeError m Bool
forall a b.
(a -> b) -> ExceptT RuntimeError m a -> ExceptT RuntimeError m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> Bool
invertFun (ExceptT RuntimeError m Bool -> ExceptT RuntimeError m Bool)
-> (Value m -> ExceptT RuntimeError m Bool)
-> Value m
-> ExceptT RuntimeError m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> Value m -> ExceptT RuntimeError m Bool
forall {t :: (* -> *) -> * -> *}.
(MonadError RuntimeError (t m), MonadTrans t) =>
Value m -> Value m -> t m Bool
apply' Value m
test
Vector (Value m) -> Value m
forall (m :: * -> *). Vector (Value m) -> Value m
ListV (Vector (Value m) -> Value m)
-> ExceptT RuntimeError m (Vector (Value m))
-> ExceptT RuntimeError m (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value m -> ExceptT RuntimeError m Bool)
-> Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Vector a -> m (Vector a)
V.filterM Value m -> ExceptT RuntimeError m Bool
apply Vector (Value m)
xs
where
toIdentifier :: Scalar -> Maybe Identifier
toIdentifier :: Scalar -> Maybe Identifier
toIdentifier (StringScalar Text
s) = Identifier -> Maybe Identifier
forall a. a -> Maybe a
Just (Identifier -> Maybe Identifier) -> Identifier -> Maybe Identifier
forall a b. (a -> b) -> a -> b
$ Text -> Identifier
Identifier Text
s
toIdentifier (IntScalar Integer
i) = Identifier -> Maybe Identifier
forall a. a -> Maybe a
Just (Identifier -> Maybe Identifier) -> Identifier -> Maybe Identifier
forall a b. (a -> b) -> a -> b
$ Text -> Identifier
Identifier (Integer -> Text
forall a. Show a => a -> Text
Text.show Integer
i)
toIdentifier (FloatScalar Double
f) = Identifier -> Maybe Identifier
forall a. a -> Maybe a
Just (Identifier -> Maybe Identifier) -> Identifier -> Maybe Identifier
forall a b. (a -> b) -> a -> b
$ Text -> Identifier
Identifier (Double -> Text
forall a. Show a => a -> Text
Text.show Double
f)
toIdentifier Scalar
_ = Maybe Identifier
forall a. Maybe a
Nothing
fnMap :: forall m. Monad m
=> (Expr -> GingerT m (Value m))
-> Filter m
fnMap :: forall (m :: * -> *).
Monad m =>
(Expr -> GingerT m (Value m)) -> Filter m
fnMap Expr -> GingerT m (Value m)
evalE =
Maybe ProcedureDoc -> FilterFunc m -> Filter m
forall (m :: * -> *).
Maybe ProcedureDoc -> FilterFunc m -> Filter m
NativeFilter
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
"builtins:map"
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list"
, procedureDocDescription :: Text
procedureDocDescription = [Text] -> Text
Text.unlines
[ Text
Item [Text]
"Map a filter or procedure over a list."
]
}
) (FilterFunc m -> Filter m) -> FilterFunc m -> Filter m
forall a b. (a -> b) -> a -> b
$
\Expr
scrutineeE [(Maybe Identifier, Value m)]
args Context m
ctx Env m
env SomePRNG
rng -> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m)))
-> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ do
let funcName :: Text
funcName = Text
"map"
Map Identifier (Value m)
argValues <- Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m)))
-> Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall a b. (a -> b) -> a -> b
$
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
forall (m :: * -> *).
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
resolveArgs
Text
funcName
[]
[(Maybe Identifier, Value m)]
args
[Value m]
varargs <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m [Value m]
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
"varargs" Map Identifier (Value m)
argValues
(Map Scalar (Value m)
kwargs :: Map Scalar (Value m)) <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m (Map Scalar (Value m))
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
"kwargs" Map Identifier (Value m)
argValues
(Value m
scrutinee :: Value m) <- m (Either RuntimeError (Value m))
-> ExceptT RuntimeError m (Value m)
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Value m))
-> ExceptT RuntimeError m (Value m))
-> m (Either RuntimeError (Value m))
-> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ GingerT m (Value m)
-> Context m
-> Env m
-> SomePRNG
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) g a.
(Monad m, SplitGen g) =>
GingerT m a -> Context m -> Env m -> g -> m (Either RuntimeError a)
runGingerT (Expr -> GingerT m (Value m)
evalE Expr
scrutineeE) Context m
ctx Env m
env SomePRNG
rng
(Vector (Value m)
xs :: Vector (Value m)) <- m (Either RuntimeError (Vector (Value m)))
-> ExceptT RuntimeError m (Vector (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Vector (Value m)))
-> ExceptT RuntimeError m (Vector (Value m)))
-> m (Either RuntimeError (Vector (Value m)))
-> ExceptT RuntimeError m (Vector (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> m (Either RuntimeError (Vector (Value m)))
forall a (m :: * -> *).
FromValue a m =>
Value m -> m (Either RuntimeError a)
fromValue Value m
scrutinee
let attributeMay :: Maybe (Value m)
attributeMay = Scalar -> Map Scalar (Value m) -> Maybe (Value m)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Scalar
"attribute" Map Scalar (Value m)
kwargs
case Maybe (Value m)
attributeMay of
Just Value m
attribute -> do
let defVal :: Value m
defVal = Value m -> Maybe (Value m) -> Value m
forall a. a -> Maybe a -> a
fromMaybe Value m
forall (m :: * -> *). Value m
NoneV (Scalar -> Map Scalar (Value m) -> Maybe (Value m)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Scalar
"default" Map Scalar (Value m)
kwargs) :: Value m
Vector (Value m) -> Value m
forall (m :: * -> *). Vector (Value m) -> Value m
ListV (Vector (Value m) -> Value m)
-> ExceptT RuntimeError m (Vector (Value m))
-> ExceptT RuntimeError m (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value m -> ExceptT RuntimeError m (Value m))
-> Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector a -> m (Vector b)
V.mapM
(\Value m
x -> do
Identifier
attributeIdent <- Text -> Identifier
Identifier (Text -> Identifier)
-> ExceptT RuntimeError m Text -> ExceptT RuntimeError m Identifier
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Either RuntimeError Text) -> ExceptT RuntimeError m Text
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (Value m -> m (Either RuntimeError Text)
forall a (m :: * -> *).
FromValue a m =>
Value m -> m (Either RuntimeError a)
fromValue Value m
attribute)
Value m -> Maybe (Value m) -> Value m
forall a. a -> Maybe a -> a
fromMaybe Value m
defVal (Maybe (Value m) -> Value m)
-> ExceptT RuntimeError m (Maybe (Value m))
-> ExceptT RuntimeError m (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM
(Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
forall (m :: * -> *).
Monad m =>
Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
getAttrOrItemRaw Value m
x Identifier
attributeIdent)
)
Vector (Value m)
xs
Maybe (Value m)
Nothing ->
case [Value m]
varargs of
[] ->
RuntimeError -> ExceptT RuntimeError m (Value m)
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m (Value m))
-> RuntimeError -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$
Text -> Text -> Text -> Text -> RuntimeError
ArgumentError
Text
funcName
Text
"attribute/callee"
Text
"attribute=identifier or callable"
Text
"no argument"
(Value m
callee:[Value m]
varargs') -> do
let args' :: [(Maybe Identifier, Value m)]
args' = [Maybe Identifier] -> [Value m] -> [(Maybe Identifier, Value m)]
forall a b. [a] -> [b] -> [(a, b)]
zip (Maybe Identifier -> [Maybe Identifier]
forall a. a -> [a]
repeat Maybe Identifier
forall a. Maybe a
Nothing) [Value m]
varargs' [(Maybe Identifier, Value m)]
-> [(Maybe Identifier, Value m)] -> [(Maybe Identifier, Value m)]
forall a. [a] -> [a] -> [a]
++
Map (Maybe Identifier) (Value m) -> [(Maybe Identifier, Value m)]
forall k a. Map k a -> [(k, a)]
Map.toList ((Scalar -> Maybe Identifier)
-> Map Scalar (Value m) -> Map (Maybe Identifier) (Value m)
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Scalar -> Maybe Identifier
toIdentifier Map Scalar (Value m)
kwargs)
let apply' :: Value m -> Value m -> t m (Value m)
apply' Value m
filterV Value m
x =
case Value m
filterV of
StringV Text
name -> do
Value m
filterV' <- m (Either RuntimeError (Value m)) -> t m (Value m)
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Value m)) -> t m (Value m))
-> m (Either RuntimeError (Value m)) -> t m (Value m)
forall a b. (a -> b) -> a -> b
$
GingerT m (Value m)
-> Context m
-> Env m
-> SomePRNG
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) g a.
(Monad m, SplitGen g) =>
GingerT m a -> Context m -> Env m -> g -> m (Either RuntimeError a)
runGingerT
(GingerT m (Value m) -> GingerT m (Value m)
forall (m :: * -> *) a. Monad m => GingerT m a -> GingerT m a
withJinjaFilters (GingerT m (Value m) -> GingerT m (Value m))
-> GingerT m (Value m) -> GingerT m (Value m)
forall a b. (a -> b) -> a -> b
$ Expr -> GingerT m (Value m)
evalE (Identifier -> Expr
VarE (Identifier -> Expr) -> Identifier -> Expr
forall a b. (a -> b) -> a -> b
$ Text -> Identifier
Identifier Text
name))
Context m
ctx Env m
env SomePRNG
rng
Value m -> Value m -> t m (Value m)
apply' Value m
filterV' Value m
x
DictV Map Scalar (Value m)
m -> do
case Scalar -> Map Scalar (Value m) -> Maybe (Value m)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Scalar
"__call__" Map Scalar (Value m)
m of
Maybe (Value m)
Nothing -> RuntimeError -> t m (Value m)
forall a. RuntimeError -> t m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> t m (Value m)) -> RuntimeError -> t m (Value m)
forall a b. (a -> b) -> a -> b
$
Text -> RuntimeError
NonCallableObjectError
(Value m -> Text
forall (m :: * -> *). Value m -> Text
tagNameOf Value m
callee Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Value m -> Text
forall a. Show a => a -> Text
Text.show Value m
filterV)
Just Value m
v -> Value m -> Value m -> t m (Value m)
apply' Value m
v Value m
x
NativeV NativeObject m
obj -> do
case NativeObject m
-> Maybe
(NativeObject m
-> [(Maybe Identifier, Value m)]
-> m (Either RuntimeError (Value m)))
forall (m :: * -> *).
NativeObject m
-> Maybe
(NativeObject m
-> [(Maybe Identifier, Value m)]
-> m (Either RuntimeError (Value m)))
nativeObjectCall NativeObject m
obj of
Maybe
(NativeObject m
-> [(Maybe Identifier, Value m)]
-> m (Either RuntimeError (Value m)))
Nothing -> RuntimeError -> t m (Value m)
forall a. RuntimeError -> t m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> t m (Value m)) -> RuntimeError -> t m (Value m)
forall a b. (a -> b) -> a -> b
$
Text -> RuntimeError
NonCallableObjectError
Text
"non-callable native object"
Just NativeObject m
-> [(Maybe Identifier, Value m)]
-> m (Either RuntimeError (Value m))
f -> m (Either RuntimeError (Value m)) -> t m (Value m)
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Value m)) -> t m (Value m))
-> m (Either RuntimeError (Value m)) -> t m (Value m)
forall a b. (a -> b) -> a -> b
$ NativeObject m
-> [(Maybe Identifier, Value m)]
-> m (Either RuntimeError (Value m))
f NativeObject m
obj [(Maybe Identifier, Value m)]
args'
FilterV Filter m
f -> do
let env' :: Env m
env' = Env m
env { envVars = Map.insert "@" x $ envVars env }
m (Either RuntimeError (Value m)) -> t m (Value m)
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Value m)) -> t m (Value m))
-> m (Either RuntimeError (Value m)) -> t m (Value m)
forall a b. (a -> b) -> a -> b
$ Filter m -> FilterFunc m
forall (m :: * -> *). Filter m -> FilterFunc m
runFilter Filter m
f (Identifier -> Expr
VarE Identifier
"@") [(Maybe Identifier, Value m)]
args' Context m
ctx Env m
env' SomePRNG
rng
ProcedureV (NativeProcedure ObjectID
_ Maybe ProcedureDoc
_ [(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m))
f) -> do
m (Either RuntimeError (Value m)) -> t m (Value m)
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Value m)) -> t m (Value m))
-> m (Either RuntimeError (Value m)) -> t m (Value m)
forall a b. (a -> b) -> a -> b
$ [(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m))
f ((Maybe Identifier
forall a. Maybe a
Nothing, Value m
x)(Maybe Identifier, Value m)
-> [(Maybe Identifier, Value m)] -> [(Maybe Identifier, Value m)]
forall a. a -> [a] -> [a]
:[(Maybe Identifier, Value m)]
args') Context m
ctx SomePRNG
rng
ProcedureV (GingerProcedure Env m
env' [(Identifier, Maybe (Value m))]
argSpecs Expr
body) -> do
Map Identifier (Value m)
args'' <- Either RuntimeError (Map Identifier (Value m))
-> t m (Map Identifier (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError (Map Identifier (Value m))
-> t m (Map Identifier (Value m)))
-> Either RuntimeError (Map Identifier (Value m))
-> t m (Map Identifier (Value m))
forall a b. (a -> b) -> a -> b
$
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
forall (m :: * -> *).
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
resolveArgs
Text
"map callback"
[(Identifier, Maybe (Value m))]
argSpecs
((Maybe Identifier
forall a. Maybe a
Nothing, Value m
x)(Maybe Identifier, Value m)
-> [(Maybe Identifier, Value m)] -> [(Maybe Identifier, Value m)]
forall a. a -> [a] -> [a]
:[(Maybe Identifier, Value m)]
args')
m (Either RuntimeError (Value m)) -> t m (Value m)
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Value m)) -> t m (Value m))
-> m (Either RuntimeError (Value m)) -> t m (Value m)
forall a b. (a -> b) -> a -> b
$
GingerT m (Value m)
-> Context m
-> Env m
-> SomePRNG
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) g a.
(Monad m, SplitGen g) =>
GingerT m a -> Context m -> Env m -> g -> m (Either RuntimeError a)
runGingerT (Map Identifier (Value m) -> GingerT m ()
forall (m :: * -> *).
Monad m =>
Map Identifier (Value m) -> GingerT m ()
setVars Map Identifier (Value m)
args'' GingerT m () -> GingerT m (Value m) -> GingerT m (Value m)
forall a b. GingerT m a -> GingerT m b -> GingerT m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Expr -> GingerT m (Value m)
evalE Expr
body) Context m
ctx Env m
env' SomePRNG
rng
Value m
_ ->
RuntimeError -> t m (Value m)
forall a. RuntimeError -> t m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> t m (Value m)) -> RuntimeError -> t m (Value m)
forall a b. (a -> b) -> a -> b
$
Text -> RuntimeError
NonCallableObjectError
(Value m -> Text
forall (m :: * -> *). Value m -> Text
tagNameOf Value m
callee Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Value m -> Text
forall a. Show a => a -> Text
Text.show Value m
filterV)
apply :: Value m -> ExceptT RuntimeError m (Value m)
apply = Value m -> Value m -> ExceptT RuntimeError m (Value m)
forall {t :: (* -> *) -> * -> *}.
(MonadError RuntimeError (t m), MonadTrans t) =>
Value m -> Value m -> t m (Value m)
apply' Value m
callee
Vector (Value m) -> Value m
forall (m :: * -> *). Vector (Value m) -> Value m
ListV (Vector (Value m) -> Value m)
-> ExceptT RuntimeError m (Vector (Value m))
-> ExceptT RuntimeError m (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value m -> ExceptT RuntimeError m (Value m))
-> Vector (Value m) -> ExceptT RuntimeError m (Vector (Value m))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector a -> m (Vector b)
mapM Value m -> ExceptT RuntimeError m (Value m)
apply Vector (Value m)
xs
where
toIdentifier :: Scalar -> Maybe Identifier
toIdentifier :: Scalar -> Maybe Identifier
toIdentifier (StringScalar Text
s) = Identifier -> Maybe Identifier
forall a. a -> Maybe a
Just (Identifier -> Maybe Identifier) -> Identifier -> Maybe Identifier
forall a b. (a -> b) -> a -> b
$ Text -> Identifier
Identifier Text
s
toIdentifier (IntScalar Integer
i) = Identifier -> Maybe Identifier
forall a. a -> Maybe a
Just (Identifier -> Maybe Identifier) -> Identifier -> Maybe Identifier
forall a b. (a -> b) -> a -> b
$ Text -> Identifier
Identifier (Integer -> Text
forall a. Show a => a -> Text
Text.show Integer
i)
toIdentifier (FloatScalar Double
f) = Identifier -> Maybe Identifier
forall a. a -> Maybe a
Just (Identifier -> Maybe Identifier) -> Identifier -> Maybe Identifier
forall a b. (a -> b) -> a -> b
$ Text -> Identifier
Identifier (Double -> Text
forall a. Show a => a -> Text
Text.show Double
f)
toIdentifier Scalar
_ = Maybe Identifier
forall a. Maybe a
Nothing
fnRound :: forall m. Monad m => Procedure m
fnRound :: forall (m :: * -> *). Monad m => Procedure m
fnRound = Text
-> Text
-> (Identifier, Maybe Double, Maybe TypeDoc, Text)
-> (Identifier, Maybe Integer, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Double -> Integer -> Text -> ExceptT RuntimeError m Double)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"round"
Text
"Round a floating-point value."
( Identifier
"value"
, Maybe Double
forall a. Maybe a
Nothing :: Maybe Double
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"float"
, Text
""
)
( Identifier
"precision"
, Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
0 :: Maybe Integer
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int"
, Text
""
)
( Identifier
"method"
, Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"common"
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
"One of 'common', 'ceil', 'floor'."
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Vector Text -> TypeDoc
TypeDocAlternatives [Text
Item (Vector Text)
"int", Text
Item (Vector Text)
"float"])
((Double -> Integer -> Text -> ExceptT RuntimeError m Double)
-> Procedure m)
-> (Double -> Integer -> Text -> ExceptT RuntimeError m Double)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Double
value Integer
precision Text
method -> do
(Double -> Integer
r :: Double -> Integer) <- case Text
method of
Text
"common" -> (Double -> Integer) -> ExceptT RuntimeError m (Double -> Integer)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> Integer
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
floor (Double -> Integer) -> (Double -> Double) -> Double -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
0.5))
Text
"ceil" -> (Double -> Integer) -> ExceptT RuntimeError m (Double -> Integer)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Double -> Integer
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
ceiling
Text
"floor" -> (Double -> Integer) -> ExceptT RuntimeError m (Double -> Integer)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Double -> Integer
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
floor
Text
x -> RuntimeError -> ExceptT RuntimeError m (Double -> Integer)
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m (Double -> Integer))
-> RuntimeError -> ExceptT RuntimeError m (Double -> Integer)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Text -> Text -> RuntimeError
ArgumentError Text
"round" Text
"method" Text
"one of 'common', 'floor', 'ceil'" Text
x
if Integer
precision Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0 then
Double -> ExceptT RuntimeError m Double
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> ExceptT RuntimeError m Double)
-> Double -> ExceptT RuntimeError m Double
forall a b. (a -> b) -> a -> b
$ Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Double) -> Integer -> Double
forall a b. (a -> b) -> a -> b
$ Double -> Integer
r Double
value
else do
let Double
factor :: Double = Double
10 Double -> Double -> Double
forall a. Floating a => a -> a -> a
** (Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
precision)
Double -> ExceptT RuntimeError m Double
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> ExceptT RuntimeError m Double)
-> Double -> ExceptT RuntimeError m Double
forall a b. (a -> b) -> a -> b
$ Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Double -> Integer
r (Double
value Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
factor) :: Integer) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
factor
fnStrReplace :: Monad m => Procedure m
fnStrReplace :: forall (m :: * -> *). Monad m => Procedure m
fnStrReplace = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Int), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text
-> Text -> Text -> Maybe Int -> ExceptT RuntimeError m Text)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 a4 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue a4 m,
FromValue a4 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4 Text
"replace"
Text
"String search-and-replace."
( Identifier
"value"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"old"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
"String to search for"
)
( Identifier
"new"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
"Replacement"
)
( Identifier
"count"
, Maybe Int -> Maybe (Maybe Int)
forall a. a -> Maybe a
Just (Maybe Int
forall a. Maybe a
Nothing :: Maybe Int)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
"Maximum number of replacements."
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
((Text -> Text -> Text -> Maybe Int -> ExceptT RuntimeError m Text)
-> Procedure m)
-> (Text
-> Text -> Text -> Maybe Int -> ExceptT RuntimeError m Text)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Text
value Text
old Text
new Maybe Int
countMay -> do
let parts :: [Text]
parts = HasCallStack => Text -> Text -> [Text]
Text -> Text -> [Text]
Text.splitOn Text
old Text
value
case Maybe Int
countMay of
Maybe Int
Nothing -> Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$ Text -> [Text] -> Text
Text.intercalate Text
new [Text]
parts
Just Int
0 -> Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
value
Just Int
count | Int
count Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< [Text] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Text]
parts ->
Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$
Text -> [Text] -> Text
Text.intercalate Text
new (Int -> [Text] -> [Text]
forall a. Int -> [a] -> [a]
take Int
count [Text]
parts) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
new Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text -> [Text] -> Text
Text.intercalate Text
old (Int -> [Text] -> [Text]
forall a. Int -> [a] -> [a]
drop Int
count [Text]
parts)
Just Int
_ -> Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$ Text -> [Text] -> Text
Text.intercalate Text
new [Text]
parts
fnStrStrip :: Monad m => Procedure m
fnStrStrip :: forall (m :: * -> *). Monad m => Procedure m
fnStrStrip = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Text), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m
forall (m :: * -> *) a1 a2 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2 Text
"strip"
Text
"Strip whitespace or selected characters from both ends of a string."
( Identifier
"value"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"chars"
, Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
"If specified: characters to strip."
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
((Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m)
-> (Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Text
value Maybe Text
charsMay -> do
case Maybe Text
charsMay of
Maybe Text
Nothing -> Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$ Text -> Text
Text.strip Text
value
Just Text
charsText -> do
let chars :: String
chars = Text -> String
Text.unpack Text
charsText
Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$
(Char -> Bool) -> Text -> Text
Text.dropWhile (Char -> String -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
chars) (Text -> Text) -> (Text -> Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
(Char -> Bool) -> Text -> Text
Text.dropWhileEnd (Char -> String -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
chars) (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$
Text
value
fnStrLStrip :: Monad m => Procedure m
fnStrLStrip :: forall (m :: * -> *). Monad m => Procedure m
fnStrLStrip = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Text), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m
forall (m :: * -> *) a1 a2 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2 Text
"lstrip"
Text
"Strip whitespace or selected characters from the beginning of a string."
( Identifier
"value"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"chars"
, Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
"If specified: characters to strip."
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
((Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m)
-> (Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Text
value Maybe Text
charsMay -> do
case Maybe Text
charsMay of
Maybe Text
Nothing -> Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$ Text -> Text
Text.stripStart Text
value
Just Text
charsText -> do
let chars :: String
chars = Text -> String
Text.unpack Text
charsText
Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> Text -> Text
Text.dropWhile (Char -> String -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
chars) Text
value
fnStrRStrip :: Monad m => Procedure m
fnStrRStrip :: forall (m :: * -> *). Monad m => Procedure m
fnStrRStrip = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Text), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m
forall (m :: * -> *) a1 a2 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2 Text
"rstrip"
Text
"Strip whitespace or selected characters from the end of a string."
( Identifier
"value"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"chars"
, Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
"If specified: characters to strip."
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
((Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m)
-> (Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Text
value Maybe Text
charsMay -> do
case Maybe Text
charsMay of
Maybe Text
Nothing -> Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$ Text -> Text
Text.stripEnd Text
value
Just Text
charsText -> do
let chars :: String
chars = Text -> String
Text.unpack Text
charsText
Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> Text -> Text
Text.dropWhileEnd (Char -> String -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
chars) Text
value
fnToJSON :: forall m. Monad m => Procedure m
fnToJSON :: forall (m :: * -> *). Monad m => Procedure m
fnToJSON = Text
-> Text
-> (Identifier, Maybe (Value m), Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Int), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Value m -> Maybe Int -> ExceptT RuntimeError m Text)
-> Procedure m
forall (m :: * -> *) a1 a2 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2 Text
"tojson"
Text
"Convert `value` to JSON"
( Identifier
"value"
, Maybe (Value m)
forall a. Maybe a
Nothing :: Maybe (Value m)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"indent"
, Maybe Int -> Maybe (Maybe Int)
forall a. a -> Maybe a
Just (Maybe Int
forall a. Maybe a
Nothing :: Maybe Int)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
((Value m -> Maybe Int -> ExceptT RuntimeError m Text)
-> Procedure m)
-> (Value m -> Maybe Int -> ExceptT RuntimeError m Text)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Value m
value Maybe Int
_indentMay ->
Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> (ByteString -> Text)
-> ByteString
-> ExceptT RuntimeError m Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Text
Text.decodeUtf8 (ByteString -> Text)
-> (ByteString -> ByteString) -> ByteString -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
LBS.toStrict (ByteString -> ExceptT RuntimeError m Text)
-> ByteString -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$ Value m -> ByteString
forall a. ToJSON a => a -> ByteString
JSON.encode Value m
value
fnJoin :: forall m. Monad m => Procedure m
fnJoin :: forall (m :: * -> *). Monad m => Procedure m
fnJoin = Text
-> Text
-> (Identifier, Maybe [Value m], Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Text), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> ([Value m] -> Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"join"
Text
"Join an iterable into a string"
( Identifier
"iterable"
, Maybe [Value m]
forall a. Maybe a
Nothing :: Maybe [Value m]
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list"
, Text
""
)
( Identifier
"d"
, Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"" :: Maybe Text
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
"Default value to use to replace empty elements"
)
( Identifier
"attr"
, Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing :: Maybe (Maybe Text)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
"If given, an attribute to pick from each element"
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
(([Value m] -> Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m)
-> ([Value m] -> Text -> Maybe Text -> ExceptT RuntimeError m Text)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \[Value m]
iterable Text
d Maybe Text
attrMay -> do
[Value m]
iterable' <- case Maybe Text
attrMay of
Maybe Text
Nothing -> [Value m] -> ExceptT RuntimeError m [Value m]
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Value m]
iterable
Just Text
attr ->
[Maybe (Value m)] -> [Value m]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe (Value m)] -> [Value m])
-> ExceptT RuntimeError m [Maybe (Value m)]
-> ExceptT RuntimeError m [Value m]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
(Value m -> ExceptT RuntimeError m (Maybe (Value m)))
-> [Value m] -> ExceptT RuntimeError m [Maybe (Value m)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM
(\Value m
x -> m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m)))
-> m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
forall (m :: * -> *).
Monad m =>
Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
getAttrOrItemRaw Value m
x (Text -> Identifier
Identifier Text
attr))
[Value m]
iterable
Text -> [Text] -> Text
Text.intercalate Text
d ([Text] -> Text)
-> ExceptT RuntimeError m [Text] -> ExceptT RuntimeError m Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value m -> ExceptT RuntimeError m Text)
-> [Value m] -> ExceptT RuntimeError m [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (Either RuntimeError Text -> ExceptT RuntimeError m Text
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError Text -> ExceptT RuntimeError m Text)
-> (Value m -> Either RuntimeError Text)
-> Value m
-> ExceptT RuntimeError m Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> Either RuntimeError Text
forall (m :: * -> *). Value m -> Either RuntimeError Text
asTextVal) [Value m]
iterable'
fnStrJoin :: Monad m => Procedure m
fnStrJoin :: forall (m :: * -> *). Monad m => Procedure m
fnStrJoin = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe [Text], Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text -> [Text] -> ExceptT RuntimeError m Text)
-> Procedure m
forall (m :: * -> *) a1 a2 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2 Text
"join"
(Text
"`str.join(iterable)` joins `iterable` into a string, using " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"`str` as a separator."
)
( Identifier
"value"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"iterable"
, [Text] -> Maybe [Text]
forall a. a -> Maybe a
Just []
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list"
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
((Text -> [Text] -> ExceptT RuntimeError m Text) -> Procedure m)
-> (Text -> [Text] -> ExceptT RuntimeError m Text) -> Procedure m
forall a b. (a -> b) -> a -> b
$ \Text
value [Text]
iterable -> do
Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$ Text -> [Text] -> Text
Text.intercalate Text
value [Text]
iterable
fnStrSplit :: Monad m => Procedure m
fnStrSplit :: forall (m :: * -> *). Monad m => Procedure m
fnStrSplit = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Text), Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Int), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text
-> Maybe Text -> Maybe Int -> ExceptT RuntimeError m [Text])
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"split"
Text
"Split a string by a separator."
( Identifier
"value"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"sep"
, Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"maxsplit"
, Maybe Int -> Maybe (Maybe Int)
forall a. a -> Maybe a
Just Maybe Int
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int"
, Text
"Maximum number of splits. Unlimited if not specified."
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
((Text -> Maybe Text -> Maybe Int -> ExceptT RuntimeError m [Text])
-> Procedure m)
-> (Text
-> Maybe Text -> Maybe Int -> ExceptT RuntimeError m [Text])
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Text
value Maybe Text
sepMay Maybe Int
maxsplitMay -> do
[Text]
items <- case Maybe Text
sepMay of
Maybe Text
Nothing -> [Text] -> ExceptT RuntimeError m [Text]
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Text] -> ExceptT RuntimeError m [Text])
-> (Text -> [Text]) -> Text -> ExceptT RuntimeError m [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text]
Text.words (Text -> [Text]) -> (Text -> Text) -> Text -> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
Text.strip (Text -> ExceptT RuntimeError m [Text])
-> Text -> ExceptT RuntimeError m [Text]
forall a b. (a -> b) -> a -> b
$ Text
value
Just Text
"" -> RuntimeError -> ExceptT RuntimeError m [Text]
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m [Text])
-> RuntimeError -> ExceptT RuntimeError m [Text]
forall a b. (a -> b) -> a -> b
$
Text -> Text -> Text -> Text -> RuntimeError
ArgumentError
Text
"split"
Text
"sep"
Text
"non-empty string"
Text
"empty string"
Just Text
sep -> [Text] -> ExceptT RuntimeError m [Text]
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Text] -> ExceptT RuntimeError m [Text])
-> [Text] -> ExceptT RuntimeError m [Text]
forall a b. (a -> b) -> a -> b
$ HasCallStack => Text -> Text -> [Text]
Text -> Text -> [Text]
Text.splitOn Text
sep Text
value
case Maybe Int
maxsplitMay of
Maybe Int
Nothing ->
[Text] -> ExceptT RuntimeError m [Text]
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Text]
items
Just Int
maxsplit ->
[Text] -> ExceptT RuntimeError m [Text]
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Text] -> ExceptT RuntimeError m [Text])
-> [Text] -> ExceptT RuntimeError m [Text]
forall a b. (a -> b) -> a -> b
$ Int -> [Text] -> [Text]
forall a. Int -> [a] -> [a]
take Int
maxsplit [Text]
items [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [[Text] -> Text
Text.unwords ([Text] -> Text) -> [Text] -> Text
forall a b. (a -> b) -> a -> b
$ Int -> [Text] -> [Text]
forall a. Int -> [a] -> [a]
drop Int
maxsplit [Text]
items]
fnStrStartswith :: Monad m => Procedure m
fnStrStartswith :: forall (m :: * -> *). Monad m => Procedure m
fnStrStartswith = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Int, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Int), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text
-> Text -> Int -> Maybe Int -> ExceptT RuntimeError m Bool)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 a4 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue a4 m,
FromValue a4 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4 Text
"startswith"
Text
"Check whether a string starts with a given prefix."
( Identifier
"value"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"prefix"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"start"
, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int"
, Text
""
)
( Identifier
"end"
, Maybe Int -> Maybe (Maybe Int)
forall a. a -> Maybe a
Just Maybe Int
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int"
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
((Text -> Text -> Int -> Maybe Int -> ExceptT RuntimeError m Bool)
-> Procedure m)
-> (Text
-> Text -> Int -> Maybe Int -> ExceptT RuntimeError m Bool)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Text
value Text
prefix Int
start Maybe Int
endMay -> do
let value' :: Text
value' = case Maybe Int
endMay of
Maybe Int
Nothing -> Int -> Text -> Text
Text.drop Int
start Text
value
Just Int
end -> Int -> Text -> Text
Text.drop Int
start (Text -> Text) -> (Text -> Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text -> Text
Text.take Int
end (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Text
value
Bool -> ExceptT RuntimeError m Bool
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool -> ExceptT RuntimeError m Bool)
-> Bool -> ExceptT RuntimeError m Bool
forall a b. (a -> b) -> a -> b
$ Text
prefix Text -> Text -> Bool
`Text.isPrefixOf` Text
value'
fnStrEndswith :: Monad m => Procedure m
fnStrEndswith :: forall (m :: * -> *). Monad m => Procedure m
fnStrEndswith = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Int, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Int), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text
-> Text -> Int -> Maybe Int -> ExceptT RuntimeError m Bool)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 a4 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue a4 m,
FromValue a4 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4 Text
"endswith"
Text
"Check whether a string ends with a given suffix."
( Identifier
"value"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"suffix"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"start"
, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int"
, Text
""
)
( Identifier
"end"
, Maybe Int -> Maybe (Maybe Int)
forall a. a -> Maybe a
Just Maybe Int
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int"
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool")
((Text -> Text -> Int -> Maybe Int -> ExceptT RuntimeError m Bool)
-> Procedure m)
-> (Text
-> Text -> Int -> Maybe Int -> ExceptT RuntimeError m Bool)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Text
value Text
suffix Int
start Maybe Int
endMay -> do
let value' :: Text
value' = case Maybe Int
endMay of
Maybe Int
Nothing -> Int -> Text -> Text
Text.drop Int
start Text
value
Just Int
end -> Int -> Text -> Text
Text.drop Int
start (Text -> Text) -> (Text -> Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text -> Text
Text.take Int
end (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Text
value
Bool -> ExceptT RuntimeError m Bool
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool -> ExceptT RuntimeError m Bool)
-> Bool -> ExceptT RuntimeError m Bool
forall a b. (a -> b) -> a -> b
$ Text
suffix Text -> Text -> Bool
`Text.isSuffixOf` Text
value'
fnStrEncode :: Monad m => Procedure m
fnStrEncode :: forall (m :: * -> *). Monad m => Procedure m
fnStrEncode = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text -> Text -> Text -> ExceptT RuntimeError m ByteString)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"encode"
Text
"Encode string into the selected encoding."
( Identifier
"value"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"encoding"
, Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"utf-8"
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
"Encoding. One of 'ascii', 'utf8' (default), 'utf16le', 'utf16be', 'utf32le', 'utf32be'"
)
( Identifier
"errors"
, Text -> Maybe Text
forall a. a -> Maybe a
Just (Text
"strict" :: Text)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"encoded")
((Text -> Text -> Text -> ExceptT RuntimeError m ByteString)
-> Procedure m)
-> (Text -> Text -> Text -> ExceptT RuntimeError m ByteString)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Text
value Text
encoding Text
_errors -> do
Text -> ByteString
func <- case (Char -> Bool) -> Text -> Text
Text.filter Char -> Bool
isAlphaNum (Text -> Text) -> (Text -> Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
Text.toCaseFold (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Text
encoding of
Text
"ascii" -> (Text -> ByteString) -> ExceptT RuntimeError m (Text -> ByteString)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text -> ByteString
encodeASCII
Text
"utf8" -> (Text -> ByteString) -> ExceptT RuntimeError m (Text -> ByteString)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text -> ByteString
Text.encodeUtf8
Text
"utf16le" -> (Text -> ByteString) -> ExceptT RuntimeError m (Text -> ByteString)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text -> ByteString
Text.encodeUtf16LE
Text
"utf16be" -> (Text -> ByteString) -> ExceptT RuntimeError m (Text -> ByteString)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text -> ByteString
Text.encodeUtf16BE
Text
"utf32le" -> (Text -> ByteString) -> ExceptT RuntimeError m (Text -> ByteString)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text -> ByteString
Text.encodeUtf32LE
Text
"utf32be" -> (Text -> ByteString) -> ExceptT RuntimeError m (Text -> ByteString)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text -> ByteString
Text.encodeUtf32BE
Text
_ -> RuntimeError -> ExceptT RuntimeError m (Text -> ByteString)
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m (Text -> ByteString))
-> RuntimeError -> ExceptT RuntimeError m (Text -> ByteString)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Text -> Text -> RuntimeError
ArgumentError Text
"encode" Text
"encoding" Text
"valid encoding" Text
encoding
ByteString -> ExceptT RuntimeError m ByteString
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ByteString -> ExceptT RuntimeError m ByteString)
-> ByteString -> ExceptT RuntimeError m ByteString
forall a b. (a -> b) -> a -> b
$ Text -> ByteString
func Text
value
where
encodeASCII :: Text -> ByteString
encodeASCII =
[Word8] -> ByteString
BS.pack ([Word8] -> ByteString) -> (Text -> [Word8]) -> Text -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
(Int -> Word8) -> [Int] -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int] -> [Word8]) -> (Text -> [Int]) -> Text -> [Word8]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
(Int -> Bool) -> [Int] -> [Int]
forall a. (a -> Bool) -> [a] -> [a]
filter (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
127) ([Int] -> [Int]) -> (Text -> [Int]) -> Text -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
(Char -> Int) -> String -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Int
ord (String -> [Int]) -> (Text -> String) -> Text -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
Text -> String
Text.unpack
fnStrCount :: Monad m => Procedure m
fnStrCount :: forall (m :: * -> *). Monad m => Procedure m
fnStrCount = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Int, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Int), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text -> Text -> Int -> Maybe Int -> ExceptT RuntimeError m Int)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 a4 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue a4 m,
FromValue a4 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4 Text
"count"
Text
"Count the number of occurrences of a substring."
( Identifier
"value"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"sub"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
"Substring to search for"
)
( Identifier
"start"
, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int"
, Text
""
)
( Identifier
"end"
, Maybe Int -> Maybe (Maybe Int)
forall a. a -> Maybe a
Just Maybe Int
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int"
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int")
((Text -> Text -> Int -> Maybe Int -> ExceptT RuntimeError m Int)
-> Procedure m)
-> (Text -> Text -> Int -> Maybe Int -> ExceptT RuntimeError m Int)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Text
value Text
sub Int
start Maybe Int
endMay -> do
let value' :: Text
value' = case Maybe Int
endMay of
Maybe Int
Nothing -> Int -> Text -> Text
Text.drop Int
start Text
value
Just Int
end -> Int -> Text -> Text
Text.drop Int
start (Text -> Text) -> (Text -> Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text -> Text
Text.take Int
end (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Text
value
Int -> ExceptT RuntimeError m Int
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> ExceptT RuntimeError m Int)
-> Int -> ExceptT RuntimeError m Int
forall a b. (a -> b) -> a -> b
$ HasCallStack => Text -> Text -> Int
Text -> Text -> Int
Text.count Text
sub Text
value'
fnCenter :: Monad m => Procedure m
fnCenter :: forall (m :: * -> *). Monad m => Procedure m
fnCenter = Text
-> Text
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe Integer, Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Text -> Integer -> Text -> ExceptT RuntimeError m Text)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"center"
Text
"Pad string on both sides to center it in the given space"
( Identifier
"value"
, Maybe Text
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"width"
, Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
80
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int"
, Text
""
)
( Identifier
"fillchar"
, Text -> Maybe Text
forall a. a -> Maybe a
Just Text
" "
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
((Text -> Integer -> Text -> ExceptT RuntimeError m Text)
-> Procedure m)
-> (Text -> Integer -> Text -> ExceptT RuntimeError m Text)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Text
value Integer
width Text
fillchar' -> do
let fillchar :: Text
fillchar = Int -> Text -> Text
Text.take Int
1 (Text -> Text) -> (Text -> Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" ") (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Text
fillchar'
let paddingTotal :: Int
paddingTotal = Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0 (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
width Int -> Int -> Int
forall a. Num a => a -> a -> a
- Text -> Int
Text.length Text
value
paddingLeft :: Int
paddingLeft = Int
paddingTotal Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2
paddingRight :: Int
paddingRight = Int
paddingTotal Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
paddingLeft
Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$
Int -> Text -> Text
Text.replicate Int
paddingLeft Text
fillchar Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
value Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Int -> Text -> Text
Text.replicate Int
paddingRight Text
fillchar
newtype FileSize = FileSize Integer
instance ToValue FileSize m where
toValue :: FileSize -> Value m
toValue (FileSize Integer
i) = Integer -> Value m
forall (m :: * -> *). Integer -> Value m
IntV Integer
i
instance Monad m => FromValue FileSize m where
fromValue :: Value m -> m (Either RuntimeError FileSize)
fromValue (IntV Integer
i) =
Either RuntimeError FileSize -> m (Either RuntimeError FileSize)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError FileSize -> m (Either RuntimeError FileSize))
-> (FileSize -> Either RuntimeError FileSize)
-> FileSize
-> m (Either RuntimeError FileSize)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FileSize -> Either RuntimeError FileSize
forall a b. b -> Either a b
Right (FileSize -> m (Either RuntimeError FileSize))
-> FileSize -> m (Either RuntimeError FileSize)
forall a b. (a -> b) -> a -> b
$ Integer -> FileSize
FileSize Integer
i
fromValue (FloatV Double
f) =
Either RuntimeError FileSize -> m (Either RuntimeError FileSize)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError FileSize -> m (Either RuntimeError FileSize))
-> (FileSize -> Either RuntimeError FileSize)
-> FileSize
-> m (Either RuntimeError FileSize)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FileSize -> Either RuntimeError FileSize
forall a b. b -> Either a b
Right (FileSize -> m (Either RuntimeError FileSize))
-> FileSize -> m (Either RuntimeError FileSize)
forall a b. (a -> b) -> a -> b
$ Integer -> FileSize
FileSize (Double -> Integer
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Double
f)
fromValue (StringV Text
txt) =
case String -> Maybe Integer
forall a. Read a => String -> Maybe a
readMaybe (Text -> String
Text.unpack Text
txt) of
Maybe Integer
Nothing ->
case String -> Maybe Double
forall a. Read a => String -> Maybe a
readMaybe (Text -> String
Text.unpack Text
txt) of
Maybe Double
Nothing ->
Either RuntimeError FileSize -> m (Either RuntimeError FileSize)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError FileSize -> m (Either RuntimeError FileSize))
-> (RuntimeError -> Either RuntimeError FileSize)
-> RuntimeError
-> m (Either RuntimeError FileSize)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RuntimeError -> Either RuntimeError FileSize
forall a b. a -> Either a b
Left (RuntimeError -> m (Either RuntimeError FileSize))
-> RuntimeError -> m (Either RuntimeError FileSize)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Text -> Text -> RuntimeError
ArgumentError Text
"int" Text
"value" Text
"numeric value" (Text -> Text
forall a. Show a => a -> Text
Text.show Text
txt)
Just (Double
f :: Double) ->
Either RuntimeError FileSize -> m (Either RuntimeError FileSize)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError FileSize -> m (Either RuntimeError FileSize))
-> (FileSize -> Either RuntimeError FileSize)
-> FileSize
-> m (Either RuntimeError FileSize)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FileSize -> Either RuntimeError FileSize
forall a b. b -> Either a b
Right (FileSize -> m (Either RuntimeError FileSize))
-> FileSize -> m (Either RuntimeError FileSize)
forall a b. (a -> b) -> a -> b
$ Integer -> FileSize
FileSize (Double -> Integer
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Double
f)
Just Integer
i ->
Either RuntimeError FileSize -> m (Either RuntimeError FileSize)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError FileSize -> m (Either RuntimeError FileSize))
-> (FileSize -> Either RuntimeError FileSize)
-> FileSize
-> m (Either RuntimeError FileSize)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FileSize -> Either RuntimeError FileSize
forall a b. b -> Either a b
Right (FileSize -> m (Either RuntimeError FileSize))
-> FileSize -> m (Either RuntimeError FileSize)
forall a b. (a -> b) -> a -> b
$ Integer -> FileSize
FileSize Integer
i
fromValue Value m
x =
Either RuntimeError FileSize -> m (Either RuntimeError FileSize)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError FileSize -> m (Either RuntimeError FileSize))
-> (RuntimeError -> Either RuntimeError FileSize)
-> RuntimeError
-> m (Either RuntimeError FileSize)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RuntimeError -> Either RuntimeError FileSize
forall a b. a -> Either a b
Left (RuntimeError -> m (Either RuntimeError FileSize))
-> RuntimeError -> m (Either RuntimeError FileSize)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Text -> Text -> RuntimeError
ArgumentError Text
"int" Text
"value" Text
"numeric value" (Value m -> Text
forall (m :: * -> *). Value m -> Text
tagNameOf Value m
x)
fnFilesizeFormat :: Monad m => Procedure m
fnFilesizeFormat :: forall (m :: * -> *). Monad m => Procedure m
fnFilesizeFormat = Text
-> Text
-> (Identifier, Maybe FileSize, Maybe TypeDoc, Text)
-> (Identifier, Maybe Bool, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (FileSize -> Bool -> ExceptT RuntimeError m Text)
-> Procedure m
forall (m :: * -> *) a1 a2 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2 Text
"filesizeformat"
Text
"Format `value` as a human-readable file size."
( Identifier
"value"
, Maybe FileSize
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"number"
, Text
""
)
( Identifier
"binary"
, Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool"
, Text
"If set, use binary units (kiB, MiB, ...) instead of decimal (kB, MB, ...)"
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
((FileSize -> Bool -> ExceptT RuntimeError m Text) -> Procedure m)
-> (FileSize -> Bool -> ExceptT RuntimeError m Text) -> Procedure m
forall a b. (a -> b) -> a -> b
$ \(FileSize Integer
value) Bool
binary -> do
let (Integer
multiplier, [Text]
units) =
if Bool
binary then
(Integer
1024, [Item [Text]
"ki", Item [Text]
"Mi", Item [Text]
"Gi", Item [Text]
"Ti", Item [Text]
"Pi"])
else
(Integer
1000, [Item [Text]
"k", Item [Text]
"M", Item [Text]
"G", Item [Text]
"T", Item [Text]
"P"])
let str :: Text
str = Integer -> [Text] -> Integer -> Text
go Integer
multiplier [Text]
units Integer
value
Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> Text -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$ Text
str Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"B"
where
go :: Integer -> [Text] -> Integer -> Text
go :: Integer -> [Text] -> Integer -> Text
go Integer
_ [] Integer
value
= Integer -> Text
forall a. Show a => a -> Text
Text.show Integer
value
go Integer
multiplier [Text]
units Integer
value | Integer
value Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0
= Text
"-" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Integer -> [Text] -> Integer -> Text
go Integer
multiplier [Text]
units (Integer -> Integer
forall a. Num a => a -> a
abs Integer
value)
go Integer
multiplier (Text
unit:[Text]
units) Integer
value
| Integer
value Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
multiplier
= Integer -> Text
forall a. Show a => a -> Text
Text.show Integer
value
| Integer
value Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
multiplier Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
multiplier Bool -> Bool -> Bool
|| [Text] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Text]
units
= String -> Text
Text.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$
String -> Integer -> Integer -> Text -> String
forall r. PrintfType r => String -> r
printf String
"%i.%01i%s"
(Integer
value Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`div` Integer
multiplier)
((Integer
value Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
10 Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`div` Integer
multiplier) Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`mod` Integer
10)
Text
unit
| Bool
otherwise
= Integer -> [Text] -> Integer -> Text
go Integer
multiplier [Text]
units (Integer
value Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`div` Integer
multiplier)
fnGroupBy :: forall m. Monad m => Procedure m
fnGroupBy :: forall (m :: * -> *). Monad m => Procedure m
fnGroupBy = Text
-> Text
-> (Identifier, Maybe [Value m], Maybe TypeDoc, Text)
-> (Identifier, Maybe (Either Integer Text), Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe (Value m)), Maybe TypeDoc, Text)
-> (Identifier, Maybe Bool, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> ([Value m]
-> Either Integer Text
-> Maybe (Value m)
-> Bool
-> ExceptT RuntimeError m (Map Scalar [Value m]))
-> Procedure m
forall (m :: * -> *) a1 a2 a3 a4 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue a4 m,
FromValue a4 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4 Text
"groupby"
([Text] -> Text
Text.unlines
[ Text
Item [Text]
"Group a list of objects by an attribute."
, Text
"The attribute can use dot notation for nested access, " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"e.g. `'address.city'`."
]
)
( Identifier
"value"
, Maybe [Value m]
forall a. Maybe a
Nothing :: Maybe [Value m]
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"attribute"
, Maybe (Either Integer Text)
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Vector Text -> TypeDoc
TypeDocAlternatives [ Text
Item (Vector Text)
"string", Text
Item (Vector Text)
"int" ]
, Text
"Attribute to group by."
)
( Identifier
"default"
, Maybe (Value m) -> Maybe (Maybe (Value m))
forall a. a -> Maybe a
Just Maybe (Value m)
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
"Default value to use if an object doesn't have the " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"requested attribute."
)
( Identifier
"case_sensitive"
, Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"bool"
, Text
"Use case-sensitive comparisons for grouping objects."
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"dict")
(([Value m]
-> Either Integer Text
-> Maybe (Value m)
-> Bool
-> ExceptT RuntimeError m (Map Scalar [Value m]))
-> Procedure m)
-> ([Value m]
-> Either Integer Text
-> Maybe (Value m)
-> Bool
-> ExceptT RuntimeError m (Map Scalar [Value m]))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \[Value m]
value Either Integer Text
attrib (Maybe (Value m)
defValMay :: Maybe (Value m)) Bool
caseSensitive -> do
let getAttribPath :: Value m -> [Text] -> ExceptT RuntimeError m (Maybe (Value m))
getAttribPath :: Value m -> [Text] -> ExceptT RuntimeError m (Maybe (Value m))
getAttribPath Value m
o [] = Maybe (Value m) -> ExceptT RuntimeError m (Maybe (Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Value m) -> ExceptT RuntimeError m (Maybe (Value m)))
-> Maybe (Value m) -> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just Value m
o
getAttribPath Value m
o (Text
p:[Text]
ps) = do
Maybe (Value m)
o'May <- m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m)))
-> m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
forall (m :: * -> *).
Monad m =>
Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
getAttrOrItemRaw Value m
o (Text -> Identifier
Identifier Text
p)
case Maybe (Value m)
o'May of
Just Value m
o' -> Value m -> [Text] -> ExceptT RuntimeError m (Maybe (Value m))
getAttribPath Value m
o' [Text]
ps
Maybe (Value m)
Nothing -> Maybe (Value m) -> ExceptT RuntimeError m (Maybe (Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Value m) -> ExceptT RuntimeError m (Maybe (Value m)))
-> Maybe (Value m) -> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Maybe (Value m)
forall a. Maybe a
Nothing
let attribProjection :: Value m -> ExceptT RuntimeError m (Maybe (Value m))
attribProjection :: Value m -> ExceptT RuntimeError m (Maybe (Value m))
attribProjection = (Maybe (Value m) -> Maybe (Value m))
-> ExceptT RuntimeError m (Maybe (Value m))
-> ExceptT RuntimeError m (Maybe (Value m))
forall a b.
(a -> b) -> ExceptT RuntimeError m a -> ExceptT RuntimeError m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Maybe (Value m)
-> (Value m -> Maybe (Value m))
-> Maybe (Value m)
-> Maybe (Value m)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just Value m
forall (m :: * -> *). Value m
NoneV) Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just) (ExceptT RuntimeError m (Maybe (Value m))
-> ExceptT RuntimeError m (Maybe (Value m)))
-> (Value m -> ExceptT RuntimeError m (Maybe (Value m)))
-> Value m
-> ExceptT RuntimeError m (Maybe (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. case Either Integer Text
attrib of
Left Integer
i -> \Value m
obj ->
m (Maybe (Value m)) -> ExceptT RuntimeError m (Maybe (Value m))
forall (m :: * -> *) a. Monad m => m a -> ExceptT RuntimeError m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Maybe (Value m)) -> ExceptT RuntimeError m (Maybe (Value m)))
-> m (Maybe (Value m)) -> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> Value m -> m (Maybe (Value m))
forall (m :: * -> *).
Monad m =>
Value m -> Value m -> m (Maybe (Value m))
getItemRaw Value m
obj (Integer -> Value m
forall (m :: * -> *). Integer -> Value m
IntV Integer
i)
Right Text
t -> \Value m
obj ->
Value m -> [Text] -> ExceptT RuntimeError m (Maybe (Value m))
getAttribPath Value m
obj ([Text] -> ExceptT RuntimeError m (Maybe (Value m)))
-> [Text] -> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ HasCallStack => Text -> Text -> [Text]
Text -> Text -> [Text]
Text.splitOn Text
"." Text
t
attribCaseFold :: Scalar -> Scalar
attribCaseFold :: Scalar -> Scalar
attribCaseFold (StringScalar Text
t) =
if Bool
caseSensitive then
Text -> Scalar
StringScalar Text
t
else
Text -> Scalar
StringScalar (Text -> Text
Text.toCaseFold Text
t)
attribCaseFold Scalar
x = Scalar
x
append :: Map Scalar [Value m] -> Maybe (Scalar, Value m) -> Map Scalar [Value m]
append :: Map Scalar [Value m]
-> Maybe (Scalar, Value m) -> Map Scalar [Value m]
append Map Scalar [Value m]
m Maybe (Scalar, Value m)
Nothing = Map Scalar [Value m]
m
append Map Scalar [Value m]
m (Just (Scalar
k, Value m
v)) =
([Value m] -> [Value m] -> [Value m])
-> Scalar
-> [Value m]
-> Map Scalar [Value m]
-> Map Scalar [Value m]
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith (([Value m] -> [Value m] -> [Value m])
-> [Value m] -> [Value m] -> [Value m]
forall a b c. (a -> b -> c) -> b -> a -> c
flip [Value m] -> [Value m] -> [Value m]
forall a. [a] -> [a] -> [a]
(++)) Scalar
k [Item [Value m]
Value m
v] Map Scalar [Value m]
m
prepare :: Value m -> ExceptT RuntimeError m (Maybe (Scalar, Value m))
prepare :: Value m -> ExceptT RuntimeError m (Maybe (Scalar, Value m))
prepare Value m
v = do
Maybe (Value m)
kMay <- Value m -> ExceptT RuntimeError m (Maybe (Value m))
attribProjection Value m
v
Maybe Scalar
skMay <- (Value m -> ExceptT RuntimeError m Scalar)
-> Maybe (Value m) -> ExceptT RuntimeError m (Maybe Scalar)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Maybe a -> m (Maybe b)
mapM
((Scalar -> Scalar)
-> ExceptT RuntimeError m Scalar -> ExceptT RuntimeError m Scalar
forall a b.
(a -> b) -> ExceptT RuntimeError m a -> ExceptT RuntimeError m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Scalar -> Scalar
attribCaseFold (ExceptT RuntimeError m Scalar -> ExceptT RuntimeError m Scalar)
-> (Value m -> ExceptT RuntimeError m Scalar)
-> Value m
-> ExceptT RuntimeError m Scalar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either RuntimeError Scalar -> ExceptT RuntimeError m Scalar
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError Scalar -> ExceptT RuntimeError m Scalar)
-> (Value m -> Either RuntimeError Scalar)
-> Value m
-> ExceptT RuntimeError m Scalar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> Either RuntimeError Scalar
forall (m :: * -> *). Value m -> Either RuntimeError Scalar
asScalarVal)
(Maybe (Value m)
kMay Maybe (Value m) -> Maybe (Value m) -> Maybe (Value m)
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe (Value m)
defValMay)
case Maybe Scalar
skMay of
Maybe Scalar
Nothing -> Maybe (Scalar, Value m)
-> ExceptT RuntimeError m (Maybe (Scalar, Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Scalar, Value m)
forall a. Maybe a
Nothing
Just Scalar
k -> Maybe (Scalar, Value m)
-> ExceptT RuntimeError m (Maybe (Scalar, Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Scalar, Value m)
-> ExceptT RuntimeError m (Maybe (Scalar, Value m)))
-> Maybe (Scalar, Value m)
-> ExceptT RuntimeError m (Maybe (Scalar, Value m))
forall a b. (a -> b) -> a -> b
$ (Scalar, Value m) -> Maybe (Scalar, Value m)
forall a. a -> Maybe a
Just (Scalar
k, Value m
v)
(Map Scalar [Value m]
-> Maybe (Scalar, Value m) -> Map Scalar [Value m])
-> Map Scalar [Value m]
-> [Maybe (Scalar, Value m)]
-> Map Scalar [Value m]
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' Map Scalar [Value m]
-> Maybe (Scalar, Value m) -> Map Scalar [Value m]
append Map Scalar [Value m]
forall a. Monoid a => a
mempty ([Maybe (Scalar, Value m)] -> Map Scalar [Value m])
-> ExceptT RuntimeError m [Maybe (Scalar, Value m)]
-> ExceptT RuntimeError m (Map Scalar [Value m])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value m -> ExceptT RuntimeError m (Maybe (Scalar, Value m)))
-> [Value m] -> ExceptT RuntimeError m [Maybe (Scalar, Value m)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Value m -> ExceptT RuntimeError m (Maybe (Scalar, Value m))
prepare [Value m]
value
fnBatch :: forall m. Monad m => Procedure m
fnBatch :: forall (m :: * -> *). Monad m => Procedure m
fnBatch = Text
-> Text
-> (Identifier, Maybe [Value m], Maybe TypeDoc, Text)
-> (Identifier, Maybe Int, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe (Value m)), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> ([Value m]
-> Int -> Maybe (Value m) -> ExceptT RuntimeError m [[Value m]])
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"batch"
Text
"Split up a list into chunks of length `linecount`."
( Identifier
"value"
, Maybe [Value m]
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
( Identifier
"linecount"
, Maybe Int
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"int"
, Text
"Number of items per chunk. Unlimited if not specified."
)
( Identifier
"fill_with"
, Maybe (Value m) -> Maybe (Maybe (Value m))
forall a. a -> Maybe a
Just Maybe (Value m)
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
"Filler to pad shorter chunks with. If not specified, don't pad."
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"list")
(([Value m]
-> Int -> Maybe (Value m) -> ExceptT RuntimeError m [[Value m]])
-> Procedure m)
-> ([Value m]
-> Int -> Maybe (Value m) -> ExceptT RuntimeError m [[Value m]])
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \[Value m]
value Int
linecount Maybe (Value m)
fillWithMay -> do
[[Value m]] -> ExceptT RuntimeError m [[Value m]]
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([[Value m]] -> ExceptT RuntimeError m [[Value m]])
-> [[Value m]] -> ExceptT RuntimeError m [[Value m]]
forall a b. (a -> b) -> a -> b
$ Maybe (Value m) -> Int -> [Value m] -> [[Value m]]
chunksOf Maybe (Value m)
fillWithMay Int
linecount [Value m]
value
where
chunksOf :: Maybe (Value m) -> Int -> [Value m] -> [[Value m]]
chunksOf :: Maybe (Value m) -> Int -> [Value m] -> [[Value m]]
chunksOf Maybe (Value m)
_ Int
_ [] = []
chunksOf Maybe (Value m)
fillMay Int
n [Value m]
xs =
case Int -> [Value m] -> [Value m]
forall a. Int -> [a] -> [a]
take Int
n [Value m]
xs of
[Value m]
xs' | [Value m] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Value m]
xs' Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n ->
let paddingLength :: Int
paddingLength = Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- [Value m] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Value m]
xs'
padding :: [Value m]
padding = case (Maybe (Value m)
fillMay, Int
paddingLength) of
(Just Value m
fill, Int
p) | Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 ->
Int -> Value m -> [Value m]
forall a. Int -> a -> [a]
replicate Int
paddingLength Value m
fill
(Maybe (Value m), Int)
_ -> []
in [[Value m]
xs' [Value m] -> [Value m] -> [Value m]
forall a. [a] -> [a] -> [a]
++ [Value m]
padding]
[Value m]
xs' -> [Value m]
xs' [Value m] -> [[Value m]] -> [[Value m]]
forall a. a -> [a] -> [a]
: Maybe (Value m) -> Int -> [Value m] -> [[Value m]]
chunksOf Maybe (Value m)
fillMay Int
n (Int -> [Value m] -> [Value m]
forall a. Int -> [a] -> [a]
drop Int
n [Value m]
xs)
fnFirst :: forall m. Monad m => Procedure m
fnFirst :: forall (m :: * -> *). Monad m => Procedure m
fnFirst = Text
-> Text
-> (Identifier, Maybe (Value m), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Value m -> ExceptT RuntimeError m (Value m))
-> Procedure m
forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1 Text
"first"
Text
"Get the first element from a list, or the first character from a string."
( Identifier
"value"
, Maybe (Value m)
forall a. Maybe a
Nothing :: Maybe (Value m)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Vector Text -> TypeDoc
TypeDocAlternatives [ Text
Item (Vector Text)
"list", Text
Item (Vector Text)
"string", Text
Item (Vector Text)
"bytes" ]
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny)
((Value m -> ExceptT RuntimeError m (Value m)) -> Procedure m)
-> (Value m -> ExceptT RuntimeError m (Value m)) -> Procedure m
forall a b. (a -> b) -> a -> b
$ \case
ListV Vector (Value m)
v -> case Vector (Value m) -> Maybe (Value m, Vector (Value m))
forall a. Vector a -> Maybe (a, Vector a)
V.uncons Vector (Value m)
v of
Just (Value m
x, Vector (Value m)
_) -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value m
x
Maybe (Value m, Vector (Value m))
Nothing -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value m
forall (m :: * -> *). Value m
NoneV
StringV Text
txt -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> Value m -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ Text -> Value m
forall (m :: * -> *). Text -> Value m
StringV (Text -> Value m) -> Text -> Value m
forall a b. (a -> b) -> a -> b
$ Int -> Text -> Text
Text.take Int
1 Text
txt
EncodedV (Encoded Text
txt) -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> Value m -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ Encoded -> Value m
forall (m :: * -> *). Encoded -> Value m
EncodedV (Encoded -> Value m) -> (Text -> Encoded) -> Text -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Encoded
Encoded (Text -> Value m) -> Text -> Value m
forall a b. (a -> b) -> a -> b
$ Int -> Text -> Text
Text.take Int
1 Text
txt
BytesV ByteString
arr -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> (Maybe Word8 -> Value m)
-> Maybe Word8
-> ExceptT RuntimeError m (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Word8 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (Maybe Word8 -> ExceptT RuntimeError m (Value m))
-> Maybe Word8 -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ ByteString -> Int -> Maybe Word8
BS.indexMaybe ByteString
arr Int
0
Value m
x -> RuntimeError -> ExceptT RuntimeError m (Value m)
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m (Value m))
-> RuntimeError -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Text -> Text -> RuntimeError
ArgumentError Text
"first" Text
"value" Text
"list or string" (Value m -> Text
forall (m :: * -> *). Value m -> Text
tagNameOf Value m
x)
fnLast :: forall m. Monad m => Procedure m
fnLast :: forall (m :: * -> *). Monad m => Procedure m
fnLast = Text
-> Text
-> (Identifier, Maybe (Value m), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Value m -> ExceptT RuntimeError m (Value m))
-> Procedure m
forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1 Text
"last"
Text
"Get the last element from a list, or the last character from a string."
( Identifier
"value"
, Maybe (Value m)
forall a. Maybe a
Nothing :: Maybe (Value m)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Vector Text -> TypeDoc
TypeDocAlternatives [ Text
Item (Vector Text)
"list", Text
Item (Vector Text)
"string", Text
Item (Vector Text)
"bytes" ]
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny)
((Value m -> ExceptT RuntimeError m (Value m)) -> Procedure m)
-> (Value m -> ExceptT RuntimeError m (Value m)) -> Procedure m
forall a b. (a -> b) -> a -> b
$ \case
ListV Vector (Value m)
v -> case Vector (Value m) -> Maybe (Vector (Value m), Value m)
forall a. Vector a -> Maybe (Vector a, a)
V.unsnoc Vector (Value m)
v of
Just (Vector (Value m)
_, Value m
x) -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value m
x
Maybe (Vector (Value m), Value m)
Nothing -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value m
forall (m :: * -> *). Value m
NoneV
StringV Text
txt -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> Value m -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ Text -> Value m
forall (m :: * -> *). Text -> Value m
StringV (Text -> Value m) -> Text -> Value m
forall a b. (a -> b) -> a -> b
$ Int -> Text -> Text
Text.takeEnd Int
1 Text
txt
BytesV ByteString
arr -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> (Maybe Word8 -> Value m)
-> Maybe Word8
-> ExceptT RuntimeError m (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Word8 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (Maybe Word8 -> ExceptT RuntimeError m (Value m))
-> Maybe Word8 -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ ByteString -> Int -> Maybe Word8
BS.indexMaybe ByteString
arr (ByteString -> Int
BS.length ByteString
arr Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
EncodedV (Encoded Text
txt) -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value m -> ExceptT RuntimeError m (Value m))
-> Value m -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ Encoded -> Value m
forall (m :: * -> *). Encoded -> Value m
EncodedV (Encoded -> Value m) -> (Text -> Encoded) -> Text -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Encoded
Encoded (Text -> Value m) -> Text -> Value m
forall a b. (a -> b) -> a -> b
$ Int -> Text -> Text
Text.takeEnd Int
1 Text
txt
Value m
x -> RuntimeError -> ExceptT RuntimeError m (Value m)
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m (Value m))
-> RuntimeError -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Text -> Text -> RuntimeError
ArgumentError Text
"first" Text
"value" Text
"list or string" (Value m -> Text
forall (m :: * -> *). Value m -> Text
tagNameOf Value m
x)
autoParseDate :: TimeZone -> Text -> Maybe ZonedTime
autoParseDate :: TimeZone -> Text -> Maybe ZonedTime
autoParseDate TimeZone
defTZ Text
input =
[Maybe ZonedTime] -> Maybe ZonedTime
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum [ String -> String -> Maybe ZonedTime
parse String
t (Text -> String
Text.unpack Text
input) | (String -> String -> Maybe ZonedTime
parse, String
t) <- [(String -> String -> Maybe ZonedTime, String)]
formats ]
where
ztparse :: String -> String -> Maybe ZonedTime
ztparse :: String -> String -> Maybe ZonedTime
ztparse String
fmt = Bool -> TimeLocale -> String -> String -> Maybe ZonedTime
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> String -> String -> m t
parseTimeM Bool
True TimeLocale
defaultTimeLocale String
fmt
utcparse :: String -> String -> Maybe ZonedTime
utcparse :: String -> String -> Maybe ZonedTime
utcparse String
fmt String
i = do
LocalTime
lt <- Bool -> TimeLocale -> String -> String -> Maybe LocalTime
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> String -> String -> m t
parseTimeM Bool
True TimeLocale
defaultTimeLocale String
fmt String
i
ZonedTime -> Maybe ZonedTime
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return (ZonedTime -> Maybe ZonedTime) -> ZonedTime -> Maybe ZonedTime
forall a b. (a -> b) -> a -> b
$ LocalTime -> TimeZone -> ZonedTime
ZonedTime LocalTime
lt TimeZone
defTZ
formats :: [(String -> String -> Maybe ZonedTime, String)]
formats =
[ (String -> String -> Maybe ZonedTime
ztparse, String
"%Y-%m-%dT%H:%M:%S%Q%Z")
, (String -> String -> Maybe ZonedTime
utcparse, String
"%Y-%m-%d %H:%M:%S%Q")
, (String -> String -> Maybe ZonedTime
ztparse, String
"%Y-%m-%d %H:%M:%S%Q%z")
, (String -> String -> Maybe ZonedTime
ztparse, String
"%Y-%m-%d %H:%M:%S%Q%Z")
, (String -> String -> Maybe ZonedTime
utcparse, String
"%Y-%m-%d")
]
dateFromParts :: forall m. Monad m
=> TimeZone
-> [Value m]
-> Maybe ZonedTime
dateFromParts :: forall (m :: * -> *).
Monad m =>
TimeZone -> [Value m] -> Maybe ZonedTime
dateFromParts TimeZone
defTZ [Value m]
parts = do
Integer
year <- case [Value m]
parts of
(IntV Integer
y : [Value m]
_) -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
y
(StringV Text
x : [Value m]
_) -> String -> Maybe Integer
forall a. Read a => String -> Maybe a
readMaybe (String -> Maybe Integer)
-> (Text -> String) -> Text -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
Text.unpack (Text -> Maybe Integer) -> Text -> Maybe Integer
forall a b. (a -> b) -> a -> b
$ Text
x
(Value m
_ : [Value m]
_) -> Maybe Integer
forall a. Maybe a
Nothing
[Value m]
_ -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
2000
Integer
month <- case [Value m]
parts of
(Value m
_ : IntV Integer
m : [Value m]
_) -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
m
(Value m
_ : StringV Text
x : [Value m]
_) -> String -> Maybe Integer
forall a. Read a => String -> Maybe a
readMaybe (String -> Maybe Integer)
-> (Text -> String) -> Text -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
Text.unpack (Text -> Maybe Integer) -> Text -> Maybe Integer
forall a b. (a -> b) -> a -> b
$ Text
x
(Value m
_ : Value m
_ : [Value m]
_) -> Maybe Integer
forall a. Maybe a
Nothing
[Value m]
_ -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
1
Integer
day <- case [Value m]
parts of
(Value m
_ : Value m
_ : IntV Integer
d : [Value m]
_) -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
d
(Value m
_ : Value m
_ : StringV Text
x : [Value m]
_) -> String -> Maybe Integer
forall a. Read a => String -> Maybe a
readMaybe (String -> Maybe Integer)
-> (Text -> String) -> Text -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
Text.unpack (Text -> Maybe Integer) -> Text -> Maybe Integer
forall a b. (a -> b) -> a -> b
$ Text
x
(Value m
_ : Value m
_ : Value m
_ : [Value m]
_) -> Maybe Integer
forall a. Maybe a
Nothing
[Value m]
_ -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
1
Integer
hour <- case [Value m]
parts of
(Value m
_ : Value m
_ : Value m
_ : IntV Integer
h : [Value m]
_) -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
h
(Value m
_ : Value m
_ : Value m
_ : StringV Text
x : [Value m]
_) -> String -> Maybe Integer
forall a. Read a => String -> Maybe a
readMaybe (String -> Maybe Integer)
-> (Text -> String) -> Text -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
Text.unpack (Text -> Maybe Integer) -> Text -> Maybe Integer
forall a b. (a -> b) -> a -> b
$ Text
x
(Value m
_ : Value m
_ : Value m
_ : Value m
_ : [Value m]
_) -> Maybe Integer
forall a. Maybe a
Nothing
[Value m]
_ -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
0
Integer
minute <- case [Value m]
parts of
(Value m
_ : Value m
_ : Value m
_ : Value m
_ : IntV Integer
m : [Value m]
_) -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
m
(Value m
_ : Value m
_ : Value m
_ : Value m
_ : StringV Text
x : [Value m]
_) -> String -> Maybe Integer
forall a. Read a => String -> Maybe a
readMaybe (String -> Maybe Integer)
-> (Text -> String) -> Text -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
Text.unpack (Text -> Maybe Integer) -> Text -> Maybe Integer
forall a b. (a -> b) -> a -> b
$ Text
x
(Value m
_ : Value m
_ : Value m
_ : Value m
_ : Value m
_ : [Value m]
_) -> Maybe Integer
forall a. Maybe a
Nothing
[Value m]
_ -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
0
Integer
second <- case [Value m]
parts of
(Value m
_ : Value m
_ : Value m
_ : Value m
_ : Value m
_ : IntV Integer
s : [Value m]
_) -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
s
(Value m
_ : Value m
_ : Value m
_ : Value m
_ : Value m
_ : StringV Text
x : [Value m]
_) -> String -> Maybe Integer
forall a. Read a => String -> Maybe a
readMaybe (String -> Maybe Integer)
-> (Text -> String) -> Text -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
Text.unpack (Text -> Maybe Integer) -> Text -> Maybe Integer
forall a b. (a -> b) -> a -> b
$ Text
x
(Value m
_ : Value m
_ : Value m
_ : Value m
_ : Value m
_ : Value m
_ : [Value m]
_) -> Maybe Integer
forall a. Maybe a
Nothing
[Value m]
_ -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
0
TimeZone
tz <- case [Value m]
parts of
(Value m
_ : Value m
_ : Value m
_ : Value m
_ : Value m
_ : Value m
_ : Value m
v : [Value m]
_) -> Value m -> Maybe TimeZone
forall (m :: * -> *). Value m -> Maybe TimeZone
parseTZ Value m
v
[Value m]
_ -> TimeZone -> Maybe TimeZone
forall a. a -> Maybe a
Just TimeZone
defTZ
ZonedTime -> Maybe ZonedTime
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ZonedTime -> Maybe ZonedTime) -> ZonedTime -> Maybe ZonedTime
forall a b. (a -> b) -> a -> b
$ LocalTime -> TimeZone -> ZonedTime
ZonedTime
(Day -> TimeOfDay -> LocalTime
LocalTime
(Integer -> Int -> Int -> Day
fromGregorian Integer
year (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
month) (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
day))
(Int -> Int -> Pico -> TimeOfDay
TimeOfDay (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
hour) (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
minute) (Integer -> Pico
forall a. Num a => Integer -> a
fromInteger Integer
second)))
TimeZone
tz
parseTZ :: Value m -> Maybe TimeZone
parseTZ :: forall (m :: * -> *). Value m -> Maybe TimeZone
parseTZ (StringV Text
s) =
Bool -> TimeLocale -> String -> String -> Maybe TimeZone
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> String -> String -> m t
parseTimeM Bool
True TimeLocale
defaultTimeLocale String
"%z" (String -> Maybe TimeZone) -> String -> Maybe TimeZone
forall a b. (a -> b) -> a -> b
$ Text -> String
Text.unpack Text
s
parseTZ (IntV Integer
i) =
TimeZone -> Maybe TimeZone
forall a. a -> Maybe a
Just (TimeZone -> Maybe TimeZone) -> TimeZone -> Maybe TimeZone
forall a b. (a -> b) -> a -> b
$ Int -> Bool -> String -> TimeZone
TimeZone (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
i) Bool
False String
""
parseTZ (ListV Vector (Value m)
v) =
case Vector (Value m) -> [Value m]
forall a. Vector a -> [a]
V.toList Vector (Value m)
v of
[IntV Integer
minutes, BoolV Bool
summerOnly, StringV Text
name] ->
TimeZone -> Maybe TimeZone
forall a. a -> Maybe a
Just (TimeZone -> Maybe TimeZone) -> TimeZone -> Maybe TimeZone
forall a b. (a -> b) -> a -> b
$ Int -> Bool -> String -> TimeZone
TimeZone (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
minutes) Bool
summerOnly (Text -> String
Text.unpack Text
name)
[Value m]
_ -> Maybe TimeZone
forall a. Maybe a
Nothing
parseTZ Value m
_ = Maybe TimeZone
forall a. Maybe a
Nothing
convertTZ :: Maybe TimeZone -> ZonedTime -> ZonedTime
convertTZ :: Maybe TimeZone -> ZonedTime -> ZonedTime
convertTZ Maybe TimeZone
Nothing = ZonedTime -> ZonedTime
forall a. a -> a
id
convertTZ (Just TimeZone
tz) = TimeZone -> UTCTime -> ZonedTime
utcToZonedTime TimeZone
tz (UTCTime -> ZonedTime)
-> (ZonedTime -> UTCTime) -> ZonedTime -> ZonedTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZonedTime -> UTCTime
zonedTimeToUTC
fnDateFormat :: forall m. Monad m => Procedure m
fnDateFormat :: forall (m :: * -> *). Monad m => Procedure m
fnDateFormat = Text
-> Text
-> (Identifier, Maybe (Either Text [Value m]), Maybe TypeDoc, Text)
-> (Identifier, Maybe Text, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe (Value m)), Maybe TypeDoc, Text)
-> (Identifier, Maybe (Maybe Text), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Either Text [Value m]
-> Text
-> Maybe (Value m)
-> Maybe Text
-> ExceptT RuntimeError m Text)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 a4 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue a4 m,
FromValue a4 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4 Text
"dateformat"
([Text] -> Text
Text.unlines
[ Text
Item [Text]
"Format a date/time value."
, Text
"Format strings follow the specification found here: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"[Date.Time.Format.formatTime](https://hackage.haskell.org/package/time-1.14/docs/Data-Time-Format.html#v:formatTime)"
, Text
Item [Text]
"Accepted input formats:"
, Text
Item [Text]
"- `%Y-%m-%dT%H:%M:%S%Q%Z` (2025-11-28T23:54:32.1234UTC)"
, Text
Item [Text]
"- `%Y-%m-%d %H:%M:%S%Q` (2025-11-28 23:54:32.1234UTC)"
, Text
Item [Text]
"- `%Y-%m-%d %H:%M:%S%Q%z` (2025-11-28 23:54:32.1234+0100)"
, Text
Item [Text]
"- `%Y-%m-%d %H:%M:%S%Q%Z` (2025-11-28 23:54:32.1234UTC)"
, Text
Item [Text]
"- `%Y-%m-%d` (2025-11-28)"
]
)
( Identifier
"date"
, Maybe (Either Text [Value m])
forall a. Maybe a
Nothing :: Maybe (Either Text [Value m])
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Vector Text -> TypeDoc
TypeDocAlternatives [ Text
Item (Vector Text)
"string", Text
Item (Vector Text)
"list" ]
, Text
"May be given as a formatted date, or as a list " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"of `[ year, month, day, hours, minutes, seconds, " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"timezone ]`. " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"Partial lists will be padded with appropriate defaults."
)
( Identifier
"format"
, Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"%c"
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string"
, Text
""
)
( Identifier
"tz"
, Maybe (Value m) -> Maybe (Maybe (Value m))
forall a. a -> Maybe a
Just Maybe (Value m)
forall a. Maybe a
Nothing :: Maybe (Maybe (Value m))
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Vector Text -> TypeDoc
TypeDocAlternatives [ Text
Item (Vector Text)
"string", Text
Item (Vector Text)
"int", Text
Item (Vector Text)
"list" ]
, Text
"Time zone. May be given as a string specifying an offset " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"(±HHMM), an integer offset in minutes, or a list " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"containing 3 elements: offset in minues (int), " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
"summer-only (bool), and timezone name (string)."
)
( Identifier
"locale"
, Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing :: Maybe (Maybe Text)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
"Select a locale. Not yet implemented, ignored."
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"string")
((Either Text [Value m]
-> Text
-> Maybe (Value m)
-> Maybe Text
-> ExceptT RuntimeError m Text)
-> Procedure m)
-> (Either Text [Value m]
-> Text
-> Maybe (Value m)
-> Maybe Text
-> ExceptT RuntimeError m Text)
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Either Text [Value m]
dateRaw Text
fmt Maybe (Value m)
tzVal Maybe Text
_localeMay -> do
let tzMay :: Maybe TimeZone
tzMay = Value m -> Maybe TimeZone
forall (m :: * -> *). Value m -> Maybe TimeZone
parseTZ (Value m -> Maybe TimeZone) -> Maybe (Value m) -> Maybe TimeZone
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe (Value m)
tzVal
defTZ :: TimeZone
defTZ = TimeZone -> Maybe TimeZone -> TimeZone
forall a. a -> Maybe a -> a
fromMaybe TimeZone
utc Maybe TimeZone
tzMay
locale :: TimeLocale
locale = TimeLocale
defaultTimeLocale
ZonedTime
date <- ExceptT RuntimeError m ZonedTime
-> (ZonedTime -> ExceptT RuntimeError m ZonedTime)
-> Maybe ZonedTime
-> ExceptT RuntimeError m ZonedTime
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(RuntimeError -> ExceptT RuntimeError m ZonedTime
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m ZonedTime)
-> RuntimeError -> ExceptT RuntimeError m ZonedTime
forall a b. (a -> b) -> a -> b
$
Text -> Text -> Text -> Text -> RuntimeError
ArgumentError
Text
"dateformat"
Text
"date"
Text
"date string or date array"
(Either Text [Value m] -> Text
forall a. Show a => a -> Text
Text.show Either Text [Value m]
dateRaw)
)
ZonedTime -> ExceptT RuntimeError m ZonedTime
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe ZonedTime -> ExceptT RuntimeError m ZonedTime)
-> Maybe ZonedTime -> ExceptT RuntimeError m ZonedTime
forall a b. (a -> b) -> a -> b
$
case Either Text [Value m]
dateRaw of
Left Text
str -> TimeZone -> Text -> Maybe ZonedTime
autoParseDate TimeZone
defTZ Text
str
Right [Value m]
parts -> TimeZone -> [Value m] -> Maybe ZonedTime
forall (m :: * -> *).
Monad m =>
TimeZone -> [Value m] -> Maybe ZonedTime
dateFromParts TimeZone
defTZ [Value m]
parts
Text -> ExceptT RuntimeError m Text
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ExceptT RuntimeError m Text)
-> (ZonedTime -> Text) -> ZonedTime -> ExceptT RuntimeError m Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack (String -> Text) -> (ZonedTime -> String) -> ZonedTime -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeLocale -> String -> ZonedTime -> String
forall t. FormatTime t => TimeLocale -> String -> t -> String
formatTime TimeLocale
locale (Text -> String
Text.unpack Text
fmt) (ZonedTime -> String)
-> (ZonedTime -> ZonedTime) -> ZonedTime -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe TimeZone -> ZonedTime -> ZonedTime
convertTZ Maybe TimeZone
tzMay (ZonedTime -> ExceptT RuntimeError m Text)
-> ZonedTime -> ExceptT RuntimeError m Text
forall a b. (a -> b) -> a -> b
$ ZonedTime
date
fnHelp :: forall m. Monad m => Procedure m
fnHelp :: forall (m :: * -> *). Monad m => Procedure m
fnHelp = Text
-> Text
-> (Identifier, Maybe (Value m), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Value m -> ExceptT RuntimeError m (Value m))
-> Procedure m
forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1 Text
"help"
Text
"Get documentation for the given value, if available."
( Identifier
"value"
, Maybe (Value m)
forall a. Maybe a
Nothing :: Maybe (Value m)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"dict")
((Value m -> ExceptT RuntimeError m (Value m)) -> Procedure m)
-> (Value m -> ExceptT RuntimeError m (Value m)) -> Procedure m
forall a b. (a -> b) -> a -> b
$ \Value m
value -> do
case Value m
value of
ProcedureV (NativeProcedure ObjectID
_ Maybe ProcedureDoc
doc [(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m))
_) ->
Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe ProcedureDoc -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue Maybe ProcedureDoc
doc :: Value m)
Value m
_ ->
Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value m
forall (m :: * -> *). Value m
NoneV
fnDictGet :: forall m. Monad m => Procedure m
fnDictGet :: forall (m :: * -> *). Monad m => Procedure m
fnDictGet = Text
-> Text
-> (Identifier, Maybe (Map Scalar (Value m)), Maybe TypeDoc, Text)
-> (Identifier, Maybe Scalar, Maybe TypeDoc, Text)
-> (Identifier, Maybe (Value m), Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Map Scalar (Value m)
-> Scalar -> Value m -> ExceptT RuntimeError m (Value m))
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
"dict.get"
Text
"Get an item from a dictionary."
( Identifier
"value"
, Maybe (Map Scalar (Value m))
forall a. Maybe a
Nothing :: Maybe (Map Scalar (Value m))
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"dict"
, Text
""
)
( Identifier
"key"
, Maybe Scalar
forall a. Maybe a
Nothing
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ Text -> TypeDoc
TypeDocSingle Text
"scalar"
, Text
""
)
( Identifier
"default"
, Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just Value m
forall (m :: * -> *). Value m
NoneV :: Maybe (Value m)
, TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny
, Text
""
)
(TypeDoc -> Maybe TypeDoc
forall a. a -> Maybe a
Just (TypeDoc -> Maybe TypeDoc) -> TypeDoc -> Maybe TypeDoc
forall a b. (a -> b) -> a -> b
$ TypeDoc
TypeDocAny)
((Map Scalar (Value m)
-> Scalar -> Value m -> ExceptT RuntimeError m (Value m))
-> Procedure m)
-> (Map Scalar (Value m)
-> Scalar -> Value m -> ExceptT RuntimeError m (Value m))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \Map Scalar (Value m)
value Scalar
key Value m
defval -> do
case Scalar -> Map Scalar (Value m) -> Maybe (Value m)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Scalar
key Map Scalar (Value m)
value of
Maybe (Value m)
Nothing -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value m
defval
Just Value m
v -> Value m -> ExceptT RuntimeError m (Value m)
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value m
v
isUpperVal :: Value m -> Value m
isUpperVal :: forall (m :: * -> *). Value m -> Value m
isUpperVal (StringV Text
txt) = Bool -> Value m
forall (m :: * -> *). Bool -> Value m
BoolV ((Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isUpper Text
txt)
isUpperVal (EncodedV (Encoded Text
txt)) = Bool -> Value m
forall (m :: * -> *). Bool -> Value m
BoolV ((Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isUpper Text
txt)
isUpperVal Value m
_ = Value m
forall (m :: * -> *). Value m
FalseV
isLowerVal :: Value m -> Value m
isLowerVal :: forall (m :: * -> *). Value m -> Value m
isLowerVal (StringV Text
txt) = Bool -> Value m
forall (m :: * -> *). Bool -> Value m
BoolV ((Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isLower Text
txt)
isLowerVal (EncodedV (Encoded Text
txt)) = Bool -> Value m
forall (m :: * -> *). Bool -> Value m
BoolV ((Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isLower Text
txt)
isLowerVal Value m
_ = Value m
forall (m :: * -> *). Value m
FalseV
isBoolean :: Bool -> Value m -> Value m
isBoolean :: forall (m :: * -> *). Bool -> Value m -> Value m
isBoolean Bool
b1 (BoolV Bool
b2) = Bool -> Value m
forall (m :: * -> *). Bool -> Value m
BoolV (Bool
b1 Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
b2)
isBoolean Bool
_ Value m
_ = Value m
forall (m :: * -> *). Value m
FalseV
isNone :: Value m -> Value m
isNone :: forall (m :: * -> *). Value m -> Value m
isNone Value m
NoneV = Value m
forall (m :: * -> *). Value m
TrueV
isNone Value m
_ = Value m
forall (m :: * -> *). Value m
FalseV
isDecimal :: Text -> Bool
isDecimal :: Text -> Bool
isDecimal Text
"" = Bool
False
isDecimal Text
t = case HasCallStack => Text -> Text -> [Text]
Text -> Text -> [Text]
Text.splitOn Text
"." Text
t of
[Item [Text]
"0"] ->
Bool
True
[Item [Text]
intpart] ->
Bool -> Bool
not (Text -> Bool
Text.null Text
Item [Text]
intpart) Bool -> Bool -> Bool
&&
(Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isDigit Text
Item [Text]
intpart Bool -> Bool -> Bool
&&
Bool -> Bool
not (Text
"0" Text -> Text -> Bool
`Text.isPrefixOf` Text
Item [Text]
intpart)
[Item [Text]
"0", Item [Text]
fracpart] ->
(Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isDigit Text
Item [Text]
fracpart
[Item [Text]
intpart, Item [Text]
fracpart] ->
Bool -> Bool
not (Text -> Bool
Text.null Text
Item [Text]
intpart Bool -> Bool -> Bool
&& Text -> Bool
Text.null Text
Item [Text]
fracpart) Bool -> Bool -> Bool
&&
(Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isDigit Text
Item [Text]
intpart Bool -> Bool -> Bool
&&
Bool -> Bool
not (Text
"0" Text -> Text -> Bool
`Text.isPrefixOf` Text
Item [Text]
intpart) Bool -> Bool -> Bool
&&
(Char -> Bool) -> Text -> Bool
Text.all Char -> Bool
isDigit Text
Item [Text]
fracpart
[Text]
_ -> Bool
False
allEitherBool :: [(Either a Bool)] -> Either a Bool
allEitherBool :: forall a. [Either a Bool] -> Either a Bool
allEitherBool [] = Bool -> Either a Bool
forall a b. b -> Either a b
Right Bool
True
allEitherBool (Right Bool
True : [Either a Bool]
xs) = [Either a Bool] -> Either a Bool
forall a. [Either a Bool] -> Either a Bool
allEitherBool [Either a Bool]
xs
allEitherBool (Either a Bool
x : [Either a Bool]
_) = Either a Bool
x
getAttrRaw :: Monad m
=> Value m
-> Identifier
-> m (Either RuntimeError (Maybe (Value m)))
getAttrRaw :: forall (m :: * -> *).
Monad m =>
Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
getAttrRaw (NativeV NativeObject m
n) Identifier
v =
Maybe (Value m) -> Either RuntimeError (Maybe (Value m))
forall a b. b -> Either a b
Right (Maybe (Value m) -> Either RuntimeError (Maybe (Value m)))
-> m (Maybe (Value m)) -> m (Either RuntimeError (Maybe (Value m)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NativeObject m -> Identifier -> m (Maybe (Value m))
forall (m :: * -> *).
NativeObject m -> Identifier -> m (Maybe (Value m))
nativeObjectGetAttribute NativeObject m
n Identifier
v
getAttrRaw (StringV Text
s) Identifier
v =
case (Identifier
-> Map Identifier (Text -> m (Either RuntimeError (Value m)))
-> Maybe (Text -> m (Either RuntimeError (Value m)))
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Identifier
v Map Identifier (Text -> m (Either RuntimeError (Value m)))
forall (m :: * -> *). Monad m => BuiltinAttribs Text m
builtinStringAttribs) of
Maybe (Text -> m (Either RuntimeError (Value m)))
Nothing -> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m))))
-> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a b. (a -> b) -> a -> b
$ Maybe (Value m) -> Either RuntimeError (Maybe (Value m))
forall a b. b -> Either a b
Right Maybe (Value m)
forall a. Maybe a
Nothing
Just Text -> m (Either RuntimeError (Value m))
attrib -> (Value m -> Maybe (Value m))
-> Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m))
forall a b.
(a -> b) -> Either RuntimeError a -> Either RuntimeError b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just (Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m)))
-> m (Either RuntimeError (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> m (Either RuntimeError (Value m))
attrib Text
s
getAttrRaw (BoolV Bool
x) Identifier
v =
case (Identifier
-> Map Identifier (Bool -> m (Either RuntimeError (Value m)))
-> Maybe (Bool -> m (Either RuntimeError (Value m)))
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Identifier
v Map Identifier (Bool -> m (Either RuntimeError (Value m)))
forall (m :: * -> *). Monad m => BuiltinAttribs Bool m
builtinBoolAttribs) of
Maybe (Bool -> m (Either RuntimeError (Value m)))
Nothing -> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m))))
-> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a b. (a -> b) -> a -> b
$ Maybe (Value m) -> Either RuntimeError (Maybe (Value m))
forall a b. b -> Either a b
Right Maybe (Value m)
forall a. Maybe a
Nothing
Just Bool -> m (Either RuntimeError (Value m))
attrib -> (Value m -> Maybe (Value m))
-> Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m))
forall a b.
(a -> b) -> Either RuntimeError a -> Either RuntimeError b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just (Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m)))
-> m (Either RuntimeError (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> m (Either RuntimeError (Value m))
attrib Bool
x
getAttrRaw (IntV Integer
x) Identifier
v =
case (Identifier
-> Map Identifier (Integer -> m (Either RuntimeError (Value m)))
-> Maybe (Integer -> m (Either RuntimeError (Value m)))
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Identifier
v Map Identifier (Integer -> m (Either RuntimeError (Value m)))
forall (m :: * -> *). Monad m => BuiltinAttribs Integer m
builtinIntAttribs) of
Maybe (Integer -> m (Either RuntimeError (Value m)))
Nothing -> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m))))
-> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a b. (a -> b) -> a -> b
$ Maybe (Value m) -> Either RuntimeError (Maybe (Value m))
forall a b. b -> Either a b
Right Maybe (Value m)
forall a. Maybe a
Nothing
Just Integer -> m (Either RuntimeError (Value m))
attrib -> (Value m -> Maybe (Value m))
-> Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m))
forall a b.
(a -> b) -> Either RuntimeError a -> Either RuntimeError b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just (Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m)))
-> m (Either RuntimeError (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Integer -> m (Either RuntimeError (Value m))
attrib Integer
x
getAttrRaw (FloatV Double
x) Identifier
v =
case (Identifier
-> Map Identifier (Double -> m (Either RuntimeError (Value m)))
-> Maybe (Double -> m (Either RuntimeError (Value m)))
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Identifier
v Map Identifier (Double -> m (Either RuntimeError (Value m)))
forall (m :: * -> *). Monad m => BuiltinAttribs Double m
builtinFloatAttribs) of
Maybe (Double -> m (Either RuntimeError (Value m)))
Nothing -> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m))))
-> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a b. (a -> b) -> a -> b
$ Maybe (Value m) -> Either RuntimeError (Maybe (Value m))
forall a b. b -> Either a b
Right Maybe (Value m)
forall a. Maybe a
Nothing
Just Double -> m (Either RuntimeError (Value m))
attrib -> (Value m -> Maybe (Value m))
-> Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m))
forall a b.
(a -> b) -> Either RuntimeError a -> Either RuntimeError b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just (Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m)))
-> m (Either RuntimeError (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> m (Either RuntimeError (Value m))
attrib Double
x
getAttrRaw (ListV Vector (Value m)
xs) Identifier
v =
case (Identifier
-> Map
Identifier (Vector (Value m) -> m (Either RuntimeError (Value m)))
-> Maybe (Vector (Value m) -> m (Either RuntimeError (Value m)))
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Identifier
v Map
Identifier (Vector (Value m) -> m (Either RuntimeError (Value m)))
forall (m :: * -> *).
Monad m =>
BuiltinAttribs (Vector (Value m)) m
builtinListAttribs) of
Maybe (Vector (Value m) -> m (Either RuntimeError (Value m)))
Nothing -> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m))))
-> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a b. (a -> b) -> a -> b
$ Maybe (Value m) -> Either RuntimeError (Maybe (Value m))
forall a b. b -> Either a b
Right Maybe (Value m)
forall a. Maybe a
Nothing
Just Vector (Value m) -> m (Either RuntimeError (Value m))
attrib -> (Value m -> Maybe (Value m))
-> Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m))
forall a b.
(a -> b) -> Either RuntimeError a -> Either RuntimeError b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just (Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m)))
-> m (Either RuntimeError (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Vector (Value m) -> m (Either RuntimeError (Value m))
attrib Vector (Value m)
xs
getAttrRaw (DictV Map Scalar (Value m)
xs) Identifier
v =
case (Identifier
-> Map
Identifier
(Map Scalar (Value m) -> m (Either RuntimeError (Value m)))
-> Maybe
(Map Scalar (Value m) -> m (Either RuntimeError (Value m)))
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Identifier
v Map
Identifier
(Map Scalar (Value m) -> m (Either RuntimeError (Value m)))
forall (m :: * -> *).
Monad m =>
BuiltinAttribs (Map Scalar (Value m)) m
builtinDictAttribs) of
Maybe (Map Scalar (Value m) -> m (Either RuntimeError (Value m)))
Nothing -> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m))))
-> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a b. (a -> b) -> a -> b
$ Maybe (Value m) -> Either RuntimeError (Maybe (Value m))
forall a b. b -> Either a b
Right Maybe (Value m)
forall a. Maybe a
Nothing
Just Map Scalar (Value m) -> m (Either RuntimeError (Value m))
attrib -> (Value m -> Maybe (Value m))
-> Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m))
forall a b.
(a -> b) -> Either RuntimeError a -> Either RuntimeError b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just (Either RuntimeError (Value m)
-> Either RuntimeError (Maybe (Value m)))
-> m (Either RuntimeError (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map Scalar (Value m) -> m (Either RuntimeError (Value m))
attrib Map Scalar (Value m)
xs
getAttrRaw Value m
_ Identifier
_ = Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m))))
-> Either RuntimeError (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a b. (a -> b) -> a -> b
$ Maybe (Value m) -> Either RuntimeError (Maybe (Value m))
forall a b. b -> Either a b
Right Maybe (Value m)
forall a. Maybe a
Nothing
getItemRaw :: Monad m
=> Value m
-> Value m
-> m (Maybe (Value m))
getItemRaw :: forall (m :: * -> *).
Monad m =>
Value m -> Value m -> m (Maybe (Value m))
getItemRaw Value m
a Value m
b = case Value m
a of
DictV Map Scalar (Value m)
m -> case Value m
b of
ScalarV Scalar
k -> Maybe (Value m) -> m (Maybe (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Value m) -> m (Maybe (Value m)))
-> Maybe (Value m) -> m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (Value m -> Value m) -> Maybe (Value m) -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Scalar
k Scalar -> Map Scalar (Value m) -> Maybe (Value m)
forall k a. Ord k => k -> Map k a -> Maybe a
`Map.lookup` Map Scalar (Value m)
m
Value m
_ -> Maybe (Value m) -> m (Maybe (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Value m)
forall a. Maybe a
Nothing
ListV Vector (Value m)
xs -> case Value m
b of
IntV Integer
i -> Maybe (Value m) -> m (Maybe (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Value m) -> m (Maybe (Value m)))
-> (Maybe (Value m) -> Maybe (Value m))
-> Maybe (Value m)
-> m (Maybe (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value m -> Value m) -> Maybe (Value m) -> Maybe (Value m)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value m -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (Maybe (Value m) -> m (Maybe (Value m)))
-> Maybe (Value m) -> m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Vector (Value m)
xs Vector (Value m) -> Int -> Maybe (Value m)
forall a. Vector a -> Int -> Maybe a
V.!? (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
i)
Value m
_ -> Maybe (Value m) -> m (Maybe (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Value m)
forall a. Maybe a
Nothing
StringV Text
str -> case Value m
b of
IntV Integer
i -> Maybe (Value m) -> m (Maybe (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
(Maybe (Value m) -> m (Maybe (Value m)))
-> (Text -> Maybe (Value m)) -> Text -> m (Maybe (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Value m) -> Maybe Char -> Maybe (Value m)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (Text -> Value m) -> (Char -> Text) -> Char -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Text
Text.singleton)
(Maybe Char -> Maybe (Value m))
-> (Text -> Maybe Char) -> Text -> Maybe (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Maybe Char
forall a. [a] -> Maybe a
listToMaybe
(String -> Maybe Char) -> (Text -> String) -> Text -> Maybe Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
Text.unpack
(Text -> String) -> (Text -> Text) -> Text -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text -> Text
Text.take Int
1
(Text -> Text) -> (Text -> Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text -> Text
Text.drop (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
i)
(Text -> m (Maybe (Value m))) -> Text -> m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Text
str
Value m
_ -> Maybe (Value m) -> m (Maybe (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Value m)
forall a. Maybe a
Nothing
NativeV NativeObject m
n -> case Value m
b of
ScalarV Scalar
k -> NativeObject m -> Scalar -> m (Maybe (Value m))
forall (m :: * -> *).
NativeObject m -> Scalar -> m (Maybe (Value m))
nativeObjectGetField NativeObject m
n Scalar
k
Value m
_ -> Maybe (Value m) -> m (Maybe (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Value m)
forall a. Maybe a
Nothing
Value m
_ -> Maybe (Value m) -> m (Maybe (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Value m)
forall a. Maybe a
Nothing
getAttrOrItemRaw :: Monad m
=> Value m
-> Identifier
-> m (Either RuntimeError (Maybe (Value m)))
getAttrOrItemRaw :: forall (m :: * -> *).
Monad m =>
Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
getAttrOrItemRaw Value m
a Identifier
i = ExceptT RuntimeError m (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT RuntimeError m (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m))))
-> ExceptT RuntimeError m (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a b. (a -> b) -> a -> b
$ do
Maybe (Value m)
xMay <- m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m)))
-> m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
forall (m :: * -> *).
Monad m =>
Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
getAttrRaw Value m
a Identifier
i
case Maybe (Value m)
xMay of
Just Value m
x -> Maybe (Value m) -> ExceptT RuntimeError m (Maybe (Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Value m) -> ExceptT RuntimeError m (Maybe (Value m)))
-> (Value m -> Maybe (Value m))
-> Value m
-> ExceptT RuntimeError m (Maybe (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just (Value m -> ExceptT RuntimeError m (Maybe (Value m)))
-> Value m -> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m
x
Maybe (Value m)
Nothing -> m (Maybe (Value m)) -> ExceptT RuntimeError m (Maybe (Value m))
forall (m :: * -> *) a. Monad m => m a -> ExceptT RuntimeError m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Maybe (Value m)) -> ExceptT RuntimeError m (Maybe (Value m)))
-> m (Maybe (Value m)) -> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> Value m -> m (Maybe (Value m))
forall (m :: * -> *).
Monad m =>
Value m -> Value m -> m (Maybe (Value m))
getItemRaw Value m
a (Text -> Value m
forall (m :: * -> *). Text -> Value m
StringV (Text -> Value m) -> (Identifier -> Text) -> Identifier -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Text
identifierName (Identifier -> Value m) -> Identifier -> Value m
forall a b. (a -> b) -> a -> b
$ Identifier
i)
getItemOrAttrRaw :: Monad m
=> Value m
-> Value m
-> m (Either RuntimeError (Maybe (Value m)))
getItemOrAttrRaw :: forall (m :: * -> *).
Monad m =>
Value m -> Value m -> m (Either RuntimeError (Maybe (Value m)))
getItemOrAttrRaw Value m
a Value m
b = ExceptT RuntimeError m (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT RuntimeError m (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m))))
-> ExceptT RuntimeError m (Maybe (Value m))
-> m (Either RuntimeError (Maybe (Value m)))
forall a b. (a -> b) -> a -> b
$ do
Maybe (Value m)
xMay <- m (Maybe (Value m)) -> ExceptT RuntimeError m (Maybe (Value m))
forall (m :: * -> *) a. Monad m => m a -> ExceptT RuntimeError m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Maybe (Value m)) -> ExceptT RuntimeError m (Maybe (Value m)))
-> m (Maybe (Value m)) -> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> Value m -> m (Maybe (Value m))
forall (m :: * -> *).
Monad m =>
Value m -> Value m -> m (Maybe (Value m))
getItemRaw Value m
a Value m
b
case Maybe (Value m)
xMay of
Just Value m
x -> Maybe (Value m) -> ExceptT RuntimeError m (Maybe (Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Value m) -> ExceptT RuntimeError m (Maybe (Value m)))
-> (Value m -> Maybe (Value m))
-> Value m
-> ExceptT RuntimeError m (Maybe (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> Maybe (Value m)
forall a. a -> Maybe a
Just (Value m -> ExceptT RuntimeError m (Maybe (Value m)))
-> Value m -> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m
x
Maybe (Value m)
Nothing -> case Value m
b of
StringV Text
i -> m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m)))
-> m (Either RuntimeError (Maybe (Value m)))
-> ExceptT RuntimeError m (Maybe (Value m))
forall a b. (a -> b) -> a -> b
$ Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
forall (m :: * -> *).
Monad m =>
Value m -> Identifier -> m (Either RuntimeError (Maybe (Value m)))
getAttrRaw Value m
a (Text -> Identifier
Identifier (Text -> Identifier) -> Text -> Identifier
forall a b. (a -> b) -> a -> b
$ Text
i)
Value m
_ -> Maybe (Value m) -> ExceptT RuntimeError m (Maybe (Value m))
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Value m)
forall a. Maybe a
Nothing
nativeMethod :: Procedure m -> Value m -> Value m
nativeMethod :: forall (m :: * -> *). Procedure m -> Value m -> Value m
nativeMethod (NativeProcedure ObjectID
oid Maybe ProcedureDoc
doc [(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m))
f) Value m
self =
Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV (Procedure m -> Value m)
-> (([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m)
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall (m :: * -> *).
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
NativeProcedure ObjectID
oid Maybe ProcedureDoc
doc (([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Value m)
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Value m
forall a b. (a -> b) -> a -> b
$ \[(Maybe Identifier, Value m)]
args -> [(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m))
f ((Identifier -> Maybe Identifier
forall a. a -> Maybe a
Just Identifier
"value", Value m
self) (Maybe Identifier, Value m)
-> [(Maybe Identifier, Value m)] -> [(Maybe Identifier, Value m)]
forall a. a -> [a] -> [a]
: [(Maybe Identifier, Value m)]
args)
nativeMethod (GingerProcedure Env m
env [(Identifier, Maybe (Value m))]
argSpec Expr
body) Value m
self =
Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV (Procedure m -> Value m) -> Procedure m -> Value m
forall a b. (a -> b) -> a -> b
$ Env m -> [(Identifier, Maybe (Value m))] -> Expr -> Procedure m
forall (m :: * -> *).
Env m -> [(Identifier, Maybe (Value m))] -> Expr -> Procedure m
GingerProcedure Env m
env' (Int
-> [(Identifier, Maybe (Value m))]
-> [(Identifier, Maybe (Value m))]
forall a. Int -> [a] -> [a]
drop Int
1 [(Identifier, Maybe (Value m))]
argSpec) Expr
body
where
env' :: Env m
env' = Env m
env { envVars = Map.insert "value" self (envVars env) }
nativeMethod Procedure m
NamespaceProcedure Value m
_self =
String -> Value m
forall a. HasCallStack => String -> a
error String
"'namespace' cannot be used as a method"
nativePureMethod :: Monad m
=> ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
nativePureMethod :: forall (m :: * -> *).
Monad m =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
nativePureMethod ObjectID
oid Maybe ProcedureDoc
doc = Procedure m -> Value m -> Value m
forall (m :: * -> *). Procedure m -> Value m -> Value m
nativeMethod (Procedure m -> Value m -> Value m)
-> ((Value m -> Either RuntimeError (Value m)) -> Procedure m)
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Procedure m
forall (m :: * -> *).
Applicative m =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Procedure m
pureNativeFunc ObjectID
oid Maybe ProcedureDoc
doc
toNativeMethod :: ToNativeProcedure m a
=> ObjectID
-> Maybe ProcedureDoc
-> a
-> Value m
-> Value m
toNativeMethod :: forall (m :: * -> *) a.
ToNativeProcedure m a =>
ObjectID -> Maybe ProcedureDoc -> a -> Value m -> Value m
toNativeMethod ObjectID
oid Maybe ProcedureDoc
doc a
f = Procedure m -> Value m -> Value m
forall (m :: * -> *). Procedure m -> Value m -> Value m
nativeMethod (ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall (m :: * -> *).
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
NativeProcedure ObjectID
oid Maybe ProcedureDoc
doc (([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m)
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ a
-> [(Maybe Identifier, Value m)]
-> Context m
-> SomePRNG
-> m (Either RuntimeError (Value m))
forall (m :: * -> *) a.
ToNativeProcedure m a =>
a
-> [(Maybe Identifier, Value m)]
-> Context m
-> SomePRNG
-> m (Either RuntimeError (Value m))
toNativeProcedure a
f)
pureAttrib :: Applicative m => (s -> a) -> s -> m (Either RuntimeError a)
pureAttrib :: forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib s -> a
f s
x = Either RuntimeError a -> m (Either RuntimeError a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError a -> m (Either RuntimeError a))
-> (a -> Either RuntimeError a) -> a -> m (Either RuntimeError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either RuntimeError a
forall a b. b -> Either a b
Right (a -> m (Either RuntimeError a)) -> a -> m (Either RuntimeError a)
forall a b. (a -> b) -> a -> b
$ s -> a
f s
x
textBuiltin :: (Monad m, ToValue a m)
=> ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Value m
textBuiltin :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID -> Maybe ProcedureDoc -> (Text -> a) -> Value m
textBuiltin ObjectID
oid Maybe ProcedureDoc
doc Text -> a
f =
Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV (Procedure m -> Value m)
-> ((Text -> Either RuntimeError a) -> Procedure m)
-> (Text -> Either RuntimeError a)
-> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Procedure m
forall (m :: * -> *).
Applicative m =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Procedure m
pureNativeFunc ObjectID
oid Maybe ProcedureDoc
doc ((Value m -> Either RuntimeError (Value m)) -> Procedure m)
-> ((Text -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m))
-> (Text -> Either RuntimeError a)
-> Procedure m
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
(Text -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Text -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
textFunc ((Text -> Either RuntimeError a) -> Value m)
-> (Text -> Either RuntimeError a) -> Value m
forall a b. (a -> b) -> a -> b
$
(a -> Either RuntimeError a
forall a b. b -> Either a b
Right (a -> Either RuntimeError a)
-> (Text -> a) -> Text -> Either RuntimeError a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> a
f)
intBuiltin :: (Monad m, ToValue a m)
=> ObjectID
-> Maybe ProcedureDoc
-> (Integer -> a)
-> Value m
intBuiltin :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID -> Maybe ProcedureDoc -> (Integer -> a) -> Value m
intBuiltin ObjectID
oid Maybe ProcedureDoc
doc Integer -> a
f =
Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV (Procedure m -> Value m)
-> ((Integer -> Either RuntimeError a) -> Procedure m)
-> (Integer -> Either RuntimeError a)
-> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Procedure m
forall (m :: * -> *).
Applicative m =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Procedure m
pureNativeFunc ObjectID
oid Maybe ProcedureDoc
doc ((Value m -> Either RuntimeError (Value m)) -> Procedure m)
-> ((Integer -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m))
-> (Integer -> Either RuntimeError a)
-> Procedure m
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
(Integer -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Integer -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
intFunc ((Integer -> Either RuntimeError a) -> Value m)
-> (Integer -> Either RuntimeError a) -> Value m
forall a b. (a -> b) -> a -> b
$
(a -> Either RuntimeError a
forall a b. b -> Either a b
Right (a -> Either RuntimeError a)
-> (Integer -> a) -> Integer -> Either RuntimeError a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
f)
numericBuiltin :: (Monad m)
=> ObjectID
-> Maybe ProcedureDoc
-> (Integer -> Integer)
-> (Double -> Double)
-> Value m
numericBuiltin :: forall (m :: * -> *).
Monad m =>
ObjectID
-> Maybe ProcedureDoc
-> (Integer -> Integer)
-> (Double -> Double)
-> Value m
numericBuiltin ObjectID
oid Maybe ProcedureDoc
doc Integer -> Integer
f Double -> Double
g =
Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV (Procedure m -> Value m)
-> ((Value m -> Either RuntimeError (Value m)) -> Procedure m)
-> (Value m -> Either RuntimeError (Value m))
-> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Procedure m
forall (m :: * -> *).
Applicative m =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Procedure m
pureNativeFunc ObjectID
oid Maybe ProcedureDoc
doc ((Value m -> Either RuntimeError (Value m)) -> Value m)
-> (Value m -> Either RuntimeError (Value m)) -> Value m
forall a b. (a -> b) -> a -> b
$
(Integer -> Integer)
-> (Double -> Double) -> Value m -> Either RuntimeError (Value m)
forall (m :: * -> *).
Monad m =>
(Integer -> Integer)
-> (Double -> Double) -> Value m -> Either RuntimeError (Value m)
numericFunc Integer -> Integer
f Double -> Double
g
anyBuiltin :: (Monad m, FromValue a m, ToValue b m)
=> ObjectID
-> Maybe ProcedureDoc
-> (a -> b)
-> Value m
anyBuiltin :: forall (m :: * -> *) a b.
(Monad m, FromValue a m, ToValue b m) =>
ObjectID -> Maybe ProcedureDoc -> (a -> b) -> Value m
anyBuiltin ObjectID
oid Maybe ProcedureDoc
doc a -> b
f =
Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV (Procedure m -> Value m)
-> ((Value m -> m (Either RuntimeError (Value m))) -> Procedure m)
-> (Value m -> m (Either RuntimeError (Value m)))
-> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> m (Either RuntimeError (Value m)))
-> Procedure m
forall (m :: * -> *).
Monad m =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> m (Either RuntimeError (Value m)))
-> Procedure m
nativeFunc ObjectID
oid Maybe ProcedureDoc
doc ((Value m -> m (Either RuntimeError (Value m))) -> Value m)
-> (Value m -> m (Either RuntimeError (Value m))) -> Value m
forall a b. (a -> b) -> a -> b
$ \Value m
x -> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m)))
-> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$
b -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (b -> Value m) -> (a -> b) -> a -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f (a -> Value m)
-> ExceptT RuntimeError m a -> ExceptT RuntimeError m (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Either RuntimeError a) -> ExceptT RuntimeError m a
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (Value m -> m (Either RuntimeError a)
forall a (m :: * -> *).
FromValue a m =>
Value m -> m (Either RuntimeError a)
fromValue Value m
x)
boolProp :: (Monad m, ToValue a m)
=> (Bool -> a)
-> Bool
-> m (Either RuntimeError (Value m))
boolProp :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Bool -> a) -> Bool -> m (Either RuntimeError (Value m))
boolProp Bool -> a
f Bool
t = Either RuntimeError (Value m) -> m (Either RuntimeError (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Value m)
-> m (Either RuntimeError (Value m)))
-> (a -> Either RuntimeError (Value m))
-> a
-> m (Either RuntimeError (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> Either RuntimeError (Value m)
forall a b. b -> Either a b
Right (Value m -> Either RuntimeError (Value m))
-> (a -> Value m) -> a -> Either RuntimeError (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a -> m (Either RuntimeError (Value m)))
-> a -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Bool -> a
f Bool
t
boolAttrib :: (Monad m, ToValue a m)
=> ObjectID
-> Maybe ProcedureDoc
-> (Bool -> a)
-> Bool
-> m (Either RuntimeError (Value m))
boolAttrib :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Bool -> a)
-> Bool
-> m (Either RuntimeError (Value m))
boolAttrib ObjectID
oid Maybe ProcedureDoc
doc Bool -> a
f =
(Bool -> Value m) -> Bool -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Bool -> Value m) -> Bool -> m (Either RuntimeError (Value m)))
-> (Bool -> Value m) -> Bool -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
forall (m :: * -> *).
Monad m =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
nativePureMethod ObjectID
oid Maybe ProcedureDoc
doc ((Bool -> a) -> Value m -> Either RuntimeError (Value m)
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Bool -> a) -> Value m -> Either RuntimeError (Value m)
boolFunc Bool -> a
f) (Value m -> Value m) -> (Bool -> Value m) -> Bool -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Value m
forall (m :: * -> *). Bool -> Value m
BoolV
boolNProcAttrib :: (Monad m, ToNativeProcedure m a)
=> ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Bool
-> m (Either RuntimeError (Value m))
boolNProcAttrib :: forall (m :: * -> *) a.
(Monad m, ToNativeProcedure m a) =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Bool
-> m (Either RuntimeError (Value m))
boolNProcAttrib ObjectID
oid Maybe ProcedureDoc
doc Value m -> a
f =
(Bool -> Value m) -> Bool -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Bool -> Value m) -> Bool -> m (Either RuntimeError (Value m)))
-> (Bool -> Value m) -> Bool -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ ObjectID
-> Maybe ProcedureDoc -> (Value m -> a) -> Value m -> Value m
forall (m :: * -> *) a.
ToNativeProcedure m a =>
ObjectID -> Maybe ProcedureDoc -> a -> Value m -> Value m
toNativeMethod ObjectID
oid Maybe ProcedureDoc
doc Value m -> a
f (Value m -> Value m) -> (Bool -> Value m) -> Bool -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Value m
forall (m :: * -> *). Bool -> Value m
BoolV
boolProcAttrib :: Monad m
=> Procedure m
-> Bool
-> m (Either RuntimeError (Value m))
boolProcAttrib :: forall (m :: * -> *).
Monad m =>
Procedure m -> Bool -> m (Either RuntimeError (Value m))
boolProcAttrib Procedure m
f =
(Bool -> Value m) -> Bool -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Bool -> Value m) -> Bool -> m (Either RuntimeError (Value m)))
-> (Bool -> Value m) -> Bool -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Procedure m -> Value m -> Value m
forall (m :: * -> *). Procedure m -> Value m -> Value m
nativeMethod Procedure m
f (Value m -> Value m) -> (Bool -> Value m) -> Bool -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Value m
forall (m :: * -> *). Bool -> Value m
BoolV
intProp :: (Monad m, ToValue a m)
=> (Integer -> a)
-> Integer
-> m (Either RuntimeError (Value m))
intProp :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Integer -> a) -> Integer -> m (Either RuntimeError (Value m))
intProp Integer -> a
f Integer
t = Either RuntimeError (Value m) -> m (Either RuntimeError (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Value m)
-> m (Either RuntimeError (Value m)))
-> (a -> Either RuntimeError (Value m))
-> a
-> m (Either RuntimeError (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> Either RuntimeError (Value m)
forall a b. b -> Either a b
Right (Value m -> Either RuntimeError (Value m))
-> (a -> Value m) -> a -> Either RuntimeError (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a -> m (Either RuntimeError (Value m)))
-> a -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Integer -> a
f Integer
t
intAttrib :: (Monad m, ToValue a m)
=> ObjectID
-> Maybe ProcedureDoc
-> (Integer -> a)
-> Integer
-> m (Either RuntimeError (Value m))
intAttrib :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Integer -> a)
-> Integer
-> m (Either RuntimeError (Value m))
intAttrib ObjectID
oid Maybe ProcedureDoc
doc Integer -> a
f =
(Integer -> Value m)
-> Integer -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Integer -> Value m)
-> Integer -> m (Either RuntimeError (Value m)))
-> (Integer -> Value m)
-> Integer
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
forall (m :: * -> *).
Monad m =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
nativePureMethod ObjectID
oid Maybe ProcedureDoc
doc ((Integer -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Integer -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
intFunc (a -> Either RuntimeError a
forall a. a -> Either RuntimeError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> Either RuntimeError a)
-> (Integer -> a) -> Integer -> Either RuntimeError a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
f)) (Value m -> Value m) -> (Integer -> Value m) -> Integer -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Value m
forall (m :: * -> *). Integer -> Value m
IntV
intNProcAttrib :: (Monad m, ToNativeProcedure m a)
=> ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Integer
-> m (Either RuntimeError (Value m))
intNProcAttrib :: forall (m :: * -> *) a.
(Monad m, ToNativeProcedure m a) =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Integer
-> m (Either RuntimeError (Value m))
intNProcAttrib ObjectID
oid Maybe ProcedureDoc
doc Value m -> a
f =
(Integer -> Value m)
-> Integer -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Integer -> Value m)
-> Integer -> m (Either RuntimeError (Value m)))
-> (Integer -> Value m)
-> Integer
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ ObjectID
-> Maybe ProcedureDoc -> (Value m -> a) -> Value m -> Value m
forall (m :: * -> *) a.
ToNativeProcedure m a =>
ObjectID -> Maybe ProcedureDoc -> a -> Value m -> Value m
toNativeMethod ObjectID
oid Maybe ProcedureDoc
doc Value m -> a
f (Value m -> Value m) -> (Integer -> Value m) -> Integer -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Value m
forall (m :: * -> *). Integer -> Value m
IntV
intProcAttrib :: Monad m
=> Procedure m
-> Integer
-> m (Either RuntimeError (Value m))
intProcAttrib :: forall (m :: * -> *).
Monad m =>
Procedure m -> Integer -> m (Either RuntimeError (Value m))
intProcAttrib Procedure m
f =
(Integer -> Value m)
-> Integer -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Integer -> Value m)
-> Integer -> m (Either RuntimeError (Value m)))
-> (Integer -> Value m)
-> Integer
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Procedure m -> Value m -> Value m
forall (m :: * -> *). Procedure m -> Value m -> Value m
nativeMethod Procedure m
f (Value m -> Value m) -> (Integer -> Value m) -> Integer -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Value m
forall (m :: * -> *). Integer -> Value m
IntV
floatProp :: (Monad m, ToValue a m)
=> (Double -> a)
-> Double
-> m (Either RuntimeError (Value m))
floatProp :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Double -> a) -> Double -> m (Either RuntimeError (Value m))
floatProp Double -> a
f Double
t = Either RuntimeError (Value m) -> m (Either RuntimeError (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Value m)
-> m (Either RuntimeError (Value m)))
-> (a -> Either RuntimeError (Value m))
-> a
-> m (Either RuntimeError (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> Either RuntimeError (Value m)
forall a b. b -> Either a b
Right (Value m -> Either RuntimeError (Value m))
-> (a -> Value m) -> a -> Either RuntimeError (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a -> m (Either RuntimeError (Value m)))
-> a -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Double -> a
f Double
t
floatAttrib :: (Monad m, ToValue a m)
=> ObjectID
-> Maybe ProcedureDoc
-> (Double -> a)
-> Double
-> m (Either RuntimeError (Value m))
floatAttrib :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Double -> a)
-> Double
-> m (Either RuntimeError (Value m))
floatAttrib ObjectID
oid Maybe ProcedureDoc
doc Double -> a
f =
(Double -> Value m) -> Double -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Double -> Value m)
-> Double -> m (Either RuntimeError (Value m)))
-> (Double -> Value m)
-> Double
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
forall (m :: * -> *).
Monad m =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
nativePureMethod ObjectID
oid Maybe ProcedureDoc
doc ((Double -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Double -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
floatFunc (a -> Either RuntimeError a
forall a. a -> Either RuntimeError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> Either RuntimeError a)
-> (Double -> a) -> Double -> Either RuntimeError a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> a
f)) (Value m -> Value m) -> (Double -> Value m) -> Double -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Value m
forall (m :: * -> *). Double -> Value m
FloatV
floatNProcAttrib :: (Monad m, ToNativeProcedure m a)
=> ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Double
-> m (Either RuntimeError (Value m))
floatNProcAttrib :: forall (m :: * -> *) a.
(Monad m, ToNativeProcedure m a) =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Double
-> m (Either RuntimeError (Value m))
floatNProcAttrib ObjectID
oid Maybe ProcedureDoc
doc Value m -> a
f =
(Double -> Value m) -> Double -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Double -> Value m)
-> Double -> m (Either RuntimeError (Value m)))
-> (Double -> Value m)
-> Double
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ ObjectID
-> Maybe ProcedureDoc -> (Value m -> a) -> Value m -> Value m
forall (m :: * -> *) a.
ToNativeProcedure m a =>
ObjectID -> Maybe ProcedureDoc -> a -> Value m -> Value m
toNativeMethod ObjectID
oid Maybe ProcedureDoc
doc Value m -> a
f (Value m -> Value m) -> (Double -> Value m) -> Double -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Value m
forall (m :: * -> *). Double -> Value m
FloatV
floatProcAttrib :: Monad m
=> Procedure m
-> Double
-> m (Either RuntimeError (Value m))
floatProcAttrib :: forall (m :: * -> *).
Monad m =>
Procedure m -> Double -> m (Either RuntimeError (Value m))
floatProcAttrib Procedure m
f =
(Double -> Value m) -> Double -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Double -> Value m)
-> Double -> m (Either RuntimeError (Value m)))
-> (Double -> Value m)
-> Double
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Procedure m -> Value m -> Value m
forall (m :: * -> *). Procedure m -> Value m -> Value m
nativeMethod Procedure m
f (Value m -> Value m) -> (Double -> Value m) -> Double -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Value m
forall (m :: * -> *). Double -> Value m
FloatV
textProp :: (Monad m, ToValue a m)
=> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textProp :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Text -> a) -> Text -> m (Either RuntimeError (Value m))
textProp Text -> a
f Text
t = Either RuntimeError (Value m) -> m (Either RuntimeError (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Value m)
-> m (Either RuntimeError (Value m)))
-> (a -> Either RuntimeError (Value m))
-> a
-> m (Either RuntimeError (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> Either RuntimeError (Value m)
forall a b. b -> Either a b
Right (Value m -> Either RuntimeError (Value m))
-> (a -> Value m) -> a -> Either RuntimeError (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a -> m (Either RuntimeError (Value m)))
-> a -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Text -> a
f Text
t
textAttrib :: (Monad m, ToValue a m)
=> ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Text -> a)
-> Text
-> m (Either RuntimeError (Value m))
textAttrib ObjectID
oid Maybe ProcedureDoc
doc Text -> a
f =
(Text -> Value m) -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Text -> Value m) -> Text -> m (Either RuntimeError (Value m)))
-> (Text -> Value m) -> Text -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
forall (m :: * -> *).
Monad m =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
nativePureMethod ObjectID
oid Maybe ProcedureDoc
doc ((Text -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Text -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
textFunc (a -> Either RuntimeError a
forall a. a -> Either RuntimeError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> Either RuntimeError a)
-> (Text -> a) -> Text -> Either RuntimeError a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> a
f)) (Value m -> Value m) -> (Text -> Value m) -> Text -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Value m
forall (m :: * -> *). Text -> Value m
StringV
textNProcAttrib :: (Monad m, ToNativeProcedure m a)
=> ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Text
-> m (Either RuntimeError (Value m))
textNProcAttrib :: forall (m :: * -> *) a.
(Monad m, ToNativeProcedure m a) =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Text
-> m (Either RuntimeError (Value m))
textNProcAttrib ObjectID
oid Maybe ProcedureDoc
doc Value m -> a
f =
(Text -> Value m) -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Text -> Value m) -> Text -> m (Either RuntimeError (Value m)))
-> (Text -> Value m) -> Text -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ ObjectID
-> Maybe ProcedureDoc -> (Value m -> a) -> Value m -> Value m
forall (m :: * -> *) a.
ToNativeProcedure m a =>
ObjectID -> Maybe ProcedureDoc -> a -> Value m -> Value m
toNativeMethod ObjectID
oid Maybe ProcedureDoc
doc Value m -> a
f (Value m -> Value m) -> (Text -> Value m) -> Text -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Value m
forall (m :: * -> *). Text -> Value m
StringV
textProcAttrib :: Monad m
=> Procedure m
-> Text
-> m (Either RuntimeError (Value m))
textProcAttrib :: forall (m :: * -> *).
Monad m =>
Procedure m -> Text -> m (Either RuntimeError (Value m))
textProcAttrib Procedure m
f =
(Text -> Value m) -> Text -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Text -> Value m) -> Text -> m (Either RuntimeError (Value m)))
-> (Text -> Value m) -> Text -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Procedure m -> Value m -> Value m
forall (m :: * -> *). Procedure m -> Value m -> Value m
nativeMethod Procedure m
f (Value m -> Value m) -> (Text -> Value m) -> Text -> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Value m
forall (m :: * -> *). Text -> Value m
StringV
dictProp :: (Monad m, ToValue a m)
=> (Map Scalar (Value m) -> a)
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
dictProp :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Map Scalar (Value m) -> a)
-> Map Scalar (Value m) -> m (Either RuntimeError (Value m))
dictProp Map Scalar (Value m) -> a
f Map Scalar (Value m)
t = Either RuntimeError (Value m) -> m (Either RuntimeError (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Value m)
-> m (Either RuntimeError (Value m)))
-> (a -> Either RuntimeError (Value m))
-> a
-> m (Either RuntimeError (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value m -> Either RuntimeError (Value m)
forall a b. b -> Either a b
Right (Value m -> Either RuntimeError (Value m))
-> (a -> Value m) -> a -> Either RuntimeError (Value m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a -> m (Either RuntimeError (Value m)))
-> a -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Map Scalar (Value m) -> a
f Map Scalar (Value m)
t
dictAttrib :: (Monad m, ToValue a m)
=> ObjectID
-> Maybe ProcedureDoc
-> (Map Scalar (Value m) -> a)
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
dictAttrib :: forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
ObjectID
-> Maybe ProcedureDoc
-> (Map Scalar (Value m) -> a)
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
dictAttrib ObjectID
oid Maybe ProcedureDoc
doc Map Scalar (Value m) -> a
f =
(Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m) -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m) -> m (Either RuntimeError (Value m)))
-> (Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
forall (m :: * -> *).
Monad m =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> Either RuntimeError (Value m))
-> Value m
-> Value m
nativePureMethod ObjectID
oid Maybe ProcedureDoc
doc ((Map Scalar (Value m) -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
forall (m :: * -> *) a.
(Monad m, ToValue a m) =>
(Map Scalar (Value m) -> Either RuntimeError a)
-> Value m -> Either RuntimeError (Value m)
dictFunc (a -> Either RuntimeError a
forall a. a -> Either RuntimeError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> Either RuntimeError a)
-> (Map Scalar (Value m) -> a)
-> Map Scalar (Value m)
-> Either RuntimeError a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Scalar (Value m) -> a
f)) (Value m -> Value m)
-> (Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m)
-> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Scalar (Value m) -> Value m
forall (m :: * -> *). Map Scalar (Value m) -> Value m
DictV
dictNProcAttrib :: (Monad m, ToNativeProcedure m a)
=> ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
dictNProcAttrib :: forall (m :: * -> *) a.
(Monad m, ToNativeProcedure m a) =>
ObjectID
-> Maybe ProcedureDoc
-> (Value m -> a)
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
dictNProcAttrib ObjectID
oid Maybe ProcedureDoc
doc Value m -> a
f =
(Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m) -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m) -> m (Either RuntimeError (Value m)))
-> (Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ ObjectID
-> Maybe ProcedureDoc -> (Value m -> a) -> Value m -> Value m
forall (m :: * -> *) a.
ToNativeProcedure m a =>
ObjectID -> Maybe ProcedureDoc -> a -> Value m -> Value m
toNativeMethod ObjectID
oid Maybe ProcedureDoc
doc Value m -> a
f (Value m -> Value m)
-> (Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m)
-> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Scalar (Value m) -> Value m
forall (m :: * -> *). Map Scalar (Value m) -> Value m
DictV
dictProcAttrib :: Monad m
=> Procedure m
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
dictProcAttrib :: forall (m :: * -> *).
Monad m =>
Procedure m
-> Map Scalar (Value m) -> m (Either RuntimeError (Value m))
dictProcAttrib Procedure m
f =
(Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m) -> m (Either RuntimeError (Value m))
forall (m :: * -> *) s a.
Applicative m =>
(s -> a) -> s -> m (Either RuntimeError a)
pureAttrib ((Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m) -> m (Either RuntimeError (Value m)))
-> (Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m)
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Procedure m -> Value m -> Value m
forall (m :: * -> *). Procedure m -> Value m -> Value m
nativeMethod Procedure m
f (Value m -> Value m)
-> (Map Scalar (Value m) -> Value m)
-> Map Scalar (Value m)
-> Value m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Scalar (Value m) -> Value m
forall (m :: * -> *). Map Scalar (Value m) -> Value m
DictV
builtinNotImplemented :: Monad m => Text -> Value m
builtinNotImplemented :: forall (m :: * -> *). Monad m => Text -> Value m
builtinNotImplemented Text
name =
Procedure m -> Value m
forall (m :: * -> *). Procedure m -> Value m
ProcedureV (Procedure m -> Value m) -> Procedure m -> Value m
forall a b. (a -> b) -> a -> b
$
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall (m :: * -> *).
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
NativeProcedure
(Text -> ObjectID
ObjectID (Text -> ObjectID) -> Text -> ObjectID
forall a b. (a -> b) -> a -> b
$ Text
"builtin:not_implemented:" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
name)
Maybe ProcedureDoc
forall a. Maybe a
Nothing
(([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m)
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \[(Maybe Identifier, Value m)]
_ Context m
_ SomePRNG
_ ->
Either RuntimeError (Value m) -> m (Either RuntimeError (Value m))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either RuntimeError (Value m)
-> m (Either RuntimeError (Value m)))
-> (RuntimeError -> Either RuntimeError (Value m))
-> RuntimeError
-> m (Either RuntimeError (Value m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RuntimeError -> Either RuntimeError (Value m)
forall a b. a -> Either a b
Left (RuntimeError -> m (Either RuntimeError (Value m)))
-> RuntimeError -> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ Text -> RuntimeError
NotImplementedError Text
name
fnMaybeArg :: Monad m => Text -> Text -> Maybe b -> ExceptT RuntimeError m b
fnMaybeArg :: forall (m :: * -> *) b.
Monad m =>
Text -> Text -> Maybe b -> ExceptT RuntimeError m b
fnMaybeArg Text
context Text
name =
ExceptT RuntimeError m b
-> (b -> ExceptT RuntimeError m b)
-> Maybe b
-> ExceptT RuntimeError m b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(RuntimeError -> ExceptT RuntimeError m b
forall a. RuntimeError -> ExceptT RuntimeError m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RuntimeError -> ExceptT RuntimeError m b)
-> RuntimeError -> ExceptT RuntimeError m b
forall a b. (a -> b) -> a -> b
$
Text -> Text -> Text -> Text -> RuntimeError
ArgumentError
Text
context
Text
name
Text
"argument"
Text
"end of arguments"
)
b -> ExceptT RuntimeError m b
forall a. a -> ExceptT RuntimeError m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
fnArg :: (Monad m, FromValue a m)
=> Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg :: forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
context Identifier
name Map Identifier (Value m)
argValues = do
Value m
argV <- Text -> Text -> Maybe (Value m) -> ExceptT RuntimeError m (Value m)
forall (m :: * -> *) b.
Monad m =>
Text -> Text -> Maybe b -> ExceptT RuntimeError m b
fnMaybeArg Text
context (Identifier -> Text
identifierName Identifier
name) (Maybe (Value m) -> ExceptT RuntimeError m (Value m))
-> Maybe (Value m) -> ExceptT RuntimeError m (Value m)
forall a b. (a -> b) -> a -> b
$ Identifier -> Map Identifier (Value m) -> Maybe (Value m)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Identifier
name Map Identifier (Value m)
argValues
m (Either RuntimeError a) -> ExceptT RuntimeError m a
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m), MonadTrans t) =>
m (Either e a) -> t m a
eitherExceptM (m (Either RuntimeError a) -> ExceptT RuntimeError m a)
-> m (Either RuntimeError a) -> ExceptT RuntimeError m a
forall a b. (a -> b) -> a -> b
$ Value m -> m (Either RuntimeError a)
forall a (m :: * -> *).
FromValue a m =>
Value m -> m (Either RuntimeError a)
fromValue Value m
argV
describeArg :: Identifier
-> Maybe (Value m)
-> Maybe TypeDoc
-> Text
-> ArgumentDoc
describeArg :: forall (m :: * -> *).
Identifier
-> Maybe (Value m) -> Maybe TypeDoc -> Text -> ArgumentDoc
describeArg Identifier
name Maybe (Value m)
defMay Maybe TypeDoc
ty Text
descr =
ArgumentDoc
{ argumentDocName :: Text
argumentDocName = Identifier -> Text
identifierName Identifier
name
, argumentDocType :: Maybe TypeDoc
argumentDocType = Maybe TypeDoc
ty
, argumentDocDefault :: Maybe Text
argumentDocDefault = Value m -> Text
forall a. RenderSyntax a => a -> Text
renderSyntaxText (Value m -> Text) -> Maybe (Value m) -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Value m)
defMay
, argumentDocDescription :: Text
argumentDocDescription = Text
descr
}
mkFn0' :: ( Monad m
, ToValue r m
)
=> Text
-> Text
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> ExceptT RuntimeError m r)
-> Procedure m
mkFn0' :: forall (m :: * -> *) r.
(Monad m, ToValue r m) =>
Text
-> Text
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> ExceptT RuntimeError m r)
-> Procedure m
mkFn0' Text
funcName Text
desc Maybe TypeDoc
retType Context m -> SomePRNG -> ExceptT RuntimeError m r
f =
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall (m :: * -> *).
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
NativeProcedure (Text -> ObjectID
ObjectID (Text -> ObjectID) -> Text -> ObjectID
forall a b. (a -> b) -> a -> b
$ Text
"builtin:" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
funcName)
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
funcName
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs = Vector ArgumentDoc
forall a. Monoid a => a
mempty
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = Maybe TypeDoc
retType
, procedureDocDescription :: Text
procedureDocDescription = Text
desc
}
)
(([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m)
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \[(Maybe Identifier, Value m)]
args Context m
ctx SomePRNG
rng -> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m)))
-> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ do
Map Identifier (Value m)
_ <- Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m)))
-> Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall a b. (a -> b) -> a -> b
$
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
forall (m :: * -> *).
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
resolveArgs
Text
funcName
[]
[(Maybe Identifier, Value m)]
args
r -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (r -> Value m)
-> ExceptT RuntimeError m r -> ExceptT RuntimeError m (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Context m -> SomePRNG -> ExceptT RuntimeError m r
f Context m
ctx SomePRNG
rng
mkFn0 :: ( Monad m
, ToValue r m
)
=> Text
-> Text
-> Maybe TypeDoc
-> (ExceptT RuntimeError m r)
-> Procedure m
mkFn0 :: forall (m :: * -> *) r.
(Monad m, ToValue r m) =>
Text
-> Text -> Maybe TypeDoc -> ExceptT RuntimeError m r -> Procedure m
mkFn0 Text
funcName Text
desc Maybe TypeDoc
retType ExceptT RuntimeError m r
f =
Text
-> Text
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> ExceptT RuntimeError m r)
-> Procedure m
forall (m :: * -> *) r.
(Monad m, ToValue r m) =>
Text
-> Text
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> ExceptT RuntimeError m r)
-> Procedure m
mkFn0' Text
funcName Text
desc Maybe TypeDoc
retType ((SomePRNG -> ExceptT RuntimeError m r)
-> Context m -> SomePRNG -> ExceptT RuntimeError m r
forall a b. a -> b -> a
const ((SomePRNG -> ExceptT RuntimeError m r)
-> Context m -> SomePRNG -> ExceptT RuntimeError m r)
-> (ExceptT RuntimeError m r
-> SomePRNG -> ExceptT RuntimeError m r)
-> ExceptT RuntimeError m r
-> Context m
-> SomePRNG
-> ExceptT RuntimeError m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptT RuntimeError m r -> SomePRNG -> ExceptT RuntimeError m r
forall a b. a -> b -> a
const (ExceptT RuntimeError m r
-> Context m -> SomePRNG -> ExceptT RuntimeError m r)
-> ExceptT RuntimeError m r
-> Context m
-> SomePRNG
-> ExceptT RuntimeError m r
forall a b. (a -> b) -> a -> b
$ ExceptT RuntimeError m r
f)
mkFn1' :: forall m a r.
( Monad m
, ToValue a m
, FromValue a m
, ToValue r m
)
=> Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1' :: forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1' Text
funcName Text
desc (Identifier
argname1, Maybe a
default1, Maybe TypeDoc
typedoc1, Text
argdesc1) Maybe TypeDoc
retType Context m -> SomePRNG -> a -> ExceptT RuntimeError m r
f =
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall (m :: * -> *).
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
NativeProcedure (Text -> ObjectID
ObjectID (Text -> ObjectID) -> Text -> ObjectID
forall a b. (a -> b) -> a -> b
$ Text
"builtin:" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
funcName)
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
funcName
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ forall (m :: * -> *).
Identifier
-> Maybe (Value m) -> Maybe TypeDoc -> Text -> ArgumentDoc
describeArg @m Identifier
argname1 (a -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a -> Value m) -> Maybe a -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a
default1) Maybe TypeDoc
typedoc1 Text
argdesc1
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = Maybe TypeDoc
retType
, procedureDocDescription :: Text
procedureDocDescription = Text
desc
}
)
(([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m)
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \[(Maybe Identifier, Value m)]
args Context m
ctx SomePRNG
rng -> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m)))
-> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ do
Map Identifier (Value m)
argValues <- Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m)))
-> Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall a b. (a -> b) -> a -> b
$
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
forall (m :: * -> *).
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
resolveArgs
Text
funcName
[ (Identifier
argname1, a -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a -> Value m) -> Maybe a -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a
default1)
]
[(Maybe Identifier, Value m)]
args
a
arg1 <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
argname1 Map Identifier (Value m)
argValues
r -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (r -> Value m)
-> ExceptT RuntimeError m r -> ExceptT RuntimeError m (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Context m -> SomePRNG -> a -> ExceptT RuntimeError m r
f Context m
ctx SomePRNG
rng a
arg1
mkFn1 :: ( Monad m
, ToValue a m
, FromValue a m
, ToValue r m
)
=> Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1 :: forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1 Text
funcName Text
a (Identifier, Maybe a, Maybe TypeDoc, Text)
desc Maybe TypeDoc
retType a -> ExceptT RuntimeError m r
f =
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a -> ExceptT RuntimeError m r)
-> Procedure m
forall (m :: * -> *) a r.
(Monad m, ToValue a m, FromValue a m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a -> ExceptT RuntimeError m r)
-> Procedure m
mkFn1' Text
funcName Text
a (Identifier, Maybe a, Maybe TypeDoc, Text)
desc Maybe TypeDoc
retType ((SomePRNG -> a -> ExceptT RuntimeError m r)
-> Context m -> SomePRNG -> a -> ExceptT RuntimeError m r
forall a b. a -> b -> a
const ((SomePRNG -> a -> ExceptT RuntimeError m r)
-> Context m -> SomePRNG -> a -> ExceptT RuntimeError m r)
-> ((a -> ExceptT RuntimeError m r)
-> SomePRNG -> a -> ExceptT RuntimeError m r)
-> (a -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a
-> ExceptT RuntimeError m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> ExceptT RuntimeError m r)
-> SomePRNG -> a -> ExceptT RuntimeError m r
forall a b. a -> b -> a
const ((a -> ExceptT RuntimeError m r)
-> Context m -> SomePRNG -> a -> ExceptT RuntimeError m r)
-> (a -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a
-> ExceptT RuntimeError m r
forall a b. (a -> b) -> a -> b
$ a -> ExceptT RuntimeError m r
f)
mkFn2' :: forall m a1 a2 r.
( Monad m
, ToValue a1 m
, FromValue a1 m
, ToValue a2 m
, FromValue a2 m
, ToValue r m
)
=> Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2' :: forall (m :: * -> *) a1 a2 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2' Text
funcName Text
desc
(Identifier
argname1, Maybe a1
default1, Maybe TypeDoc
typedoc1, Text
argdesc1)
(Identifier
argname2, Maybe a2
default2, Maybe TypeDoc
typedoc2, Text
argdesc2)
Maybe TypeDoc
retType
Context m -> SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r
f =
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall (m :: * -> *).
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
NativeProcedure (Text -> ObjectID
ObjectID (Text -> ObjectID) -> Text -> ObjectID
forall a b. (a -> b) -> a -> b
$ Text
"builtin:" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
funcName)
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
funcName
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ forall (m :: * -> *).
Identifier
-> Maybe (Value m) -> Maybe TypeDoc -> Text -> ArgumentDoc
describeArg @m Identifier
argname1 (a1 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a1 -> Value m) -> Maybe a1 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a1
default1) Maybe TypeDoc
typedoc1 Text
argdesc1
, forall (m :: * -> *).
Identifier
-> Maybe (Value m) -> Maybe TypeDoc -> Text -> ArgumentDoc
describeArg @m Identifier
argname2 (a2 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a2 -> Value m) -> Maybe a2 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a2
default2) Maybe TypeDoc
typedoc2 Text
argdesc2
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = Maybe TypeDoc
retType
, procedureDocDescription :: Text
procedureDocDescription = Text
desc
}
)
(([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m)
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \[(Maybe Identifier, Value m)]
args Context m
ctx SomePRNG
rng -> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m)))
-> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ do
Map Identifier (Value m)
argValues <- Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m)))
-> Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall a b. (a -> b) -> a -> b
$
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
forall (m :: * -> *).
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
resolveArgs
Text
funcName
[ (Identifier
argname1, a1 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a1 -> Value m) -> Maybe a1 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a1
default1)
, (Identifier
argname2, a2 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a2 -> Value m) -> Maybe a2 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a2
default2)
]
[(Maybe Identifier, Value m)]
args
a1
arg1 <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a1
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
argname1 Map Identifier (Value m)
argValues
a2
arg2 <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a2
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
argname2 Map Identifier (Value m)
argValues
r -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (r -> Value m)
-> ExceptT RuntimeError m r -> ExceptT RuntimeError m (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Context m -> SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r
f Context m
ctx SomePRNG
rng a1
arg1 a2
arg2
mkFn2 :: ( Monad m
, ToValue a1 m
, FromValue a1 m
, ToValue a2 m
, FromValue a2 m
, ToValue r m
)
=> Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2 :: forall (m :: * -> *) a1 a2 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2 Text
funcName Text
desc (Identifier, Maybe a1, Maybe TypeDoc, Text)
a (Identifier, Maybe a2, Maybe TypeDoc, Text)
b Maybe TypeDoc
retType a1 -> a2 -> ExceptT RuntimeError m r
f =
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
forall (m :: * -> *) a1 a2 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn2' Text
funcName Text
desc (Identifier, Maybe a1, Maybe TypeDoc, Text)
a (Identifier, Maybe a2, Maybe TypeDoc, Text)
b Maybe TypeDoc
retType ((SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r)
-> Context m -> SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r
forall a b. a -> b -> a
const ((SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r)
-> Context m -> SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r)
-> ((a1 -> a2 -> ExceptT RuntimeError m r)
-> SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r)
-> (a1 -> a2 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> ExceptT RuntimeError m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a1 -> a2 -> ExceptT RuntimeError m r)
-> SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r
forall a b. a -> b -> a
const ((a1 -> a2 -> ExceptT RuntimeError m r)
-> Context m -> SomePRNG -> a1 -> a2 -> ExceptT RuntimeError m r)
-> (a1 -> a2 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> ExceptT RuntimeError m r
forall a b. (a -> b) -> a -> b
$ a1 -> a2 -> ExceptT RuntimeError m r
f)
mkFn3' :: forall m a1 a2 a3 r.
( Monad m
, ToValue a1 m
, FromValue a1 m
, ToValue a2 m
, FromValue a2 m
, ToValue a3 m
, FromValue a3 m
, ToValue r m
)
=> Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3' :: forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m
-> SomePRNG -> a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3' Text
funcName Text
desc
(Identifier
argname1, Maybe a1
default1, Maybe TypeDoc
typedoc1, Text
argdesc1)
(Identifier
argname2, Maybe a2
default2, Maybe TypeDoc
typedoc2, Text
argdesc2)
(Identifier
argname3, Maybe a3
default3, Maybe TypeDoc
typedoc3, Text
argdesc3)
Maybe TypeDoc
retType
Context m -> SomePRNG -> a1 -> a2 -> a3 -> ExceptT RuntimeError m r
f =
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall (m :: * -> *).
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
NativeProcedure (Text -> ObjectID
ObjectID (Text -> ObjectID) -> Text -> ObjectID
forall a b. (a -> b) -> a -> b
$ Text
"builtin:" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
funcName)
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
funcName
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ forall (m :: * -> *).
Identifier
-> Maybe (Value m) -> Maybe TypeDoc -> Text -> ArgumentDoc
describeArg @m Identifier
argname1 (a1 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a1 -> Value m) -> Maybe a1 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a1
default1) Maybe TypeDoc
typedoc1 Text
argdesc1
, forall (m :: * -> *).
Identifier
-> Maybe (Value m) -> Maybe TypeDoc -> Text -> ArgumentDoc
describeArg @m Identifier
argname2 (a2 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a2 -> Value m) -> Maybe a2 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a2
default2) Maybe TypeDoc
typedoc2 Text
argdesc2
, forall (m :: * -> *).
Identifier
-> Maybe (Value m) -> Maybe TypeDoc -> Text -> ArgumentDoc
describeArg @m Identifier
argname3 (a3 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a3 -> Value m) -> Maybe a3 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a3
default3) Maybe TypeDoc
typedoc3 Text
argdesc3
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = Maybe TypeDoc
retType
, procedureDocDescription :: Text
procedureDocDescription = Text
desc
}
)
(([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m)
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \[(Maybe Identifier, Value m)]
args Context m
ctx SomePRNG
rng -> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m)))
-> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ do
Map Identifier (Value m)
argValues <- Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m)))
-> Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall a b. (a -> b) -> a -> b
$
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
forall (m :: * -> *).
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
resolveArgs
Text
funcName
[ (Identifier
argname1, a1 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a1 -> Value m) -> Maybe a1 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a1
default1)
, (Identifier
argname2, a2 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a2 -> Value m) -> Maybe a2 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a2
default2)
, (Identifier
argname3, a3 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a3 -> Value m) -> Maybe a3 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a3
default3)
]
[(Maybe Identifier, Value m)]
args
a1
arg1 <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a1
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
argname1 Map Identifier (Value m)
argValues
a2
arg2 <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a2
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
argname2 Map Identifier (Value m)
argValues
a3
arg3 <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a3
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
argname3 Map Identifier (Value m)
argValues
r -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (r -> Value m)
-> ExceptT RuntimeError m r -> ExceptT RuntimeError m (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Context m -> SomePRNG -> a1 -> a2 -> a3 -> ExceptT RuntimeError m r
f Context m
ctx SomePRNG
rng a1
arg1 a2
arg2 a3
arg3
mkFn3 :: ( Monad m
, ToValue a1 m
, FromValue a1 m
, ToValue a2 m
, FromValue a2 m
, ToValue a3 m
, FromValue a3 m
, ToValue r m
)
=> Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 :: forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3 Text
funcName Text
desc (Identifier, Maybe a1, Maybe TypeDoc, Text)
a (Identifier, Maybe a2, Maybe TypeDoc, Text)
b (Identifier, Maybe a3, Maybe TypeDoc, Text)
c Maybe TypeDoc
retType a1 -> a2 -> a3 -> ExceptT RuntimeError m r
f =
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m
-> SomePRNG -> a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m
-> SomePRNG -> a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn3' Text
funcName Text
desc (Identifier, Maybe a1, Maybe TypeDoc, Text)
a (Identifier, Maybe a2, Maybe TypeDoc, Text)
b (Identifier, Maybe a3, Maybe TypeDoc, Text)
c Maybe TypeDoc
retType ((SomePRNG -> a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> a3
-> ExceptT RuntimeError m r
forall a b. a -> b -> a
const ((SomePRNG -> a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> a3
-> ExceptT RuntimeError m r)
-> ((a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> SomePRNG -> a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> a3
-> ExceptT RuntimeError m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> SomePRNG -> a1 -> a2 -> a3 -> ExceptT RuntimeError m r
forall a b. a -> b -> a
const ((a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> a3
-> ExceptT RuntimeError m r)
-> (a1 -> a2 -> a3 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> a3
-> ExceptT RuntimeError m r
forall a b. (a -> b) -> a -> b
$ a1 -> a2 -> a3 -> ExceptT RuntimeError m r
f)
mkFn4' :: forall m a1 a2 a3 a4 r.
( Monad m
, ToValue a1 m
, FromValue a1 m
, ToValue a2 m
, FromValue a2 m
, ToValue a3 m
, FromValue a3 m
, ToValue a4 m
, FromValue a4 m
, ToValue r m
)
=> Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m -> SomePRNG -> a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4' :: forall (m :: * -> *) a1 a2 a3 a4 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue a4 m,
FromValue a4 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m
-> SomePRNG -> a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4' Text
funcName Text
desc
(Identifier
argname1, Maybe a1
default1, Maybe TypeDoc
typedoc1, Text
argdesc1)
(Identifier
argname2, Maybe a2
default2, Maybe TypeDoc
typedoc2, Text
argdesc2)
(Identifier
argname3, Maybe a3
default3, Maybe TypeDoc
typedoc3, Text
argdesc3)
(Identifier
argname4, Maybe a4
default4, Maybe TypeDoc
typedoc4, Text
argdesc4)
Maybe TypeDoc
retType
Context m
-> SomePRNG -> a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r
f =
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall (m :: * -> *).
ObjectID
-> Maybe ProcedureDoc
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
NativeProcedure (Text -> ObjectID
ObjectID (Text -> ObjectID) -> Text -> ObjectID
forall a b. (a -> b) -> a -> b
$ Text
"builtin:" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
funcName)
(ProcedureDoc -> Maybe ProcedureDoc
forall a. a -> Maybe a
Just ProcedureDoc
{ procedureDocName :: Text
procedureDocName = Text
funcName
, procedureDocArgs :: Vector ArgumentDoc
procedureDocArgs =
[ forall (m :: * -> *).
Identifier
-> Maybe (Value m) -> Maybe TypeDoc -> Text -> ArgumentDoc
describeArg @m Identifier
argname1 (a1 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a1 -> Value m) -> Maybe a1 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a1
default1) Maybe TypeDoc
typedoc1 Text
argdesc1
, forall (m :: * -> *).
Identifier
-> Maybe (Value m) -> Maybe TypeDoc -> Text -> ArgumentDoc
describeArg @m Identifier
argname2 (a2 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a2 -> Value m) -> Maybe a2 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a2
default2) Maybe TypeDoc
typedoc2 Text
argdesc2
, forall (m :: * -> *).
Identifier
-> Maybe (Value m) -> Maybe TypeDoc -> Text -> ArgumentDoc
describeArg @m Identifier
argname3 (a3 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a3 -> Value m) -> Maybe a3 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a3
default3) Maybe TypeDoc
typedoc3 Text
argdesc3
, forall (m :: * -> *).
Identifier
-> Maybe (Value m) -> Maybe TypeDoc -> Text -> ArgumentDoc
describeArg @m Identifier
argname4 (a4 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a4 -> Value m) -> Maybe a4 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a4
default4) Maybe TypeDoc
typedoc4 Text
argdesc4
]
, procedureDocReturnType :: Maybe TypeDoc
procedureDocReturnType = Maybe TypeDoc
retType
, procedureDocDescription :: Text
procedureDocDescription = Text
desc
}
)
(([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m)
-> ([(Maybe Identifier, Value m)]
-> Context m -> SomePRNG -> m (Either RuntimeError (Value m)))
-> Procedure m
forall a b. (a -> b) -> a -> b
$ \[(Maybe Identifier, Value m)]
args Context m
ctx SomePRNG
rng -> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m)))
-> ExceptT RuntimeError m (Value m)
-> m (Either RuntimeError (Value m))
forall a b. (a -> b) -> a -> b
$ do
Map Identifier (Value m)
argValues <- Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall (m :: * -> *) e (t :: (* -> *) -> * -> *) a.
(Monad m, MonadError e (t m)) =>
Either e a -> t m a
eitherExcept (Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m)))
-> Either RuntimeError (Map Identifier (Value m))
-> ExceptT RuntimeError m (Map Identifier (Value m))
forall a b. (a -> b) -> a -> b
$
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
forall (m :: * -> *).
Text
-> [(Identifier, Maybe (Value m))]
-> [(Maybe Identifier, Value m)]
-> Either RuntimeError (Map Identifier (Value m))
resolveArgs
Text
funcName
[ (Identifier
argname1, a1 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a1 -> Value m) -> Maybe a1 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a1
default1)
, (Identifier
argname2, a2 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a2 -> Value m) -> Maybe a2 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a2
default2)
, (Identifier
argname3, a3 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a3 -> Value m) -> Maybe a3 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a3
default3)
, (Identifier
argname4, a4 -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (a4 -> Value m) -> Maybe a4 -> Maybe (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a4
default4)
]
[(Maybe Identifier, Value m)]
args
a1
arg1 <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a1
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
argname1 Map Identifier (Value m)
argValues
a2
arg2 <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a2
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
argname2 Map Identifier (Value m)
argValues
a3
arg3 <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a3
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
argname3 Map Identifier (Value m)
argValues
a4
arg4 <- Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a4
forall (m :: * -> *) a.
(Monad m, FromValue a m) =>
Text
-> Identifier
-> Map Identifier (Value m)
-> ExceptT RuntimeError m a
fnArg Text
funcName Identifier
argname4 Map Identifier (Value m)
argValues
r -> Value m
forall a (m :: * -> *). ToValue a m => a -> Value m
toValue (r -> Value m)
-> ExceptT RuntimeError m r -> ExceptT RuntimeError m (Value m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Context m
-> SomePRNG -> a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r
f Context m
ctx SomePRNG
rng a1
arg1 a2
arg2 a3
arg3 a4
arg4
mkFn4 :: ( Monad m
, ToValue a1 m
, FromValue a1 m
, ToValue a2 m
, FromValue a2 m
, ToValue a3 m
, FromValue a3 m
, ToValue a4 m
, FromValue a4 m
, ToValue r m
)
=> Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4 :: forall (m :: * -> *) a1 a2 a3 a4 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue a4 m,
FromValue a4 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4 Text
funcName Text
desc (Identifier, Maybe a1, Maybe TypeDoc, Text)
a (Identifier, Maybe a2, Maybe TypeDoc, Text)
b (Identifier, Maybe a3, Maybe TypeDoc, Text)
c (Identifier, Maybe a4, Maybe TypeDoc, Text)
d Maybe TypeDoc
retType a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r
f =
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m
-> SomePRNG -> a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
forall (m :: * -> *) a1 a2 a3 a4 r.
(Monad m, ToValue a1 m, FromValue a1 m, ToValue a2 m,
FromValue a2 m, ToValue a3 m, FromValue a3 m, ToValue a4 m,
FromValue a4 m, ToValue r m) =>
Text
-> Text
-> (Identifier, Maybe a1, Maybe TypeDoc, Text)
-> (Identifier, Maybe a2, Maybe TypeDoc, Text)
-> (Identifier, Maybe a3, Maybe TypeDoc, Text)
-> (Identifier, Maybe a4, Maybe TypeDoc, Text)
-> Maybe TypeDoc
-> (Context m
-> SomePRNG -> a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Procedure m
mkFn4' Text
funcName Text
desc (Identifier, Maybe a1, Maybe TypeDoc, Text)
a (Identifier, Maybe a2, Maybe TypeDoc, Text)
b (Identifier, Maybe a3, Maybe TypeDoc, Text)
c (Identifier, Maybe a4, Maybe TypeDoc, Text)
d Maybe TypeDoc
retType ((SomePRNG -> a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> a3
-> a4
-> ExceptT RuntimeError m r
forall a b. a -> b -> a
const ((SomePRNG -> a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> a3
-> a4
-> ExceptT RuntimeError m r)
-> ((a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> SomePRNG -> a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> a3
-> a4
-> ExceptT RuntimeError m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> SomePRNG -> a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r
forall a b. a -> b -> a
const ((a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> a3
-> a4
-> ExceptT RuntimeError m r)
-> (a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r)
-> Context m
-> SomePRNG
-> a1
-> a2
-> a3
-> a4
-> ExceptT RuntimeError m r
forall a b. (a -> b) -> a -> b
$ a1 -> a2 -> a3 -> a4 -> ExceptT RuntimeError m r
f)