{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
module Knit.Effect.Serialize
(
SerializeDict(..)
, Serialize(..)
, SerializeEnv
, serializeOne
, serializeStreamlyViaList
, DefaultCacheData
, DefaultSerializer
, cerealStreamlyDict
, getSerializeDict
, runSerializeEnv
, SerializationError(..)
)
where
import qualified Polysemy as P
import qualified Polysemy.Error as P
import qualified Polysemy.Reader as PR
import Data.Int (Int64)
import qualified Data.Serialize as S
import qualified Data.Text as T
import qualified Data.Word as Word
import qualified Streamly as Streamly
import qualified Streamly.Prelude as Streamly
import qualified Streamly.Data.Fold as Streamly.Fold
import qualified Streamly.Memory.Array as Streamly.Array
import qualified Streamly.Internal.Data.Array as Streamly.Data.Array
import qualified Streamly.External.Cereal as Streamly.Cereal
data SerializationError = SerializationError T.Text deriving (Int -> SerializationError -> ShowS
[SerializationError] -> ShowS
SerializationError -> String
(Int -> SerializationError -> ShowS)
-> (SerializationError -> String)
-> ([SerializationError] -> ShowS)
-> Show SerializationError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SerializationError] -> ShowS
$cshowList :: [SerializationError] -> ShowS
show :: SerializationError -> String
$cshow :: SerializationError -> String
showsPrec :: Int -> SerializationError -> ShowS
$cshowsPrec :: Int -> SerializationError -> ShowS
Show)
data SerializeDict c ct =
SerializeDict
{ SerializeDict c ct -> forall a. c a => a -> ct
encodeOne :: forall a. c a => a -> ct
, SerializeDict c ct
-> forall a. c a => ct -> Either SerializationError a
decodeOne :: forall a. c a => ct -> Either SerializationError a
, SerializeDict c ct -> ct -> Int64
encBytes :: ct -> Int64
}
type SerializeEnv c ct = PR.Reader (SerializeDict c ct)
getSerializeDict :: P.Member (SerializeEnv c ct) r => P.Sem r (SerializeDict c ct)
getSerializeDict :: Sem r (SerializeDict c ct)
getSerializeDict = Sem r (SerializeDict c ct)
forall i (r :: [Effect]). MemberWithError (Reader i) r => Sem r i
PR.ask
{-# INLINEABLE getSerializeDict #-}
runSerializeEnv :: SerializeDict c ct -> P.InterpreterFor (SerializeEnv c ct) r
runSerializeEnv :: SerializeDict c ct -> InterpreterFor (SerializeEnv c ct) r
runSerializeEnv = SerializeDict c ct -> Sem (SerializeEnv c ct : r) a -> Sem r a
forall i (r :: [Effect]) a. i -> Sem (Reader i : r) a -> Sem r a
PR.runReader
{-# INLINEABLE runSerializeEnv #-}
data Serialize e r a ct where
Serialize :: (P.MemberWithError (P.Error e) r)
=> (a -> P.Sem r (ct, a))
-> (ct -> P.Sem r a)
-> (ct -> Int64)
-> Serialize e r a ct
serializeOne :: (c a, P.MemberWithError (P.Error SerializationError) r)
=> SerializeDict c ct
-> Serialize SerializationError r a ct
serializeOne :: SerializeDict c ct -> Serialize SerializationError r a ct
serializeOne (SerializeDict encOne :: forall a. c a => a -> ct
encOne decOne :: forall a. c a => ct -> Either SerializationError a
decOne bytes :: ct -> Int64
bytes) =
let enc :: a -> Sem r (ct, a)
enc a :: a
a = (ct, a) -> Sem r (ct, a)
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> ct
forall a. c a => a -> ct
encOne a
a, a
a)
{-# INLINEABLE enc #-}
dec :: ct -> Sem r a
dec = forall (r :: [Effect]) a.
Member (Error SerializationError) r =>
Either SerializationError a -> Sem r a
forall e (r :: [Effect]) a.
Member (Error e) r =>
Either e a -> Sem r a
P.fromEither @SerializationError (Either SerializationError a -> Sem r a)
-> (ct -> Either SerializationError a) -> ct -> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ct -> Either SerializationError a
forall a. c a => ct -> Either SerializationError a
decOne
{-# INLINEABLE dec #-}
in (a -> Sem r (ct, a))
-> (ct -> Sem r a)
-> (ct -> Int64)
-> Serialize SerializationError r a ct
forall e (r :: [Effect]) a ct.
MemberWithError (Error e) r =>
(a -> Sem r (ct, a))
-> (ct -> Sem r a) -> (ct -> Int64) -> Serialize e r a ct
Serialize a -> Sem r (ct, a)
enc ct -> Sem r a
dec ct -> Int64
bytes
{-# INLINEABLE serializeOne #-}
serializeStreamlyViaList ::
(P.MemberWithError (P.Error SerializationError) r, P.Member (P.Embed IO) r, c [a])
=> SerializeDict c ct
-> Serialize SerializationError r (Streamly.SerialT (P.Sem r) a) ct
serializeStreamlyViaList :: SerializeDict c ct
-> Serialize SerializationError r (SerialT (Sem r) a) ct
serializeStreamlyViaList (SerializeDict encOne :: forall a. c a => a -> ct
encOne decOne :: forall a. c a => ct -> Either SerializationError a
decOne bytes :: ct -> Int64
bytes) =
let enc :: SerialT (Sem r) a -> Sem r (ct, SerialT (Sem r) a)
enc = Fold (Sem r) a (ct, SerialT (Sem r) a)
-> SerialT (Sem r) a -> Sem r (ct, SerialT (Sem r) a)
forall (m :: * -> *) a b.
Monad m =>
Fold m a b -> SerialT m a -> m b
Streamly.fold (Fold (Sem r) a ct
-> Fold (Sem r) a (SerialT (Sem r) a)
-> Fold (Sem r) a (ct, SerialT (Sem r) a)
forall (m :: * -> *) a b c.
Monad m =>
Fold m a b -> Fold m a c -> Fold m a (b, c)
Streamly.Fold.tee
(([a] -> ct) -> Fold (Sem r) a [a] -> Fold (Sem r) a ct
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [a] -> ct
forall a. c a => a -> ct
encOne (Fold (Sem r) a [a] -> Fold (Sem r) a ct)
-> Fold (Sem r) a [a] -> Fold (Sem r) a ct
forall a b. (a -> b) -> a -> b
$ Fold (Sem r) a [a]
forall (m :: * -> *) a. Monad m => Fold m a [a]
Streamly.Fold.toList)
((Array a -> SerialT (Sem r) a)
-> Fold (Sem r) a (Array a) -> Fold (Sem r) a (SerialT (Sem r) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Array a -> SerialT (Sem r) a
forall (m :: * -> *) (t :: Effect) a.
(Monad m, IsStream t) =>
Array a -> t m a
Streamly.Data.Array.toStream) Fold (Sem r) a (Array a)
forall (m :: * -> *) a. MonadIO m => Fold m a (Array a)
Streamly.Data.Array.write)
)
{-# INLINEABLE enc #-}
dec :: ct -> Sem r (SerialT (Sem r) a)
dec = Either SerializationError (SerialT (Sem r) a)
-> Sem r (SerialT (Sem r) a)
forall e (r :: [Effect]) a.
Member (Error e) r =>
Either e a -> Sem r a
P.fromEither (Either SerializationError (SerialT (Sem r) a)
-> Sem r (SerialT (Sem r) a))
-> (ct -> Either SerializationError (SerialT (Sem r) a))
-> ct
-> Sem r (SerialT (Sem r) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([a] -> SerialT (Sem r) a)
-> Either SerializationError [a]
-> Either SerializationError (SerialT (Sem r) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [a] -> SerialT (Sem r) a
forall (m :: * -> *) (t :: Effect) a.
(Monad m, IsStream t) =>
[a] -> t m a
Streamly.fromList (Either SerializationError [a]
-> Either SerializationError (SerialT (Sem r) a))
-> (ct -> Either SerializationError [a])
-> ct
-> Either SerializationError (SerialT (Sem r) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ct -> Either SerializationError [a]
forall a. c a => ct -> Either SerializationError a
decOne
{-# INLINEABLE dec #-}
in (SerialT (Sem r) a -> Sem r (ct, SerialT (Sem r) a))
-> (ct -> Sem r (SerialT (Sem r) a))
-> (ct -> Int64)
-> Serialize SerializationError r (SerialT (Sem r) a) ct
forall e (r :: [Effect]) a ct.
MemberWithError (Error e) r =>
(a -> Sem r (ct, a))
-> (ct -> Sem r a) -> (ct -> Int64) -> Serialize e r a ct
Serialize SerialT (Sem r) a -> Sem r (ct, SerialT (Sem r) a)
enc ct -> Sem r (SerialT (Sem r) a)
dec ct -> Int64
bytes
{-# INLINEABLE serializeStreamlyViaList #-}
type DefaultCacheData = Streamly.Array.Array Word.Word8
type DefaultSerializer = S.Serialize
cerealStreamlyDict :: SerializeDict DefaultSerializer DefaultCacheData
cerealStreamlyDict :: SerializeDict DefaultSerializer DefaultCacheData
cerealStreamlyDict =
(forall a. DefaultSerializer a => a -> DefaultCacheData)
-> (forall a.
DefaultSerializer a =>
DefaultCacheData -> Either SerializationError a)
-> (DefaultCacheData -> Int64)
-> SerializeDict DefaultSerializer DefaultCacheData
forall (c :: * -> Constraint) ct.
(forall a. c a => a -> ct)
-> (forall a. c a => ct -> Either SerializationError a)
-> (ct -> Int64)
-> SerializeDict c ct
SerializeDict
forall a. DefaultSerializer a => a -> DefaultCacheData
Streamly.Cereal.encodeStreamlyArray
((Text -> SerializationError)
-> Either Text a -> Either SerializationError a
forall a b c. (a -> b) -> Either a c -> Either b c
mapLeft Text -> SerializationError
SerializationError (Either Text a -> Either SerializationError a)
-> (DefaultCacheData -> Either Text a)
-> DefaultCacheData
-> Either SerializationError a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DefaultCacheData -> Either Text a
forall a. Serialize a => DefaultCacheData -> Either Text a
Streamly.Cereal.decodeStreamlyArray)
(Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int64)
-> (DefaultCacheData -> Int) -> DefaultCacheData -> Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DefaultCacheData -> Int
forall a. Storable a => Array a -> Int
Streamly.Array.length)
{-# INLINEABLE cerealStreamlyDict #-}
mapLeft :: (a -> b) -> Either a c -> Either b c
mapLeft :: (a -> b) -> Either a c -> Either b c
mapLeft f :: a -> b
f = (a -> Either b c) -> (c -> Either b c) -> Either a c -> Either b c
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (b -> Either b c
forall a b. a -> Either a b
Left (b -> Either b c) -> (a -> b) -> a -> Either b c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f) c -> Either b c
forall a b. b -> Either a b
Right
{-# INLINEABLE mapLeft #-}