{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE BinaryLiterals #-}
{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE UnboxedTuples #-}

module Json
  ( -- * Types
    Value (..)
  , Member (..)
  , SyntaxException (..)

    -- * Classes
  , ToValue (..)

    -- * Functions
  , decode
  , decodeNewlineDelimited
  , encode
  , toChunks
  , toShortText
  , toText
  , toBytes
  , toByteArray

    -- * Infix Synonyms
  , pattern (:->)

    -- * Constants
  , emptyArray
  , emptyObject

    -- * Value Construction
  , int
  , int8
  , int16
  , int32
  , int64
  , word8
  , word16
  , word32
  , word64
  , bool
  , text
  , shortText

    -- * Array Construction
  , arrayFromList

    -- * Object Construction
  , objectFromList
  , object1
  , object2
  , object3
  , object4
  , object5
  , object6
  , object7
  , object8
  , object9
  , object10
  , object11
  , object12
  , object13
  , object14
  , object15
  , object16
  ) where

import Prelude hiding (Bool (False, True))

import Control.Exception (Exception)
import Control.Monad.ST (ST, runST)
import Control.Monad.ST.Run (runSmallArrayST)
import Control.Monad.Trans.Class (lift)
import Control.Monad.Trans.Except (except, runExceptT)
import Data.Bits (unsafeShiftR, (.&.), (.|.))
import Data.Builder.ST (Builder)
import Data.Bytes.Chunks (Chunks)
import Data.Bytes.Parser (Parser)
import Data.Bytes.Types (Bytes (..))
import Data.Char (ord)
import Data.Foldable (foldlM)
import Data.Number.Scientific (Scientific)
import Data.Primitive (Array, ByteArray (ByteArray), MutableByteArray, Prim, PrimArray, SmallArray)
import Data.Text (Text)
import Data.Text.Short (ShortText)
import GHC.Exts (Char (C#), Int (I#), chr#, gtWord#, ltWord#, word2Int#)
import GHC.Int (Int16, Int32, Int64, Int8)
import GHC.Word (Word16, Word32, Word64, Word8)

import qualified Data.Builder.ST as B
import qualified Data.ByteString.Short.Internal as BSS
import qualified Data.Bytes as Bytes
import qualified Data.Bytes.Builder as BLDR
import qualified Data.Bytes.Chunks as ByteChunks
import qualified Data.Bytes.Parser as P
import qualified Data.Bytes.Parser.Latin as Latin
import qualified Data.Bytes.Parser.Unsafe as Unsafe
import qualified Data.Bytes.Parser.Utf8 as Utf8
import qualified Data.Chunks as Chunks
import qualified Data.List as List
import qualified Data.Number.Scientific as SCI
import qualified Data.Primitive as PM
import qualified Data.Primitive.Contiguous as Contiguous
import qualified Data.Text.Short as TS
import qualified Data.Text.Short.Unsafe as TS
import qualified GHC.Word.Compat
import qualified Prelude

{- | The JSON syntax tree described by the ABNF in RFC 7159. Notable
design decisions include:

* @True@ and @False@ are their own data constructors rather than
  being lumped together under a data constructor for boolean values.
  This improves performance when decoding the syntax tree to a @Bool@.
* @Object@ uses an association list rather than a hash map. This is
  the data type that key-value pairs can be parsed into most cheaply.
* @Object@ and @Array@ both use 'Chunks' rather than using @SmallArray@
  or cons-list directly. This a middle ground between those two types. We
  get the efficent use of cache lines that @SmallArray@ offers, and we get
  the worst-case @O(1)@ appends that cons-list offers. Users will typically
  fold over the elements with the @Foldable@ instance of 'Chunks', although
  there are functions in @Data.Chunks@ that efficently perform other
  operations.
-}
data Value
  = Object !(SmallArray Member)
  | Array !(SmallArray Value)
  | String {-# UNPACK #-} !ShortText
  | Number {-# UNPACK #-} !Scientific
  | Null
  | True
  | False
  deriving stock (Value -> Value -> Bool
(Value -> Value -> Bool) -> (Value -> Value -> Bool) -> Eq Value
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Value -> Value -> Bool
== :: Value -> Value -> Bool
$c/= :: Value -> Value -> Bool
/= :: Value -> Value -> Bool
Eq, Int -> Value -> ShowS
[Value] -> ShowS
Value -> String
(Int -> Value -> ShowS)
-> (Value -> String) -> ([Value] -> ShowS) -> Show Value
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Value -> ShowS
showsPrec :: Int -> Value -> ShowS
$cshow :: Value -> String
show :: Value -> String
$cshowList :: [Value] -> ShowS
showList :: [Value] -> ShowS
Show)

{- | Exceptions that can happen while parsing JSON. Do not pattern
match on values of this type. New data constructors may be added
at any time without a major version bump.
-}
data SyntaxException
  = EmptyInput
  | ExpectedColon
  | ExpectedCommaOrRightBracket
  | ExpectedFalse
  | ExpectedNull
  | ExpectedQuote
  | ExpectedQuoteOrRightBrace
  | ExpectedTrue
  | IncompleteArray
  | IncompleteEscapeSequence
  | IncompleteObject
  | IncompleteString
  | InvalidEscapeSequence
  | InvalidLeader
  | InvalidNumber
  | LeadingZero
  | UnexpectedLeftovers
  | PossibleOverflow
  deriving stock (SyntaxException -> SyntaxException -> Bool
(SyntaxException -> SyntaxException -> Bool)
-> (SyntaxException -> SyntaxException -> Bool)
-> Eq SyntaxException
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SyntaxException -> SyntaxException -> Bool
== :: SyntaxException -> SyntaxException -> Bool
$c/= :: SyntaxException -> SyntaxException -> Bool
/= :: SyntaxException -> SyntaxException -> Bool
Eq, Int -> SyntaxException -> ShowS
[SyntaxException] -> ShowS
SyntaxException -> String
(Int -> SyntaxException -> ShowS)
-> (SyntaxException -> String)
-> ([SyntaxException] -> ShowS)
-> Show SyntaxException
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SyntaxException -> ShowS
showsPrec :: Int -> SyntaxException -> ShowS
$cshow :: SyntaxException -> String
show :: SyntaxException -> String
$cshowList :: [SyntaxException] -> ShowS
showList :: [SyntaxException] -> ShowS
Show)
  deriving anyclass (Show SyntaxException
Typeable SyntaxException
(Typeable SyntaxException, Show SyntaxException) =>
(SyntaxException -> SomeException)
-> (SomeException -> Maybe SyntaxException)
-> (SyntaxException -> String)
-> Exception SyntaxException
SomeException -> Maybe SyntaxException
SyntaxException -> String
SyntaxException -> SomeException
forall e.
(Typeable e, Show e) =>
(e -> SomeException)
-> (SomeException -> Maybe e) -> (e -> String) -> Exception e
$ctoException :: SyntaxException -> SomeException
toException :: SyntaxException -> SomeException
$cfromException :: SomeException -> Maybe SyntaxException
fromException :: SomeException -> Maybe SyntaxException
$cdisplayException :: SyntaxException -> String
displayException :: SyntaxException -> String
Exception)

{- | A key-value pair in a JSON object. The name of this type is
taken from section 4 of RFC 7159.
-}
data Member = Member
  { Member -> ShortText
key :: {-# UNPACK #-} !ShortText
  , Member -> Value
value :: !Value
  }
  deriving stock (Member -> Member -> Bool
(Member -> Member -> Bool)
-> (Member -> Member -> Bool) -> Eq Member
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Member -> Member -> Bool
== :: Member -> Member -> Bool
$c/= :: Member -> Member -> Bool
/= :: Member -> Member -> Bool
Eq, Int -> Member -> ShowS
[Member] -> ShowS
Member -> String
(Int -> Member -> ShowS)
-> (Member -> String) -> ([Member] -> ShowS) -> Show Member
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Member -> ShowS
showsPrec :: Int -> Member -> ShowS
$cshow :: Member -> String
show :: Member -> String
$cshowList :: [Member] -> ShowS
showList :: [Member] -> ShowS
Show)

-- | An array with no elements (i.e. @[]@)
emptyArray :: Value
{-# NOINLINE emptyArray #-}
emptyArray :: Value
emptyArray = SmallArray Value -> Value
Array SmallArray Value
forall a. Monoid a => a
mempty

-- | An object with no members (i.e. @{}@)
emptyObject :: Value
{-# NOINLINE emptyObject #-}
emptyObject :: Value
emptyObject = SmallArray Member -> Value
Object SmallArray Member
forall a. Monoid a => a
mempty

isSpace :: Word8 -> Prelude.Bool
{-# INLINE isSpace #-}
isSpace :: Word8 -> Bool
isSpace Word8
w =
  Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Word8
c2w Char
' '
    Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Word8
c2w Char
'\t'
    Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Word8
c2w Char
'\r'
    Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Word8
c2w Char
'\n'

-- | Decode a JSON syntax tree from a byte sequence.
decode :: Bytes -> Either SyntaxException Value
{-# NOINLINE decode #-}
decode :: Bytes -> Either SyntaxException Value
decode = (forall s. Parser SyntaxException s Value)
-> Bytes -> Either SyntaxException Value
forall e a. (forall s. Parser e s a) -> Bytes -> Either e a
P.parseBytesEither Parser SyntaxException s Value
forall s. Parser SyntaxException s Value
parser

parser :: Parser SyntaxException s Value
{-# INLINE parser #-}
parser :: forall s. Parser SyntaxException s Value
parser = do
  (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
  Value
result <- SyntaxException -> Parser SyntaxException s Char
forall e s. e -> Parser e s Char
Latin.any SyntaxException
EmptyInput Parser SyntaxException s Char
-> (Char -> Parser SyntaxException s Value)
-> Parser SyntaxException s Value
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Char -> Parser SyntaxException s Value
forall s. Char -> Parser SyntaxException s Value
parserStep
  (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
  SyntaxException -> Parser SyntaxException s ()
forall e s. e -> Parser e s ()
P.endOfInput SyntaxException
UnexpectedLeftovers
  Value -> Parser SyntaxException s Value
forall a. a -> Parser SyntaxException s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value
result

{- | Decode newline-delimited JSON. Both the LF and the CRLF conventions
are supported. The newline character (or character sequence) following
the final object may be omitted. This also allows blanks lines consisting
of only whitespace.

It's not strictly necessary for this to be a part of this library, but
newline-delimited JSON is somewhat common in practice. It's nice to have
this here instead of having to reimplement it in a bunch of different
applications.

Note: To protect against malicious input, this reject byte sequences with
more than 10 million newlines. If this is causing a problem for you, open
an issue.

Other note: in the future, this function might be changed transparently
to parallelize the decoding of large input (at least 1000 lines) with
GHC sparks.
-}
decodeNewlineDelimited :: Bytes -> Either SyntaxException (SmallArray Value)
{-# NOINLINE decodeNewlineDelimited #-}
decodeNewlineDelimited :: Bytes -> Either SyntaxException (SmallArray Value)
decodeNewlineDelimited !Bytes
everything =
  let maxVals :: Int
maxVals = Word8 -> Bytes -> Int
Bytes.count Word8
0x0A Bytes
everything Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
   in if Int
maxVals Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10000000
        then SyntaxException -> Either SyntaxException (SmallArray Value)
forall a b. a -> Either a b
Left SyntaxException
PossibleOverflow
        else (forall s. ST s (Either SyntaxException (SmallArray Value)))
-> Either SyntaxException (SmallArray Value)
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (Either SyntaxException (SmallArray Value)))
 -> Either SyntaxException (SmallArray Value))
-> (forall s. ST s (Either SyntaxException (SmallArray Value)))
-> Either SyntaxException (SmallArray Value)
forall a b. (a -> b) -> a -> b
$ ExceptT SyntaxException (ST s) (SmallArray Value)
-> ST s (Either SyntaxException (SmallArray Value))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT SyntaxException (ST s) (SmallArray Value)
 -> ST s (Either SyntaxException (SmallArray Value)))
-> ExceptT SyntaxException (ST s) (SmallArray Value)
-> ST s (Either SyntaxException (SmallArray Value))
forall a b. (a -> b) -> a -> b
$ do
          !SmallMutableArray s Value
dst <- Int
-> Value
-> ExceptT
     SyntaxException
     (ST s)
     (SmallMutableArray
        (PrimState (ExceptT SyntaxException (ST s))) Value)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
maxVals Value
Null
          !Int
total <-
            (Int -> Bytes -> ExceptT SyntaxException (ST s) Int)
-> Int -> [Bytes] -> ExceptT SyntaxException (ST s) Int
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldlM
              ( \ !Int
ix Bytes
b ->
                  let clean :: Bytes
clean = (Word8 -> Bool) -> Bytes -> Bytes
Bytes.dropWhile Word8 -> Bool
isSpace ((Word8 -> Bool) -> Bytes -> Bytes
Bytes.dropWhileEnd Word8 -> Bool
isSpace Bytes
b)
                   in if Bytes -> Bool
Bytes.null Bytes
clean
                        then Int -> ExceptT SyntaxException (ST s) Int
forall a. a -> ExceptT SyntaxException (ST s) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
ix
                        else do
                          Value
v <- Either SyntaxException Value
-> ExceptT SyntaxException (ST s) Value
forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
except (Bytes -> Either SyntaxException Value
decode Bytes
clean)
                          ST s () -> ExceptT SyntaxException (ST s) ()
forall (m :: * -> *) a.
Monad m =>
m a -> ExceptT SyntaxException m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (SmallMutableArray (PrimState (ST s)) Value
-> Int -> Value -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Value
SmallMutableArray (PrimState (ST s)) Value
dst Int
ix Value
v)
                          Int -> ExceptT SyntaxException (ST s) Int
forall a. a -> ExceptT SyntaxException (ST s) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
              )
              Int
0
              (Word8 -> Bytes -> [Bytes]
Bytes.split Word8
0x0A Bytes
everything)
          ST s () -> ExceptT SyntaxException (ST s) ()
forall (m :: * -> *) a.
Monad m =>
m a -> ExceptT SyntaxException m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ST s () -> ExceptT SyntaxException (ST s) ())
-> ST s () -> ExceptT SyntaxException (ST s) ()
forall a b. (a -> b) -> a -> b
$ SmallMutableArray (PrimState (ST s)) Value -> Int -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> m ()
PM.shrinkSmallMutableArray SmallMutableArray s Value
SmallMutableArray (PrimState (ST s)) Value
dst Int
total
          SmallArray Value
dst' <- ST s (SmallArray Value)
-> ExceptT SyntaxException (ST s) (SmallArray Value)
forall (m :: * -> *) a.
Monad m =>
m a -> ExceptT SyntaxException m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ST s (SmallArray Value)
 -> ExceptT SyntaxException (ST s) (SmallArray Value))
-> ST s (SmallArray Value)
-> ExceptT SyntaxException (ST s) (SmallArray Value)
forall a b. (a -> b) -> a -> b
$ SmallMutableArray (PrimState (ST s)) Value
-> ST s (SmallArray Value)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Value
SmallMutableArray (PrimState (ST s)) Value
dst
          SmallArray Value
-> ExceptT SyntaxException (ST s) (SmallArray Value)
forall a. a -> ExceptT SyntaxException (ST s) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SmallArray Value
dst'

toChunks :: Value -> Chunks
{-# INLINE toChunks #-}
toChunks :: Value -> Chunks
toChunks = Int -> Builder -> Chunks
BLDR.run Int
512 (Builder -> Chunks) -> (Value -> Builder) -> Value -> Chunks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Builder
encode

toBytes :: Value -> Bytes
{-# INLINE toBytes #-}
toBytes :: Value -> Bytes
toBytes = Chunks -> Bytes
ByteChunks.concat (Chunks -> Bytes) -> (Value -> Chunks) -> Value -> Bytes
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Chunks
toChunks

toByteArray :: Value -> ByteArray
{-# INLINE toByteArray #-}
toByteArray :: Value -> ByteArray
toByteArray = Chunks -> ByteArray
ByteChunks.concatU (Chunks -> ByteArray) -> (Value -> Chunks) -> Value -> ByteArray
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Chunks
toChunks

toShortText :: Value -> ShortText
{-# INLINE toShortText #-}
toShortText :: Value -> ShortText
toShortText Value
v = case Value -> ByteArray
toByteArray Value
v of
  ByteArray ByteArray#
x -> ShortByteString -> ShortText
TS.fromShortByteStringUnsafe (ByteArray# -> ShortByteString
BSS.SBS ByteArray#
x)

toText :: Value -> Text
{-# INLINE toText #-}
toText :: Value -> Text
toText = ShortText -> Text
TS.toText (ShortText -> Text) -> (Value -> ShortText) -> Value -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> ShortText
toShortText

-- | Encode a JSON syntax tree.
encode :: Value -> BLDR.Builder
{-# NOINLINE encode #-}
encode :: Value -> Builder
encode Value
v0 = Builder -> Builder
BLDR.rebuild (Builder -> Builder) -> Builder -> Builder
forall a b. (a -> b) -> a -> b
$ case Value
v0 of
  Value
True -> Char -> Char -> Char -> Char -> Builder
BLDR.ascii4 Char
't' Char
'r' Char
'u' Char
'e'
  Value
False -> Char -> Char -> Char -> Char -> Char -> Builder
BLDR.ascii5 Char
'f' Char
'a' Char
'l' Char
's' Char
'e'
  Value
Null -> Char -> Char -> Char -> Char -> Builder
BLDR.ascii4 Char
'n' Char
'u' Char
'l' Char
'l'
  String ShortText
s -> ShortText -> Builder
BLDR.shortTextJsonString ShortText
s
  Number Scientific
n -> Scientific -> Builder
SCI.builderUtf8 Scientific
n
  Array SmallArray Value
ys -> case SmallArray Value -> Int
forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray Value
ys of
    Int
0 -> Char -> Char -> Builder
BLDR.ascii2 Char
'[' Char
']'
    Int
_ ->
      let !(# Value
z #) = SmallArray Value -> Int -> (# Value #)
forall a. SmallArray a -> Int -> (# a #)
PM.indexSmallArray## SmallArray Value
ys Int
0
       in Char -> Builder
BLDR.ascii Char
'['
            Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Value -> Builder
encode Value
z
            Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (Value -> Builder -> Builder)
-> Builder -> SmallArray Value -> Builder
forall a b. (a -> b -> b) -> b -> SmallArray a -> b
foldrTail
              ( \Value
v Builder
b -> Char -> Builder
BLDR.ascii Char
',' Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Value -> Builder
encode Value
v Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
b
              )
              (Char -> Builder
BLDR.ascii Char
']')
              SmallArray Value
ys
  Object SmallArray Member
ys -> case SmallArray Member -> Int
forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray Member
ys of
    Int
0 -> Char -> Char -> Builder
BLDR.ascii2 Char
'{' Char
'}'
    Int
_ ->
      let !(# Member
z #) = SmallArray Member -> Int -> (# Member #)
forall a. SmallArray a -> Int -> (# a #)
PM.indexSmallArray## SmallArray Member
ys Int
0
       in Char -> Builder
BLDR.ascii Char
'{'
            Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Member -> Builder
encodeMember Member
z
            Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (Member -> Builder -> Builder)
-> Builder -> SmallArray Member -> Builder
forall a b. (a -> b -> b) -> b -> SmallArray a -> b
foldrTail
              ( \Member
v Builder
b -> Char -> Builder
BLDR.ascii Char
',' Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Member -> Builder
encodeMember Member
v Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
b
              )
              (Char -> Builder
BLDR.ascii Char
'}')
              SmallArray Member
ys

encodeMember :: Member -> BLDR.Builder
encodeMember :: Member -> Builder
encodeMember Member {ShortText
key :: Member -> ShortText
key :: ShortText
key, Value
value :: Member -> Value
value :: Value
value} =
  ShortText -> Builder
BLDR.shortTextJsonString ShortText
key
    Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Char -> Builder
BLDR.ascii Char
':'
    Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Value -> Builder
encode Value
value

foldrTail :: (a -> b -> b) -> b -> PM.SmallArray a -> b
{-# INLINE foldrTail #-}
foldrTail :: forall a b. (a -> b -> b) -> b -> SmallArray a -> b
foldrTail a -> b -> b
f b
z !SmallArray a
ary = Int -> b
go Int
1
 where
  !sz :: Int
sz = SmallArray a -> Int
forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
ary
  go :: Int -> b
go Int
i
    | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
sz = b
z
    | (# a
x #) <- SmallArray a -> Int -> (# a #)
forall a. SmallArray a -> Int -> (# a #)
PM.indexSmallArray## SmallArray a
ary Int
i =
        a -> b -> b
f a
x (Int -> b
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1))

-- Precondition: skip over all space before calling this.
-- It will not skip leading space for you. It does not skip
-- over trailing space either.
parserStep :: Char -> Parser SyntaxException s Value
parserStep :: forall s. Char -> Parser SyntaxException s Value
parserStep = \case
  Char
'{' -> Parser SyntaxException s Value
forall s. Parser SyntaxException s Value
objectTrailedByBrace
  Char
'[' -> Parser SyntaxException s Value
forall s. Parser SyntaxException s Value
arrayTrailedByBracket
  Char
't' -> do
    SyntaxException
-> Char -> Char -> Char -> Parser SyntaxException s ()
forall e s. e -> Char -> Char -> Char -> Parser e s ()
Latin.char3 SyntaxException
ExpectedTrue Char
'r' Char
'u' Char
'e'
    Value -> Parser SyntaxException s Value
forall a. a -> Parser SyntaxException s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value
True
  Char
'f' -> do
    SyntaxException
-> Char -> Char -> Char -> Char -> Parser SyntaxException s ()
forall e s. e -> Char -> Char -> Char -> Char -> Parser e s ()
Latin.char4 SyntaxException
ExpectedFalse Char
'a' Char
'l' Char
's' Char
'e'
    Value -> Parser SyntaxException s Value
forall a. a -> Parser SyntaxException s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value
False
  Char
'n' -> do
    SyntaxException
-> Char -> Char -> Char -> Parser SyntaxException s ()
forall e s. e -> Char -> Char -> Char -> Parser e s ()
Latin.char3 SyntaxException
ExpectedNull Char
'u' Char
'l' Char
'l'
    Value -> Parser SyntaxException s Value
forall a. a -> Parser SyntaxException s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value
Null
  Char
'"' -> do
    Int
start <- Parser SyntaxException s Int
forall e s. Parser e s Int
Unsafe.cursor
    (ShortText -> Value) -> Int -> Parser SyntaxException s Value
forall a s. (ShortText -> a) -> Int -> Parser SyntaxException s a
string ShortText -> Value
String Int
start
  Char
'-' -> (Scientific -> Value)
-> Parser SyntaxException s Scientific
-> Parser SyntaxException s Value
forall a b.
(a -> b)
-> Parser SyntaxException s a -> Parser SyntaxException s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Scientific -> Value
Number (SyntaxException -> Parser SyntaxException s Scientific
forall e s. e -> Parser e s Scientific
SCI.parserNegatedUtf8Bytes SyntaxException
InvalidNumber)
  Char
'0' ->
    (Char -> Bool) -> Parser SyntaxException s Bool
forall e s. (Char -> Bool) -> Parser e s Bool
Latin.trySatisfy (\Char
c -> Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
'0' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'9') Parser SyntaxException s Bool
-> (Bool -> Parser SyntaxException s Value)
-> Parser SyntaxException s Value
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Bool
Prelude.True -> SyntaxException -> Parser SyntaxException s Value
forall e s a. e -> Parser e s a
P.fail SyntaxException
LeadingZero
      Bool
Prelude.False -> (Scientific -> Value)
-> Parser SyntaxException s Scientific
-> Parser SyntaxException s Value
forall a b.
(a -> b)
-> Parser SyntaxException s a -> Parser SyntaxException s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Scientific -> Value
Number (SyntaxException -> Int -> Parser SyntaxException s Scientific
forall e s. e -> Int -> Parser e s Scientific
SCI.parserTrailingUtf8Bytes SyntaxException
InvalidNumber Int
0)
  Char
c
    | Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
'1' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'9' ->
        (Scientific -> Value)
-> Parser SyntaxException s Scientific
-> Parser SyntaxException s Value
forall a b.
(a -> b)
-> Parser SyntaxException s a -> Parser SyntaxException s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Scientific -> Value
Number (SyntaxException -> Int -> Parser SyntaxException s Scientific
forall e s. e -> Int -> Parser e s Scientific
SCI.parserTrailingUtf8Bytes SyntaxException
InvalidNumber (Char -> Int
ord Char
c Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
48))
  Char
_ -> SyntaxException -> Parser SyntaxException s Value
forall e s a. e -> Parser e s a
P.fail SyntaxException
InvalidLeader

objectTrailedByBrace :: Parser SyntaxException s Value
{-# INLINE objectTrailedByBrace #-}
objectTrailedByBrace :: forall s. Parser SyntaxException s Value
objectTrailedByBrace = do
  (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
  SyntaxException -> Parser SyntaxException s Char
forall e s. e -> Parser e s Char
Latin.any SyntaxException
IncompleteObject Parser SyntaxException s Char
-> (Char -> Parser SyntaxException s Value)
-> Parser SyntaxException s Value
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Char
'}' -> Value -> Parser SyntaxException s Value
forall a. a -> Parser SyntaxException s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value
emptyObject
    Char
'"' -> do
      Int
start <- Parser SyntaxException s Int
forall e s. Parser e s Int
Unsafe.cursor
      !ShortText
theKey <- (ShortText -> ShortText)
-> Int -> Parser SyntaxException s ShortText
forall a s. (ShortText -> a) -> Int -> Parser SyntaxException s a
string ShortText -> ShortText
forall a. a -> a
id Int
start
      (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
      SyntaxException -> Char -> Parser SyntaxException s ()
forall e s. e -> Char -> Parser e s ()
Latin.char SyntaxException
ExpectedColon Char
':'
      (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
      Value
val <- SyntaxException -> Parser SyntaxException s Char
forall e s. e -> Parser e s Char
Latin.any SyntaxException
IncompleteObject Parser SyntaxException s Char
-> (Char -> Parser SyntaxException s Value)
-> Parser SyntaxException s Value
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Char -> Parser SyntaxException s Value
forall s. Char -> Parser SyntaxException s Value
parserStep
      let !mbr :: Member
mbr = ShortText -> Value -> Member
Member ShortText
theKey Value
val
      !Builder s Member
b0 <- ST s (Builder s Member)
-> Parser SyntaxException s (Builder s Member)
forall s a e. ST s a -> Parser e s a
P.effect ST s (Builder s Member)
forall s a. ST s (Builder s a)
B.new
      Builder s Member
b1 <- ST s (Builder s Member)
-> Parser SyntaxException s (Builder s Member)
forall s a e. ST s a -> Parser e s a
P.effect (Member -> Builder s Member -> ST s (Builder s Member)
forall a s. a -> Builder s a -> ST s (Builder s a)
B.push Member
mbr Builder s Member
b0)
      Builder s Member -> Parser SyntaxException s Value
forall s. Builder s Member -> Parser SyntaxException s Value
objectStep Builder s Member
b1
    Char
_ -> SyntaxException -> Parser SyntaxException s Value
forall e s a. e -> Parser e s a
P.fail SyntaxException
ExpectedQuoteOrRightBrace

objectStep :: Builder s Member -> Parser SyntaxException s Value
objectStep :: forall s. Builder s Member -> Parser SyntaxException s Value
objectStep !Builder s Member
b = do
  (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
  SyntaxException -> Parser SyntaxException s Char
forall e s. e -> Parser e s Char
Latin.any SyntaxException
IncompleteObject Parser SyntaxException s Char
-> (Char -> Parser SyntaxException s Value)
-> Parser SyntaxException s Value
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Char
',' -> do
      (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
      SyntaxException -> Char -> Parser SyntaxException s ()
forall e s. e -> Char -> Parser e s ()
Latin.char SyntaxException
ExpectedQuote Char
'"'
      Int
start <- Parser SyntaxException s Int
forall e s. Parser e s Int
Unsafe.cursor
      !ShortText
theKey <- (ShortText -> ShortText)
-> Int -> Parser SyntaxException s ShortText
forall a s. (ShortText -> a) -> Int -> Parser SyntaxException s a
string ShortText -> ShortText
forall a. a -> a
id Int
start
      (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
      SyntaxException -> Char -> Parser SyntaxException s ()
forall e s. e -> Char -> Parser e s ()
Latin.char SyntaxException
ExpectedColon Char
':'
      (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
      Value
val <- SyntaxException -> Parser SyntaxException s Char
forall e s. e -> Parser e s Char
Latin.any SyntaxException
IncompleteObject Parser SyntaxException s Char
-> (Char -> Parser SyntaxException s Value)
-> Parser SyntaxException s Value
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Char -> Parser SyntaxException s Value
forall s. Char -> Parser SyntaxException s Value
parserStep
      let !mbr :: Member
mbr = ShortText -> Value -> Member
Member ShortText
theKey Value
val
      ST s (Builder s Member)
-> Parser SyntaxException s (Builder s Member)
forall s a e. ST s a -> Parser e s a
P.effect (Member -> Builder s Member -> ST s (Builder s Member)
forall a s. a -> Builder s a -> ST s (Builder s a)
B.push Member
mbr Builder s Member
b) Parser SyntaxException s (Builder s Member)
-> (Builder s Member -> Parser SyntaxException s Value)
-> Parser SyntaxException s Value
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Builder s Member -> Parser SyntaxException s Value
forall s. Builder s Member -> Parser SyntaxException s Value
objectStep
    Char
'}' -> do
      !Chunks Member
r <- ST s (Chunks Member) -> Parser SyntaxException s (Chunks Member)
forall s a e. ST s a -> Parser e s a
P.effect (Builder s Member -> ST s (Chunks Member)
forall s a. Builder s a -> ST s (Chunks a)
B.freeze Builder s Member
b)
      let !arr :: SmallArray Member
arr = Chunks Member -> SmallArray Member
forall a. Chunks a -> SmallArray a
Chunks.concat Chunks Member
r
      Value -> Parser SyntaxException s Value
forall a. a -> Parser SyntaxException s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SmallArray Member -> Value
Object SmallArray Member
arr)
    Char
_ -> SyntaxException -> Parser SyntaxException s Value
forall e s a. e -> Parser e s a
P.fail SyntaxException
ExpectedCommaOrRightBracket

-- This eats all the space at the front of the input. There
-- is no need to skip over it before calling this function.
-- RFC 7159 defines array as:
--
-- > begin-array = ws LBRACKET ws
-- > array = begin-array [ value *( value-separator value ) ] end-array
--
-- This parser handles everything after the LBRACKET character.
arrayTrailedByBracket :: Parser SyntaxException s Value
{-# INLINE arrayTrailedByBracket #-}
arrayTrailedByBracket :: forall s. Parser SyntaxException s Value
arrayTrailedByBracket = do
  (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
  SyntaxException -> Parser SyntaxException s Char
forall e s. e -> Parser e s Char
Latin.any SyntaxException
IncompleteArray Parser SyntaxException s Char
-> (Char -> Parser SyntaxException s Value)
-> Parser SyntaxException s Value
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Char
']' -> Value -> Parser SyntaxException s Value
forall a. a -> Parser SyntaxException s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value
emptyArray
    Char
c -> do
      !Builder s Value
b0 <- ST s (Builder s Value)
-> Parser SyntaxException s (Builder s Value)
forall s a e. ST s a -> Parser e s a
P.effect ST s (Builder s Value)
forall s a. ST s (Builder s a)
B.new
      Value
val <- Char -> Parser SyntaxException s Value
forall s. Char -> Parser SyntaxException s Value
parserStep Char
c
      Builder s Value
b1 <- ST s (Builder s Value)
-> Parser SyntaxException s (Builder s Value)
forall s a e. ST s a -> Parser e s a
P.effect (Value -> Builder s Value -> ST s (Builder s Value)
forall a s. a -> Builder s a -> ST s (Builder s a)
B.push Value
val Builder s Value
b0)
      Builder s Value -> Parser SyntaxException s Value
forall s. Builder s Value -> Parser SyntaxException s Value
arrayStep Builder s Value
b1

-- From RFC 7159:
--
-- > value-separator = ws COMMA ws
-- > array = begin-array [ value *( value-separator value ) ] end-array
--
-- This handles the all values after the first one. That is:
--
-- > *( value-separator value )
arrayStep :: Builder s Value -> Parser SyntaxException s Value
arrayStep :: forall s. Builder s Value -> Parser SyntaxException s Value
arrayStep !Builder s Value
b = do
  (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
  SyntaxException -> Parser SyntaxException s Char
forall e s. e -> Parser e s Char
Latin.any SyntaxException
IncompleteArray Parser SyntaxException s Char
-> (Char -> Parser SyntaxException s Value)
-> Parser SyntaxException s Value
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Char
',' -> do
      (Word8 -> Bool) -> Parser SyntaxException s ()
forall e s. (Word8 -> Bool) -> Parser e s ()
P.skipWhile Word8 -> Bool
isSpace
      Value
val <- SyntaxException -> Parser SyntaxException s Char
forall e s. e -> Parser e s Char
Latin.any SyntaxException
IncompleteArray Parser SyntaxException s Char
-> (Char -> Parser SyntaxException s Value)
-> Parser SyntaxException s Value
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Char -> Parser SyntaxException s Value
forall s. Char -> Parser SyntaxException s Value
parserStep
      ST s (Builder s Value)
-> Parser SyntaxException s (Builder s Value)
forall s a e. ST s a -> Parser e s a
P.effect (Value -> Builder s Value -> ST s (Builder s Value)
forall a s. a -> Builder s a -> ST s (Builder s a)
B.push Value
val Builder s Value
b) Parser SyntaxException s (Builder s Value)
-> (Builder s Value -> Parser SyntaxException s Value)
-> Parser SyntaxException s Value
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Builder s Value -> Parser SyntaxException s Value
forall s. Builder s Value -> Parser SyntaxException s Value
arrayStep
    Char
']' -> do
      !Chunks Value
r <- ST s (Chunks Value) -> Parser SyntaxException s (Chunks Value)
forall s a e. ST s a -> Parser e s a
P.effect (Builder s Value -> ST s (Chunks Value)
forall s a. Builder s a -> ST s (Chunks a)
B.freeze Builder s Value
b)
      let !arr :: SmallArray Value
arr = Chunks Value -> SmallArray Value
forall a. Chunks a -> SmallArray a
Chunks.concat Chunks Value
r
      Value -> Parser SyntaxException s Value
forall a. a -> Parser SyntaxException s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SmallArray Value -> Value
Array SmallArray Value
arr)
    Char
_ -> SyntaxException -> Parser SyntaxException s Value
forall e s a. e -> Parser e s a
P.fail SyntaxException
ExpectedCommaOrRightBracket

c2w :: Char -> Word8
c2w :: Char -> Word8
c2w = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> (Char -> Int) -> Char -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord

-- This is adapted from the function bearing the same name
-- in json-tokens. If you find a problem with it, then
-- something if wrong in json-tokens as well.
--
-- TODO: Quit doing this CPS and inline nonsense. We should
-- be able to unbox the resulting ShortText as ByteArray# and
-- mark the function as NOINLINE. This would prevent the generated
-- code from being needlessly duplicated in three different places.
string :: (ShortText -> a) -> Int -> Parser SyntaxException s a
{-# INLINE string #-}
string :: forall a s. (ShortText -> a) -> Int -> Parser SyntaxException s a
string ShortText -> a
wrap !Int
start = Int -> Parser SyntaxException s a
forall {s}. Int -> Parser SyntaxException s a
go Int
1
 where
  go :: Int -> Parser SyntaxException s a
go !Int
canMemcpy = do
    SyntaxException -> Parser SyntaxException s Word8
forall e s. e -> Parser e s Word8
P.any SyntaxException
IncompleteString Parser SyntaxException s Word8
-> (Word8 -> Parser SyntaxException s a)
-> Parser SyntaxException s a
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Word8
92 -> SyntaxException -> Parser SyntaxException s Word8
forall e s. e -> Parser e s Word8
P.any SyntaxException
InvalidEscapeSequence Parser SyntaxException s Word8
-> Parser SyntaxException s a -> Parser SyntaxException s a
forall a b.
Parser SyntaxException s a
-> Parser SyntaxException s b -> Parser SyntaxException s b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Int -> Parser SyntaxException s a
go Int
0 -- backslash
      Word8
34 -> do
        -- double quote
        !Int
pos <- Parser SyntaxException s Int
forall e s. Parser e s Int
Unsafe.cursor
        case Int
canMemcpy of
          Int
1 -> do
            ByteArray
src <- Parser SyntaxException s ByteArray
forall e s. Parser e s ByteArray
Unsafe.expose
            ByteArray
str <- ST s ByteArray -> Parser SyntaxException s ByteArray
forall s a e. ST s a -> Parser e s a
P.effect (ST s ByteArray -> Parser SyntaxException s ByteArray)
-> ST s ByteArray -> Parser SyntaxException s ByteArray
forall a b. (a -> b) -> a -> b
$ do
              let end :: Int
end = Int
pos Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
              let len :: Int
len = Int
end Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
start
              MutableByteArray s
dst <- Int -> ST s (MutableByteArray (PrimState (ST s)))
forall (m :: * -> *).
PrimMonad m =>
Int -> m (MutableByteArray (PrimState m))
PM.newByteArray Int
len
              MutableByteArray (PrimState (ST s))
-> Int -> ByteArray -> Int -> Int -> ST s ()
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m)
-> Int -> ByteArray -> Int -> Int -> m ()
PM.copyByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst Int
0 ByteArray
src Int
start Int
len
              MutableByteArray (PrimState (ST s)) -> ST s ByteArray
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> m ByteArray
PM.unsafeFreezeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst
            a -> Parser SyntaxException s a
forall a. a -> Parser SyntaxException s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ShortText -> a
wrap (ShortByteString -> ShortText
TS.fromShortByteStringUnsafe (ByteArray -> ShortByteString
byteArrayToShortByteString ByteArray
str)))
          Int
_ -> do
            Int -> Parser SyntaxException s ()
forall e s. Int -> Parser e s ()
Unsafe.unconsume (Int
pos Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
start)
            let end :: Int
end = Int
pos Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
            let maxLen :: Int
maxLen = Int
end Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
start
            (ShortText -> a) -> Int -> Parser SyntaxException s a
forall a s. (ShortText -> a) -> Int -> Parser SyntaxException s a
copyAndEscape ShortText -> a
wrap Int
maxLen
      GHC.Word.Compat.W8# Word#
w -> Int -> Parser SyntaxException s a
go (Int
canMemcpy Int -> Int -> Int
forall a. Bits a => a -> a -> a
.&. Int# -> Int
I# (Word# -> Word# -> Int#
ltWord# Word#
w Word#
128##) Int -> Int -> Int
forall a. Bits a => a -> a -> a
.&. Int# -> Int
I# (Word# -> Word# -> Int#
gtWord# Word#
w Word#
31##))

copyAndEscape :: (ShortText -> a) -> Int -> Parser SyntaxException s a
{-# INLINE copyAndEscape #-}
copyAndEscape :: forall a s. (ShortText -> a) -> Int -> Parser SyntaxException s a
copyAndEscape ShortText -> a
wrap !Int
maxLen = do
  !MutableByteArray s
dst <- ST s (MutableByteArray s)
-> Parser SyntaxException s (MutableByteArray s)
forall s a e. ST s a -> Parser e s a
P.effect (Int -> ST s (MutableByteArray (PrimState (ST s)))
forall (m :: * -> *).
PrimMonad m =>
Int -> m (MutableByteArray (PrimState m))
PM.newByteArray Int
maxLen)
  let go :: Int -> Parser SyntaxException s a
go !Int
ix =
        SyntaxException -> Parser SyntaxException s Char#
forall e s. e -> Parser e s Char#
Utf8.any# SyntaxException
IncompleteString Parser SyntaxException s Char#
-> (Char# -> Parser SyntaxException s a)
-> Parser SyntaxException s a
forall s e a.
Parser s e Char# -> (Char# -> Parser s e a) -> Parser s e a
`P.bindFromCharToLifted` \Char#
c -> case Char#
c of
          Char#
'\\'# ->
            SyntaxException -> Parser SyntaxException s Char
forall e s. e -> Parser e s Char
Latin.any SyntaxException
IncompleteEscapeSequence Parser SyntaxException s Char
-> (Char -> Parser SyntaxException s a)
-> Parser SyntaxException s a
forall a b.
Parser SyntaxException s a
-> (a -> Parser SyntaxException s b) -> Parser SyntaxException s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
              Char
'"' -> do
                ST s () -> Parser SyntaxException s ()
forall s a e. ST s a -> Parser e s a
P.effect (MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst Int
ix (Char -> Word8
c2w Char
'"'))
                Int -> Parser SyntaxException s a
go (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
              Char
'\\' -> do
                ST s () -> Parser SyntaxException s ()
forall s a e. ST s a -> Parser e s a
P.effect (MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst Int
ix (Char -> Word8
c2w Char
'\\'))
                Int -> Parser SyntaxException s a
go (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
              Char
't' -> do
                ST s () -> Parser SyntaxException s ()
forall s a e. ST s a -> Parser e s a
P.effect (MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst Int
ix (Char -> Word8
c2w Char
'\t'))
                Int -> Parser SyntaxException s a
go (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
              Char
'n' -> do
                ST s () -> Parser SyntaxException s ()
forall s a e. ST s a -> Parser e s a
P.effect (MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst Int
ix (Char -> Word8
c2w Char
'\n'))
                Int -> Parser SyntaxException s a
go (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
              Char
'r' -> do
                ST s () -> Parser SyntaxException s ()
forall s a e. ST s a -> Parser e s a
P.effect (MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst Int
ix (Char -> Word8
c2w Char
'\r'))
                Int -> Parser SyntaxException s a
go (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
              Char
'/' -> do
                ST s () -> Parser SyntaxException s ()
forall s a e. ST s a -> Parser e s a
P.effect (MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst Int
ix (Char -> Word8
c2w Char
'/'))
                Int -> Parser SyntaxException s a
go (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
              Char
'b' -> do
                ST s () -> Parser SyntaxException s ()
forall s a e. ST s a -> Parser e s a
P.effect (MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst Int
ix (Char -> Word8
c2w Char
'\b'))
                Int -> Parser SyntaxException s a
go (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
              Char
'f' -> do
                ST s () -> Parser SyntaxException s ()
forall s a e. ST s a -> Parser e s a
P.effect (MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst Int
ix (Char -> Word8
c2w Char
'\f'))
                Int -> Parser SyntaxException s a
go (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
              Char
'u' -> do
                Word16
w <- SyntaxException -> Parser SyntaxException s Word16
forall e s. e -> Parser e s Word16
Latin.hexFixedWord16 SyntaxException
InvalidEscapeSequence
                if Word16
w Word16 -> Word16 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word16
0xD800 Bool -> Bool -> Bool
&& Word16
w Word16 -> Word16 -> Bool
forall a. Ord a => a -> a -> Bool
< Word16
0xDFFF
                  then Int -> Parser SyntaxException s a
go (Int -> Parser SyntaxException s a)
-> Parser SyntaxException s Int -> Parser SyntaxException s a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ST s Int -> Parser SyntaxException s Int
forall s a e. ST s a -> Parser e s a
P.effect (MutableByteArray s -> Int -> Char -> ST s Int
forall s. MutableByteArray s -> Int -> Char -> ST s Int
encodeUtf8Char MutableByteArray s
dst Int
ix Char
'\xFFFD')
                  else Int -> Parser SyntaxException s a
go (Int -> Parser SyntaxException s a)
-> Parser SyntaxException s Int -> Parser SyntaxException s a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ST s Int -> Parser SyntaxException s Int
forall s a e. ST s a -> Parser e s a
P.effect (MutableByteArray s -> Int -> Char -> ST s Int
forall s. MutableByteArray s -> Int -> Char -> ST s Int
encodeUtf8Char MutableByteArray s
dst Int
ix (Word16 -> Char
w16ToChar Word16
w))
              Char
_ -> SyntaxException -> Parser SyntaxException s a
forall e s a. e -> Parser e s a
P.fail SyntaxException
InvalidEscapeSequence
          Char#
'"'# -> do
            ByteArray
str <-
              ST s ByteArray -> Parser SyntaxException s ByteArray
forall s a e. ST s a -> Parser e s a
P.effect
                (MutableByteArray s -> ST s ByteArray
MutableByteArray (PrimState (ST s)) -> ST s ByteArray
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> m ByteArray
PM.unsafeFreezeByteArray (MutableByteArray s -> ST s ByteArray)
-> ST s (MutableByteArray s) -> ST s ByteArray
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< MutableByteArray (PrimState (ST s))
-> Int -> ST s (MutableByteArray (PrimState (ST s)))
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m)
-> Int -> m (MutableByteArray (PrimState m))
PM.resizeMutableByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst Int
ix)
            a -> Parser SyntaxException s a
forall a. a -> Parser SyntaxException s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ShortText -> a
wrap (ShortByteString -> ShortText
TS.fromShortByteStringUnsafe (ByteArray -> ShortByteString
byteArrayToShortByteString ByteArray
str)))
          Char#
_ -> Int -> Parser SyntaxException s a
go (Int -> Parser SyntaxException s a)
-> Parser SyntaxException s Int -> Parser SyntaxException s a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ST s Int -> Parser SyntaxException s Int
forall s a e. ST s a -> Parser e s a
P.effect (MutableByteArray s -> Int -> Char -> ST s Int
forall s. MutableByteArray s -> Int -> Char -> ST s Int
encodeUtf8Char MutableByteArray s
dst Int
ix (Char# -> Char
C# Char#
c))
  Int -> Parser SyntaxException s a
go Int
0

encodeUtf8Char :: MutableByteArray s -> Int -> Char -> ST s Int
encodeUtf8Char :: forall s. MutableByteArray s -> Int -> Char -> ST s Int
encodeUtf8Char !MutableByteArray s
marr !Int
ix !Char
c
  | Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
< Char
'\128' = do
      MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
marr Int
ix (Char -> Word8
c2w Char
c)
      Int -> ST s Int
forall a. a -> ST s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
  | Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
< Char
'\x0800' = do
      MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray
        MutableByteArray s
MutableByteArray (PrimState (ST s))
marr
        Int
ix
        (forall a b. (Integral a, Num b) => a -> b
fromIntegral @Int @Word8 (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
unsafeShiftR (Char -> Int
ord Char
c) Int
6 Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|. Int
0b11000000))
      MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray
        MutableByteArray s
MutableByteArray (PrimState (ST s))
marr
        (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
        (Word8
0b10000000 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. (Word8
0b00111111 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. (forall a b. (Integral a, Num b) => a -> b
fromIntegral @Int @Word8 (Char -> Int
ord Char
c))))
      Int -> ST s Int
forall a. a -> ST s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
  | Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'\xffff' = do
      MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray
        MutableByteArray s
MutableByteArray (PrimState (ST s))
marr
        Int
ix
        (forall a b. (Integral a, Num b) => a -> b
fromIntegral @Int @Word8 (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
unsafeShiftR (Char -> Int
ord Char
c) Int
12 Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|. Int
0b11100000))
      MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray
        MutableByteArray s
MutableByteArray (PrimState (ST s))
marr
        (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
        (Word8
0b10000000 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. (Word8
0b00111111 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. (forall a b. (Integral a, Num b) => a -> b
fromIntegral @Int @Word8 (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
unsafeShiftR (Char -> Int
ord Char
c) Int
6))))
      MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray
        MutableByteArray s
MutableByteArray (PrimState (ST s))
marr
        (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
        (Word8
0b10000000 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. (Word8
0b00111111 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. (forall a b. (Integral a, Num b) => a -> b
fromIntegral @Int @Word8 (Char -> Int
ord Char
c))))
      Int -> ST s Int
forall a. a -> ST s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)
  | Bool
otherwise = do
      MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray
        MutableByteArray s
MutableByteArray (PrimState (ST s))
marr
        Int
ix
        (forall a b. (Integral a, Num b) => a -> b
fromIntegral @Int @Word8 (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
unsafeShiftR (Char -> Int
ord Char
c) Int
18 Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|. Int
0b11110000))
      MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray
        MutableByteArray s
MutableByteArray (PrimState (ST s))
marr
        (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
        (Word8
0b10000000 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. (Word8
0b00111111 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. (forall a b. (Integral a, Num b) => a -> b
fromIntegral @Int @Word8 (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
unsafeShiftR (Char -> Int
ord Char
c) Int
12))))
      MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray
        MutableByteArray s
MutableByteArray (PrimState (ST s))
marr
        (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
        (Word8
0b10000000 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. (Word8
0b00111111 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. (forall a b. (Integral a, Num b) => a -> b
fromIntegral @Int @Word8 (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
unsafeShiftR (Char -> Int
ord Char
c) Int
6))))
      MutableByteArray (PrimState (ST s)) -> Int -> Word8 -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
PM.writeByteArray
        MutableByteArray s
MutableByteArray (PrimState (ST s))
marr
        (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)
        (Word8
0b10000000 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. (Word8
0b00111111 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. (forall a b. (Integral a, Num b) => a -> b
fromIntegral @Int @Word8 (Char -> Int
ord Char
c))))
      Int -> ST s Int
forall a. a -> ST s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4)

byteArrayToShortByteString :: ByteArray -> BSS.ShortByteString
byteArrayToShortByteString :: ByteArray -> ShortByteString
byteArrayToShortByteString (PM.ByteArray ByteArray#
x) = ByteArray# -> ShortByteString
BSS.SBS ByteArray#
x

-- Precondition: Not in the range [U+D800 .. U+DFFF]
w16ToChar :: Word16 -> Char
w16ToChar :: Word16 -> Char
w16ToChar (GHC.Word.Compat.W16# Word#
w) = Char# -> Char
C# (Int# -> Char#
chr# (Word# -> Int#
word2Int# Word#
w))

-- | Infix pattern synonym for 'Member'.
pattern (:->) :: ShortText -> Value -> Member
pattern key $m:-> :: forall {r}.
Member -> (ShortText -> Value -> r) -> ((# #) -> r) -> r
$b:-> :: ShortText -> Value -> Member
:-> value = Member {key, value}

{- | Construct a JSON array from a list of JSON values.

Unlike 'objectFromList', this is not currently equipped with a
rewrite rule.
-}
arrayFromList :: [Value] -> Value
arrayFromList :: [Value] -> Value
arrayFromList [Value]
ms = SmallArray Value -> Value
Array (SmallArray Value -> Value) -> SmallArray Value -> Value
forall a b. (a -> b) -> a -> b
$ [Value] -> SmallArray Value
forall a. [a] -> SmallArray a
PM.smallArrayFromList [Value]
ms

{- | Construct a JSON object from a list of members.

Note: When the argument is a list literal with 16 or fewer elements,
a rewrite rule transforms this into the appropriate @objectN@ function.
When the argument is not a list literal, this function just calls
@smallArrayFromList@ on the members, which has poor performance.
-}
objectFromList :: [Member] -> Value
objectFromList :: [Member] -> Value
objectFromList [Member]
ms = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ [Member] -> SmallArray Member
forall a. [a] -> SmallArray a
PM.smallArrayFromList [Member]
ms
{-# NOINLINE objectFromList #-}

{-# RULES
"objectFromList/1" forall a.
  objectFromList (a : []) =
    object1 a
  #-}
{-# RULES
"objectFromList/2" forall a b.
  objectFromList (a : b : []) =
    object2 a b
  #-}
{-# RULES
"objectFromList/3" forall a b c.
  objectFromList (a : b : c : []) =
    object3 a b c
  #-}
{-# RULES
"objectFromList/4" forall a b c d.
  objectFromList (a : b : c : d : []) =
    object4 a b c d
  #-}
{-# RULES
"objectFromList/5" forall a b c d e.
  objectFromList (a : b : c : d : e : []) =
    object5 a b c d e
  #-}
{-# RULES
"objectFromList/6" forall a b c d e f.
  objectFromList (a : b : c : d : e : f : []) =
    object6 a b c d e f
  #-}
{-# RULES
"objectFromList/7" forall a b c d e f g.
  objectFromList (a : b : c : d : e : f : g : []) =
    object7 a b c d e f g
  #-}
{-# RULES
"objectFromList/8" forall a b c d e f g h.
  objectFromList (a : b : c : d : e : f : g : h : []) =
    object8 a b c d e f g h
  #-}
{-# RULES
"objectFromList/9" forall a b c d e f g h i.
  objectFromList (a : b : c : d : e : f : g : h : i : []) =
    object9 a b c d e f g h i
  #-}
{-# RULES
"objectFromList/10" forall a b c d e f g h i j.
  objectFromList (a : b : c : d : e : f : g : h : i : j : []) =
    object10 a b c d e f g h i j
  #-}
{-# RULES
"objectFromList/11" forall a b c d e f g h i j k.
  objectFromList (a : b : c : d : e : f : g : h : i : j : k : []) =
    object11 a b c d e f g h i j k
  #-}
{-# RULES
"objectFromList/12" forall a b c d e f g h i j k l.
  objectFromList (a : b : c : d : e : f : g : h : i : j : k : l : []) =
    object12 a b c d e f g h i j k l
  #-}
{-# RULES
"objectFromList/13" forall a b c d e f g h i j k l m.
  objectFromList (a : b : c : d : e : f : g : h : i : j : k : l : m : []) =
    object13 a b c d e f g h i j k l m
  #-}
{-# RULES
"objectFromList/14" forall a b c d e f g h i j k l m n.
  objectFromList (a : b : c : d : e : f : g : h : i : j : k : l : m : n : []) =
    object14 a b c d e f g h i j k l m n
  #-}
{-# RULES
"objectFromList/15" forall a b c d e f g h i j k l m n o.
  objectFromList (a : b : c : d : e : f : g : h : i : j : k : l : m : n : o : []) =
    object15 a b c d e f g h i j k l m n o
  #-}
{-# RULES
"objectFromList/16" forall a b c d e f g h i j k l m n o p.
  objectFromList (a : b : c : d : e : f : g : h : i : j : k : l : m : n : o : p : []) =
    object16 a b c d e f g h i j k l m n o p
  #-}

-- | Construct a JSON object with one member.
object1 :: Member -> Value
{-# INLINE object1 #-}
object1 :: Member -> Value
object1 Member
a = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
1 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with two members.
object2 :: Member -> Member -> Value
{-# INLINE object2 #-}
object2 :: Member -> Member -> Value
object2 Member
a Member
b = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
2 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with three members.
object3 :: Member -> Member -> Member -> Value
{-# INLINE object3 #-}
object3 :: Member -> Member -> Member -> Value
object3 Member
a Member
b Member
c = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
3 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with four members.
object4 :: Member -> Member -> Member -> Member -> Value
{-# INLINE object4 #-}
object4 :: Member -> Member -> Member -> Member -> Value
object4 Member
a Member
b Member
c Member
d = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
4 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with five members.
object5 :: Member -> Member -> Member -> Member -> Member -> Value
{-# INLINE object5 #-}
object5 :: Member -> Member -> Member -> Member -> Member -> Value
object5 Member
a Member
b Member
c Member
d Member
e = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
5 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with six members.
object6 :: Member -> Member -> Member -> Member -> Member -> Member -> Value
{-# INLINE object6 #-}
object6 :: Member -> Member -> Member -> Member -> Member -> Member -> Value
object6 Member
a Member
b Member
c Member
d Member
e Member
f = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
6 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
5 Member
f
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with seven members.
object7 :: Member -> Member -> Member -> Member -> Member -> Member -> Member -> Value
{-# INLINE object7 #-}
object7 :: Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Value
object7 Member
a Member
b Member
c Member
d Member
e Member
f Member
g = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
7 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
5 Member
f
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
6 Member
g
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with nine members.
object8 :: Member -> Member -> Member -> Member -> Member -> Member -> Member -> Member -> Value
{-# INLINE object8 #-}
object8 :: Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Value
object8 Member
a Member
b Member
c Member
d Member
e Member
f Member
g Member
h = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
8 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
5 Member
f
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
6 Member
g
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
7 Member
h
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with nine members.
object9 ::
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Value
{-# INLINE object9 #-}
object9 :: Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Value
object9 Member
a Member
b Member
c Member
d Member
e Member
f Member
g Member
h Member
i = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
9 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
5 Member
f
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
6 Member
g
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
7 Member
h
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
8 Member
i
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with ten members.
object10 ::
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Value
{-# INLINE object10 #-}
object10 :: Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Value
object10 Member
a Member
b Member
c Member
d Member
e Member
f Member
g Member
h Member
i Member
j = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
10 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
5 Member
f
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
6 Member
g
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
7 Member
h
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
8 Member
i
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
9 Member
j
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with eleven members.
object11 ::
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Value
{-# INLINE object11 #-}
object11 :: Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Value
object11 Member
a Member
b Member
c Member
d Member
e Member
f Member
g Member
h Member
i Member
j Member
k = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
11 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
5 Member
f
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
6 Member
g
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
7 Member
h
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
8 Member
i
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
9 Member
j
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
10 Member
k
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with twelve members.
object12 ::
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Value
{-# INLINE object12 #-}
object12 :: Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Value
object12 Member
a Member
b Member
c Member
d Member
e Member
f Member
g Member
h Member
i Member
j Member
k Member
l = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
12 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
5 Member
f
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
6 Member
g
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
7 Member
h
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
8 Member
i
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
9 Member
j
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
10 Member
k
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
11 Member
l
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with thirteen members.
object13 ::
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Value
{-# INLINE object13 #-}
object13 :: Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Value
object13 Member
a Member
b Member
c Member
d Member
e Member
f Member
g Member
h Member
i Member
j Member
k Member
l Member
m = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
13 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
5 Member
f
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
6 Member
g
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
7 Member
h
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
8 Member
i
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
9 Member
j
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
10 Member
k
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
11 Member
l
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
12 Member
m
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with fourteen members.
object14 ::
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Value
{-# INLINE object14 #-}
object14 :: Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Value
object14 Member
a Member
b Member
c Member
d Member
e Member
f Member
g Member
h Member
i Member
j Member
k Member
l Member
m Member
n = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
14 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
5 Member
f
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
6 Member
g
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
7 Member
h
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
8 Member
i
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
9 Member
j
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
10 Member
k
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
11 Member
l
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
12 Member
m
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
13 Member
n
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with fifteen members.
object15 ::
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Value
{-# INLINE object15 #-}
object15 :: Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Value
object15 Member
a Member
b Member
c Member
d Member
e Member
f Member
g Member
h Member
i Member
j Member
k Member
l Member
m Member
n Member
o = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
15 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
5 Member
f
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
6 Member
g
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
7 Member
h
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
8 Member
i
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
9 Member
j
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
10 Member
k
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
11 Member
l
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
12 Member
m
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
13 Member
n
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
14 Member
o
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

-- | Construct a JSON object with sixteen members.
object16 ::
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Member ->
  Value
{-# INLINE object16 #-}
object16 :: Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Member
-> Value
object16 Member
a Member
b Member
c Member
d Member
e Member
f Member
g Member
h Member
i Member
j Member
k Member
l Member
m Member
n Member
o Member
p = SmallArray Member -> Value
Object (SmallArray Member -> Value) -> SmallArray Member -> Value
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray Member)) -> SmallArray Member)
-> (forall s. ST s (SmallArray Member)) -> SmallArray Member
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s Member
dst <- Int -> Member -> ST s (SmallMutableArray (PrimState (ST s)) Member)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
16 Member
a
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
1 Member
b
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
2 Member
c
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
3 Member
d
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
4 Member
e
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
5 Member
f
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
6 Member
g
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
7 Member
h
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
8 Member
i
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
9 Member
j
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
10 Member
k
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
11 Member
l
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
12 Member
m
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
13 Member
n
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
14 Member
o
  SmallMutableArray (PrimState (ST s)) Member
-> Int -> Member -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst Int
15 Member
p
  SmallMutableArray (PrimState (ST s)) Member
-> ST s (SmallArray Member)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s Member
SmallMutableArray (PrimState (ST s)) Member
dst

word8 :: Word8 -> Json.Value
{-# INLINE word8 #-}
word8 :: Word8 -> Value
word8 = Scientific -> Value
Json.Number (Scientific -> Value) -> (Word8 -> Scientific) -> Word8 -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Scientific
SCI.fromWord8

word16 :: Word16 -> Json.Value
{-# INLINE word16 #-}
word16 :: Word16 -> Value
word16 = Scientific -> Value
Json.Number (Scientific -> Value) -> (Word16 -> Scientific) -> Word16 -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Scientific
SCI.fromWord16

word32 :: Word32 -> Json.Value
{-# INLINE word32 #-}
word32 :: Word32 -> Value
word32 = Scientific -> Value
Json.Number (Scientific -> Value) -> (Word32 -> Scientific) -> Word32 -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Scientific
SCI.fromWord32

word64 :: Word64 -> Json.Value
{-# INLINE word64 #-}
word64 :: Word64 -> Value
word64 = Scientific -> Value
Json.Number (Scientific -> Value) -> (Word64 -> Scientific) -> Word64 -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Scientific
SCI.fromWord64

int8 :: Int8 -> Json.Value
{-# INLINE int8 #-}
int8 :: Int8 -> Value
int8 = Scientific -> Value
Json.Number (Scientific -> Value) -> (Int8 -> Scientific) -> Int8 -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int8 -> Scientific
SCI.fromInt8

int16 :: Int16 -> Json.Value
{-# INLINE int16 #-}
int16 :: Int16 -> Value
int16 = Scientific -> Value
Json.Number (Scientific -> Value) -> (Int16 -> Scientific) -> Int16 -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Scientific
SCI.fromInt16

int32 :: Int32 -> Json.Value
{-# INLINE int32 #-}
int32 :: Int32 -> Value
int32 = Scientific -> Value
Json.Number (Scientific -> Value) -> (Int32 -> Scientific) -> Int32 -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> Scientific
SCI.fromInt32

int64 :: Int64 -> Json.Value
{-# INLINE int64 #-}
int64 :: Int64 -> Value
int64 = Scientific -> Value
Json.Number (Scientific -> Value) -> (Int64 -> Scientific) -> Int64 -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Scientific
SCI.fromInt64

int :: Int -> Json.Value
{-# INLINE int #-}
int :: Int -> Value
int = Scientific -> Value
Json.Number (Scientific -> Value) -> (Int -> Scientific) -> Int -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Scientific
SCI.fromInt

text :: Text -> Json.Value
{-# INLINE text #-}
text :: Text -> Value
text = ShortText -> Value
Json.String (ShortText -> Value) -> (Text -> ShortText) -> Text -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ShortText
TS.fromText

shortText :: ShortText -> Json.Value
{-# INLINE shortText #-}
shortText :: ShortText -> Value
shortText = ShortText -> Value
String

bool :: Prelude.Bool -> Json.Value
{-# INLINE bool #-}
bool :: Bool -> Value
bool Bool
Prelude.True = Value
True
bool Bool
_ = Value
False

-- | Typeclass for types that can be encoded as JSON.
class ToValue a where
  toValue :: a -> Value

-- | Encodes the unit value as JSON @null@.
instance ToValue () where toValue :: () -> Value
toValue ()
_ = Value
Null

instance ToValue Value where toValue :: Value -> Value
toValue = Value -> Value
forall a. a -> a
id
instance ToValue Scientific where toValue :: Scientific -> Value
toValue = Scientific -> Value
Number
instance ToValue Int where toValue :: Int -> Value
toValue = Int -> Value
int
instance ToValue Int8 where toValue :: Int8 -> Value
toValue = Int8 -> Value
int8
instance ToValue Int16 where toValue :: Int16 -> Value
toValue = Int16 -> Value
int16
instance ToValue Int32 where toValue :: Int32 -> Value
toValue = Int32 -> Value
int32
instance ToValue Int64 where toValue :: Int64 -> Value
toValue = Int64 -> Value
int64
instance ToValue Word8 where toValue :: Word8 -> Value
toValue = Word8 -> Value
word8
instance ToValue Word16 where toValue :: Word16 -> Value
toValue = Word16 -> Value
word16
instance ToValue Word32 where toValue :: Word32 -> Value
toValue = Word32 -> Value
word32
instance ToValue Word64 where toValue :: Word64 -> Value
toValue = Word64 -> Value
word64
instance ToValue ShortText where toValue :: ShortText -> Value
toValue = ShortText -> Value
shortText
instance ToValue Text where toValue :: Text -> Value
toValue = Text -> Value
text
instance ToValue Prelude.Bool where toValue :: Bool -> Value
toValue = Bool -> Value
bool
instance ToValue Word where
  toValue :: Word -> Value
toValue = Word64 -> Value
word64 (Word64 -> Value) -> (Word -> Word64) -> Word -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral @Word @Word64

instance (ToValue a) => ToValue [a] where
  toValue :: [a] -> Value
toValue ![a]
xs = (forall s. ST s Value) -> Value
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s Value) -> Value)
-> (forall s. ST s Value) -> Value
forall a b. (a -> b) -> a -> b
$ do
    let len :: Int
len = [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
List.length [a]
xs
    SmallMutableArray (PrimState (ST s)) Value
dst <- Int -> Value -> ST s (SmallMutableArray (PrimState (ST s)) Value)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
len Value
Null
    let go :: Int -> [a] -> ST s Value
go !Int
ix [a]
ys = case [a]
ys of
          [] -> do
            SmallArray Value
dst' <- SmallMutableArray (PrimState (ST s)) Value
-> ST s (SmallArray Value)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray (PrimState (ST s)) Value
dst
            Value -> ST s Value
forall a. a -> ST s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SmallArray Value -> Value
Array SmallArray Value
dst')
          a
z : [a]
zs -> do
            SmallMutableArray (PrimState (ST s)) Value
-> Int -> Value -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray (PrimState (ST s)) Value
dst Int
ix (Value -> ST s ()) -> Value -> ST s ()
forall a b. (a -> b) -> a -> b
$! a -> Value
forall a. ToValue a => a -> Value
toValue a
z
            Int -> [a] -> ST s Value
go (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) [a]
zs
    Int -> [a] -> ST s Value
forall {a}. ToValue a => Int -> [a] -> ST s Value
go Int
0 [a]
xs

instance (ToValue a) => ToValue (SmallArray a) where
  toValue :: SmallArray a -> Value
toValue !SmallArray a
xs = SmallArray Value -> Value
Json.Array (SmallArray Value -> Value) -> SmallArray Value -> Value
forall a b. (a -> b) -> a -> b
$! (a -> Value) -> SmallArray a -> SmallArray Value
forall (arr1 :: * -> *) b (arr2 :: * -> *) c.
(Contiguous arr1, Element arr1 b, Contiguous arr2,
 Element arr2 c) =>
(b -> c) -> arr1 b -> arr2 c
Contiguous.map' a -> Value
forall a. ToValue a => a -> Value
toValue SmallArray a
xs

instance (ToValue a) => ToValue (Array a) where
  toValue :: Array a -> Value
toValue !Array a
xs = SmallArray Value -> Value
Json.Array (SmallArray Value -> Value) -> SmallArray Value -> Value
forall a b. (a -> b) -> a -> b
$! (a -> Value) -> Array a -> SmallArray Value
forall (arr1 :: * -> *) b (arr2 :: * -> *) c.
(Contiguous arr1, Element arr1 b, Contiguous arr2,
 Element arr2 c) =>
(b -> c) -> arr1 b -> arr2 c
Contiguous.map' a -> Value
forall a. ToValue a => a -> Value
toValue Array a
xs

instance (Prim a, ToValue a) => ToValue (PrimArray a) where
  toValue :: PrimArray a -> Value
toValue !PrimArray a
xs = SmallArray Value -> Value
Json.Array (SmallArray Value -> Value) -> SmallArray Value -> Value
forall a b. (a -> b) -> a -> b
$! (a -> Value) -> PrimArray a -> SmallArray Value
forall (arr1 :: * -> *) b (arr2 :: * -> *) c.
(Contiguous arr1, Element arr1 b, Contiguous arr2,
 Element arr2 c) =>
(b -> c) -> arr1 b -> arr2 c
Contiguous.map' a -> Value
forall a. ToValue a => a -> Value
toValue PrimArray a
xs