{-# LANGUAGE BlockArguments #-}

module Data.RdsData.Encode.Array
  ( EncodeArray(..)

  , rdsArray
  , arrays

  , bools
  , doubles
  , integers
  , texts

  , days
  , int16s
  , int32s
  , int64s
  , int8s
  , ints
  , jsons
  , lazyTexts
  , timesOfDay
  , ulids
  , uuids
  , utcTimes
  , word16s
  , word32s
  , word64s
  , word8s
  , words
  ) where

import Data.Functor.Contravariant
import Data.Int
import Data.RdsData.Internal.Convert
import Data.RdsData.Types.Array (Array(..))
import Data.Text (Text)
import Data.Time
import Data.ULID
import Data.UUID
import Data.Word
import Prelude hiding (words)

import qualified Data.Aeson           as J
import qualified Data.Text.Lazy       as LT

newtype EncodeArray a = EncodeArray
  { forall a. EncodeArray a -> a -> Array
encodeArray :: a -> Array
  }

instance Contravariant EncodeArray where
  contramap :: forall a' a. (a' -> a) -> EncodeArray a -> EncodeArray a'
contramap a' -> a
f (EncodeArray a -> Array
g) =
    (a' -> Array) -> EncodeArray a'
forall a. (a -> Array) -> EncodeArray a
EncodeArray (a -> Array
g (a -> Array) -> (a' -> a) -> a' -> Array
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a' -> a
f)

--------------------------------------------------------------------------------

rdsArray :: EncodeArray Array
rdsArray :: EncodeArray Array
rdsArray =
  (Array -> Array) -> EncodeArray Array
forall a. (a -> Array) -> EncodeArray a
EncodeArray Array -> Array
forall a. a -> a
id

--------------------------------------------------------------------------------

arrays :: EncodeArray Array -> EncodeArray [Array]
arrays :: EncodeArray Array -> EncodeArray [Array]
arrays =
  ([Array] -> Array) -> EncodeArray Array -> EncodeArray [Array]
forall a' a. (a' -> a) -> EncodeArray a -> EncodeArray a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap [Array] -> Array
ArrayOfArrays

--------------------------------------------------------------------------------

bools :: EncodeArray [Bool]
bools :: EncodeArray [Bool]
bools =
  [Bool] -> Array
ArrayOfBools ([Bool] -> Array) -> EncodeArray Array -> EncodeArray [Bool]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray Array
rdsArray

integers :: EncodeArray [Integer]
integers :: EncodeArray [Integer]
integers =
  [Integer] -> Array
ArrayOfIntegers ([Integer] -> Array) -> EncodeArray Array -> EncodeArray [Integer]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray Array
rdsArray

texts :: EncodeArray [Text]
texts :: EncodeArray [Text]
texts =
  [Text] -> Array
ArrayOfTexts ([Text] -> Array) -> EncodeArray Array -> EncodeArray [Text]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray Array
rdsArray

doubles :: EncodeArray [Double]
doubles :: EncodeArray [Double]
doubles =
  [Double] -> Array
ArrayOfDoubles ([Double] -> Array) -> EncodeArray Array -> EncodeArray [Double]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray Array
rdsArray

--------------------------------------------------------------------------------

ints :: EncodeArray [Int]
ints :: EncodeArray [Int]
ints =
  (Int -> Integer) -> [Int] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int] -> [Integer]) -> EncodeArray [Integer] -> EncodeArray [Int]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Integer]
integers

int8s :: EncodeArray [Int8]
int8s :: EncodeArray [Int8]
int8s =
  (Int8 -> Integer) -> [Int8] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int8 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int8] -> [Integer])
-> EncodeArray [Integer] -> EncodeArray [Int8]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Integer]
integers

int16s :: EncodeArray [Int16]
int16s :: EncodeArray [Int16]
int16s =
  (Int16 -> Integer) -> [Int16] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int16 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int16] -> [Integer])
-> EncodeArray [Integer] -> EncodeArray [Int16]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Integer]
integers

int32s :: EncodeArray [Int32]
int32s :: EncodeArray [Int32]
int32s =
  (Int32 -> Integer) -> [Int32] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int32] -> [Integer])
-> EncodeArray [Integer] -> EncodeArray [Int32]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Integer]
integers

int64s :: EncodeArray [Int64]
int64s :: EncodeArray [Int64]
int64s =
  (Int64 -> Integer) -> [Int64] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int64] -> [Integer])
-> EncodeArray [Integer] -> EncodeArray [Int64]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Integer]
integers

words :: EncodeArray [Word]
words :: EncodeArray [Word]
words =
  (Word -> Integer) -> [Word] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Word] -> [Integer])
-> EncodeArray [Integer] -> EncodeArray [Word]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Integer]
integers

word8s :: EncodeArray [Word8]
word8s :: EncodeArray [Word8]
word8s =
  (Word8 -> Integer) -> [Word8] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word8 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Word8] -> [Integer])
-> EncodeArray [Integer] -> EncodeArray [Word8]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Integer]
integers

word16s :: EncodeArray [Word16]
word16s :: EncodeArray [Word16]
word16s =
  (Word16 -> Integer) -> [Word16] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word16 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Word16] -> [Integer])
-> EncodeArray [Integer] -> EncodeArray [Word16]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Integer]
integers

word32s :: EncodeArray [Word32]
word32s :: EncodeArray [Word32]
word32s =
  (Word32 -> Integer) -> [Word32] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Word32] -> [Integer])
-> EncodeArray [Integer] -> EncodeArray [Word32]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Integer]
integers

word64s :: EncodeArray [Word64]
word64s :: EncodeArray [Word64]
word64s =
  (Word64 -> Integer) -> [Word64] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Word64] -> [Integer])
-> EncodeArray [Integer] -> EncodeArray [Word64]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Integer]
integers

lazyTexts :: EncodeArray [LT.Text]
lazyTexts :: EncodeArray [Text]
lazyTexts =
  (Text -> Text) -> [Text] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Text
LT.toStrict ([Text] -> [Text]) -> EncodeArray [Text] -> EncodeArray [Text]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Text]
texts

timesOfDay :: EncodeArray [TimeOfDay]
timesOfDay :: EncodeArray [TimeOfDay]
timesOfDay =
  (TimeOfDay -> Text) -> [TimeOfDay] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TimeOfDay -> Text
timeOfDayToText ([TimeOfDay] -> [Text])
-> EncodeArray [Text] -> EncodeArray [TimeOfDay]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Text]
texts

days :: EncodeArray [Day]
days :: EncodeArray [Day]
days =
  (Day -> Text) -> [Day] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Day -> Text
dayToText ([Day] -> [Text]) -> EncodeArray [Text] -> EncodeArray [Day]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Text]
texts

jsons :: EncodeArray [J.Value]
jsons :: EncodeArray [Value]
jsons =
  (Value -> Text) -> [Value] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value -> Text
jsonToText ([Value] -> [Text]) -> EncodeArray [Text] -> EncodeArray [Value]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Text]
texts

ulids :: EncodeArray [ULID]
ulids :: EncodeArray [ULID]
ulids =
  (ULID -> Text) -> [ULID] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ULID -> Text
ulidToText ([ULID] -> [Text]) -> EncodeArray [Text] -> EncodeArray [ULID]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Text]
texts

uuids :: EncodeArray [UUID]
uuids :: EncodeArray [UUID]
uuids =
  (UUID -> Text) -> [UUID] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap UUID -> Text
uuidToText ([UUID] -> [Text]) -> EncodeArray [Text] -> EncodeArray [UUID]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Text]
texts

utcTimes :: EncodeArray [UTCTime]
utcTimes :: EncodeArray [UTCTime]
utcTimes =
  (UTCTime -> Text) -> [UTCTime] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap UTCTime -> Text
utcTimeToText ([UTCTime] -> [Text])
-> EncodeArray [Text] -> EncodeArray [UTCTime]
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeArray [Text]
texts