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.

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.

FormatAscii Int

Ints are formated in base-10.

FormatAscii String

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

FormatAscii ()

Empty tuples produce no output.

FormatAscii Date32

Dates are formatted as YYYY-MM-DD.

Units

data UnitAsc

A particular ASCII string.

Constructors

UnitAsc String

Instances

Eq UnitAsc

Show UnitAsc

Format UnitAsc

Unpackable UnitAsc

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

Show f => Show (MaybeChars f)

Format f => Format (MaybeChars f)

Unpackable f => Unpackable (MaybeChars f)

Packable f => Packable (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)

Show f => Show (MaybeBytes f)

Format f => Format (MaybeBytes f)

Unpackable f => Unpackable (MaybeBytes f)

Packable f => Packable (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

Show FixChars

Format FixChars

Unpackable FixChars

Packable FixChars

type Value FixChars = String

data VarChars

Like FixChars, but with a variable length.

Constructors

VarChars

Instances

Eq VarChars

Show VarChars

Format VarChars

Unpackable VarChars

Packable 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

Show VarCharString

Format VarCharString

Unpackable VarCharString

Packable VarCharString

type Value VarCharString = String

data ExactChars

Match an exact sequence of characters.

Constructors

ExactChars String

Instances

Show ExactChars

Format ExactChars

Unpackable ExactChars

Packable ExactChars

type Value ExactChars = ()

for Data.Text

data VarText

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

Constructors

VarText

Instances

Eq VarText

Show VarText

Format VarText

Unpackable VarText

Packable 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

Show VarTextString

Format VarTextString

Unpackable VarTextString

Packable VarTextString

type Value VarTextString = Text

for Data.ByteString

data VarBytes

Variable length sequence of bytes, represented as a ByteString.

Constructors

VarBytes

Instances

Eq VarBytes

Show VarBytes

Format VarBytes

Unpackable VarBytes

Packable VarBytes

type Value VarBytes = ByteString

ASCII Atoms

ASCII integers

data IntAsc

Human-readable ASCII Integer.

Constructors

IntAsc

Instances

Eq IntAsc

Show IntAsc

Format IntAsc

Unpackable IntAsc

Packable 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

Show IntAsc0

Format IntAsc0

Unpackable IntAsc0

Packable IntAsc0

type Value IntAsc0 = Int

ASCII doubles

data DoubleAsc

Human-readable ASCII Double.

Constructors

DoubleAsc

Instances

Eq DoubleAsc

Show DoubleAsc

Format DoubleAsc

Unpackable DoubleAsc

Packable 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

Show DoubleFixedPack

Format DoubleFixedPack

Unpackable DoubleFixedPack

Packable DoubleFixedPack

type Value DoubleFixedPack = Double

ASCII dates

data YYYYsMMsDD

Human readable ASCII date in YYYYsMMsDD format.

Constructors

YYYYsMMsDD Char

Instances

Eq YYYYsMMsDD

Show YYYYsMMsDD

Format YYYYsMMsDD

Unpackable YYYYsMMsDD

Packable YYYYsMMsDD

type Value YYYYsMMsDD = Date32

data DDsMMsYYYY

Human readable ASCII date in DDsMMsYYYY format.

Constructors

DDsMMsYYYY Char

Instances

Eq DDsMMsYYYY

Show DDsMMsYYYY

Format DDsMMsYYYY

Unpackable DDsMMsYYYY

Packable DDsMMsYYYY

type Value DDsMMsYYYY = Date32

Binary Atoms

8-bit binary

data Word8be

Big-endian 8-bit unsigned word.

Constructors

Word8be

Instances

Eq Word8be

Show Word8be

Format Word8be

Unpackable Word8be

Packable Word8be

type Value Word8be = Word8

data Int8be

Big-endian 8-bit signed integer.

Constructors

Int8be

Instances

Eq Int8be

Show Int8be

Format Int8be

Unpackable Int8be

Packable Int8be

type Value Int8be = Int8

16-bit binary

data Word16be

Big-endian 32-bit unsigned word.

Constructors

Word16be

Instances

Eq Word16be

Show Word16be

Format Word16be

Unpackable Word16be

Packable Word16be

type Value Word16be = Word16

data Int16be

Constructors

Int16be

Instances

Eq Int16be

Show Int16be

Format Int16be

Unpackable Int16be

Packable Int16be

type Value Int16be = Int16

32-bit binary

data Word32be

Big-endian 32-bit unsigned word.

Constructors

Word32be

Instances

Eq Word32be

Show Word32be

Format Word32be

Unpackable Word32be

Packable Word32be

type Value Word32be = Word32

data Int32be

Big-endian 32-bit signed integer.

Constructors

Int32be

Instances

Eq Int32be

Show Int32be

Format Int32be

Unpackable Int32be

Packable Int32be

type Value Int32be = Int32

data Float32be

Big-endian 32-bit IEEE 754 float.

Constructors

Float32be

Instances

Eq Float32be

Show Float32be

Format Float32be

Unpackable Float32be

Packable Float32be

type Value Float32be = Float

64-bit binary

data Word64be

Big-endian 64-bit unsigned word.

Constructors

Word64be

Instances

Eq Word64be

Show Word64be

Format Word64be

Unpackable Word64be

Packable Word64be

type Value Word64be = Word64

data Int64be

Big-endian 64-bit signed integer.

Constructors

Int64be

Instances

Eq Int64be

Show Int64be

Format Int64be

Unpackable Int64be

Packable Int64be

type Value Int64be = Int64

data Float64be

Big-endian 64-bit IEEE 754 float.

Constructors

Float64be

Instances

Eq Float64be

Show Float64be

Format Float64be

Unpackable Float64be

Packable Float64be

type Value Float64be = Double

Compounds

Appended fields

data App f

Append fields without separators.

Constructors

App f

Instances

Format (App ())

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

Unpackable (App ())

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

Packable (App ())

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

type Value (App ()) = ()

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

Separated fields

data Sep f

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.

Instances

Format (Sep ())

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

Unpackable (Sep ())

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

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

Packable (Sep ())

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

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

type Value (Sep ()) = ()

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

class SepFormat f where

Methods

mkSep :: Char -> f -> Sep f

Instances

SepFormat ()

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

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)

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

type Value (Object fs) = Value fs

class ObjectFormat f

Minimal complete definition

mkObjectFields

Instances

ObjectFormat ()

(Format f1, ObjectFormat fs) => 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)

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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