Data.Repa.Convert.Formats

Pre-defined data formats.

Default Ascii Format

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.

(FormatAscii t1, FormatAscii (Plain ts)) => FormatAscii ((:*:) t1 ts)

Tuples are displayed with round parens and commas to separate the fields.

Field Products

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

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)

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

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

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

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

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

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)

(FormatAscii t1, FormatAscii (Plain ts)) => FormatAscii ((:*:) t1 ts)

Tuples are displayed with round parens and commas to separate the fields.

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 Value (Tup ((:*:) 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 FormatAscii' ((:*:) t1 ts)

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

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

Field Separators

data App f

Append fields without separators.

Constructors

App f

Instances

Show f => Show (App f)

Packable (App ())

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

Format (App ())

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

type Value (App ()) = ()

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

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.

Constructors

Sep Char f

Instances

Show f => Show (Sep f)

Packable (Sep ())

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

Format (Sep ())

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

type Value (Sep ()) = ()

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

data Tup f

Display fields as a tuple, like (x,y,z).

Constructors

Tup f

Instances

Show f => Show (Tup f)

Packable (Tup ())

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

Format (Tup ())

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

type Value (Tup ()) = ()

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

Strings

data FixAsc

Fixed length string.

• When packing, the length of the provided string must match the field width, else packing will fail.
• When unpacking, the length of the result will be as set by the field width.

Constructors

FixAsc Int

Instances

Eq FixAsc

Show FixAsc

Packable FixAsc

Format FixAsc

type Value FixAsc = String

data VarAsc

Variable length raw string (with no quotes).

Constructors

VarAsc

Instances

Eq VarAsc

Show VarAsc

Packable VarAsc

Format VarAsc

type Value VarAsc = String

data VarString

Variable length string in double quotes, and standard backslash encoding of special characters.

Constructors

VarString

Instances

Eq VarString

Show VarString

Packable VarString

Format VarString

type Value VarString = String

Atomic values

ASCII numeric

data IntAsc

Human-readable ASCII Integer.

Constructors

IntAsc

Instances

Eq IntAsc

Show IntAsc

Packable IntAsc

Format IntAsc

type Value IntAsc = Int

data IntAsc0

Human-readable ASCII integer, with leading zeros.

Constructors

IntAsc0 Int

Instances

Eq IntAsc0

Show IntAsc0

Packable IntAsc0

Format IntAsc0

type Value IntAsc0 = Int

data DoubleAsc

Human-readable ASCII Double.

Constructors

DoubleAsc

Instances

Eq DoubleAsc

Show DoubleAsc

Packable DoubleAsc

Format DoubleAsc

type Value DoubleAsc = Double

ASCII dates

data YYYYsMMsDD

Date32 in ASCII YYYYsMMsDD format.

Constructors

YYYYsMMsDD Char

Instances

Eq YYYYsMMsDD

Show YYYYsMMsDD

Packable YYYYsMMsDD

Format YYYYsMMsDD

type Value YYYYsMMsDD = Date32

data DDsMMsYYYY

Date32 in ASCII DDsMMsYYYY format.

Constructors

DDsMMsYYYY Char

Instances

Eq DDsMMsYYYY

Show DDsMMsYYYY

Packable DDsMMsYYYY

Format DDsMMsYYYY

type Value DDsMMsYYYY = Date32

8-bit binary

data Word8be

Big-endian 8-bit unsigned word.

Constructors

Word8be

Instances

Eq Word8be

Show Word8be

Packable Word8be

Format Word8be

type Value Word8be = Word8

data Int8be

Big-endian 8-bit signed integer.

Constructors

Int8be

Instances

Eq Int8be

Show Int8be

Packable Int8be

Format Int8be

type Value Int8be = Int8

16-bit binary

data Word16be

Big-endian 32-bit unsigned word.

Constructors

Word16be

Instances

Eq Word16be

Show Word16be

Packable Word16be

Format Word16be

type Value Word16be = Word16

data Int16be

Constructors

Int16be

Instances

Eq Int16be

Show Int16be

Packable Int16be

Format Int16be

type Value Int16be = Int16

32-bit binary

data Word32be

Big-endian 32-bit unsigned word.

Constructors

Word32be

Instances

Eq Word32be

Show Word32be

Packable Word32be

Format Word32be

type Value Word32be = Word32

data Int32be

Big-endian 32-bit signed integer.

Constructors

Int32be

Instances

Eq Int32be

Show Int32be

Packable Int32be

Format Int32be

type Value Int32be = Int32

data Float32be

Big-endian 32-bit IEEE 754 float.

Constructors

Float32be

Instances

Eq Float32be

Show Float32be

Packable Float32be

Format Float32be

type Value Float32be = Float

64-bit binary

data Word64be

Big-endian 64-bit unsigned word.

Constructors

Word64be

Instances

Eq Word64be

Show Word64be

Packable Word64be

Format Word64be

type Value Word64be = Word64

data Int64be

Big-endian 64-bit signed integer.

Constructors

Int64be

Instances

Eq Int64be

Show Int64be

Packable Int64be

Format Int64be

type Value Int64be = Int64

data Float64be

Big-endian 64-bit IEEE 754 float.

Constructors

Float64be

Instances

Eq Float64be

Show Float64be

Packable Float64be

Format Float64be

type Value Float64be = Double