Text.Columnar

Documentation

class EnumText c => Columnar c where

a columnar type enumerates the columns of a CSV/table; it is just an EnumText with options for CSV codecs and the table generators

Minimal complete definition

Nothing

Methods

columnOptions :: ColumnOptions c

data ColumnOptions c

Constructors

ColumnOptions

Fields

• _co_csv_nmd :: IsNamed

  encoding CSV with headers?

• _co_csv_eos :: EncodeOptions

  Cassava encode options

• _co_csv_dos :: DecodeOptions

  Cassava decode options

• _co_col_hdr :: WithColHeader

  teabular: include a header line

• _co_col_fmt :: RowNo -> c -> Builder -> Builder

  teabular: field formatters

Instances

Show (ColumnOptions c)

Defined in Text.Columnar.Types

Methods

showsPrec :: Int -> ColumnOptions c -> ShowS

show :: ColumnOptions c -> String

showList :: [ColumnOptions c] -> ShowS

data IsNamed

are we generating/expecting a header for CSVs

Constructors

Named

we are generating and expecting headers

Positional HasHeader

we are not generating headers but possibly skipping them on read

Instances

Show IsNamed

Defined in Text.Columnar.Types

Methods

showsPrec :: Int -> IsNamed -> ShowS

show :: IsNamed -> String

showList :: [IsNamed] -> ShowS

data WithColHeader

are we generating/expecting a header for tabular data

Constructors

WithColHeader

WithoutColHeader

Instances

Eq WithColHeader

Defined in Text.Columnar.Types

Methods

(==) :: WithColHeader -> WithColHeader -> Bool

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

Ord WithColHeader

Defined in Text.Columnar.Types

Methods

compare :: WithColHeader -> WithColHeader -> Ordering

(<) :: WithColHeader -> WithColHeader -> Bool

(<=) :: WithColHeader -> WithColHeader -> Bool

(>) :: WithColHeader -> WithColHeader -> Bool

(>=) :: WithColHeader -> WithColHeader -> Bool

max :: WithColHeader -> WithColHeader -> WithColHeader

min :: WithColHeader -> WithColHeader -> WithColHeader

Show WithColHeader

Defined in Text.Columnar.Types

Methods

showsPrec :: Int -> WithColHeader -> ShowS

show :: WithColHeader -> String

showList :: [WithColHeader] -> ShowS

newtype RowNo

which Row is being formatted

Constructors

RowNo

Fields

• _RowNo :: Int

Instances

Enum RowNo

Defined in Text.Columnar.Types

Methods

succ :: RowNo -> RowNo

pred :: RowNo -> RowNo

toEnum :: Int -> RowNo

fromEnum :: RowNo -> Int

enumFrom :: RowNo -> [RowNo]

enumFromThen :: RowNo -> RowNo -> [RowNo]

enumFromTo :: RowNo -> RowNo -> [RowNo]

enumFromThenTo :: RowNo -> RowNo -> RowNo -> [RowNo]

Eq RowNo

Defined in Text.Columnar.Types

Methods

(==) :: RowNo -> RowNo -> Bool

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

Num RowNo

Defined in Text.Columnar.Types

Methods

(+) :: RowNo -> RowNo -> RowNo

(-) :: RowNo -> RowNo -> RowNo

(*) :: RowNo -> RowNo -> RowNo

negate :: RowNo -> RowNo

abs :: RowNo -> RowNo

signum :: RowNo -> RowNo

fromInteger :: Integer -> RowNo

Ord RowNo

Defined in Text.Columnar.Types

Methods

compare :: RowNo -> RowNo -> Ordering

(<) :: RowNo -> RowNo -> Bool

(<=) :: RowNo -> RowNo -> Bool

(>) :: RowNo -> RowNo -> Bool

(>=) :: RowNo -> RowNo -> Bool

max :: RowNo -> RowNo -> RowNo

min :: RowNo -> RowNo -> RowNo

Show RowNo

Defined in Text.Columnar.Types

Methods

showsPrec :: Int -> RowNo -> ShowS

show :: RowNo -> String

showList :: [RowNo] -> ShowS

headerRowNo :: RowNo

the header is row 0, first data row is 1

firstRowNo :: RowNo

the header is row 0, first data row is 1

rowNoSupply :: [RowNo]

the list of valid RowNo, starting with the first row (NOT the header)

defaultPositionalColumnOptions :: ColumnOptions c

defaultColumnOptions :: ColumnOptions c

class Columnar c => IsRecord r c | r -> c, c -> r where

IsRecord combines the column type with the record type, each record type determining the column type and vice versa

Methods

zeroRecord :: r

fieldMethods :: c -> FieldMethods r c

class (Monoid r, IsRecord r c) => IsMonoidalRecord r c where

IsRecord combines the column type with the record type, each record type determining the column type and vice versa

Methods

monoidalFieldMethods :: c -> MonoidalFieldMethods r c

data FieldMethods r c

for each column we need a lens the field of the record, which must be Buildable and TextParsable

Constructors

(Buildable f, TextParsable f) => FieldMethods

Fields

• _fm_lens :: Lens' r f

data MonoidalFieldMethods r c

if we need monoidal records then the fields must be Monoidal too.

Constructors

(Buildable f, TextParsable f, Monoid f) => MonoidalFieldMethods

Fields

• _mfm_lens :: Lens' r f

data Records r c

a record set contains the ColumnOptions along with the vector of records

Constructors

Records

Fields

• _recs_options :: ColumnOptions c
• _recs_vector :: Vector r

Instances

Show r => Show (Records r c)

Defined in Text.Columnar.Types

Methods

showsPrec :: Int -> Records r c -> ShowS

show :: Records r c -> String

showList :: [Records r c] -> ShowS

(IsRecord r c, Buildable (Rows c)) => Buildable (Records r c)

Defined in Text.Columnar.Types

Methods

build :: Records r c -> Builder

class (IsRecord r c, Coercible m (IntMap r)) => IsRecordIntMap r c m | r -> c, c -> r, r -> m, m -> r where

Methods

recordKey :: r -> Int

encodeRecordMap :: forall r c m. IsRecordIntMap r c m => m -> ByteString

encoding to an Intmap

decodeRecordMap :: forall r c m. IsRecordIntMap r c m => ByteString -> Possibly m

decoding into an Intmap

memptyRecordMap :: forall r c m. (Monoid r, IsRecordIntMap r c m) => m

often we will want to construct a Monoid Intmap from Monoid records

mappendRecordMap :: forall r c m. (Monoid r, IsRecordIntMap r c m) => m -> m -> m

often we will want to construct a Monoid Intmap from Monoid records

summarizeMap :: forall r c m. IsRecordIntMap r c m => m -> Text

provide evidence that Map is well formed

class (IsRecord r c, Coercible m (HashMap Text r)) => IsRecordHashMap r c m | r -> c, c -> r, r -> m, m -> r where

Methods

recordTextKey :: r -> Text

encodeRecordHashMap :: forall r c m. IsRecordHashMap r c m => m -> ByteString

encoding to an Intmap

decodeRecordHashMap :: forall r c m. IsRecordHashMap r c m => ByteString -> Possibly m

decoding into an Intmap

memptyRecordHashMap :: forall r c m. (Monoid r, IsRecordHashMap r c m) => m

often we will want to construct a Monoid HashMap from Monoid records

mappendRecordHashMap :: forall r c m. (Monoid r, IsRecordHashMap r c m) => m -> m -> m

often we will want to construct a Monoid HashMap from Monoid records

summarizeHashMap :: forall r c m. IsRecordHashMap r c m => m -> Text

provide evidence that HashMap is well formed

newtype Row c

Constructors

Row

Fields

• _Row :: c -> Builder

Instances

Columnar c => Eq (Row c)

Defined in Text.Columnar.Types

Methods

(==) :: Row c -> Row c -> Bool

(/=) :: Row c -> Row c -> Bool

Show (Row c)

Defined in Text.Columnar.Types

Methods

showsPrec :: Int -> Row c -> ShowS

show :: Row c -> String

showList :: [Row c] -> ShowS

Columnar c => FromRecord (Row c)

Defined in Text.Columnar.Types

Methods

parseRecord :: Record -> Parser (Row c)

Columnar c => ToRecord (Row c)

Defined in Text.Columnar.Types

Methods

toRecord :: Row c -> Record

Columnar c => FromNamedRecord (Row c)

Defined in Text.Columnar.Types

Methods

parseNamedRecord :: NamedRecord -> Parser (Row c)

Columnar c => ToNamedRecord (Row c)

Defined in Text.Columnar.Types

Methods

toNamedRecord :: Row c -> NamedRecord

data Rows c

Rows are used for generating tabular output and do not need access to any record type

Constructors

Rows

Fields

• _rows_options :: ColumnOptions c
• _rows_vector :: Vector (Row c)

Instances

Show (Rows c)

Defined in Text.Columnar.Types

Methods

showsPrec :: Int -> Rows c -> ShowS

show :: Rows c -> String

showList :: [Rows c] -> ShowS

Columnar c => Buildable (Rows c)

Defined in Text.Columnar.Types

Methods

build :: Rows c -> Builder

mkRows :: Columnar c => [Row c] -> Rows c

mkRowsWith :: ColumnOptions c -> [Row c] -> Rows c

getRows :: Rows c -> [Row c]

mkRow :: (c -> Builder) -> Row c

data ColumnarIx c

sometimes we just need the column type, as with listColumns

Constructors

ColumnarIx

Instances

Show (ColumnarIx c)

Defined in Text.Columnar.Types

Methods

showsPrec :: Int -> ColumnarIx c -> ShowS

show :: ColumnarIx c -> String

showList :: [ColumnarIx c] -> ShowS

listColumns :: Columnar c => ColumnarIx c -> [c]

mkFieldMethods :: (TextParsable f, Buildable f) => Lens' r f -> FieldMethods r c

for constructing each field's FieldMethods

mkMonoidalFieldMethods :: (TextParsable f, Buildable f, Monoid f) => Lens' r f -> MonoidalFieldMethods r c

for constructing each field's MonoidalFieldMethods

convertMonoidalFieldMethodsToFieldMethods :: MonoidalFieldMethods r c -> FieldMethods r c

constructRecordMappend :: (Bounded c, Enum c) => (c -> MonoidalFieldMethods r c) -> r -> r -> r

haskellRecords

Arguments

:: IsRecord r c

=> [r]

list of records to encode

-> Builder

Haskell defining LBS for decoding

encode the list of records as a Haskell list of strings, one line per line, indented at two spaces

mkRecords :: Columnar c => [r] -> Records r c

mkRecordsWith :: ColumnOptions c -> [r] -> Records r c

buildRecord :: forall r c. IsRecord r c => r -> Builder

encodeRecordsT :: forall r c. IsRecord r c => Records r c -> Text

encodeRecords :: forall r c. IsRecord r c => Records r c -> ByteString

decodeRecordsT :: IsRecord r c => Text -> Possibly (Records r c)

decodeRecords :: IsRecord r c => ByteString -> Possibly (Records r c)

parseRecord :: IsRecord r c => TextParser r

decodeRecordsWithT :: IsRecord r c => ColumnOptions c -> Text -> Possibly (Records r c)

decodeRecordsWith :: IsRecord r c => ColumnOptions c -> ByteString -> Possibly (Records r c)

recordsToRows :: IsRecord r c => Records r c -> Rows c

recordToRow :: IsRecord r c => r -> Row c

rowsToRecords :: forall r c. IsRecord r c => Rows c -> Possibly (Records r c)

rowToRecord :: forall r c. IsRecord r c => Row c -> Possibly r

encodeColumnarCsv :: forall c. Columnar c => Rows c -> ByteString

csvHeader :: Columnar c => ColumnarIx c -> Header

decodeColumnarCsv :: Columnar c => ByteString -> Possibly (Rows c)

decodeColumnarCsvWith :: Columnar c => ColumnOptions c -> ByteString -> Possibly (Rows c)

recordFields :: forall r c. IsRecord r c => [(ByteString, r -> ByteString)]

listRecords :: Columnar c => Records r c -> [r]

mkNamedRecord :: [(ByteString, a -> ByteString)] -> a -> NamedRecord

mkIntMap :: (a -> Int) -> [a] -> IntMap a

module Text.Enum.Text