| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Data.Repa.Convert.Formats
Description
Pre-defined data formats.
Synopsis
- class FormatAscii a where
- type FormatAscii' a
- formatAscii :: a -> FormatAscii' a
- data UnitAsc = UnitAsc String
- data MaybeChars f = MaybeChars String f
- data MaybeBytes f = MaybeBytes ByteString f
- data FixChars = FixChars Int
- data VarChars = VarChars
- data VarCharString = VarCharString
- data ExactChars = ExactChars String
- data VarText = VarText
- data VarTextString = VarTextString
- data VarBytes = VarBytes
- data IntAsc = IntAsc
- data IntAsc0 = IntAsc0 Int
- data DoubleAsc = DoubleAsc
- data DoubleFixedPack = DoubleFixedPack Int
- data YYYYsMMsDD = YYYYsMMsDD Char
- data DDsMMsYYYY = DDsMMsYYYY Char
- data Word8be = Word8be
- data Int8be = Int8be
- data Word16be = Word16be
- data Int16be = Int16be
- data Word32be = Word32be
- data Int32be = Int32be
- data Float32be = Float32be
- data Word64be = Word64be
- data Int64be = Int64be
- data Float64be = Float64be
- data App f = App f
- data Sep f where
- class SepFormat f where
- data Object fields
- class ObjectFormat f
- data Field f = Field {
- fieldName :: String
- fieldFormat :: f
- fieldInclude :: Maybe (Value f -> Bool)
- mkObject :: ObjectFormat f => f -> Object (ObjectFormat' f)
- data a :*: b = !a :*: !b
Default
class FormatAscii a where Source #
Class of types that can be formatted in some default human readable ASCII way.
Methods
formatAscii :: a -> FormatAscii' a Source #
Get the standard ASCII format for a value.
The element value itself is not demanded.
Instances
Units
A particular ASCII string.
Maybes
data MaybeChars f Source #
Maybe a raw list of characters, or something else.
Constructors
| MaybeChars String f |
Instances
data MaybeBytes f Source #
Maybe a raw sequence of bytes, or something else.
Constructors
| MaybeBytes ByteString f |
Instances
String Formats
for Haskell Strings
Fixed length sequence of characters, represented as a (hated) Haskell String.
- The runtime performance of the Haskell
Stringis 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.
Like FixChars, but with a variable length.
Constructors
| VarChars |
data VarCharString Source #
Variable length string in double quotes, and standard backslash encoding of non-printable characters.
Constructors
| VarCharString |
Instances
data ExactChars Source #
Match an exact sequence of characters.
Constructors
| ExactChars String |
Instances
| Show ExactChars Source # | |
Defined in Data.Repa.Convert.Format.String Methods showsPrec :: Int -> ExactChars -> ShowS # show :: ExactChars -> String # showList :: [ExactChars] -> ShowS # | |
| Format ExactChars Source # | |
Defined in Data.Repa.Convert.Format.String Associated Types type Value ExactChars Source # Methods fieldCount :: ExactChars -> Int Source # minSize :: ExactChars -> Int Source # fixedSize :: ExactChars -> Maybe Int Source # packedSize :: ExactChars -> Value ExactChars -> Maybe Int Source # | |
| Packable ExactChars Source # | |
Defined in Data.Repa.Convert.Format.String Methods pack :: ExactChars -> Value ExactChars -> Packer Source # packer :: ExactChars -> Value ExactChars -> Addr# -> IO () -> (Addr# -> IO ()) -> IO () Source # | |
| Unpackable ExactChars Source # | |
Defined in Data.Repa.Convert.Format.String | |
| type Value ExactChars Source # | |
Defined in Data.Repa.Convert.Format.String | |
for Data.Text
Variable length unicode text, represented as a Data.Text thing.
Constructors
| VarText |
data VarTextString Source #
Variable length string in double quotes, and standard backslash encoding of non-printable characters.
Constructors
| VarTextString |
Instances
for Data.ByteString
Variable length sequence of bytes, represented as a ByteString.
Constructors
| VarBytes |
ASCII Atoms
ASCII integers
Human-readable ASCII Integer.
Constructors
| IntAsc |
Human-readable ASCII integer, using leading zeros to pad the encoding out to a fixed length.
ASCII doubles
Human-readable ASCII Double.
Constructors
| DoubleAsc |
data DoubleFixedPack Source #
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
ASCII dates
data YYYYsMMsDD Source #
Human readable ASCII date in YYYYsMMsDD format.
Constructors
| YYYYsMMsDD Char |
Instances
| Show YYYYsMMsDD Source # | |
Defined in Data.Repa.Convert.Format.Date32 Methods showsPrec :: Int -> YYYYsMMsDD -> ShowS # show :: YYYYsMMsDD -> String # showList :: [YYYYsMMsDD] -> ShowS # | |
| Eq YYYYsMMsDD Source # | |
Defined in Data.Repa.Convert.Format.Date32 | |
| Format YYYYsMMsDD Source # | |
Defined in Data.Repa.Convert.Format.Date32 Associated Types type Value YYYYsMMsDD Source # Methods fieldCount :: YYYYsMMsDD -> Int Source # minSize :: YYYYsMMsDD -> Int Source # fixedSize :: YYYYsMMsDD -> Maybe Int Source # packedSize :: YYYYsMMsDD -> Value YYYYsMMsDD -> Maybe Int Source # | |
| Packable YYYYsMMsDD Source # | |
Defined in Data.Repa.Convert.Format.Date32 Methods pack :: YYYYsMMsDD -> Value YYYYsMMsDD -> Packer Source # packer :: YYYYsMMsDD -> Value YYYYsMMsDD -> Addr# -> IO () -> (Addr# -> IO ()) -> IO () Source # | |
| Unpackable YYYYsMMsDD Source # | |
Defined in Data.Repa.Convert.Format.Date32 | |
| type Value YYYYsMMsDD Source # | |
Defined in Data.Repa.Convert.Format.Date32 | |
data DDsMMsYYYY Source #
Human readable ASCII date in DDsMMsYYYY format.
Constructors
| DDsMMsYYYY Char |
Instances
| Show DDsMMsYYYY Source # | |
Defined in Data.Repa.Convert.Format.Date32 Methods showsPrec :: Int -> DDsMMsYYYY -> ShowS # show :: DDsMMsYYYY -> String # showList :: [DDsMMsYYYY] -> ShowS # | |
| Eq DDsMMsYYYY Source # | |
Defined in Data.Repa.Convert.Format.Date32 | |
| Format DDsMMsYYYY Source # | |
Defined in Data.Repa.Convert.Format.Date32 Associated Types type Value DDsMMsYYYY Source # Methods fieldCount :: DDsMMsYYYY -> Int Source # minSize :: DDsMMsYYYY -> Int Source # fixedSize :: DDsMMsYYYY -> Maybe Int Source # packedSize :: DDsMMsYYYY -> Value DDsMMsYYYY -> Maybe Int Source # | |
| Packable DDsMMsYYYY Source # | |
Defined in Data.Repa.Convert.Format.Date32 Methods pack :: DDsMMsYYYY -> Value DDsMMsYYYY -> Packer Source # packer :: DDsMMsYYYY -> Value DDsMMsYYYY -> Addr# -> IO () -> (Addr# -> IO ()) -> IO () Source # | |
| Unpackable DDsMMsYYYY Source # | |
Defined in Data.Repa.Convert.Format.Date32 | |
| type Value DDsMMsYYYY Source # | |
Defined in Data.Repa.Convert.Format.Date32 | |
Binary Atoms
8-bit binary
Big-endian 8-bit unsigned word.
Constructors
| Word8be |
Big-endian 8-bit signed integer.
Constructors
| Int8be |
16-bit binary
Big-endian 32-bit unsigned word.
Constructors
| Word16be |
Constructors
| Int16be |
32-bit binary
Big-endian 32-bit unsigned word.
Constructors
| Word32be |
Big-endian 32-bit signed integer.
Constructors
| Int32be |
Big-endian 32-bit IEEE 754 float.
Constructors
| Float32be |
64-bit binary
Big-endian 64-bit unsigned word.
Constructors
| Word64be |
Big-endian 64-bit signed integer.
Constructors
| Int64be |
Big-endian 64-bit IEEE 754 float.
Constructors
| Float64be |
Compounds
Appended fields
Append fields without separators.
Constructors
| App f |
Instances
| (Format f1, Format (App fs), Value (App fs) ~ Value fs) => Format (App (f1 :*: fs)) Source # | |
Defined in Data.Repa.Convert.Format.App | |
| Format (App ()) Source # | |
| (Packable f1, Packable (App fs), Value (App fs) ~ Value fs) => Packable (App (f1 :*: fs)) Source # | |
| Packable (App ()) Source # | |
| (Unpackable f1, Unpackable (App fs), Value (App fs) ~ Value fs) => Unpackable (App (f1 :*: fs)) Source # | |
| Unpackable (App ()) Source # | |
| type Value (App (f1 :*: fs)) Source # | |
| type Value (App ()) Source # | |
Defined in Data.Repa.Convert.Format.App | |
Separated fields
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
mkSepto make one.
Instances
| (Format f1, Format (Sep fs), Value (Sep fs) ~ Value fs) => Format (Sep (f1 :*: fs)) Source # | |
Defined in Data.Repa.Convert.Format.Sep | |
| Format (Sep ()) Source # | |
| (Packable f1, Packable (Sep (f2 :*: fs)), Value (Sep (f2 :*: fs)) ~ Value (f2 :*: fs), Value (Sep fs) ~ Value fs) => Packable (Sep (f1 :*: (f2 :*: fs))) Source # | |
| (Packable f1, Value (Sep ()) ~ Value ()) => Packable (Sep (f1 :*: ())) Source # | |
| Packable (Sep ()) Source # | |
| (Unpackable f1, Unpackable (Sep (f2 :*: fs)), Value (Sep (f2 :*: fs)) ~ Value (f2 :*: fs), Value (Sep fs) ~ Value fs) => Unpackable (Sep (f1 :*: (f2 :*: fs))) Source # | |
| (Unpackable f1, Value (Sep ()) ~ Value ()) => Unpackable (Sep (f1 :*: ())) Source # | |
| Unpackable (Sep ()) Source # | |
| type Value (Sep (f1 :*: fs)) Source # | |
| type Value (Sep ()) Source # | |
Defined in Data.Repa.Convert.Format.Sep | |
Object with labeled fields
Format of a simple object format with labeled fields.
class ObjectFormat f Source #
Minimal complete definition
mkObjectFields
Instances
| ObjectFormat () Source # | |
Defined in Data.Repa.Convert.Format.Object Associated Types type ObjectFormat' () Methods mkObjectFields :: () -> ObjectFields (ObjectFormat' ()) | |
| (Format f1, ObjectFormat fs) => ObjectFormat (Field f1 :*: fs) Source # | |
Defined in Data.Repa.Convert.Format.Object Methods mkObjectFields :: (Field f1 :*: fs) -> ObjectFields (ObjectFormat' (Field f1 :*: fs)) | |
A single field in an object.
Constructors
| Field | |
Fields
| |
Instances
| (Format f1, ObjectFormat fs) => ObjectFormat (Field f1 :*: fs) Source # | |
Defined in Data.Repa.Convert.Format.Object Methods mkObjectFields :: (Field f1 :*: fs) -> ObjectFields (ObjectFormat' (Field f1 :*: fs)) | |
mkObject :: ObjectFormat f => f -> Object (ObjectFormat' f) Source #
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
A strict product type, written infix.
Constructors
| !a :*: !b infixr 9 |
Instances
| IsProdList ts => Discard 'Z (t1 :*: ts) | |
| IsProdList ts => Select 'Z (t1 :*: ts) | |
| (Unbox a, Unbox b) => Vector Vector (a :*: b) | |
Defined in Data.Repa.Scalar.Product Methods basicUnsafeFreeze :: Mutable Vector s (a :*: b) -> ST s (Vector (a :*: b)) basicUnsafeThaw :: Vector (a :*: b) -> ST s (Mutable Vector s (a :*: b)) basicLength :: Vector (a :*: b) -> Int basicUnsafeSlice :: Int -> Int -> Vector (a :*: b) -> Vector (a :*: b) basicUnsafeIndexM :: Vector (a :*: b) -> Int -> Box (a :*: b) basicUnsafeCopy :: Mutable Vector s (a :*: b) -> Vector (a :*: b) -> ST s () | |
| (Unbox a, Unbox b) => MVector MVector (a :*: b) | |
Defined in Data.Repa.Scalar.Product 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 :: Int -> ST s (MVector s (a :*: b)) basicInitialize :: MVector s (a :*: b) -> ST s () basicUnsafeReplicate :: Int -> (a :*: b) -> ST s (MVector s (a :*: b)) basicUnsafeRead :: MVector s (a :*: b) -> Int -> ST s (a :*: b) basicUnsafeWrite :: MVector s (a :*: b) -> Int -> (a :*: b) -> ST s () basicClear :: MVector s (a :*: b) -> ST s () basicSet :: MVector s (a :*: b) -> (a :*: b) -> ST s () basicUnsafeCopy :: MVector s (a :*: b) -> MVector s (a :*: b) -> ST s () basicUnsafeMove :: MVector s (a :*: b) -> MVector s (a :*: b) -> ST s () basicUnsafeGrow :: MVector s (a :*: b) -> Int -> ST s (MVector s (a :*: b)) | |
| Functor ((:*:) a) | |
| (Format f1, Format (App fs), Value (App fs) ~ Value fs) => Format (App (f1 :*: fs)) Source # | |
Defined in Data.Repa.Convert.Format.App | |
| (Format f1, Format (Sep fs), Value (Sep fs) ~ Value fs) => Format (Sep (f1 :*: fs)) Source # | |
Defined in Data.Repa.Convert.Format.Sep | |
| (Packable f1, Packable (App fs), Value (App fs) ~ Value fs) => Packable (App (f1 :*: fs)) Source # | |
| (Packable f1, Packable (Sep (f2 :*: fs)), Value (Sep (f2 :*: fs)) ~ Value (f2 :*: fs), Value (Sep fs) ~ Value fs) => Packable (Sep (f1 :*: (f2 :*: fs))) Source # | |
| (Packable f1, Value (Sep ()) ~ Value ()) => Packable (Sep (f1 :*: ())) Source # | |
| (Unpackable f1, Unpackable (App fs), Value (App fs) ~ Value fs) => Unpackable (App (f1 :*: fs)) Source # | |
| (Unpackable f1, Unpackable (Sep (f2 :*: fs)), Value (Sep (f2 :*: fs)) ~ Value (f2 :*: fs), Value (Sep fs) ~ Value fs) => Unpackable (Sep (f1 :*: (f2 :*: fs))) Source # | |
| (Unpackable f1, Value (Sep ()) ~ Value ()) => Unpackable (Sep (f1 :*: ())) Source # | |
| Discard n ts => Discard ('S n) (t1 :*: ts) | |
| Select n ts => Select ('S n) (t1 :*: ts) | |
| (Show a, Show b) => Show (a :*: b) | |
| (Eq a, Eq b) => Eq (a :*: b) | |
| (Format f1, ObjectFormat fs) => ObjectFormat (Field f1 :*: fs) Source # | |
Defined in Data.Repa.Convert.Format.Object Methods mkObjectFields :: (Field f1 :*: fs) -> ObjectFields (ObjectFormat' (Field f1 :*: fs)) | |
| (Format f1, SepFormat fs) => SepFormat (f1 :*: fs) Source # | |
| (Format a, Format b) => Format (a :*: b) Source # | Formatting fields. |
| (IsKeyValues p, IsKeyValues ps, Keys p ~ Keys ps) => IsKeyValues (p :*: ps) | |
| IsProdList fs => IsProdList (f :*: fs) | |
Defined in Data.Repa.Scalar.Product Methods isProdList :: (f :*: fs) -> Bool # | |
| (Unbox a, Unbox b) => Unbox (a :*: b) | |
Defined in Data.Repa.Scalar.Product | |
| Mask ms ts => Mask (Drop :*: ms) (t1 :*: ts) | |
| Mask ms ts => Mask (Keep :*: ms) (t1 :*: ts) | |
| type Discard' 'Z (t1 :*: ts) | |
Defined in Data.Repa.Scalar.Product | |
| type Select' 'Z (t1 :*: ts) | |
Defined in Data.Repa.Scalar.Product | |
| data MVector s (a :*: b) | |
Defined in Data.Repa.Scalar.Product | |
| type Value (App (f1 :*: fs)) Source # | |
| type Value (Sep (f1 :*: fs)) Source # | |
| type Discard' ('S n) (t1 :*: ts) | |
| type Select' ('S n) (t1 :*: ts) | |
Defined in Data.Repa.Scalar.Product | |
| type Value (a :*: b) Source # | |
| type Keys (p :*: ps) | |
Defined in Data.Repa.Scalar.Product | |
| type Values (p :*: ps) | |
| data Vector (a :*: b) | |
Defined in Data.Repa.Scalar.Product | |
| type Mask' (Drop :*: ms) (t1 :*: ts) | |
| type Mask' (Keep :*: ms) (t1 :*: ts) | |