Data.Svfactor.Syntax.Sv

This file defines a datatype for a complete Sv document. The datatype preserves information such as whitespace so that the original text can be recovered.

You can program against it using the provided functions and optics. For an example of this see Requote.hs

Documentation

data Sv s

Sv is a whitespace-preserving data type for separated values. Often the separator is a comma, but this type does not make that assumption so that it can be used for pipe- or tab-separated values as well.

Constructors

Sv

Fields

• _separatorSv :: Separator
• _maybeHeader :: Maybe (Header s)
• _records :: Records s
• _finalNewlines :: [Newline]

Instances

Functor Sv

Defined in Data.Svfactor.Syntax.Sv

Methods

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

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

Foldable Sv

Defined in Data.Svfactor.Syntax.Sv

Methods

fold :: Monoid m => Sv m -> m

foldMap :: Monoid m => (a -> m) -> Sv a -> m

foldr :: (a -> b -> b) -> b -> Sv a -> b

foldr' :: (a -> b -> b) -> b -> Sv a -> b

foldl :: (b -> a -> b) -> b -> Sv a -> b

foldl' :: (b -> a -> b) -> b -> Sv a -> b

foldr1 :: (a -> a -> a) -> Sv a -> a

foldl1 :: (a -> a -> a) -> Sv a -> a

toList :: Sv a -> [a]

null :: Sv a -> Bool

length :: Sv a -> Int

elem :: Eq a => a -> Sv a -> Bool

maximum :: Ord a => Sv a -> a

minimum :: Ord a => Sv a -> a

sum :: Num a => Sv a -> a

product :: Num a => Sv a -> a

Traversable Sv

Defined in Data.Svfactor.Syntax.Sv

Methods

traverse :: Applicative f => (a -> f b) -> Sv a -> f (Sv b)

sequenceA :: Applicative f => Sv (f a) -> f (Sv a)

mapM :: Monad m => (a -> m b) -> Sv a -> m (Sv b)

sequence :: Monad m => Sv (m a) -> m (Sv a)

Eq s => Eq (Sv s)

Defined in Data.Svfactor.Syntax.Sv

Methods

(==) :: Sv s -> Sv s -> Bool

(/=) :: Sv s -> Sv s -> Bool

Ord s => Ord (Sv s)

Defined in Data.Svfactor.Syntax.Sv

Methods

compare :: Sv s -> Sv s -> Ordering

(<) :: Sv s -> Sv s -> Bool

(<=) :: Sv s -> Sv s -> Bool

(>) :: Sv s -> Sv s -> Bool

(>=) :: Sv s -> Sv s -> Bool

max :: Sv s -> Sv s -> Sv s

min :: Sv s -> Sv s -> Sv s

Show s => Show (Sv s)

Defined in Data.Svfactor.Syntax.Sv

Methods

showsPrec :: Int -> Sv s -> ShowS

show :: Sv s -> String

showList :: [Sv s] -> ShowS

Generic (Sv s)

Defined in Data.Svfactor.Syntax.Sv

Associated Types

type Rep (Sv s) :: * -> *

Methods

from :: Sv s -> Rep (Sv s) x

to :: Rep (Sv s) x -> Sv s

NFData s => NFData (Sv s)

Defined in Data.Svfactor.Syntax.Sv

Methods

rnf :: Sv s -> ()

HasSeparator (Sv s)

Defined in Data.Svfactor.Syntax.Sv

Methods

separator :: Lens' (Sv s) Separator

HasRecords (Sv s) s

Defined in Data.Svfactor.Syntax.Sv

Methods

records :: Lens' (Sv s) (Records s)

traverseRecords :: Traversal' (Sv s) (Record s)

traverseNewlines :: Traversal' (Sv s) Newline

HasSv (Sv s) s

Defined in Data.Svfactor.Syntax.Sv

Methods

sv :: Lens' (Sv s) (Sv s)

maybeHeader :: Lens' (Sv s) (Maybe (Header s))

traverseHeader :: Traversal' (Sv s) (Header s)

finalNewlines :: Lens' (Sv s) [Newline]

type Rep (Sv s)

Defined in Data.Svfactor.Syntax.Sv

type Rep (Sv s) = D1 (MetaData "Sv" "Data.Svfactor.Syntax.Sv" "svfactor-0.1-GDLTyJD8FfREVKdyivwTvx" False) (C1 (MetaCons "Sv" PrefixI True) ((S1 (MetaSel (Just "_separatorSv") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Separator) :*: S1 (MetaSel (Just "_maybeHeader") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Header s)))) :*: (S1 (MetaSel (Just "_records") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Records s)) :*: S1 (MetaSel (Just "_finalNewlines") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Newline]))))

class (HasRecords c s, HasSeparator c) => HasSv c s | c -> s where

Classy lenses for Sv

Minimal complete definition

sv

Methods

sv :: Lens' c (Sv s)

maybeHeader :: Lens' c (Maybe (Header s))

traverseHeader :: Traversal' c (Header s)

finalNewlines :: Lens' c [Newline]

Instances

HasSv (Sv s) s

Defined in Data.Svfactor.Syntax.Sv

Methods

sv :: Lens' (Sv s) (Sv s)

maybeHeader :: Lens' (Sv s) (Maybe (Header s))

traverseHeader :: Traversal' (Sv s) (Header s)

finalNewlines :: Lens' (Sv s) [Newline]

class HasRecords c s | c -> s where

Classy lenses for Records

Minimal complete definition

records

Methods

records :: Lens' c (Records s)

traverseRecords :: Traversal' c (Record s)

traverseNewlines :: Traversal' c Newline

Instances

HasRecords (Records s) s

Defined in Data.Svfactor.Syntax.Record

Methods

records :: Lens' (Records s) (Records s)

traverseRecords :: Traversal' (Records s) (Record s)

traverseNewlines :: Traversal' (Records s) Newline

HasRecords (Sv s) s

Defined in Data.Svfactor.Syntax.Sv

Methods

records :: Lens' (Sv s) (Records s)

traverseRecords :: Traversal' (Sv s) (Record s)

traverseNewlines :: Traversal' (Sv s) Newline

mkSv :: Separator -> Maybe (Header s) -> [Newline] -> Records s -> Sv s

Convenience constructor for Sv

emptySv :: Separator -> Sv s

An empty Sv

recordList :: HasRecords c s => c -> [Record s]

Collect the list of Records from anything that HasRecords

data Header s

A Header is present in many CSV documents, usually listing the names of the columns. We keep this separate from the regular records.

Constructors

Header (Record s) Newline

Instances

Functor Header

Defined in Data.Svfactor.Syntax.Sv

Methods

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

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

Foldable Header

Defined in Data.Svfactor.Syntax.Sv

Methods

fold :: Monoid m => Header m -> m

foldMap :: Monoid m => (a -> m) -> Header a -> m

foldr :: (a -> b -> b) -> b -> Header a -> b

foldr' :: (a -> b -> b) -> b -> Header a -> b

foldl :: (b -> a -> b) -> b -> Header a -> b

foldl' :: (b -> a -> b) -> b -> Header a -> b

foldr1 :: (a -> a -> a) -> Header a -> a

foldl1 :: (a -> a -> a) -> Header a -> a

toList :: Header a -> [a]

null :: Header a -> Bool

length :: Header a -> Int

elem :: Eq a => a -> Header a -> Bool

maximum :: Ord a => Header a -> a

minimum :: Ord a => Header a -> a

sum :: Num a => Header a -> a

product :: Num a => Header a -> a

Traversable Header

Defined in Data.Svfactor.Syntax.Sv

Methods

traverse :: Applicative f => (a -> f b) -> Header a -> f (Header b)

sequenceA :: Applicative f => Header (f a) -> f (Header a)

mapM :: Monad m => (a -> m b) -> Header a -> m (Header b)

sequence :: Monad m => Header (m a) -> m (Header a)

Eq s => Eq (Header s)

Defined in Data.Svfactor.Syntax.Sv

Methods

(==) :: Header s -> Header s -> Bool

(/=) :: Header s -> Header s -> Bool

Ord s => Ord (Header s)

Defined in Data.Svfactor.Syntax.Sv

Methods

compare :: Header s -> Header s -> Ordering

(<) :: Header s -> Header s -> Bool

(<=) :: Header s -> Header s -> Bool

(>) :: Header s -> Header s -> Bool

(>=) :: Header s -> Header s -> Bool

max :: Header s -> Header s -> Header s

min :: Header s -> Header s -> Header s

Show s => Show (Header s)

Defined in Data.Svfactor.Syntax.Sv

Methods

showsPrec :: Int -> Header s -> ShowS

show :: Header s -> String

showList :: [Header s] -> ShowS

Generic (Header s)

Defined in Data.Svfactor.Syntax.Sv

Associated Types

type Rep (Header s) :: * -> *

Methods

from :: Header s -> Rep (Header s) x

to :: Rep (Header s) x -> Header s

NFData s => NFData (Header s)

Defined in Data.Svfactor.Syntax.Sv

Methods

rnf :: Header s -> ()

HasFields (Header a) (Header b) a b

Defined in Data.Svfactor.Syntax.Sv

Methods

fields :: Traversal (Header a) (Header b) (Field a) (Field b)

HasRecord (Header a) (Header b) a b

Defined in Data.Svfactor.Syntax.Sv

Methods

record :: Lens (Header a) (Header b) (Record a) (Record b)

spacedFields :: Lens (Header a) (Header b) (NonEmptyVector (Spaced (Field a))) (NonEmptyVector (Spaced (Field b)))

HasHeader (Header a) (Header b) a b

Defined in Data.Svfactor.Syntax.Sv

Methods

header :: Lens (Header a) (Header b) (Header a) (Header b)

headerNewline :: Lens (Header a) (Header b) Newline Newline

headerRecord :: Lens (Header a) (Header b) (Record a) (Record b)

type Rep (Header s)

Defined in Data.Svfactor.Syntax.Sv

type Rep (Header s) = D1 (MetaData "Header" "Data.Svfactor.Syntax.Sv" "svfactor-0.1-GDLTyJD8FfREVKdyivwTvx" False) (C1 (MetaCons "Header" PrefixI True) (S1 (MetaSel (Just "_headerRecord") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Record s)) :*: S1 (MetaSel (Just "_headerNewline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Newline)))

class HasHeader s t a b | s -> a, t -> b, s b -> t, t a -> s where

Classy lenses for Header

Minimal complete definition

header

Methods

header :: Lens s t (Header a) (Header b)

headerNewline :: s ~ t => Lens s t Newline Newline

headerRecord :: Lens s t (Record a) (Record b)

headerNewline :: a ~ b => Lens s t Newline Newline

Instances

HasHeader (Header a) (Header b) a b

Defined in Data.Svfactor.Syntax.Sv

Methods

header :: Lens (Header a) (Header b) (Header a) (Header b)

headerNewline :: Lens (Header a) (Header b) Newline Newline

headerRecord :: Lens (Header a) (Header b) (Record a) (Record b)

noHeader :: Maybe (Header s)

Used to build Svs that don't have a header

mkHeader :: Record s -> Newline -> Maybe (Header s)

Convenience constructor for Header, usually when you're building Svs

data Headedness

Does the Sv have a Header or not? A header is a row at the beginning of a file which contains the string names of each of the columns.

If a header is present, it must not be decoded with the rest of the data.

Constructors

Unheaded

Headed

Instances

Eq Headedness

Defined in Data.Svfactor.Structure.Headedness

Methods

(==) :: Headedness -> Headedness -> Bool

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

Ord Headedness

Defined in Data.Svfactor.Structure.Headedness

Methods

compare :: Headedness -> Headedness -> Ordering

(<) :: Headedness -> Headedness -> Bool

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

(>) :: Headedness -> Headedness -> Bool

(>=) :: Headedness -> Headedness -> Bool

max :: Headedness -> Headedness -> Headedness

min :: Headedness -> Headedness -> Headedness

Show Headedness

Defined in Data.Svfactor.Structure.Headedness

Methods

showsPrec :: Int -> Headedness -> ShowS

show :: Headedness -> String

showList :: [Headedness] -> ShowS

HasHeadedness Headedness

Defined in Data.Svfactor.Structure.Headedness

Methods

headedness :: Lens' Headedness Headedness

class HasHeadedness c where

Classy lens for Headedness

Minimal complete definition

headedness

Methods

headedness :: Lens' c Headedness

Instances

HasHeadedness Headedness

Defined in Data.Svfactor.Structure.Headedness

Methods

headedness :: Lens' Headedness Headedness

HasHeadedness (ParseOptions s)

Defined in Data.Svfactor.Parse.Options

Methods

headedness :: Lens' (ParseOptions s) Headedness

getHeadedness :: Sv s -> Headedness

Determine the Headedness of an Sv

type Separator = Char

By what are your values separated? The answer is often comma, but not always.

A Separator is just a Char. It could be a sum type instead, since it will usually be comma or pipe, but our preference has been to be open here so that you can use whatever you'd like. There are test cases, for example, ensuring that you're free to use null-byte separated values if you so desire.

class HasSeparator c where

Classy lens for Separator

Minimal complete definition

separator

Methods

separator :: Lens' c Separator

Instances

HasSeparator Char

Defined in Data.Svfactor.Text.Separator

Methods

separator :: Lens' Char Separator

HasSeparator (Sv s)

Defined in Data.Svfactor.Syntax.Sv

Methods

separator :: Lens' (Sv s) Separator

HasSeparator (ParseOptions s)

Defined in Data.Svfactor.Parse.Options

Methods

separator :: Lens' (ParseOptions s) Separator

comma :: Separator

The venerable comma separator. Used for CSV documents.

pipe :: Separator

The pipe separator. Used for PSV documents.

tab :: Separator

Tab is a separator too - why not?