{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TupleSections #-}

module Typst.Constructors
  ( getConstructor
  )
where

import qualified Data.Vector as V
import qualified Data.Map.Ordered as OM
import qualified Data.Map as M
import Data.Time (fromGregorian, secondsToDiffTime)
import Data.Maybe (fromMaybe)
import Typst.Types
import Typst.Util (makeFunction, makeFunctionWithScope, namedArg, nthArg, allArgs)
import qualified Data.Set as Set
import Data.Text (Text)
import qualified Data.Text as T
import Typst.Regex (makeRE)
import Data.List (genericTake)
import Control.Monad.Reader (asks)
import Control.Monad (mplus)
import Data.Char (ord, chr)

getConstructor :: ValType -> Maybe Val
getConstructor :: ValType -> Maybe Val
getConstructor ValType
typ =
  case ValType
typ of
    ValType
TFloat -> Val -> Maybe Val
forall a. a -> Maybe a
Just (Val -> Maybe Val) -> Val -> Maybe Val
forall a b. (a -> b) -> a -> b
$ (forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
-> Val
makeFunction ((forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
 -> Val)
-> (forall (m' :: * -> *).
    Monad m' =>
    ReaderT Arguments (MP m') Val)
-> Val
forall a b. (a -> b) -> a -> b
$ Double -> Val
VFloat (Double -> Val)
-> ReaderT Arguments (MP m') Double
-> ReaderT Arguments (MP m') Val
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> ReaderT Arguments (MP m') Double
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Int -> ReaderT Arguments (MP m) a
nthArg Int
1
    ValType
TInteger -> Val -> Maybe Val
forall a. a -> Maybe a
Just (Val -> Maybe Val) -> Val -> Maybe Val
forall a b. (a -> b) -> a -> b
$ (forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
-> Val
makeFunction ((forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
 -> Val)
-> (forall (m' :: * -> *).
    Monad m' =>
    ReaderT Arguments (MP m') Val)
-> Val
forall a b. (a -> b) -> a -> b
$ Integer -> Val
VInteger (Integer -> Val)
-> ReaderT Arguments (MP m') Integer
-> ReaderT Arguments (MP m') Val
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> ReaderT Arguments (MP m') Integer
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Int -> ReaderT Arguments (MP m) a
nthArg Int
1
    ValType
TRegex -> Val -> Maybe Val
forall a. a -> Maybe a
Just (Val -> Maybe Val) -> Val -> Maybe Val
forall a b. (a -> b) -> a -> b
$ (forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
-> Val
makeFunction ((forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
 -> Val)
-> (forall (m' :: * -> *).
    Monad m' =>
    ReaderT Arguments (MP m') Val)
-> Val
forall a b. (a -> b) -> a -> b
$ RE -> Val
VRegex (RE -> Val)
-> ReaderT Arguments (MP m') RE -> ReaderT Arguments (MP m') Val
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> ReaderT Arguments (MP m') Text
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Int -> ReaderT Arguments (MP m) a
nthArg Int
1 ReaderT Arguments (MP m') Text
-> (Text -> ReaderT Arguments (MP m') RE)
-> ReaderT Arguments (MP m') RE
forall a b.
ReaderT Arguments (MP m') a
-> (a -> ReaderT Arguments (MP m') b)
-> ReaderT Arguments (MP m') b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> ReaderT Arguments (MP m') RE
forall (m :: * -> *). MonadFail m => Text -> m RE
makeRE)
    ValType
TVersion -> Val -> Maybe Val
forall a. a -> Maybe a
Just (Val -> Maybe Val) -> Val -> Maybe Val
forall a b. (a -> b) -> a -> b
$ (forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
-> Val
makeFunction ((forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
 -> Val)
-> (forall (m' :: * -> *).
    Monad m' =>
    ReaderT Arguments (MP m') Val)
-> Val
forall a b. (a -> b) -> a -> b
$ [Integer] -> Val
VVersion ([Integer] -> Val)
-> ReaderT Arguments (MP m') [Integer]
-> ReaderT Arguments (MP m') Val
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Arguments -> [Val]) -> ReaderT Arguments (MP m') [Val]
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks Arguments -> [Val]
positional ReaderT Arguments (MP m') [Val]
-> ([Val] -> ReaderT Arguments (MP m') [Integer])
-> ReaderT Arguments (MP m') [Integer]
forall a b.
ReaderT Arguments (MP m') a
-> (a -> ReaderT Arguments (MP m') b)
-> ReaderT Arguments (MP m') b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Val -> ReaderT Arguments (MP m') Integer)
-> [Val] -> ReaderT Arguments (MP m') [Integer]
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 Val -> ReaderT Arguments (MP m') Integer
forall a (m :: * -> *).
(FromVal a, MonadPlus m, MonadFail m) =>
Val -> m a
forall (m :: * -> *).
(MonadPlus m, MonadFail m) =>
Val -> m Integer
fromVal)
    ValType
TString -> Val -> Maybe Val
forall a. a -> Maybe a
Just (Val -> Maybe Val) -> Val -> Maybe Val
forall a b. (a -> b) -> a -> b
$ (forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
-> Map Identifier Val -> Val
makeFunctionWithScope
      (do
        Val
val <- Int -> ReaderT Arguments (MP m') Val
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Int -> ReaderT Arguments (MP m) a
nthArg Int
1
        Integer
base <- Identifier -> Integer -> ReaderT Arguments (MP m') Integer
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Identifier -> a -> ReaderT Arguments (MP m) a
namedArg Identifier
"base" (Integer
10 :: Integer)
        let digitVector :: V.Vector Char
            digitVector :: Vector Char
digitVector = [Char] -> Vector Char
forall a. [a] -> Vector a
V.fromList ([Char] -> Vector Char) -> [Char] -> Vector Char
forall a b. (a -> b) -> a -> b
$ [Char
Item [Char]
'0'..Char
Item [Char]
'9'] [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char
Item [Char]
'A'..Char
Item [Char]
'Z']
        let renderDigit :: a -> Maybe Char
renderDigit a
n = Vector Char
digitVector Vector Char -> Int -> Maybe Char
forall a. Vector a -> Int -> Maybe a
V.!? (a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
n)
        Text -> Val
VString (Text -> Val)
-> ReaderT Arguments (MP m') Text -> ReaderT Arguments (MP m') Val
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
          case Val
val of
            VInteger Integer
n | Integer
base Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
/= Integer
10
              -> case Integer -> Integer -> Maybe [Integer]
forall n. Integral n => n -> n -> Maybe [n]
mDigits Integer
base Integer
n of
                   Maybe [Integer]
Nothing -> [Char] -> ReaderT Arguments (MP m') Text
forall a. [Char] -> ReaderT Arguments (MP m') a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"Could not convert number to base"
                   Just [Integer]
ds -> ReaderT Arguments (MP m') Text
-> ([Char] -> ReaderT Arguments (MP m') Text)
-> Maybe [Char]
-> ReaderT Arguments (MP m') Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
                     ([Char] -> ReaderT Arguments (MP m') Text
forall a. [Char] -> ReaderT Arguments (MP m') a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"Could not convert number to base")
                     (Text -> ReaderT Arguments (MP m') Text
forall a. a -> ReaderT Arguments (MP m') a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ReaderT Arguments (MP m') Text)
-> ([Char] -> Text) -> [Char] -> ReaderT Arguments (MP m') Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Text
T.pack)
                     ((Integer -> Maybe Char) -> [Integer] -> Maybe [Char]
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 Integer -> Maybe Char
forall {a}. Integral a => a -> Maybe Char
renderDigit [Integer]
ds)
            Val
_ -> Val -> ReaderT Arguments (MP m') Text
forall a (m :: * -> *).
(FromVal a, MonadPlus m, MonadFail m) =>
Val -> m a
forall (m :: * -> *). (MonadPlus m, MonadFail m) => Val -> m Text
fromVal Val
val ReaderT Arguments (MP m') Text
-> ReaderT Arguments (MP m') Text -> ReaderT Arguments (MP m') Text
forall a.
ReaderT Arguments (MP m') a
-> ReaderT Arguments (MP m') a -> ReaderT Arguments (MP m') a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` Text -> ReaderT Arguments (MP m') Text
forall a. a -> ReaderT Arguments (MP m') a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Val -> Text
repr Val
val))
      [ ( Identifier
"to-unicode",
           (forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
-> Val
makeFunction ((forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
 -> Val)
-> (forall (m' :: * -> *).
    Monad m' =>
    ReaderT Arguments (MP m') Val)
-> Val
forall a b. (a -> b) -> a -> b
$ do
             (Text
val :: Text) <- Int -> ReaderT Arguments (MP m') Text
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Int -> ReaderT Arguments (MP m) a
nthArg Int
1
             case Text -> Maybe (Char, Text)
T.uncons Text
val of
               Just (Char
c, Text
t) | Text -> Bool
T.null Text
t ->
                 Val -> ReaderT Arguments (MP m') Val
forall a. a -> ReaderT Arguments (MP m') a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Val -> ReaderT Arguments (MP m') Val)
-> Val -> ReaderT Arguments (MP m') Val
forall a b. (a -> b) -> a -> b
$ Integer -> Val
VInteger (Integer -> Val) -> Integer -> Val
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
$ Char -> Int
ord Char
c
               Maybe (Char, Text)
_ -> [Char] -> ReaderT Arguments (MP m') Val
forall a. [Char] -> ReaderT Arguments (MP m') a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"to-unicode expects a single character" )
      , ( Identifier
"from-unicode",
           (forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
-> Val
makeFunction ((forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
 -> Val)
-> (forall (m' :: * -> *).
    Monad m' =>
    ReaderT Arguments (MP m') Val)
-> Val
forall a b. (a -> b) -> a -> b
$ do
             (Int
val :: Int) <- Int -> ReaderT Arguments (MP m') Int
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Int -> ReaderT Arguments (MP m) a
nthArg Int
1
             Val -> ReaderT Arguments (MP m') Val
forall a. a -> ReaderT Arguments (MP m') a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Val -> ReaderT Arguments (MP m') Val)
-> Val -> ReaderT Arguments (MP m') Val
forall a b. (a -> b) -> a -> b
$ Text -> Val
VString (Text -> Val) -> Text -> Val
forall a b. (a -> b) -> a -> b
$ [Char] -> Text
T.pack [Int -> Char
chr Int
val] )
      ]
    ValType
TLabel -> Val -> Maybe Val
forall a. a -> Maybe a
Just (Val -> Maybe Val) -> Val -> Maybe Val
forall a b. (a -> b) -> a -> b
$ (forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
-> Val
makeFunction ((forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
 -> Val)
-> (forall (m' :: * -> *).
    Monad m' =>
    ReaderT Arguments (MP m') Val)
-> Val
forall a b. (a -> b) -> a -> b
$ Text -> Val
VLabel (Text -> Val)
-> ReaderT Arguments (MP m') Text -> ReaderT Arguments (MP m') Val
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> ReaderT Arguments (MP m') Text
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Int -> ReaderT Arguments (MP m) a
nthArg Int
1
    ValType
TSymbol -> Val -> Maybe Val
forall a. a -> Maybe a
Just (Val -> Maybe Val) -> Val -> Maybe Val
forall a b. (a -> b) -> a -> b
$ (forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
-> Val
makeFunction ((forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
 -> Val)
-> (forall (m' :: * -> *).
    Monad m' =>
    ReaderT Arguments (MP m') Val)
-> Val
forall a b. (a -> b) -> a -> b
$ do
        (Text
t :: Text) <- Int -> ReaderT Arguments (MP m') Text
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Int -> ReaderT Arguments (MP m) a
nthArg Int
1
        [Val]
vs <- Int -> [Val] -> [Val]
forall a. Int -> [a] -> [a]
drop Int
1 ([Val] -> [Val])
-> ReaderT Arguments (MP m') [Val]
-> ReaderT Arguments (MP m') [Val]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReaderT Arguments (MP m') [Val]
forall (m :: * -> *). Monad m => ReaderT Arguments (MP m) [Val]
allArgs
        [(Set Text, Text)]
variants <-
          (Val -> ReaderT Arguments (MP m') (Set Text, Text))
-> [Val] -> ReaderT Arguments (MP m') [(Set Text, 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
            ( \case
                VArray [VString Text
k, VString Text
v] ->
                  (Set Text, Text) -> ReaderT Arguments (MP m') (Set Text, Text)
forall a. a -> ReaderT Arguments (MP m') a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Text] -> Set Text
forall a. Ord a => [a] -> Set a
Set.fromList ((Char -> Bool) -> Text -> [Text]
T.split (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'.') Text
k), Text
v)
                Val
_ -> [Char] -> ReaderT Arguments (MP m') (Set Text, Text)
forall a. [Char] -> ReaderT Arguments (MP m') a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"wrong type in symbol arguments"
            )
            [Val]
vs
        Val -> ReaderT Arguments (MP m') Val
forall a. a -> ReaderT Arguments (MP m') a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Val -> ReaderT Arguments (MP m') Val)
-> Val -> ReaderT Arguments (MP m') Val
forall a b. (a -> b) -> a -> b
$ Symbol -> Val
VSymbol (Symbol -> Val) -> Symbol -> Val
forall a b. (a -> b) -> a -> b
$ Text -> Bool -> [(Set Text, Text)] -> Symbol
Symbol Text
t Bool
False [(Set Text, Text)]
variants
    ValType
TDateTime -> Val -> Maybe Val
forall a. a -> Maybe a
Just (Val -> Maybe Val) -> Val -> Maybe Val
forall a b. (a -> b) -> a -> b
$ (forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
-> Val
makeFunction ((forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
 -> Val)
-> (forall (m' :: * -> *).
    Monad m' =>
    ReaderT Arguments (MP m') Val)
-> Val
forall a b. (a -> b) -> a -> b
$ do
      Maybe Integer
mbyr <- Identifier
-> Maybe Integer -> ReaderT Arguments (MP m') (Maybe Integer)
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Identifier -> a -> ReaderT Arguments (MP m) a
namedArg Identifier
"year" Maybe Integer
forall a. Maybe a
Nothing
      Maybe Int
mbmo <- Identifier -> Maybe Int -> ReaderT Arguments (MP m') (Maybe Int)
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Identifier -> a -> ReaderT Arguments (MP m) a
namedArg Identifier
"month" Maybe Int
forall a. Maybe a
Nothing
      Maybe Int
mbda <- Identifier -> Maybe Int -> ReaderT Arguments (MP m') (Maybe Int)
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Identifier -> a -> ReaderT Arguments (MP m) a
namedArg Identifier
"day" Maybe Int
forall a. Maybe a
Nothing
      Maybe Integer
mbhr <- Identifier
-> Maybe Integer -> ReaderT Arguments (MP m') (Maybe Integer)
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Identifier -> a -> ReaderT Arguments (MP m) a
namedArg Identifier
"hour" Maybe Integer
forall a. Maybe a
Nothing
      Maybe Integer
mbmn <- Identifier
-> Maybe Integer -> ReaderT Arguments (MP m') (Maybe Integer)
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Identifier -> a -> ReaderT Arguments (MP m) a
namedArg Identifier
"minute" Maybe Integer
forall a. Maybe a
Nothing
      Maybe Integer
mbsc <- Identifier
-> Maybe Integer -> ReaderT Arguments (MP m') (Maybe Integer)
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Identifier -> a -> ReaderT Arguments (MP m) a
namedArg Identifier
"second" Maybe Integer
forall a. Maybe a
Nothing
      let mbday :: Maybe Day
mbday = case (Maybe Integer
mbyr, Maybe Int
mbmo, Maybe Int
mbda) of
                     (Maybe Integer
Nothing, Maybe Int
_, Maybe Int
_) -> Maybe Day
forall a. Maybe a
Nothing
                     (Just Integer
yr, Maybe Int
_, Maybe Int
_) -> Day -> Maybe Day
forall a. a -> Maybe a
Just (Day -> Maybe Day) -> Day -> Maybe Day
forall a b. (a -> b) -> a -> b
$
                       Integer -> Int -> Int -> Day
fromGregorian Integer
yr (Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
1 Maybe Int
mbmo) (Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
1 Maybe Int
mbda)
      let mbdifftime :: Maybe DiffTime
mbdifftime = case (Maybe Integer
mbhr, Maybe Integer
mbmn, Maybe Integer
mbsc) of
                              (Maybe Integer
Nothing, Maybe Integer
_, Maybe Integer
_) -> Maybe DiffTime
forall a. Maybe a
Nothing
                              (Just Integer
hr, Maybe Integer
_, Maybe Integer
_) -> DiffTime -> Maybe DiffTime
forall a. a -> Maybe a
Just (DiffTime -> Maybe DiffTime) -> DiffTime -> Maybe DiffTime
forall a b. (a -> b) -> a -> b
$ Integer -> DiffTime
secondsToDiffTime (Integer -> DiffTime) -> Integer -> DiffTime
forall a b. (a -> b) -> a -> b
$
                                (Integer
hr Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
60 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
60) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer -> (Integer -> Integer) -> Maybe Integer -> Integer
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Integer
0 (Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
60) Maybe Integer
mbmn Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+
                                  Integer -> Maybe Integer -> Integer
forall a. a -> Maybe a -> a
fromMaybe Integer
0 Maybe Integer
mbsc
      Val -> ReaderT Arguments (MP m') Val
forall a. a -> ReaderT Arguments (MP m') a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Val -> ReaderT Arguments (MP m') Val)
-> Val -> ReaderT Arguments (MP m') Val
forall a b. (a -> b) -> a -> b
$ Maybe Day -> Maybe DiffTime -> Val
VDateTime Maybe Day
mbday Maybe DiffTime
mbdifftime
    ValType
TDict -> Val -> Maybe Val
forall a. a -> Maybe a
Just (Val -> Maybe Val) -> Val -> Maybe Val
forall a b. (a -> b) -> a -> b
$ (forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
-> Val
makeFunction ((forall (m' :: * -> *). Monad m' => ReaderT Arguments (MP m') Val)
 -> Val)
-> (forall (m' :: * -> *).
    Monad m' =>
    ReaderT Arguments (MP m') Val)
-> Val
forall a b. (a -> b) -> a -> b
$ do
      Val
a <- Int -> ReaderT Arguments (MP m') Val
forall (m :: * -> *) a.
(Monad m, FromVal a) =>
Int -> ReaderT Arguments (MP m) a
nthArg Int
1
      case Val
a of
        VModule Identifier
_ Map Identifier Val
m -> Val -> ReaderT Arguments (MP m') Val
forall a. a -> ReaderT Arguments (MP m') a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Val -> ReaderT Arguments (MP m') Val)
-> Val -> ReaderT Arguments (MP m') Val
forall a b. (a -> b) -> a -> b
$ OMap Identifier Val -> Val
VDict (OMap Identifier Val -> Val) -> OMap Identifier Val -> Val
forall a b. (a -> b) -> a -> b
$ [(Identifier, Val)] -> OMap Identifier Val
forall k v. Ord k => [(k, v)] -> OMap k v
OM.fromList ([(Identifier, Val)] -> OMap Identifier Val)
-> [(Identifier, Val)] -> OMap Identifier Val
forall a b. (a -> b) -> a -> b
$ Map Identifier Val -> [(Identifier, Val)]
forall k a. Map k a -> [(k, a)]
M.toList Map Identifier Val
m
        Val
_ -> [Char] -> ReaderT Arguments (MP m') Val
forall a. [Char] -> ReaderT Arguments (MP m') a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"dictionary constructor requires a module as argument"
    ValType
TArguments -> Maybe Val
forall a. Maybe a
Nothing
    -- TODO https://typst.app/docs/reference/foundations/arguments/
    ValType
TSelector -> Maybe Val
forall a. Maybe a
Nothing
    -- TODO https://typst.app/docs/reference/foundations/selector/
    ValType
TCounter -> Maybe Val
forall a. Maybe a
Nothing
    -- TODO https://typst.app/docs/reference/introspection/counter/
    ValType
_ -> Maybe Val
forall a. Maybe a
Nothing


-- mDigitsRev, mDigits from the unmaintained digits package
-- https://hackage.haskell.org/package/digits-0.3.1
-- (c) 2009-2016 Henry Bucklow, Charlie Harvey -- BSD-3-Clause license.
mDigitsRev :: Integral n
    => n         -- ^ The base to use.
    -> n         -- ^ The number to convert to digit form.
    -> Maybe [n] -- ^ Nothing or Just the digits of the number in list form, in reverse.
mDigitsRev :: forall n. Integral n => n -> n -> Maybe [n]
mDigitsRev n
base n
i = if n
base n -> n -> Bool
forall a. Ord a => a -> a -> Bool
< n
1
                    then Maybe [n]
forall a. Maybe a
Nothing -- We do not support zero or negative bases
                    else [n] -> Maybe [n]
forall a. a -> Maybe a
Just ([n] -> Maybe [n]) -> [n] -> Maybe [n]
forall a b. (a -> b) -> a -> b
$ n -> n -> [n]
forall {t}. Integral t => t -> t -> [t]
dr n
base n
i
    where
      dr :: t -> t -> [t]
dr t
_ t
0 = []
      dr t
b t
x = case n
base of
                n
1 -> t -> [t] -> [t]
forall i a. Integral i => i -> [a] -> [a]
genericTake t
x ([t] -> [t]) -> [t] -> [t]
forall a b. (a -> b) -> a -> b
$ t -> [t]
forall a. a -> [a]
repeat t
1
                n
_ -> let (t
rest, t
lastDigit) = t -> t -> (t, t)
forall a. Integral a => a -> a -> (a, a)
quotRem t
x t
b
                     in t
lastDigit t -> [t] -> [t]
forall a. a -> [a] -> [a]
: t -> t -> [t]
dr t
b t
rest

-- | Returns the digits of a positive integer as a Maybe list.
--   or Nothing if a zero or negative base is given
mDigits :: Integral n
    => n -- ^ The base to use.
    -> n -- ^ The number to convert to digit form.
    -> Maybe [n] -- ^ Nothing or Just the digits of the number in list form
mDigits :: forall n. Integral n => n -> n -> Maybe [n]
mDigits n
base n
i = [n] -> [n]
forall a. [a] -> [a]
reverse ([n] -> [n]) -> Maybe [n] -> Maybe [n]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> n -> n -> Maybe [n]
forall n. Integral n => n -> n -> Maybe [n]
mDigitsRev n
base n
i