Data.Sv.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.

In the usual workflow, this type is only an intermediate stage between parsing and decoding. You can program against it directly using the provided functions and optics if you'd like. 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

Methods

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

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

Foldable 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

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)

Methods

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

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

Ord s => Ord (Sv s)

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)

Methods

showsPrec :: Int -> Sv s -> ShowS

show :: Sv s -> String

showList :: [Sv s] -> ShowS

Generic (Sv s)

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)

Methods

rnf :: Sv s -> ()

HasSeparator (Sv s)

Methods

separator :: Lens' (Sv s) Separator

HasRecords (Sv s) s

Methods

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

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

traverseNewlines :: Traversal' (Sv s) Newline

HasSv (Sv s) s

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)

type Rep (Sv s) = D1 * (MetaData "Sv" "Data.Sv.Syntax.Sv" "sv-0.1-LEjGD2ajzYS6ZNIUObPicZ" False) (C1 * (MetaCons "Sv" PrefixI True) ((:*:) * ((:*:) * (S1 * (MetaSel (Just Symbol "_separatorSv") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Separator)) (S1 * (MetaSel (Just Symbol "_maybeHeader") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe (Header s))))) ((:*:) * (S1 * (MetaSel (Just Symbol "_records") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Records s))) (S1 * (MetaSel (Just Symbol "_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

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

Methods

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

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

traverseNewlines :: Traversal' (Records s) Newline

HasRecords (Sv s) s

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

Methods

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

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

Foldable Header

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

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)

Methods

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

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

Ord s => Ord (Header s)

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)

Methods

showsPrec :: Int -> Header s -> ShowS

show :: Header s -> String

showList :: [Header s] -> ShowS

Generic (Header s)

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)

Methods

rnf :: Header s -> ()

HasFields (Header a) (Header b) a b

Methods

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

HasRecord (Header a) (Header b) a b

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

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)

type Rep (Header s) = D1 * (MetaData "Header" "Data.Sv.Syntax.Sv" "sv-0.1-LEjGD2ajzYS6ZNIUObPicZ" False) (C1 * (MetaCons "Header" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "_headerRecord") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Record s))) (S1 * (MetaSel (Just Symbol "_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

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

Methods

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

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

Ord 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

Methods

showsPrec :: Int -> Headedness -> ShowS

show :: Headedness -> String

showList :: [Headedness] -> ShowS

HasHeadedness 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

Methods

headedness :: Lens' Headedness Headedness

HasHeadedness (ParseOptions s)

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

Methods

separator :: Lens' Char Separator

HasSeparator EncodeOptions

Methods

separator :: Lens' EncodeOptions Separator

HasSeparator (Sv s)

Methods

separator :: Lens' (Sv s) Separator

HasSeparator (ParseOptions s)

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?