Data.Repa.Convert.Formats

Pre-defined data formats.

Default

class FormatAscii a where

Class of types that can be formatted in some default human readable ASCII way.

Minimal complete definition

formatAscii

Associated Types

type FormatAscii' a

The format for values of this type.

Methods

formatAscii :: a -> FormatAscii' a

Get the standard ASCII format for a value.

The element value itself is not demanded.

Instances

FormatAscii Double

Doubles are formatted as base-10 decimal.

Associated Types

type FormatAscii' Double :: *

Methods

formatAscii :: Double -> FormatAscii' Double

FormatAscii Int

Ints are formated in base-10.

Associated Types

type FormatAscii' Int :: *

Methods

formatAscii :: Int -> FormatAscii' Int

FormatAscii ()

Empty tuples produce no output.

Associated Types

type FormatAscii' () :: *

Methods

formatAscii :: () -> FormatAscii' ()

FormatAscii String

Strings are formatted with double quotes and back-slash escaping of special characters.

Associated Types

type FormatAscii' String :: *

Methods

formatAscii :: String -> FormatAscii' String

FormatAscii Date32

Dates are formatted as YYYY-MM-DD.

Associated Types

type FormatAscii' Date32 :: *

Methods

formatAscii :: Date32 -> FormatAscii' Date32

Units

data UnitAsc

A particular ASCII string.

Constructors

UnitAsc String

Instances

Eq UnitAsc

Methods

(==) :: UnitAsc -> UnitAsc -> Bool

(/=) :: UnitAsc -> UnitAsc -> Bool

Show UnitAsc

Methods

showsPrec :: Int -> UnitAsc -> ShowS

show :: UnitAsc -> String

showList :: [UnitAsc] -> ShowS

Format UnitAsc

Associated Types

type Value UnitAsc :: *

Methods

fieldCount :: UnitAsc -> Int

minSize :: UnitAsc -> Int

fixedSize :: UnitAsc -> Maybe Int

packedSize :: UnitAsc -> Value UnitAsc -> Maybe Int

Unpackable UnitAsc

Methods

unpack :: UnitAsc -> Unpacker (Value UnitAsc)

unpacker :: UnitAsc -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value UnitAsc -> IO ()) -> IO ()

Packable UnitAsc

Methods

pack :: UnitAsc -> Value UnitAsc -> Packer

packer :: UnitAsc -> Value UnitAsc -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value UnitAsc

type Value UnitAsc = ()

Maybes

data MaybeChars f

Maybe a raw list of characters, or something else.

Constructors

MaybeChars String f

Instances

Eq f => Eq (MaybeChars f)

Methods

(==) :: MaybeChars f -> MaybeChars f -> Bool

(/=) :: MaybeChars f -> MaybeChars f -> Bool

Show f => Show (MaybeChars f)

Methods

showsPrec :: Int -> MaybeChars f -> ShowS

show :: MaybeChars f -> String

showList :: [MaybeChars f] -> ShowS

Format f => Format (MaybeChars f)

Associated Types

type Value (MaybeChars f) :: *

Methods

fieldCount :: MaybeChars f -> Int

minSize :: MaybeChars f -> Int

fixedSize :: MaybeChars f -> Maybe Int

packedSize :: MaybeChars f -> Value (MaybeChars f) -> Maybe Int

Unpackable f => Unpackable (MaybeChars f)

Methods

unpack :: MaybeChars f -> Unpacker (Value (MaybeChars f))

unpacker :: MaybeChars f -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value (MaybeChars f) -> IO ()) -> IO ()

Packable f => Packable (MaybeChars f)

Methods

pack :: MaybeChars f -> Value (MaybeChars f) -> Packer

packer :: MaybeChars f -> Value (MaybeChars f) -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value (MaybeChars f)

type Value (MaybeChars f) = Maybe (Value f)

data MaybeBytes f

Maybe a raw sequence of bytes, or something else.

Constructors

MaybeBytes ByteString f

Instances

Eq f => Eq (MaybeBytes f)

Methods

(==) :: MaybeBytes f -> MaybeBytes f -> Bool

(/=) :: MaybeBytes f -> MaybeBytes f -> Bool

Show f => Show (MaybeBytes f)

Methods

showsPrec :: Int -> MaybeBytes f -> ShowS

show :: MaybeBytes f -> String

showList :: [MaybeBytes f] -> ShowS

Format f => Format (MaybeBytes f)

Associated Types

type Value (MaybeBytes f) :: *

Methods

fieldCount :: MaybeBytes f -> Int

minSize :: MaybeBytes f -> Int

fixedSize :: MaybeBytes f -> Maybe Int

packedSize :: MaybeBytes f -> Value (MaybeBytes f) -> Maybe Int

Unpackable f => Unpackable (MaybeBytes f)

Methods

unpack :: MaybeBytes f -> Unpacker (Value (MaybeBytes f))

unpacker :: MaybeBytes f -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value (MaybeBytes f) -> IO ()) -> IO ()

Packable f => Packable (MaybeBytes f)

Methods

pack :: MaybeBytes f -> Value (MaybeBytes f) -> Packer

packer :: MaybeBytes f -> Value (MaybeBytes f) -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value (MaybeBytes f)

type Value (MaybeBytes f) = Maybe (Value f)

String Formats

for Haskell Strings

data FixChars

Fixed length sequence of characters, represented as a (hated) Haskell String.

• The runtime performance of the Haskell String is atrocious. You really shouldn't be using them for large data sets.
• When packing, the length of the provided string must match the width of the format, else packing will fail.
• When unpacking, the length of the result will be the width of the format.

Constructors

FixChars Int

Instances

Eq FixChars

Methods

(==) :: FixChars -> FixChars -> Bool

(/=) :: FixChars -> FixChars -> Bool

Show FixChars

Methods

showsPrec :: Int -> FixChars -> ShowS

show :: FixChars -> String

showList :: [FixChars] -> ShowS

Format FixChars

Associated Types

type Value FixChars :: *

Methods

fieldCount :: FixChars -> Int

minSize :: FixChars -> Int

fixedSize :: FixChars -> Maybe Int

packedSize :: FixChars -> Value FixChars -> Maybe Int

Unpackable FixChars

Methods

unpack :: FixChars -> Unpacker (Value FixChars)

unpacker :: FixChars -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value FixChars -> IO ()) -> IO ()

Packable FixChars

Methods

pack :: FixChars -> Value FixChars -> Packer

packer :: FixChars -> Value FixChars -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value FixChars

type Value FixChars = String

data VarChars

Like FixChars, but with a variable length.

Constructors

VarChars

Instances

Eq VarChars

Methods

(==) :: VarChars -> VarChars -> Bool

(/=) :: VarChars -> VarChars -> Bool

Show VarChars

Methods

showsPrec :: Int -> VarChars -> ShowS

show :: VarChars -> String

showList :: [VarChars] -> ShowS

Format VarChars

Associated Types

type Value VarChars :: *

Methods

fieldCount :: VarChars -> Int

minSize :: VarChars -> Int

fixedSize :: VarChars -> Maybe Int

packedSize :: VarChars -> Value VarChars -> Maybe Int

Unpackable VarChars

Methods

unpack :: VarChars -> Unpacker (Value VarChars)

unpacker :: VarChars -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value VarChars -> IO ()) -> IO ()

Packable VarChars

Methods

pack :: VarChars -> Value VarChars -> Packer

packer :: VarChars -> Value VarChars -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value VarChars

type Value VarChars = String

data VarCharString

Variable length string in double quotes, and standard backslash encoding of non-printable characters.

Constructors

VarCharString

Instances

Eq VarCharString

Methods

(==) :: VarCharString -> VarCharString -> Bool

(/=) :: VarCharString -> VarCharString -> Bool

Show VarCharString

Methods

showsPrec :: Int -> VarCharString -> ShowS

show :: VarCharString -> String

showList :: [VarCharString] -> ShowS

Format VarCharString

Associated Types

type Value VarCharString :: *

Methods

fieldCount :: VarCharString -> Int

minSize :: VarCharString -> Int

fixedSize :: VarCharString -> Maybe Int

packedSize :: VarCharString -> Value VarCharString -> Maybe Int

Unpackable VarCharString

Methods

unpack :: VarCharString -> Unpacker (Value VarCharString)

unpacker :: VarCharString -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value VarCharString -> IO ()) -> IO ()

Packable VarCharString

Methods

pack :: VarCharString -> Value VarCharString -> Packer

packer :: VarCharString -> Value VarCharString -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value VarCharString

type Value VarCharString = String

data ExactChars

Match an exact sequence of characters.

Constructors

ExactChars String

Instances

Show ExactChars

Methods

showsPrec :: Int -> ExactChars -> ShowS

show :: ExactChars -> String

showList :: [ExactChars] -> ShowS

Format ExactChars

Associated Types

type Value ExactChars :: *

Methods

fieldCount :: ExactChars -> Int

minSize :: ExactChars -> Int

fixedSize :: ExactChars -> Maybe Int

packedSize :: ExactChars -> Value ExactChars -> Maybe Int

Unpackable ExactChars

Methods

unpack :: ExactChars -> Unpacker (Value ExactChars)

unpacker :: ExactChars -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value ExactChars -> IO ()) -> IO ()

Packable ExactChars

Methods

pack :: ExactChars -> Value ExactChars -> Packer

packer :: ExactChars -> Value ExactChars -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value ExactChars

type Value ExactChars = ()

for Data.Text

data VarText

Variable length unicode text, represented as a Data.Text thing.

Constructors

VarText

Instances

Eq VarText

Methods

(==) :: VarText -> VarText -> Bool

(/=) :: VarText -> VarText -> Bool

Show VarText

Methods

showsPrec :: Int -> VarText -> ShowS

show :: VarText -> String

showList :: [VarText] -> ShowS

Format VarText

Associated Types

type Value VarText :: *

Methods

fieldCount :: VarText -> Int

minSize :: VarText -> Int

fixedSize :: VarText -> Maybe Int

packedSize :: VarText -> Value VarText -> Maybe Int

Unpackable VarText

Methods

unpack :: VarText -> Unpacker (Value VarText)

unpacker :: VarText -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value VarText -> IO ()) -> IO ()

Packable VarText

Methods

pack :: VarText -> Value VarText -> Packer

packer :: VarText -> Value VarText -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value VarText

type Value VarText = Text

data VarTextString

Variable length string in double quotes, and standard backslash encoding of non-printable characters.

Constructors

VarTextString

Instances

Eq VarTextString

Methods

(==) :: VarTextString -> VarTextString -> Bool

(/=) :: VarTextString -> VarTextString -> Bool

Show VarTextString

Methods

showsPrec :: Int -> VarTextString -> ShowS

show :: VarTextString -> String

showList :: [VarTextString] -> ShowS

Format VarTextString

Associated Types

type Value VarTextString :: *

Methods

fieldCount :: VarTextString -> Int

minSize :: VarTextString -> Int

fixedSize :: VarTextString -> Maybe Int

packedSize :: VarTextString -> Value VarTextString -> Maybe Int

Unpackable VarTextString

Methods

unpack :: VarTextString -> Unpacker (Value VarTextString)

unpacker :: VarTextString -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value VarTextString -> IO ()) -> IO ()

Packable VarTextString

Methods

pack :: VarTextString -> Value VarTextString -> Packer

packer :: VarTextString -> Value VarTextString -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value VarTextString

type Value VarTextString = Text

for Data.ByteString

data VarBytes

Variable length sequence of bytes, represented as a ByteString.

Constructors

VarBytes

Instances

Eq VarBytes

Methods

(==) :: VarBytes -> VarBytes -> Bool

(/=) :: VarBytes -> VarBytes -> Bool

Show VarBytes

Methods

showsPrec :: Int -> VarBytes -> ShowS

show :: VarBytes -> String

showList :: [VarBytes] -> ShowS

Format VarBytes

Associated Types

type Value VarBytes :: *

Methods

fieldCount :: VarBytes -> Int

minSize :: VarBytes -> Int

fixedSize :: VarBytes -> Maybe Int

packedSize :: VarBytes -> Value VarBytes -> Maybe Int

Unpackable VarBytes

Methods

unpack :: VarBytes -> Unpacker (Value VarBytes)

unpacker :: VarBytes -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value VarBytes -> IO ()) -> IO ()

Packable VarBytes

Methods

pack :: VarBytes -> Value VarBytes -> Packer

packer :: VarBytes -> Value VarBytes -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value VarBytes

type Value VarBytes = ByteString

ASCII Atoms

ASCII integers

data IntAsc

Human-readable ASCII Integer.

Constructors

IntAsc

Instances

Eq IntAsc

Methods

(==) :: IntAsc -> IntAsc -> Bool

(/=) :: IntAsc -> IntAsc -> Bool

Show IntAsc

Methods

showsPrec :: Int -> IntAsc -> ShowS

show :: IntAsc -> String

showList :: [IntAsc] -> ShowS

Format IntAsc

Associated Types

type Value IntAsc :: *

Methods

fieldCount :: IntAsc -> Int

minSize :: IntAsc -> Int

fixedSize :: IntAsc -> Maybe Int

packedSize :: IntAsc -> Value IntAsc -> Maybe Int

Unpackable IntAsc

Methods

unpack :: IntAsc -> Unpacker (Value IntAsc)

unpacker :: IntAsc -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value IntAsc -> IO ()) -> IO ()

Packable IntAsc

Methods

pack :: IntAsc -> Value IntAsc -> Packer

packer :: IntAsc -> Value IntAsc -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value IntAsc

type Value IntAsc = Int

data IntAsc0

Human-readable ASCII integer, using leading zeros to pad the encoding out to a fixed length.

Constructors

IntAsc0 Int

Instances

Eq IntAsc0

Methods

(==) :: IntAsc0 -> IntAsc0 -> Bool

(/=) :: IntAsc0 -> IntAsc0 -> Bool

Show IntAsc0

Methods

showsPrec :: Int -> IntAsc0 -> ShowS

show :: IntAsc0 -> String

showList :: [IntAsc0] -> ShowS

Format IntAsc0

Associated Types

type Value IntAsc0 :: *

Methods

fieldCount :: IntAsc0 -> Int

minSize :: IntAsc0 -> Int

fixedSize :: IntAsc0 -> Maybe Int

packedSize :: IntAsc0 -> Value IntAsc0 -> Maybe Int

Unpackable IntAsc0

Methods

unpack :: IntAsc0 -> Unpacker (Value IntAsc0)

unpacker :: IntAsc0 -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value IntAsc0 -> IO ()) -> IO ()

Packable IntAsc0

Methods

pack :: IntAsc0 -> Value IntAsc0 -> Packer

packer :: IntAsc0 -> Value IntAsc0 -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value IntAsc0

type Value IntAsc0 = Int

ASCII doubles

data DoubleAsc

Human-readable ASCII Double.

Constructors

DoubleAsc

Instances

Eq DoubleAsc

Methods

(==) :: DoubleAsc -> DoubleAsc -> Bool

(/=) :: DoubleAsc -> DoubleAsc -> Bool

Show DoubleAsc

Methods

showsPrec :: Int -> DoubleAsc -> ShowS

show :: DoubleAsc -> String

showList :: [DoubleAsc] -> ShowS

Format DoubleAsc

Associated Types

type Value DoubleAsc :: *

Methods

fieldCount :: DoubleAsc -> Int

minSize :: DoubleAsc -> Int

fixedSize :: DoubleAsc -> Maybe Int

packedSize :: DoubleAsc -> Value DoubleAsc -> Maybe Int

Unpackable DoubleAsc

Methods

unpack :: DoubleAsc -> Unpacker (Value DoubleAsc)

unpacker :: DoubleAsc -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value DoubleAsc -> IO ()) -> IO ()

Packable DoubleAsc

Methods

pack :: DoubleAsc -> Value DoubleAsc -> Packer

packer :: DoubleAsc -> Value DoubleAsc -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value DoubleAsc

type Value DoubleAsc = Double

data DoubleFixedPack

Human-readable ASCII Double.

When packing we use a fixed number of zeros after the decimal point, though when unpacking we allow a greater precision.

Constructors

DoubleFixedPack Int

Instances

Eq DoubleFixedPack

Methods

(==) :: DoubleFixedPack -> DoubleFixedPack -> Bool

(/=) :: DoubleFixedPack -> DoubleFixedPack -> Bool

Show DoubleFixedPack

Methods

showsPrec :: Int -> DoubleFixedPack -> ShowS

show :: DoubleFixedPack -> String

showList :: [DoubleFixedPack] -> ShowS

Format DoubleFixedPack

Associated Types

type Value DoubleFixedPack :: *

Methods

fieldCount :: DoubleFixedPack -> Int

minSize :: DoubleFixedPack -> Int

fixedSize :: DoubleFixedPack -> Maybe Int

packedSize :: DoubleFixedPack -> Value DoubleFixedPack -> Maybe Int

Unpackable DoubleFixedPack

Methods

unpack :: DoubleFixedPack -> Unpacker (Value DoubleFixedPack)

unpacker :: DoubleFixedPack -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value DoubleFixedPack -> IO ()) -> IO ()

Packable DoubleFixedPack

Methods

pack :: DoubleFixedPack -> Value DoubleFixedPack -> Packer

packer :: DoubleFixedPack -> Value DoubleFixedPack -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value DoubleFixedPack

type Value DoubleFixedPack = Double

ASCII dates

data YYYYsMMsDD

Human readable ASCII date in YYYYsMMsDD format.

Constructors

YYYYsMMsDD Char

Instances

Eq YYYYsMMsDD

Methods

(==) :: YYYYsMMsDD -> YYYYsMMsDD -> Bool

(/=) :: YYYYsMMsDD -> YYYYsMMsDD -> Bool

Show YYYYsMMsDD

Methods

showsPrec :: Int -> YYYYsMMsDD -> ShowS

show :: YYYYsMMsDD -> String

showList :: [YYYYsMMsDD] -> ShowS

Format YYYYsMMsDD

Associated Types

type Value YYYYsMMsDD :: *

Methods

fieldCount :: YYYYsMMsDD -> Int

minSize :: YYYYsMMsDD -> Int

fixedSize :: YYYYsMMsDD -> Maybe Int

packedSize :: YYYYsMMsDD -> Value YYYYsMMsDD -> Maybe Int

Unpackable YYYYsMMsDD

Methods

unpack :: YYYYsMMsDD -> Unpacker (Value YYYYsMMsDD)

unpacker :: YYYYsMMsDD -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value YYYYsMMsDD -> IO ()) -> IO ()

Packable YYYYsMMsDD

Methods

pack :: YYYYsMMsDD -> Value YYYYsMMsDD -> Packer

packer :: YYYYsMMsDD -> Value YYYYsMMsDD -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value YYYYsMMsDD

type Value YYYYsMMsDD = Date32

data DDsMMsYYYY

Human readable ASCII date in DDsMMsYYYY format.

Constructors

DDsMMsYYYY Char

Instances

Eq DDsMMsYYYY

Methods

(==) :: DDsMMsYYYY -> DDsMMsYYYY -> Bool

(/=) :: DDsMMsYYYY -> DDsMMsYYYY -> Bool

Show DDsMMsYYYY

Methods

showsPrec :: Int -> DDsMMsYYYY -> ShowS

show :: DDsMMsYYYY -> String

showList :: [DDsMMsYYYY] -> ShowS

Format DDsMMsYYYY

Associated Types

type Value DDsMMsYYYY :: *

Methods

fieldCount :: DDsMMsYYYY -> Int

minSize :: DDsMMsYYYY -> Int

fixedSize :: DDsMMsYYYY -> Maybe Int

packedSize :: DDsMMsYYYY -> Value DDsMMsYYYY -> Maybe Int

Unpackable DDsMMsYYYY

Methods

unpack :: DDsMMsYYYY -> Unpacker (Value DDsMMsYYYY)

unpacker :: DDsMMsYYYY -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value DDsMMsYYYY -> IO ()) -> IO ()

Packable DDsMMsYYYY

Methods

pack :: DDsMMsYYYY -> Value DDsMMsYYYY -> Packer

packer :: DDsMMsYYYY -> Value DDsMMsYYYY -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value DDsMMsYYYY

type Value DDsMMsYYYY = Date32

Binary Atoms

8-bit binary

data Word8be

Big-endian 8-bit unsigned word.

Constructors

Word8be

Instances

Eq Word8be

Methods

(==) :: Word8be -> Word8be -> Bool

(/=) :: Word8be -> Word8be -> Bool

Show Word8be

Methods

showsPrec :: Int -> Word8be -> ShowS

show :: Word8be -> String

showList :: [Word8be] -> ShowS

Format Word8be

Associated Types

type Value Word8be :: *

Methods

fieldCount :: Word8be -> Int

minSize :: Word8be -> Int

fixedSize :: Word8be -> Maybe Int

packedSize :: Word8be -> Value Word8be -> Maybe Int

Unpackable Word8be

Methods

unpack :: Word8be -> Unpacker (Value Word8be)

unpacker :: Word8be -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value Word8be -> IO ()) -> IO ()

Packable Word8be

Methods

pack :: Word8be -> Value Word8be -> Packer

packer :: Word8be -> Value Word8be -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value Word8be

type Value Word8be = Word8

data Int8be

Big-endian 8-bit signed integer.

Constructors

Int8be

Instances

Eq Int8be

Methods

(==) :: Int8be -> Int8be -> Bool

(/=) :: Int8be -> Int8be -> Bool

Show Int8be

Methods

showsPrec :: Int -> Int8be -> ShowS

show :: Int8be -> String

showList :: [Int8be] -> ShowS

Format Int8be

Associated Types

type Value Int8be :: *

Methods

fieldCount :: Int8be -> Int

minSize :: Int8be -> Int

fixedSize :: Int8be -> Maybe Int

packedSize :: Int8be -> Value Int8be -> Maybe Int

Unpackable Int8be

Methods

unpack :: Int8be -> Unpacker (Value Int8be)

unpacker :: Int8be -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value Int8be -> IO ()) -> IO ()

Packable Int8be

Methods

pack :: Int8be -> Value Int8be -> Packer

packer :: Int8be -> Value Int8be -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value Int8be

type Value Int8be = Int8

16-bit binary

data Word16be

Big-endian 32-bit unsigned word.

Constructors

Word16be

Instances

Eq Word16be

Methods

(==) :: Word16be -> Word16be -> Bool

(/=) :: Word16be -> Word16be -> Bool

Show Word16be

Methods

showsPrec :: Int -> Word16be -> ShowS

show :: Word16be -> String

showList :: [Word16be] -> ShowS

Format Word16be

Associated Types

type Value Word16be :: *

Methods

fieldCount :: Word16be -> Int

minSize :: Word16be -> Int

fixedSize :: Word16be -> Maybe Int

packedSize :: Word16be -> Value Word16be -> Maybe Int

Unpackable Word16be

Methods

unpack :: Word16be -> Unpacker (Value Word16be)

unpacker :: Word16be -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value Word16be -> IO ()) -> IO ()

Packable Word16be

Methods

pack :: Word16be -> Value Word16be -> Packer

packer :: Word16be -> Value Word16be -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value Word16be

type Value Word16be = Word16

data Int16be

Constructors

Int16be

Instances

Eq Int16be

Methods

(==) :: Int16be -> Int16be -> Bool

(/=) :: Int16be -> Int16be -> Bool

Show Int16be

Methods

showsPrec :: Int -> Int16be -> ShowS

show :: Int16be -> String

showList :: [Int16be] -> ShowS

Format Int16be

Associated Types

type Value Int16be :: *

Methods

fieldCount :: Int16be -> Int

minSize :: Int16be -> Int

fixedSize :: Int16be -> Maybe Int

packedSize :: Int16be -> Value Int16be -> Maybe Int

Unpackable Int16be

Methods

unpack :: Int16be -> Unpacker (Value Int16be)

unpacker :: Int16be -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value Int16be -> IO ()) -> IO ()

Packable Int16be

Methods

pack :: Int16be -> Value Int16be -> Packer

packer :: Int16be -> Value Int16be -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value Int16be

type Value Int16be = Int16

32-bit binary

data Word32be

Big-endian 32-bit unsigned word.

Constructors

Word32be

Instances

Eq Word32be

Methods

(==) :: Word32be -> Word32be -> Bool

(/=) :: Word32be -> Word32be -> Bool

Show Word32be

Methods

showsPrec :: Int -> Word32be -> ShowS

show :: Word32be -> String

showList :: [Word32be] -> ShowS

Format Word32be

Associated Types

type Value Word32be :: *

Methods

fieldCount :: Word32be -> Int

minSize :: Word32be -> Int

fixedSize :: Word32be -> Maybe Int

packedSize :: Word32be -> Value Word32be -> Maybe Int

Unpackable Word32be

Methods

unpack :: Word32be -> Unpacker (Value Word32be)

unpacker :: Word32be -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value Word32be -> IO ()) -> IO ()

Packable Word32be

Methods

pack :: Word32be -> Value Word32be -> Packer

packer :: Word32be -> Value Word32be -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value Word32be

type Value Word32be = Word32

data Int32be

Big-endian 32-bit signed integer.

Constructors

Int32be

Instances

Eq Int32be

Methods

(==) :: Int32be -> Int32be -> Bool

(/=) :: Int32be -> Int32be -> Bool

Show Int32be

Methods

showsPrec :: Int -> Int32be -> ShowS

show :: Int32be -> String

showList :: [Int32be] -> ShowS

Format Int32be

Associated Types

type Value Int32be :: *

Methods

fieldCount :: Int32be -> Int

minSize :: Int32be -> Int

fixedSize :: Int32be -> Maybe Int

packedSize :: Int32be -> Value Int32be -> Maybe Int

Unpackable Int32be

Methods

unpack :: Int32be -> Unpacker (Value Int32be)

unpacker :: Int32be -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value Int32be -> IO ()) -> IO ()

Packable Int32be

Methods

pack :: Int32be -> Value Int32be -> Packer

packer :: Int32be -> Value Int32be -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value Int32be

type Value Int32be = Int32

data Float32be

Big-endian 32-bit IEEE 754 float.

Constructors

Float32be

Instances

Eq Float32be

Methods

(==) :: Float32be -> Float32be -> Bool

(/=) :: Float32be -> Float32be -> Bool

Show Float32be

Methods

showsPrec :: Int -> Float32be -> ShowS

show :: Float32be -> String

showList :: [Float32be] -> ShowS

Format Float32be

Associated Types

type Value Float32be :: *

Methods

fieldCount :: Float32be -> Int

minSize :: Float32be -> Int

fixedSize :: Float32be -> Maybe Int

packedSize :: Float32be -> Value Float32be -> Maybe Int

Unpackable Float32be

Methods

unpack :: Float32be -> Unpacker (Value Float32be)

unpacker :: Float32be -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value Float32be -> IO ()) -> IO ()

Packable Float32be

Methods

pack :: Float32be -> Value Float32be -> Packer

packer :: Float32be -> Value Float32be -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value Float32be

type Value Float32be = Float

64-bit binary

data Word64be

Big-endian 64-bit unsigned word.

Constructors

Word64be

Instances

Eq Word64be

Methods

(==) :: Word64be -> Word64be -> Bool

(/=) :: Word64be -> Word64be -> Bool

Show Word64be

Methods

showsPrec :: Int -> Word64be -> ShowS

show :: Word64be -> String

showList :: [Word64be] -> ShowS

Format Word64be

Associated Types

type Value Word64be :: *

Methods

fieldCount :: Word64be -> Int

minSize :: Word64be -> Int

fixedSize :: Word64be -> Maybe Int

packedSize :: Word64be -> Value Word64be -> Maybe Int

Unpackable Word64be

Methods

unpack :: Word64be -> Unpacker (Value Word64be)

unpacker :: Word64be -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value Word64be -> IO ()) -> IO ()

Packable Word64be

Methods

pack :: Word64be -> Value Word64be -> Packer

packer :: Word64be -> Value Word64be -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value Word64be

type Value Word64be = Word64

data Int64be

Big-endian 64-bit signed integer.

Constructors

Int64be

Instances

Eq Int64be

Methods

(==) :: Int64be -> Int64be -> Bool

(/=) :: Int64be -> Int64be -> Bool

Show Int64be

Methods

showsPrec :: Int -> Int64be -> ShowS

show :: Int64be -> String

showList :: [Int64be] -> ShowS

Format Int64be

Associated Types

type Value Int64be :: *

Methods

fieldCount :: Int64be -> Int

minSize :: Int64be -> Int

fixedSize :: Int64be -> Maybe Int

packedSize :: Int64be -> Value Int64be -> Maybe Int

Unpackable Int64be

Methods

unpack :: Int64be -> Unpacker (Value Int64be)

unpacker :: Int64be -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value Int64be -> IO ()) -> IO ()

Packable Int64be

Methods

pack :: Int64be -> Value Int64be -> Packer

packer :: Int64be -> Value Int64be -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value Int64be

type Value Int64be = Int64

data Float64be

Big-endian 64-bit IEEE 754 float.

Constructors

Float64be

Instances

Eq Float64be

Methods

(==) :: Float64be -> Float64be -> Bool

(/=) :: Float64be -> Float64be -> Bool

Show Float64be

Methods

showsPrec :: Int -> Float64be -> ShowS

show :: Float64be -> String

showList :: [Float64be] -> ShowS

Format Float64be

Associated Types

type Value Float64be :: *

Methods

fieldCount :: Float64be -> Int

minSize :: Float64be -> Int

fixedSize :: Float64be -> Maybe Int

packedSize :: Float64be -> Value Float64be -> Maybe Int

Unpackable Float64be

Methods

unpack :: Float64be -> Unpacker (Value Float64be)

unpacker :: Float64be -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value Float64be -> IO ()) -> IO ()

Packable Float64be

Methods

pack :: Float64be -> Value Float64be -> Packer

packer :: Float64be -> Value Float64be -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value Float64be

type Value Float64be = Double

Compounds

Appended fields

data App f

Append fields without separators.

Constructors

App f

Instances

Format (App ())

Associated Types

type Value (App ()) :: *

Methods

fieldCount :: App () -> Int

minSize :: App () -> Int

fixedSize :: App () -> Maybe Int

packedSize :: App () -> Value (App ()) -> Maybe Int

(Format f1, Format (App fs), (~) * (Value (App fs)) (Value fs)) => Format (App ((:*:) f1 fs))

Associated Types

type Value (App ((:*:) f1 fs)) :: *

Methods

fieldCount :: App (f1 :*: fs) -> Int

minSize :: App (f1 :*: fs) -> Int

fixedSize :: App (f1 :*: fs) -> Maybe Int

packedSize :: App (f1 :*: fs) -> Value (App (f1 :*: fs)) -> Maybe Int

Unpackable (App ())

Methods

unpack :: App () -> Unpacker (Value (App ()))

unpacker :: App () -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value (App ()) -> IO ()) -> IO ()

(Unpackable f1, Unpackable (App fs), (~) * (Value (App fs)) (Value fs)) => Unpackable (App ((:*:) f1 fs))

Methods

unpack :: App (f1 :*: fs) -> Unpacker (Value (App (f1 :*: fs)))

unpacker :: App (f1 :*: fs) -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value (App (f1 :*: fs)) -> IO ()) -> IO ()

Packable (App ())

Methods

pack :: App () -> Value (App ()) -> Packer

packer :: App () -> Value (App ()) -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

(Packable f1, Packable (App fs), (~) * (Value (App fs)) (Value fs)) => Packable (App ((:*:) f1 fs))

Methods

pack :: App (f1 :*: fs) -> Value (App (f1 :*: fs)) -> Packer

packer :: App (f1 :*: fs) -> Value (App (f1 :*: fs)) -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value (App ())

type Value (App ()) = ()

type Value (App ((:*:) f1 fs))

type Value (App ((:*:) f1 fs)) = (:*:) (Value f1) (Value fs)

Separated fields

data Sep f where

Separate fields with the given character.

• The separating character is un-escapable.
• The format (Sep ',') does NOT parse a CSV file according to the CSV specification: http://tools.ietf.org/html/rfc4180.
• The type is kept abstract as we cache some pre-computed values we use to unpack this format. Use mkSep to make one.

Constructors

SepNil :: Sep ()

SepCons :: !SepMeta -> !f -> Sep fs -> Sep (f :*: fs)

Instances

Format (Sep ())

Associated Types

type Value (Sep ()) :: *

Methods

fieldCount :: Sep () -> Int

minSize :: Sep () -> Int

fixedSize :: Sep () -> Maybe Int

packedSize :: Sep () -> Value (Sep ()) -> Maybe Int

(Format f1, Format (Sep fs), (~) * (Value (Sep fs)) (Value fs)) => Format (Sep ((:*:) f1 fs))

Associated Types

type Value (Sep ((:*:) f1 fs)) :: *

Methods

fieldCount :: Sep (f1 :*: fs) -> Int

minSize :: Sep (f1 :*: fs) -> Int

fixedSize :: Sep (f1 :*: fs) -> Maybe Int

packedSize :: Sep (f1 :*: fs) -> Value (Sep (f1 :*: fs)) -> Maybe Int

Unpackable (Sep ())

Methods

unpack :: Sep () -> Unpacker (Value (Sep ()))

unpacker :: Sep () -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value (Sep ()) -> IO ()) -> IO ()

(Unpackable f1, Unpackable (Sep ((:*:) f2 fs)), (~) * (Value (Sep ((:*:) f2 fs))) (Value ((:*:) f2 fs)), (~) * (Value (Sep fs)) (Value fs)) => Unpackable (Sep ((:*:) f1 ((:*:) f2 fs)))

Methods

unpack :: Sep (f1 :*: (f2 :*: fs)) -> Unpacker (Value (Sep (f1 :*: (f2 :*: fs))))

unpacker :: Sep (f1 :*: (f2 :*: fs)) -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value (Sep (f1 :*: (f2 :*: fs))) -> IO ()) -> IO ()

(Unpackable f1, (~) * (Value (Sep ())) (Value ())) => Unpackable (Sep ((:*:) f1 ()))

Methods

unpack :: Sep (f1 :*: ()) -> Unpacker (Value (Sep (f1 :*: ())))

unpacker :: Sep (f1 :*: ()) -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value (Sep (f1 :*: ())) -> IO ()) -> IO ()

Packable (Sep ())

Methods

pack :: Sep () -> Value (Sep ()) -> Packer

packer :: Sep () -> Value (Sep ()) -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

(Packable f1, Packable (Sep ((:*:) f2 fs)), (~) * (Value (Sep ((:*:) f2 fs))) (Value ((:*:) f2 fs)), (~) * (Value (Sep fs)) (Value fs)) => Packable (Sep ((:*:) f1 ((:*:) f2 fs)))

Methods

pack :: Sep (f1 :*: (f2 :*: fs)) -> Value (Sep (f1 :*: (f2 :*: fs))) -> Packer

packer :: Sep (f1 :*: (f2 :*: fs)) -> Value (Sep (f1 :*: (f2 :*: fs))) -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

(Packable f1, (~) * (Value (Sep ())) (Value ())) => Packable (Sep ((:*:) f1 ()))

Methods

pack :: Sep (f1 :*: ()) -> Value (Sep (f1 :*: ())) -> Packer

packer :: Sep (f1 :*: ()) -> Value (Sep (f1 :*: ())) -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value (Sep ())

type Value (Sep ()) = ()

type Value (Sep ((:*:) f1 fs))

type Value (Sep ((:*:) f1 fs)) = (:*:) (Value f1) (Value fs)

class SepFormat f where

Minimal complete definition

mkSep, takeSepChar

Methods

mkSep :: Char -> f -> Sep f

takeSepChar :: Sep f -> Maybe Char

Instances

SepFormat ()

Methods

mkSep :: Char -> () -> Sep ()

takeSepChar :: Sep () -> Maybe Char

(Format f1, SepFormat fs) => SepFormat ((:*:) f1 fs)

Methods

mkSep :: Char -> (f1 :*: fs) -> Sep (f1 :*: fs)

takeSepChar :: Sep (f1 :*: fs) -> Maybe Char

Object with labeled fields

data Object fields

Format of a simple object format with labeled fields.

Instances

(Format (ObjectFields fs), (~) * (Value (ObjectFields fs)) (Value fs)) => Format (Object fs)

Associated Types

type Value (Object fs) :: *

Methods

fieldCount :: Object fs -> Int

minSize :: Object fs -> Int

fixedSize :: Object fs -> Maybe Int

packedSize :: Object fs -> Value (Object fs) -> Maybe Int

(Format (Object f), (~) * (Value (ObjectFields f)) (Value f), Packable (ObjectFields f)) => Packable (Object f)

Methods

pack :: Object f -> Value (Object f) -> Packer

packer :: Object f -> Value (Object f) -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

type Value (Object fs)

type Value (Object fs) = Value fs

class ObjectFormat f

Minimal complete definition

mkObjectFields

Instances

ObjectFormat ()

Associated Types

type ObjectFormat' () :: *

Methods

mkObjectFields :: () -> ObjectFields (ObjectFormat' ())

(Format f1, ObjectFormat fs) => ObjectFormat ((:*:) (Field f1) fs)

Associated Types

type ObjectFormat' ((:*:) (Field f1) fs) :: *

Methods

mkObjectFields :: (Field f1 :*: fs) -> ObjectFields (ObjectFormat' (Field f1 :*: fs))

data Field f

A single field in an object.

Constructors

Field

Fields

• fieldName :: String
• fieldFormat :: f
• fieldInclude :: Maybe (Value f -> Bool)

Instances

(Format f1, ObjectFormat fs) => ObjectFormat ((:*:) (Field f1) fs)

Associated Types

type ObjectFormat' ((:*:) (Field f1) fs) :: *

Methods

mkObjectFields :: (Field f1 :*: fs) -> ObjectFields (ObjectFormat' (Field f1 :*: fs))

mkObject :: ObjectFormat f => f -> Object (ObjectFormat' f)

Make an object format with the given labeled fields. For example:

> let fmt =   mkObject 
          $   Field "index"   IntAsc                      Nothing
          :*: Field "message" (VarCharString '-')         Nothing 
          :*: Field "value"   (MaybeChars NULL DoubleAsc) (Just isJust)
          :*: ()

Packing this produces:

> let Just str = packToString fmt (27 :*: "foo" :*: Nothing :*: ())
> putStrLn str
> {"index":27,"message":"foo"}

Note that the encodings that this format can generate are a superset of the JavaScript Object Notation (JSON). With the Repa format, the fields of an object can directly encode dates and other values, wheras in JSON these values must be represented by strings.

Products

data a :*: b :: * -> * -> * infixr 9

A strict product type, written infix.

Constructors

~a :*: ~b infixr 9

Instances

IsProdList ts => Select Z ((:*:) t1 ts)

Associated Types

type Select' (Z :: N) ((:*:) t1 ts) :: *

Methods

select :: Nat Z -> (t1 :*: ts) -> Select' Z (t1 :*: ts)

IsProdList ts => Discard Z ((:*:) t1 ts)

Associated Types

type Discard' (Z :: N) ((:*:) t1 ts) :: *

Methods

discard :: Nat Z -> (t1 :*: ts) -> Discard' Z (t1 :*: ts)

(Unbox a, Unbox b) => Vector Vector ((:*:) a b)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a :*: b) -> m (Vector (a :*: b))

basicUnsafeThaw :: PrimMonad m => Vector (a :*: b) -> m (Mutable Vector (PrimState m) (a :*: b))

basicLength :: Vector (a :*: b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a :*: b) -> Vector (a :*: b)

basicUnsafeIndexM :: Monad m => Vector (a :*: b) -> Int -> m (a :*: b)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a :*: b) -> Vector (a :*: b) -> m ()

elemseq :: Vector (a :*: b) -> (a :*: b) -> b -> b

(Unbox a, Unbox b) => MVector MVector ((:*:) a b)

Methods

basicLength :: MVector s (a :*: b) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a :*: b) -> MVector s (a :*: b)

basicOverlaps :: MVector s (a :*: b) -> MVector s (a :*: b) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a :*: b))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a :*: b) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a :*: b) -> m (MVector (PrimState m) (a :*: b))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a :*: b) -> Int -> m (a :*: b)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a :*: b) -> Int -> (a :*: b) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a :*: b) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a :*: b) -> (a :*: b) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a :*: b) -> MVector (PrimState m) (a :*: b) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a :*: b) -> MVector (PrimState m) (a :*: b) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a :*: b) -> Int -> m (MVector (PrimState m) (a :*: b))

Functor ((:*:) a)

Methods

fmap :: (a -> b) -> (a :*: a) -> a :*: b

(<$) :: a -> (a :*: b) -> a :*: a

(Format f1, Format (Sep fs), (~) * (Value (Sep fs)) (Value fs)) => Format (Sep ((:*:) f1 fs))

Associated Types

type Value (Sep ((:*:) f1 fs)) :: *

Methods

fieldCount :: Sep (f1 :*: fs) -> Int

minSize :: Sep (f1 :*: fs) -> Int

fixedSize :: Sep (f1 :*: fs) -> Maybe Int

packedSize :: Sep (f1 :*: fs) -> Value (Sep (f1 :*: fs)) -> Maybe Int

(Format f1, Format (App fs), (~) * (Value (App fs)) (Value fs)) => Format (App ((:*:) f1 fs))

Associated Types

type Value (App ((:*:) f1 fs)) :: *

Methods

fieldCount :: App (f1 :*: fs) -> Int

minSize :: App (f1 :*: fs) -> Int

fixedSize :: App (f1 :*: fs) -> Maybe Int

packedSize :: App (f1 :*: fs) -> Value (App (f1 :*: fs)) -> Maybe Int

(Unpackable f1, Unpackable (Sep ((:*:) f2 fs)), (~) * (Value (Sep ((:*:) f2 fs))) (Value ((:*:) f2 fs)), (~) * (Value (Sep fs)) (Value fs)) => Unpackable (Sep ((:*:) f1 ((:*:) f2 fs)))

Methods

unpack :: Sep (f1 :*: (f2 :*: fs)) -> Unpacker (Value (Sep (f1 :*: (f2 :*: fs))))

unpacker :: Sep (f1 :*: (f2 :*: fs)) -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value (Sep (f1 :*: (f2 :*: fs))) -> IO ()) -> IO ()

(Unpackable f1, (~) * (Value (Sep ())) (Value ())) => Unpackable (Sep ((:*:) f1 ()))

Methods

unpack :: Sep (f1 :*: ()) -> Unpacker (Value (Sep (f1 :*: ())))

unpacker :: Sep (f1 :*: ()) -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value (Sep (f1 :*: ())) -> IO ()) -> IO ()

(Unpackable f1, Unpackable (App fs), (~) * (Value (App fs)) (Value fs)) => Unpackable (App ((:*:) f1 fs))

Methods

unpack :: App (f1 :*: fs) -> Unpacker (Value (App (f1 :*: fs)))

unpacker :: App (f1 :*: fs) -> Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> Value (App (f1 :*: fs)) -> IO ()) -> IO ()

(Packable f1, Packable (Sep ((:*:) f2 fs)), (~) * (Value (Sep ((:*:) f2 fs))) (Value ((:*:) f2 fs)), (~) * (Value (Sep fs)) (Value fs)) => Packable (Sep ((:*:) f1 ((:*:) f2 fs)))

Methods

pack :: Sep (f1 :*: (f2 :*: fs)) -> Value (Sep (f1 :*: (f2 :*: fs))) -> Packer

packer :: Sep (f1 :*: (f2 :*: fs)) -> Value (Sep (f1 :*: (f2 :*: fs))) -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

(Packable f1, (~) * (Value (Sep ())) (Value ())) => Packable (Sep ((:*:) f1 ()))

Methods

pack :: Sep (f1 :*: ()) -> Value (Sep (f1 :*: ())) -> Packer

packer :: Sep (f1 :*: ()) -> Value (Sep (f1 :*: ())) -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

(Packable f1, Packable (App fs), (~) * (Value (App fs)) (Value fs)) => Packable (App ((:*:) f1 fs))

Methods

pack :: App (f1 :*: fs) -> Value (App (f1 :*: fs)) -> Packer

packer :: App (f1 :*: fs) -> Value (App (f1 :*: fs)) -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()

Select n ts => Select (S n) ((:*:) t1 ts)

Associated Types

type Select' (S n :: N) ((:*:) t1 ts) :: *

Methods

select :: Nat (S n) -> (t1 :*: ts) -> Select' (S n) (t1 :*: ts)

Discard n ts => Discard (S n) ((:*:) t1 ts)

Associated Types

type Discard' (S n :: N) ((:*:) t1 ts) :: *

Methods

discard :: Nat (S n) -> (t1 :*: ts) -> Discard' (S n) (t1 :*: ts)

(Eq b, Eq a) => Eq ((:*:) a b)

Methods

(==) :: (a :*: b) -> (a :*: b) -> Bool

(/=) :: (a :*: b) -> (a :*: b) -> Bool

(Show b, Show a) => Show ((:*:) a b)

Methods

showsPrec :: Int -> (a :*: b) -> ShowS

show :: (a :*: b) -> String

showList :: [a :*: b] -> ShowS

IsProdList fs => IsProdList ((:*:) f fs)

Methods

isProdList :: (f :*: fs) -> Bool

(IsKeyValues p, IsKeyValues ps, (~) * (Keys p) (Keys ps)) => IsKeyValues ((:*:) p ps)

Associated Types

type Keys ((:*:) p ps) :: *

type Values ((:*:) p ps) :: *

Methods

keys :: (p :*: ps) -> [Keys (p :*: ps)]

values :: (p :*: ps) -> Values (p :*: ps)

(Unbox a, Unbox b) => Unbox ((:*:) a b)

(Format f1, SepFormat fs) => SepFormat ((:*:) f1 fs)

Methods

mkSep :: Char -> (f1 :*: fs) -> Sep (f1 :*: fs)

takeSepChar :: Sep (f1 :*: fs) -> Maybe Char

(Format f1, ObjectFormat fs) => ObjectFormat ((:*:) (Field f1) fs)

Associated Types

type ObjectFormat' ((:*:) (Field f1) fs) :: *

Methods

mkObjectFields :: (Field f1 :*: fs) -> ObjectFields (ObjectFormat' (Field f1 :*: fs))

Mask ms ts => Mask ((:*:) Drop ms) ((:*:) t1 ts)

Associated Types

type Mask' ((:*:) Drop ms) ((:*:) t1 ts) :: *

Methods

mask :: (Drop :*: ms) -> (t1 :*: ts) -> Mask' (Drop :*: ms) (t1 :*: ts)

Mask ms ts => Mask ((:*:) Keep ms) ((:*:) t1 ts)

Associated Types

type Mask' ((:*:) Keep ms) ((:*:) t1 ts) :: *

Methods

mask :: (Keep :*: ms) -> (t1 :*: ts) -> Mask' (Keep :*: ms) (t1 :*: ts)

type Select' Z ((:*:) t1 ts)

type Select' Z ((:*:) t1 ts) = t1

type Discard' Z ((:*:) t1 ts)

type Discard' Z ((:*:) t1 ts) = ts

data MVector s ((:*:) a b)

data MVector s ((:*:) a b) = MV_Prod ~Int ~(MVector s a) ~(MVector s b)

type Value (Sep ((:*:) f1 fs))

type Value (Sep ((:*:) f1 fs)) = (:*:) (Value f1) (Value fs)

type Value (App ((:*:) f1 fs))

type Value (App ((:*:) f1 fs)) = (:*:) (Value f1) (Value fs)

type Select' (S n) ((:*:) t1 ts)

type Select' (S n) ((:*:) t1 ts) = Select' n ts

type Discard' (S n) ((:*:) t1 ts)

type Discard' (S n) ((:*:) t1 ts) = (:*:) t1 (Discard' n ts)

type Values ((:*:) p ps)

type Values ((:*:) p ps) = (:*:) (Values p) (Values ps)

type Keys ((:*:) p ps)

type Keys ((:*:) p ps) = Keys p

data Vector ((:*:) a b)

data Vector ((:*:) a b) = V_Prod ~Int ~(Vector a) ~(Vector b)

type Value ((:*:) a b)

type Value ((:*:) a b) = (:*:) (Value a) (Value b)

type Mask' ((:*:) Drop ms) ((:*:) t1 ts)

type Mask' ((:*:) Drop ms) ((:*:) t1 ts) = Mask' ms ts

type Mask' ((:*:) Keep ms) ((:*:) t1 ts)

type Mask' ((:*:) Keep ms) ((:*:) t1 ts) = (:*:) t1 (Mask' ms ts)