Data.TypedEncoding

Overview

This library uses TypeLits symbols to specify and work with types like

-- Base 64 encoded bytes (could represent binary files)
Enc '["enc-B64"] ByteString

-- Base 64 encoded UTF8 bytes
Enc '["enc-B64", "r-UTF8"] ByteString

-- Text that contains only ASCII characters
Enc '["r-ASCII"] Text

or to do transformations to strings like

upper :: Text -> Enc '["do-UPPER"] Text
upper = ...

or to define precise types to use with toEncString and fromEncString

date :: Enc '["r-date-%d%b%Y:%X %Z"] Text
date = toEncString ...

Primary focus of type-encodings is to provide type safe

• encoding
• decoding
• recreation (verification of existing payload)
• type conversions between encoded types

of string-like data (ByteString, Text) that is subject of some encoding or formatting restrictions.

as well as

• toEncString
• fromEncString

conversions.

Groups of annotations

typed-encoding uses type annotations grouped into semantic categories

"r-" restriction / predicate

• encoding is a partial identity
• recreation is a partial identity (matching encoding)
• decoding is identity

Examples: "r-UTF8", "r-ASCII", upper alpha-numeric bound r-ban restrictions like "r-999-999-9999"

"do-" transformations

• encoding applies transformation to the string (could be partial)
• decoding - typically none
• recreation - typically none but, if present, verifies the payload has expected data (e.g. only uppercase chars for "do-UPPER")

Examples: "do-UPPER", "do-lower", "do-reverse"

"enc-" data encoding that is not "r-"

• encoding applies encoding transformation to the string (could be partial)
• decoding reverses the transformation (can be used as pure function)
• recreation verifies that the payload has correctly encoded data

Examples: "enc-B64"

"bool[Op]:" encodings

Encodings that are defined in terms of other encodings using boolean algebra.

(early, beta version)

Examples:

"boolOr:(r-ban:FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF)(r-ban:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)"

"@boolNot:(r-ASCII)"

Usage

To use this library import this module and one or more instance or combinator module.

Here is list of instance modules available in typed-encoding library itself

• Data.TypedEncoding.Instances.Enc.Base64
• Data.TypedEncoding.Instances.Restriction.Common
• Data.TypedEncoding.Instances.Restriction.ASCII
• Data.TypedEncoding.Instances.Restriction.UTF8
• Data.TypedEncoding.Instances.Do.Sample
• Data.TypedEncoding.Instances.ToEncString.Common

This list is not intended to be exhaustive, rather separate libraries can provide instances for other encodings and transformations.

To implement a new encoding import this module and

• Data.TypedEncoding.Instances.Support

Defining annotations with combinators is an alternative to using typeclass instances.

Combinator modules with be merged with Instances modules in the future.

Included combinator modules:

• Data.TypedEncoding.Combinators.Restriction.Bool
• Data.TypedEncoding.Combinators.Restriction.BoundedAlphaNums

Conversion combinator module structure is similar to one found in text and bytestring packages And can be found (since 0.2.2) in

• Data.TypedEncoding.Conv.Text
• Data.TypedEncoding.Conv.Text.Encoding
• Data.TypedEncoding.Conv.Text.Lazy
• Data.TypedEncoding.Conv.Text.Lazy.Encoding
• Data.TypedEncoding.Conv.ByteString.Char8
• Data.TypedEncoding.Conv.ByteString.Lazy.Char8

Examples

Examples of how to use this library are included in

• Examples.TypedEncoding

Classes

module Data.TypedEncoding.Internal.Class

Encoding class and Encoder (replaces EncodeFAll)

module Data.TypedEncoding.Internal.Class.Encoder

Combinators

module Data.TypedEncoding.Internal.Combinators

Types

data Enc enc conf str

Instances

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

Defined in Data.TypedEncoding.Instances.Restriction.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.Restriction.UTF8

Methods

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

(IsStringR str, RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c str :: Type) (Enc ("r-Int-decimal" ': xs) c str)

Defined in Data.TypedEncoding.Instances.Restriction.Common

Methods

checkPrevF :: Enc ("r-Int-decimal" ': xs) c str -> f (Enc xs c str)

(IsStringR str, RecreateErr f, Applicative f) => RecreateF (f :: Type -> Type) (Enc xs c str :: Type) (Enc ("r-Word8-decimal" ': xs) c str)

Defined in Data.TypedEncoding.Instances.Restriction.Common

Methods

checkPrevF :: Enc ("r-Word8-decimal" ': xs) c str -> f (Enc xs c str)

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

Defined in Data.TypedEncoding.Instances.Enc.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.Enc.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.Enc.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.Enc.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.Enc.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.Enc.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 Text :: Type) (Enc ("do-UPPER" ': xs) c Text)

Defined in Data.TypedEncoding.Instances.Do.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 ByteString :: Type) (Enc ("r-ASCII" ': xs) c ByteString)

Defined in Data.TypedEncoding.Instances.Restriction.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.Restriction.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.Restriction.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.Restriction.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 String :: Type) (Enc ("r-ASCII" ': xs) c String)

Defined in Data.TypedEncoding.Instances.Restriction.ASCII

Methods

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

(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)

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

Defined in Data.TypedEncoding.Instances.Enc.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.Enc.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.Enc.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.Enc.Base64

Methods

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

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

Defined in Data.TypedEncoding.Instances.Do.Sample

Methods

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

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

Defined in Data.TypedEncoding.Instances.Do.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.Do.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.Do.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.Do.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.Do.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.Do.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.Do.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.Do.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.Do.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 ("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)

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

Defined in Data.TypedEncoding.Instances.Restriction.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.Restriction.UTF8

Methods

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

(IsStringR str, Applicative f) => DecodeF (f :: Type -> Type) (Enc ("r-Int-decimal" ': xs) c str) (Enc xs c str :: Type)

Defined in Data.TypedEncoding.Instances.Restriction.Common

Methods

decodeF :: Enc ("r-Int-decimal" ': xs) c str -> f (Enc xs c str)

(IsStringR str, Applicative f) => DecodeF (f :: Type -> Type) (Enc ("r-Word8-decimal" ': xs) c str) (Enc xs c str :: Type)

Defined in Data.TypedEncoding.Instances.Restriction.Common

Methods

decodeF :: Enc ("r-Word8-decimal" ': xs) c str -> f (Enc xs c str)

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

Defined in Data.TypedEncoding.Instances.Enc.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.Enc.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.Enc.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.Enc.Base64

Methods

decodeF :: Enc ("enc-B64" ': 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.Restriction.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.Restriction.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.Restriction.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.Restriction.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 String) (Enc xs c String :: Type)

Defined in Data.TypedEncoding.Instances.Restriction.ASCII

Methods

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

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

Defined in Data.TypedEncoding.Instances.Restriction.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)

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

Defined in Data.TypedEncoding.Instances.Restriction.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)

Defined in Data.TypedEncoding.Instances.Restriction.UTF8

Methods

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

IsStringR str => EncodeF (Either EncodeEx) (Enc xs c str) (Enc ("r-Int-decimal" ': xs) c str :: Type)

Defined in Data.TypedEncoding.Instances.Restriction.Common

Methods

encodeF :: Enc xs c str -> Either EncodeEx (Enc ("r-Int-decimal" ': xs) c str)

IsStringR str => EncodeF (Either EncodeEx) (Enc xs c str) (Enc ("r-Word8-decimal" ': xs) c str :: Type)

Defined in Data.TypedEncoding.Instances.Restriction.Common

Methods

encodeF :: Enc xs c str -> Either EncodeEx (Enc ("r-Word8-decimal" ': xs) c str)

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

Defined in Data.TypedEncoding.Instances.Restriction.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.Restriction.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.Restriction.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.Restriction.ASCII

Methods

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

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

Defined in Data.TypedEncoding.Instances.Restriction.ASCII

Methods

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

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

Defined in Data.TypedEncoding.Instances.Restriction.ASCII

Methods

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

(Eq conf, Eq str) => Eq (Enc enc conf str)

Defined in Data.TypedEncoding.Internal.Types.Enc

Methods

(==) :: Enc enc conf str -> Enc enc conf str -> Bool

(/=) :: Enc enc conf str -> Enc enc conf str -> Bool

(Show conf, Show str) => Show (Enc enc conf str)

Defined in Data.TypedEncoding.Internal.Types.Enc

Methods

showsPrec :: Int -> Enc enc conf str -> ShowS

show :: Enc enc conf str -> String

showList :: [Enc enc conf str] -> ShowS

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

>>> let disptest = unsafeSetPayload () "hello" :: Enc '["TEST"] () T.Text
>>> displ disptest
"MkEnc '[TEST] () (Text hello)"

Defined in Data.TypedEncoding.Internal.Types.Enc

Methods

displ :: Enc xs c str -> String

data CheckedEnc conf str

Represents some validated encoded string.

CheckedEnc is untyped version of Enc. CheckedEnc contains verified encoded data, encoding is visible at the value level only.

Instances

(Eq conf, Eq str) => Eq (CheckedEnc conf str)

Defined in Data.TypedEncoding.Internal.Types.CheckedEnc

Methods

(==) :: CheckedEnc conf str -> CheckedEnc conf str -> Bool

(/=) :: CheckedEnc conf str -> CheckedEnc conf str -> Bool

(Show conf, Show str) => Show (CheckedEnc conf str)

Defined in Data.TypedEncoding.Internal.Types.CheckedEnc

Methods

showsPrec :: Int -> CheckedEnc conf str -> ShowS

show :: CheckedEnc conf str -> String

showList :: [CheckedEnc conf str] -> ShowS

(Show c, Displ str) => Displ (CheckedEnc c str)

>>> displ $ unsafeCheckedEnc ["TEST"] () ("hello" :: T.Text)
"MkCheckedEnc [TEST] () (Text hello)"

Defined in Data.TypedEncoding.Internal.Types.CheckedEnc

Methods

displ :: CheckedEnc c str -> String

data EncodeEx where

Represents errors in encoding

Constructors

EncodeEx :: (Show a, KnownSymbol x) => Proxy x -> a -> EncodeEx

Instances

Show EncodeEx

Defined in Data.TypedEncoding.Internal.Types

Methods

showsPrec :: Int -> EncodeEx -> ShowS

show :: EncodeEx -> String

showList :: [EncodeEx] -> ShowS

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

Defined in Data.TypedEncoding.Instances.Restriction.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)

Defined in Data.TypedEncoding.Instances.Restriction.UTF8

Methods

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

IsStringR str => EncodeF (Either EncodeEx) (Enc xs c str) (Enc ("r-Int-decimal" ': xs) c str :: Type)

Defined in Data.TypedEncoding.Instances.Restriction.Common

Methods

encodeF :: Enc xs c str -> Either EncodeEx (Enc ("r-Int-decimal" ': xs) c str)

IsStringR str => EncodeF (Either EncodeEx) (Enc xs c str) (Enc ("r-Word8-decimal" ': xs) c str :: Type)

Defined in Data.TypedEncoding.Instances.Restriction.Common

Methods

encodeF :: Enc xs c str -> Either EncodeEx (Enc ("r-Word8-decimal" ': xs) c str)

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

Defined in Data.TypedEncoding.Instances.Restriction.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.Restriction.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.Restriction.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.Restriction.ASCII

Methods

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

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

Defined in Data.TypedEncoding.Instances.Restriction.ASCII

Methods

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

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

Defined in Data.TypedEncoding.Instances.Restriction.ASCII

Methods

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

(KnownSymbol s, "r-ban" ~ TakeUntil s ":", IsStringR str, Encodings (Either EncodeEx) xs grps c str) => Encodings (Either EncodeEx) (s ': xs) ("r-ban" ': grps) c str

Defined in Data.TypedEncoding.Combinators.Restriction.BoundedAlphaNums

Methods

encodings :: Encoder (Either EncodeEx) (s ': xs) ("r-ban" ': grps) c str

Encodings (Either EncodeEx) xs grps c ByteString => Encodings (Either EncodeEx) ("enc-B64" ': xs) ("enc-B64" ': grps) c ByteString

Defined in Data.TypedEncoding.Instances.Enc.Base64

Methods

encodings :: Encoder (Either EncodeEx) ("enc-B64" ': xs) ("enc-B64" ': grps) c ByteString

Encodings (Either EncodeEx) xs grps c ByteString => Encodings (Either EncodeEx) ("r-ASCII" ': xs) ("r-ASCII" ': grps) c ByteString

Defined in Data.TypedEncoding.Instances.Restriction.ASCII

Methods

encodings :: Encoder (Either EncodeEx) ("r-ASCII" ': xs) ("r-ASCII" ': grps) c ByteString

Encodings (Either EncodeEx) xs grps c ByteString => Encodings (Either EncodeEx) ("r-ASCII" ': xs) ("r-ASCII" ': grps) c ByteString

Defined in Data.TypedEncoding.Instances.Restriction.ASCII

Methods

encodings :: Encoder (Either EncodeEx) ("r-ASCII" ': xs) ("r-ASCII" ': grps) c ByteString

Encodings (Either EncodeEx) xs grps c Text => Encodings (Either EncodeEx) ("r-ASCII" ': xs) ("r-ASCII" ': grps) c Text

Defined in Data.TypedEncoding.Instances.Restriction.ASCII

Methods

encodings :: Encoder (Either EncodeEx) ("r-ASCII" ': xs) ("r-ASCII" ': grps) c Text

Encodings (Either EncodeEx) xs grps c Text => Encodings (Either EncodeEx) ("r-ASCII" ': xs) ("r-ASCII" ': grps) c Text

Defined in Data.TypedEncoding.Instances.Restriction.ASCII

Methods

encodings :: Encoder (Either EncodeEx) ("r-ASCII" ': xs) ("r-ASCII" ': grps) c Text

Encodings (Either EncodeEx) xs grps c String => Encodings (Either EncodeEx) ("r-ASCII" ': xs) ("r-ASCII" ': grps) c String

Defined in Data.TypedEncoding.Instances.Restriction.ASCII

Methods

encodings :: Encoder (Either EncodeEx) ("r-ASCII" ': xs) ("r-ASCII" ': grps) c String

Encodings (Either EncodeEx) xs grps c ByteString => Encodings (Either EncodeEx) ("r-UTF8" ': xs) ("r-UTF8" ': grps) c ByteString

Defined in Data.TypedEncoding.Instances.Restriction.UTF8

Methods

encodings :: Encoder (Either EncodeEx) ("r-UTF8" ': xs) ("r-UTF8" ': grps) c ByteString

Encodings (Either EncodeEx) xs grps c ByteString => Encodings (Either EncodeEx) ("r-UTF8" ': xs) ("r-UTF8" ': grps) c ByteString

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.Restriction.UTF8

Methods

encodings :: Encoder (Either EncodeEx) ("r-UTF8" ': xs) ("r-UTF8" ': grps) c ByteString

data RecreateEx where

Represents errors in recovery (recreation of encoded types).

Constructors

RecreateEx :: (Show e, KnownSymbol x) => Proxy x -> e -> RecreateEx

RecreateExUnkStep :: Show e => e -> RecreateEx

Instances

Show RecreateEx

Defined in Data.TypedEncoding.Internal.Types

Methods

showsPrec :: Int -> RecreateEx -> ShowS

show :: RecreateEx -> String

showList :: [RecreateEx] -> ShowS

RecreateErr (Either RecreateEx)

Defined in Data.TypedEncoding.Internal.Class.Recreate

Methods

recoveryErr :: RecreateEx -> Either RecreateEx a

data UnexpectedDecodeEx where

Type safety over encodings makes decoding process safe. However failures are still possible due to bugs or unsafe payload modifications. UnexpectedDecodeEx represents such errors.

Constructors

UnexpectedDecodeEx :: (Show a, KnownSymbol x) => Proxy x -> a -> UnexpectedDecodeEx

Instances

Show UnexpectedDecodeEx

Defined in Data.TypedEncoding.Internal.Types

Methods

showsPrec :: Int -> UnexpectedDecodeEx -> ShowS

show :: UnexpectedDecodeEx -> String

showList :: [UnexpectedDecodeEx] -> ShowS

UnexpectedDecodeErr (Either UnexpectedDecodeEx)

Defined in Data.TypedEncoding.Internal.Class.Decode

Methods

unexpectedDecodeErr :: UnexpectedDecodeEx -> Either UnexpectedDecodeEx a

type EncAnn = String

Represents value level (single) annotation.

Existentially quantified version of Enc and basic combinators

module Data.TypedEncoding.Internal.Types.SomeEnc

Types and combinators for not verfied encoding

module Data.TypedEncoding.Internal.Types.UncheckedEnc

Basic Enc Combinators

getPayload :: Enc enc conf str -> str

unsafeSetPayload :: conf -> str -> Enc enc conf str

fromEncoding :: Enc '[] conf str -> str

toEncoding :: conf -> str -> Enc '[] conf str

Basic CheckedEnc Combinators

unsafeCheckedEnc :: [EncAnn] -> c -> s -> CheckedEnc c s

getCheckedPayload :: CheckedEnc conf str -> str

getCheckedEncPayload :: CheckedEnc conf str -> ([EncAnn], str)

toCheckedEnc :: forall xs c str. SymbolList xs => Enc xs c str -> CheckedEnc c str

fromCheckedEnc :: forall xs c str. SymbolList xs => CheckedEnc c str -> Maybe (Enc xs c str)

Other Basic Combinators

recreateErrUnknown :: Show e => e -> RecreateEx