Data.TypedEncoding.Internal.Class

Documentation

>>> :set -XScopedTypeVariables -XKindSignatures -XMultiParamTypeClasses -XDataKinds -XPolyKinds -XFlexibleInstances -XFlexibleContexts
>>> import Data.TypedEncoding.Internal.Types (unsafeSetPayload)

class EncodeF f instr outstr where

Methods

encodeF :: instr -> f outstr

Instances

(HasA c SizeLimit, Applicative f) => EncodeF (f :: Type -> Type) (Enc xs c ByteString) (Enc ("do-size-limit" ': xs) c ByteString :: Type)

Defined in Data.TypedEncoding.Instances.Encode.Sample

Methods

encodeF :: Enc xs c ByteString -> f (Enc ("do-size-limit" ': xs) c ByteString)

(HasA c SizeLimit, Applicative f) => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("do-size-limit" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.Encode.Sample

Methods

encodeF :: Enc xs c Text -> f (Enc ("do-size-limit" ': xs) c Text)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("do-reverse" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.Encode.Sample

Methods

encodeF :: Enc xs c Text -> f (Enc ("do-reverse" ': xs) c Text)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("do-reverse" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.Encode.Sample

Methods

encodeF :: Enc xs c Text -> f (Enc ("do-reverse" ': xs) c Text)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("do-Title" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.Encode.Sample

Methods

encodeF :: Enc xs c Text -> f (Enc ("do-Title" ': xs) c Text)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("do-Title" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.Encode.Sample

Methods

encodeF :: Enc xs c Text -> f (Enc ("do-Title" ': xs) c Text)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("do-lower" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.Encode.Sample

Methods

encodeF :: Enc xs c Text -> f (Enc ("do-lower" ': xs) c Text)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("do-lower" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.Encode.Sample

Methods

encodeF :: Enc xs c Text -> f (Enc ("do-lower" ': xs) c Text)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("do-UPPER" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.Encode.Sample

Methods

encodeF :: Enc xs c Text -> f (Enc ("do-UPPER" ': xs) c Text)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("do-UPPER" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.Encode.Sample

Methods

encodeF :: Enc xs c Text -> f (Enc ("do-UPPER" ': xs) c Text)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("enc-B64" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.Base64

Methods

encodeF :: Enc xs c Text -> f (Enc ("enc-B64" ': xs) c Text)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("enc-B64" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.Base64

Methods

encodeF :: Enc xs c Text -> f (Enc ("enc-B64" ': xs) c Text)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c ByteString) (Enc ("enc-B64" ': xs) c ByteString :: Type)

Defined in Data.TypedEncoding.Instances.Base64

Methods

encodeF :: Enc xs c ByteString -> f (Enc ("enc-B64" ': xs) c ByteString)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c ByteString) (Enc ("enc-B64" ': xs) c ByteString :: Type)

Defined in Data.TypedEncoding.Instances.Base64

Methods

encodeF :: Enc xs c ByteString -> f (Enc ("enc-B64" ': xs) c ByteString)

Applicative f => EncodeF (f :: Type -> Type) (Enc xs c Text) (Enc ("my-sign" ': xs) c Text :: Type)

Because encoding function is pure we can create instance of EncodeF that is polymorphic in effect f. This is done using implTranP combinator.

Defined in Examples.TypedEncoding.DiySignEncoding

Methods

encodeF :: Enc xs c Text -> f (Enc ("my-sign" ': xs) c Text)

EncodeF (Either EncodeEx) (Enc xs c ByteString) (Enc ("r-UTF8" ': xs) c ByteString :: Type)

Defined in Data.TypedEncoding.Instances.UTF8

Methods

encodeF :: Enc xs c ByteString -> Either EncodeEx (Enc ("r-UTF8" ': xs) c ByteString)

EncodeF (Either EncodeEx) (Enc xs c ByteString) (Enc ("r-UTF8" ': xs) c ByteString :: Type)

UTF8 encodings are defined for ByteString only as that would not make much sense for Text

>>> encodeFAll . toEncoding () $ "\xc3\xb1" :: Either EncodeEx (Enc '["r-UTF8"] () B.ByteString)
Right (MkEnc Proxy () "\195\177")
>>> encodeFAll . toEncoding () $ "\xc3\x28" :: Either EncodeEx (Enc '["r-UTF8"] () B.ByteString)
Left (EncodeEx "r-UTF8" (Cannot decode byte '\xc3': Data.Text.Internal.Encoding.decodeUtf8: Invalid UTF-8 stream))

Following test uses verEncoding helper that checks that bytes are encoded as Right iff they are valid UTF8 bytes

\(b :: B.ByteString) -> verEncoding b (fmap (fromEncoding . decodeAll . proxiedId (Proxy :: Proxy (Enc '["r-UTF8"] _ _))) . (encodeFAll :: _ -> Either EncodeEx _). toEncoding () $ b)

Defined in Data.TypedEncoding.Instances.UTF8

Methods

encodeF :: Enc xs c ByteString -> Either EncodeEx (Enc ("r-UTF8" ': xs) c ByteString)

EncodeF (Either EncodeEx) (Enc xs c ByteString) (Enc ("r-ASCII" ': xs) c ByteString :: Type)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

encodeF :: Enc xs c ByteString -> Either EncodeEx (Enc ("r-ASCII" ': xs) c ByteString)

EncodeF (Either EncodeEx) (Enc xs c ByteString) (Enc ("r-ASCII" ': xs) c ByteString :: Type)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

encodeF :: Enc xs c ByteString -> Either EncodeEx (Enc ("r-ASCII" ': xs) c ByteString)

EncodeF (Either EncodeEx) (Enc xs c Text) (Enc ("r-ASCII" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

encodeF :: Enc xs c Text -> Either EncodeEx (Enc ("r-ASCII" ': xs) c Text)

EncodeF (Either EncodeEx) (Enc xs c Text) (Enc ("r-ASCII" ': xs) c Text :: Type)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

encodeF :: Enc xs c Text -> Either EncodeEx (Enc ("r-ASCII" ': xs) c Text)

EncodeF (Either EncodeEx) (Enc xs c Char) (Enc ("r-ASCII" ': xs) c Char :: Type)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

encodeF :: Enc xs c Char -> Either EncodeEx (Enc ("r-ASCII" ': xs) c Char)

class EncodeFAll f (xs :: [k]) c str where

Methods

encodeFAll :: Enc '[] c str -> f (Enc xs c str)

Instances

Applicative f => EncodeFAll f ([] :: [k]) c str

Defined in Data.TypedEncoding.Internal.Class

Methods

encodeFAll :: Enc [] c str -> f (Enc [] c str)

(Monad f, EncodeFAll f xs c str, EncodeF f (Enc xs c str) (Enc (x ': xs) c str)) => EncodeFAll f (x ': xs :: [k]) c str

Defined in Data.TypedEncoding.Internal.Class

Methods

encodeFAll :: Enc [] c str -> f (Enc (x ': xs) c str)

encodeAll :: EncodeFAll Identity (xs :: [k]) c str => Enc '[] c str -> Enc xs c str

class DecodeF f instr outstr where

Methods

decodeF :: instr -> f outstr

Instances

(UnexpectedDecodeErr f, Applicative f) => DecodeF (f :: Type -> Type) (Enc ("enc-B64" ': xs) c Text) (Enc xs c Text :: Type)

Defined in Data.TypedEncoding.Instances.Base64

Methods

decodeF :: Enc ("enc-B64" ': xs) c Text -> f (Enc xs c Text)

(UnexpectedDecodeErr f, Applicative f) => DecodeF (f :: Type -> Type) (Enc ("enc-B64" ': xs) c Text) (Enc xs c Text :: Type)

Defined in Data.TypedEncoding.Instances.Base64

Methods

decodeF :: Enc ("enc-B64" ': xs) c Text -> f (Enc xs c Text)

(UnexpectedDecodeErr f, Applicative f) => DecodeF (f :: Type -> Type) (Enc ("enc-B64" ': xs) c ByteString) (Enc xs c ByteString :: Type)

Defined in Data.TypedEncoding.Instances.Base64

Methods

decodeF :: Enc ("enc-B64" ': xs) c ByteString -> f (Enc xs c ByteString)

(UnexpectedDecodeErr f, Applicative f) => DecodeF (f :: Type -> Type) (Enc ("enc-B64" ': xs) c ByteString) (Enc xs c ByteString :: Type)

Effectful instance for corruption detection. This protocol is used, for example, in emails. It is a well known encoding and hackers will have no problem making undetectable changes, but error handling at this stage could verify that email was corrupted.

Defined in Data.TypedEncoding.Instances.Base64

Methods

decodeF :: Enc ("enc-B64" ': xs) c ByteString -> f (Enc xs c ByteString)

Applicative f => DecodeF (f :: Type -> Type) (Enc ("r-UTF8" ': xs) c ByteString) (Enc xs c ByteString :: Type)

Defined in Data.TypedEncoding.Instances.UTF8

Methods

decodeF :: Enc ("r-UTF8" ': xs) c ByteString -> f (Enc xs c ByteString)

Applicative f => DecodeF (f :: Type -> Type) (Enc ("r-UTF8" ': xs) c ByteString) (Enc xs c ByteString :: Type)

Defined in Data.TypedEncoding.Instances.UTF8

Methods

decodeF :: Enc ("r-UTF8" ': xs) c ByteString -> f (Enc xs c ByteString)

Applicative f => DecodeF (f :: Type -> Type) (Enc ("r-ASCII" ': xs) c ByteString) (Enc xs c ByteString :: Type)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

decodeF :: Enc ("r-ASCII" ': xs) c ByteString -> f (Enc xs c ByteString)

Applicative f => DecodeF (f :: Type -> Type) (Enc ("r-ASCII" ': xs) c ByteString) (Enc xs c ByteString :: Type)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

decodeF :: Enc ("r-ASCII" ': xs) c ByteString -> f (Enc xs c ByteString)

Applicative f => DecodeF (f :: Type -> Type) (Enc ("r-ASCII" ': xs) c Text) (Enc xs c Text :: Type)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

decodeF :: Enc ("r-ASCII" ': xs) c Text -> f (Enc xs c Text)

Applicative f => DecodeF (f :: Type -> Type) (Enc ("r-ASCII" ': xs) c Text) (Enc xs c Text :: Type)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

decodeF :: Enc ("r-ASCII" ': xs) c Text -> f (Enc xs c Text)

Applicative f => DecodeF (f :: Type -> Type) (Enc ("r-ASCII" ': xs) c Char) (Enc xs c Char :: Type)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

decodeF :: Enc ("r-ASCII" ': xs) c Char -> f (Enc xs c Char)

(UnexpectedDecodeErr f, Applicative f) => DecodeF (f :: Type -> Type) (Enc ("my-sign" ': xs) c Text) (Enc xs c Text :: Type)

Decoding allows effectful f to allow for troubleshooting and unsafe payload changes.

Implementation simply uses implDecodeF combinator on the asUnexpected composed with decoding function. UnexpectedDecodeErr has Identity instance allowing for decoding that assumes errors are not possible. For debugging purposes or when unsafe changes to "my-sign" Error UnexpectedDecodeEx instance can be used.

Defined in Examples.TypedEncoding.DiySignEncoding

Methods

decodeF :: Enc ("my-sign" ': xs) c Text -> f (Enc xs c Text)

class DecodeFAll f (xs :: [k]) c str where

Methods

decodeFAll :: Enc xs c str -> f (Enc '[] c str)

Instances

Applicative f => DecodeFAll f ([] :: [k]) c str

Defined in Data.TypedEncoding.Internal.Class

Methods

decodeFAll :: Enc [] c str -> f (Enc [] c str)

(Monad f, DecodeFAll f xs c str, DecodeF f (Enc (x ': xs) c str) (Enc xs c str)) => DecodeFAll f (x ': xs :: [k]) c str

Defined in Data.TypedEncoding.Internal.Class

Methods

decodeFAll :: Enc (x ': xs) c str -> f (Enc [] c str)

decodeAll :: DecodeFAll Identity (xs :: [k]) c str => Enc xs c str -> Enc '[] c str

class RecreateF f instr outstr where

Used to safely recover encoded data validating all encodingss

Methods

checkPrevF :: outstr -> f instr

Instances

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c Text :: Type) (Enc ("do-UPPER" ': xs) c Text)

Defined in Data.TypedEncoding.Instances.Encode.Sample

Methods

checkPrevF :: Enc ("do-UPPER" ': xs) c Text -> f (Enc xs c Text)

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c Text :: Type) (Enc ("enc-B64" ': xs) c Text)

Defined in Data.TypedEncoding.Instances.Base64

Methods

checkPrevF :: Enc ("enc-B64" ': xs) c Text -> f (Enc xs c Text)

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c Text :: Type) (Enc ("enc-B64" ': xs) c Text)

Defined in Data.TypedEncoding.Instances.Base64

Methods

checkPrevF :: Enc ("enc-B64" ': xs) c Text -> f (Enc xs c Text)

Applicative f => RecreateF (f :: Type -> Type) (Enc xs c ByteString :: Type) (Enc ("enc-B64-len" ': xs) c ByteString)

Defined in Data.TypedEncoding.Instances.Base64

Methods

checkPrevF :: Enc ("enc-B64-len" ': xs) c ByteString -> f (Enc xs c ByteString)

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c ByteString :: Type) (Enc ("enc-B64" ': xs) c ByteString)

Defined in Data.TypedEncoding.Instances.Base64

Methods

checkPrevF :: Enc ("enc-B64" ': xs) c ByteString -> f (Enc xs c ByteString)

Applicative f => RecreateF (f :: Type -> Type) (Enc xs c ByteString :: Type) (Enc ("enc-B64-len" ': xs) c ByteString)

Defined in Data.TypedEncoding.Instances.Base64

Methods

checkPrevF :: Enc ("enc-B64-len" ': xs) c ByteString -> f (Enc xs c ByteString)

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c ByteString :: Type) (Enc ("enc-B64" ': xs) c ByteString)

Defined in Data.TypedEncoding.Instances.Base64

Methods

checkPrevF :: Enc ("enc-B64" ': xs) c ByteString -> f (Enc xs c ByteString)

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c ByteString :: Type) (Enc ("r-UTF8" ': xs) c ByteString)

Defined in Data.TypedEncoding.Instances.UTF8

Methods

checkPrevF :: Enc ("r-UTF8" ': xs) c ByteString -> f (Enc xs c ByteString)

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c ByteString :: Type) (Enc ("r-UTF8" ': xs) c ByteString)

Defined in Data.TypedEncoding.Instances.UTF8

Methods

checkPrevF :: Enc ("r-UTF8" ': xs) c ByteString -> f (Enc xs c ByteString)

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c ByteString :: Type) (Enc ("r-ASCII" ': xs) c ByteString)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

checkPrevF :: Enc ("r-ASCII" ': xs) c ByteString -> f (Enc xs c ByteString)

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c ByteString :: Type) (Enc ("r-ASCII" ': xs) c ByteString)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

checkPrevF :: Enc ("r-ASCII" ': xs) c ByteString -> f (Enc xs c ByteString)

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c Text :: Type) (Enc ("r-ASCII" ': xs) c Text)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

checkPrevF :: Enc ("r-ASCII" ': xs) c Text -> f (Enc xs c Text)

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c Text :: Type) (Enc ("r-ASCII" ': xs) c Text)

Defined in Data.TypedEncoding.Instances.ASCII

Methods

checkPrevF :: Enc ("r-ASCII" ': xs) c Text -> f (Enc xs c Text)

(RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c Text :: Type) (Enc ("my-sign" ': xs) c Text)

Recreation allows effectful f to check for tampering with data. Implementation simply uses implCheckPrevF combinator on the recovery function.

Defined in Examples.TypedEncoding.DiySignEncoding

Methods

checkPrevF :: Enc ("my-sign" ': xs) c Text -> f (Enc xs c Text)

class Functor f => RecreateFAll f (xs :: [k]) c str where

Minimal complete definition

checkFAll

Methods

checkFAll :: Enc xs c str -> f (Enc '[] c str)

recreateFAll :: Enc '[] c str -> f (Enc xs c str)

Instances

Applicative f => RecreateFAll f ([] :: [k]) c str

Defined in Data.TypedEncoding.Internal.Class

Methods

checkFAll :: Enc [] c str -> f (Enc [] c str)

recreateFAll :: Enc [] c str -> f (Enc [] c str)

(Monad f, RecreateFAll f xs c str, RecreateF f (Enc xs c str) (Enc (x ': xs) c str)) => RecreateFAll f (x ': xs :: [k]) c str

Defined in Data.TypedEncoding.Internal.Class

Methods

checkFAll :: Enc (x ': xs) c str -> f (Enc [] c str)

recreateFAll :: Enc [] c str -> f (Enc (x ': xs) c str)

recreateAll :: RecreateFAll Identity (xs :: [k]) c str => Enc '[] c str -> Enc xs c str

type family Append (xs :: [k]) (ys :: [k]) :: [k] where ...

TODO use singletons definition instead?

Equations

Append '[] xs = xs

Append (y ': ys) xs = y ': Append ys xs

encodeFPart :: forall f xs xsf c str. (Functor f, EncodeFAll f xs c str) => Proxy xs -> Enc xsf c str -> f (Enc (Append xs xsf) c str)

encodePart :: EncodeFAll Identity (xs :: [k]) c str => Proxy xs -> Enc xsf c str -> Enc (Append xs xsf) c str

decodeFPart :: forall f xs xsf c str. (Functor f, DecodeFAll f xs c str) => Proxy xs -> Enc (Append xs xsf) c str -> f (Enc xsf c str)

Unsafe implementation guarded by safe type definition

decodePart :: DecodeFAll Identity (xs :: [k]) c str => Proxy xs -> Enc (Append xs xsf) c str -> Enc xsf c str

class Subset (x :: k) (y :: k) where

Minimal complete definition

Nothing

Methods

inject :: Proxy y -> Enc (x ': xs) c str -> Enc (y ': xs) c str

Instances

Subset "r-ASCII" "r-UTF8"

allow to treat ASCII encodings as UTF8 forgetting about B64 encoding

>>> let Right tstAscii = encodeFAll . toEncoding () $ "Hello World" :: Either EncodeEx (Enc '["r-ASCII"] () T.Text)
>>> displ (inject (Proxy :: Proxy "r-UTF8") tstAscii)
"MkEnc '[r-UTF8] () (Text Hello World)"

Defined in Data.TypedEncoding.Instances.ASCII

Methods

inject :: Proxy "r-UTF8" -> Enc ("r-ASCII" ': xs) c str -> Enc ("r-UTF8" ': xs) c str

class FlattenAs (x :: k) (y :: k) where

Minimal complete definition

Nothing

Methods

flattenAs :: Proxy y -> Enc (x ': xs) c str -> Enc '[y] c str

Instances

FlattenAs "enc-B64" "r-ASCII"

Defined in Data.TypedEncoding.Instances.Base64

Methods

flattenAs :: Proxy "r-ASCII" -> Enc ("enc-B64" ': xs) c str -> Enc ("r-ASCII" ': []) c str

FlattenAs "enc-B64-nontext" "r-ASCII"

allow to treat B64 encodings as ASCII forgetting about B64 encoding

>>> let tstB64 = encodeAll . toEncoding () $ "Hello World" :: Enc '["enc-B64"] () B.ByteString
>>> displ (flattenAs (Proxy :: Proxy "r-ASCII") tstB64 :: Enc '["r-ASCII"] () B.ByteString)
"MkEnc '[r-ASCII] () (ByteString SGVsbG8gV29ybGQ=)"

Defined in Data.TypedEncoding.Instances.Base64

Methods

flattenAs :: Proxy "r-ASCII" -> Enc ("enc-B64-nontext" ': xs) c str -> Enc ("r-ASCII" ': []) c str

class HasA c a where

Polymorphic data payloads used to encode/decode

Methods

has :: Proxy a -> c -> a

Instances

HasA a ()

Defined in Data.TypedEncoding.Internal.Class

Methods

has :: Proxy () -> a -> ()

HasA Config SizeLimit

Defined in Examples.TypedEncoding.Overview

Methods

has :: Proxy SizeLimit -> Config -> SizeLimit

class UnexpectedDecodeErr f where

With type safety in pace decoding errors should be unexpected this class can be used to provide extra info if decoding could fail

Methods

unexpectedDecodeErr :: UnexpectedDecodeEx -> f a

Instances

UnexpectedDecodeErr Identity

Defined in Data.TypedEncoding.Internal.Class

Methods

unexpectedDecodeErr :: UnexpectedDecodeEx -> Identity a

UnexpectedDecodeErr (Either UnexpectedDecodeEx)

Defined in Data.TypedEncoding.Internal.Class

Methods

unexpectedDecodeErr :: UnexpectedDecodeEx -> Either UnexpectedDecodeEx a

asUnexpected :: (UnexpectedDecodeErr f, Applicative f, Show err, KnownSymbol x) => Proxy x -> Either err a -> f a

class RecreateErr f where

Recovery errors are expected unless Recovery allows Identity instance

Methods

recoveryErr :: RecreateEx -> f a

Instances

RecreateErr (Either RecreateEx)

Defined in Data.TypedEncoding.Internal.Class

Methods

recoveryErr :: RecreateEx -> Either RecreateEx a

asRecreateErr :: (RecreateErr f, Applicative f, Show err, KnownSymbol x) => Proxy x -> Either err a -> f a

Display

class Displ x where

Human friendly version of Show

Methods

displ :: x -> String

Instances

Displ String

Defined in Data.TypedEncoding.Internal.Class

Methods

displ :: String -> String

Displ ByteString

Defined in Data.TypedEncoding.Internal.Class

Methods

displ :: ByteString -> String

Displ ByteString

Defined in Data.TypedEncoding.Internal.Class

Methods

displ :: ByteString -> String

Displ Text

Defined in Data.TypedEncoding.Internal.Class

Methods

displ :: Text -> String

Displ Text

Defined in Data.TypedEncoding.Internal.Class

Methods

displ :: Text -> String

(pxs ~ Proxy xs, Displ pxs, KnownSymbol x) => Displ (Proxy (x ': xs))

>>> displ (Proxy :: Proxy ["FIRST", "SECOND"])
"FIRST,SECOND"

Defined in Data.TypedEncoding.Internal.Class

Methods

displ :: Proxy (x ': xs) -> String

Displ (Proxy ([] :: [k]))

Defined in Data.TypedEncoding.Internal.Class

Methods

displ :: Proxy [] -> String

(Displ (Proxy xs), Show c, Displ str) => Displ (Enc xs c str)

Defined in Data.TypedEncoding.Internal.Class

Methods

displ :: Enc xs c str -> String

errorOnLeft :: Show err => Either err a -> a