-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Syntax-preserving CSV manipulation
--   
--   
--   svfactor is a library for parsing, manipulating, and printing CSV and
--   similar formats (such as PSV, TSV, and many more).
--   
--   svfactor retains all syntactic information including newlines, and
--   provides lenses, prisms, and traversals to query and manipulate this
--   structure. This should make it useful for writing custom CSV
--   transformations and sanitisation tools. For example, one could easily
--   use it to rewrite all CRLF newlines to LF. It also extends RFC4180 by
--   allowing optional spacing surrounding fields.
--   
--   svfactor's parser is exposed so you can use it independently and
--   printing is similarly standalone.
--   
--   Please note that there are <b>known performance problems with
--   svfactor</b>.
--   
--   Examples:
--   
--   <ul>
--   <li>Handling multiple logical documents in one file:
--   <a>Concat.hs</a></li>
--   <li>Fixing inconsistent formatting with lenses: <a>Requote.hs</a></li>
--   </ul>
@package svfactor
@version 0.1


module Data.Svfactor.Structure.Headedness

-- | Does the <tt>Sv</tt> have a <tt>Header</tt> 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.
data Headedness
Unheaded :: Headedness
Headed :: Headedness

-- | Classy lens for <a>Headedness</a>
class HasHeadedness c
headedness :: HasHeadedness c => Lens' c Headedness
instance GHC.Show.Show Data.Svfactor.Structure.Headedness.Headedness
instance GHC.Classes.Ord Data.Svfactor.Structure.Headedness.Headedness
instance GHC.Classes.Eq Data.Svfactor.Structure.Headedness.Headedness
instance Data.Svfactor.Structure.Headedness.HasHeadedness Data.Svfactor.Structure.Headedness.Headedness


-- | Quote characters can be escaped in CSV documents by using two quote
--   characters instead of one. sv's parser will unescape these sequences
--   as it parses them, so it wraps them in the newtype <a>Unescaped</a>
--   
--   Encoding requires you to provide an <a>Escaper</a>, which is a
--   function to escape strings on the way out.
module Data.Svfactor.Text.Escape

-- | Wrapper for text that is known to be in an unescaped form
newtype Unescaped a
Unescaped :: a -> Unescaped a
[getRawUnescaped] :: Unescaped a -> a

-- | A function that, given a char, escapes all occurrences of that char.
--   
--   This version allows the escaping to be type-changing. For example,
--   escaping a single char can result in a string with two characters.
type Escaper s t = Char -> Unescaped s -> t

-- | A function that, given a char, escapes all occurrences of that char.
type Escaper' a = Char -> Unescaped a -> a

-- | Replaces all occurrences of the given character with two occurrences
--   of that character, non-recursively, in the given <a>String</a>.
--   
--   <pre>
--   &gt;&gt;&gt; escapeString ''' "hello 'string'"
--   "hello ''string''"
--   </pre>
escapeString :: Escaper' String

-- | Replaces all occurrences of the given character with two occurrences
--   of that character in the given <a>Text</a>
--   
--   <pre>
--   {- LANGUAGE OverloadedStrings -}
--   
--   &gt;&gt;&gt; escapeText ''' "hello <tt>text</tt>"
--   "hello '<tt>text'</tt>"
--   </pre>
escapeText :: Escaper' Text

-- | Replaces all occurrences of the given character with two occurrences
--   of that character in the given ByteString, which is assumed to be
--   UTF-8 compatible.
--   
--   <pre>
--   {- LANGUAGE OverloadedStrings -}
--   &gt;&gt;&gt; escapeUtf8 ''' "hello <tt>bytestring</tt>"
--   "hello '<tt>bytestring'</tt>"
--   </pre>
escapeUtf8 :: Escaper' ByteString

-- | Replaces all occurrences of the given character with two occurrences
--   of that character in the given lazy ByteString, which is assumed to be
--   UTF-8 compatible.
--   
--   <pre>
--   {- LANGUAGE OverloadedStrings -}
--   
--   &gt;&gt;&gt; escapeUtf8Lazy ''' "hello 'lazy bytestring'"
--   "hello ''lazy bytestring''"
--   </pre>
escapeUtf8Lazy :: Escaper' ByteString

-- | Escape a character, which must return a string.
--   
--   <pre>
--   &gt;&gt;&gt; escapeChar ''' '''
--   "''"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; escapeChar ''' 'z'
--   "z"
--   </pre>
escapeChar :: Escaper Char String
instance GHC.Generics.Generic (Data.Svfactor.Text.Escape.Unescaped a)
instance Data.Traversable.Traversable Data.Svfactor.Text.Escape.Unescaped
instance Data.Foldable.Foldable Data.Svfactor.Text.Escape.Unescaped
instance GHC.Base.Functor Data.Svfactor.Text.Escape.Unescaped
instance GHC.Base.Monoid a => GHC.Base.Monoid (Data.Svfactor.Text.Escape.Unescaped a)
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Data.Svfactor.Text.Escape.Unescaped a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Svfactor.Text.Escape.Unescaped a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Svfactor.Text.Escape.Unescaped a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Svfactor.Text.Escape.Unescaped a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Data.Svfactor.Text.Escape.Unescaped a)


module Data.Svfactor.Print.Options

-- | Options to configure the printing process
data PrintOptions a
PrintOptions :: a -> Builder -> Escaper' a -> PrintOptions a

-- | How do I convert these values into ByteString <a>Builder</a>s? This
--   depends not only on type, but on character encoding. Default:
--   <a>utf8PrintOptions</a>
[_build] :: PrintOptions a -> a -> Builder

-- | How do I escape quotes which appear in this value? Default:
--   <a>escapeUtf8</a>
[_escape] :: PrintOptions a -> Escaper' a

-- | Classy optics for <a>PrintOptions</a>
class HasPrintOptions c a | c -> a
printOptions :: HasPrintOptions c a => Lens' c (PrintOptions a)
build :: HasPrintOptions c a => Lens' c (a -> Builder)
escape :: HasPrintOptions c a => Lens' c (Escaper' a)

-- | Print options for <tt>Sv</tt>s containing UTF-8 bytestrings
defaultPrintOptions :: PrintOptions ByteString

-- | Print options for <tt>Sv</tt>s containing UTF-8 bytestrings
utf8PrintOptions :: PrintOptions ByteString

-- | Print options for <tt>Sv</tt>s containing UTF-8 lazy bytestrings
utf8LazyPrintOptions :: PrintOptions ByteString

-- | Print options for <tt>Sv</tt>s containing <a>Text</a>
textPrintOptions :: PrintOptions Text

-- | Print options for <tt>Sv</tt>s containing <a>String</a>s
stringPrintOptions :: PrintOptions String
instance Data.Svfactor.Print.Options.HasPrintOptions (Data.Svfactor.Print.Options.PrintOptions a) a


-- | A sum type for line endings
module Data.Svfactor.Text.Newline

-- | <a>Newline</a> is a sum type for line endings
data Newline

-- | <pre>
--   "\r"
--   </pre>
CR :: Newline

-- | <pre>
--   "\n"
--   </pre>
LF :: Newline

-- | <pre>
--   "\rn"
--   </pre>
CRLF :: Newline

-- | <a>AsNewline</a> is a classy prism for <a>Newline</a>
class AsNewline r
_Newline :: AsNewline r => Prism' r Newline
_CR :: AsNewline r => Prism' r ()
_LF :: AsNewline r => Prism' r ()
_CRLF :: AsNewline r => Prism' r ()

-- | Convert a <a>Newline</a> to a <a>String</a>. Since this uses
--   <a>IsString</a>, it works for other data types, like <a>Text</a> or
--   <a>ByteString</a>.
newlineToString :: IsString s => Newline -> s

-- | Try to parse text into a <a>Newline</a>
parseNewline :: Text -> Maybe Newline
instance GHC.Show.Show Data.Svfactor.Text.Newline.Newline
instance GHC.Classes.Ord Data.Svfactor.Text.Newline.Newline
instance GHC.Classes.Eq Data.Svfactor.Text.Newline.Newline
instance Data.Svfactor.Text.Newline.AsNewline Data.Svfactor.Text.Newline.Newline
instance Data.Svfactor.Text.Newline.AsNewline Data.Text.Internal.Text
instance Control.DeepSeq.NFData Data.Svfactor.Text.Newline.Newline


-- | A sum type for quote characters
module Data.Svfactor.Text.Quote

-- | A sum type for quote characters. Either single or double quotes.
data Quote
SingleQuote :: Quote
DoubleQuote :: Quote

-- | Classy prisms for <a>Quote</a>
class AsQuote r
_Quote :: AsQuote r => Prism' r Quote
_SingleQuote :: AsQuote r => Prism' r ()
_DoubleQuote :: AsQuote r => Prism' r ()

-- | Convert a Quote to the Char it represents.
quoteChar :: Prism' Char Quote

-- | Convert a <a>Quote</a> to a <a>String</a>. Since this uses
--   <a>IsString</a>, it works for other data types, like <a>Text</a> or
--   <a>ByteString</a>.
quoteToString :: IsString a => Quote -> a
instance GHC.Show.Show Data.Svfactor.Text.Quote.Quote
instance GHC.Classes.Ord Data.Svfactor.Text.Quote.Quote
instance GHC.Classes.Eq Data.Svfactor.Text.Quote.Quote
instance Data.Svfactor.Text.Quote.AsQuote Data.Svfactor.Text.Quote.Quote
instance Data.Svfactor.Text.Quote.AsQuote GHC.Types.Char
instance Control.DeepSeq.NFData Data.Svfactor.Text.Quote.Quote


-- | A sum type for space characters
module Data.Svfactor.Text.Separator

-- | By what are your values separated? The answer is often <a>comma</a>,
--   but not always.
--   
--   A <a>Separator</a> is just a <a>Char</a>. 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.
type Separator = Char

-- | Classy lens for <a>Separator</a>
class HasSeparator c
separator :: HasSeparator c => Lens' c Separator

-- | The venerable comma separator. Used for CSV documents.
comma :: Separator

-- | The pipe separator. Used for PSV documents.
pipe :: Separator

-- | Tab is a separator too - why not?
tab :: Separator
instance Data.Svfactor.Text.Separator.HasSeparator GHC.Types.Char


-- | A sum type for space characters
module Data.Svfactor.Text.Space

-- | <a>HorizontalSpace</a> is a subset of <a>Char</a>. To move back and
--   forth betwen it and <a>Char</a>, <a>String</a>, or <a>Text</a>, use
--   <a>_HorizontalSpace</a>
data HorizontalSpace
Space :: HorizontalSpace
Tab :: HorizontalSpace

-- | Classy prisms for <a>HorizontalSpace</a>s
class AsHorizontalSpace r
_HorizontalSpace :: AsHorizontalSpace r => Prism' r HorizontalSpace
_Space :: AsHorizontalSpace r => Prism' r ()
_Tab :: AsHorizontalSpace r => Prism' r ()

-- | Helpful alias for lists of <a>Space</a>s
type Spaces = Vector HorizontalSpace

-- | One space
single :: Spaces

-- | As many spaces as you'd like
manySpaces :: Int -> Spaces

-- | One tab
tab :: Spaces

-- | Turn a <a>Space</a> into a <a>Char</a>. To go the other way, see
--   <a>charToSpace</a>
spaceToChar :: HorizontalSpace -> Char

-- | Try to turn a <a>Char</a> into a Space. To go the other way, see
--   <a>spaceToChar</a>
charToSpace :: Char -> Maybe HorizontalSpace

-- | Parse <a>Text</a> into <a>Spaces</a>, or turn spaces into <a>Text</a>
spacesText :: Prism' Text Spaces

-- | Parse <a>String</a> into <a>Spaces</a>, or convert <a>Spaces</a> into
--   <a>String</a>
spacesString :: Prism' String Spaces

-- | <a>Spaced</a> is a value with zero or many horizontal spaces around it
--   on both sides.
data Spaced a
Spaced :: Spaces -> Spaces -> a -> Spaced a
[_before] :: Spaced a -> Spaces
[_after] :: Spaced a -> Spaces
[_value] :: Spaced a -> a

-- | Classy lenses for <a>Spaced</a>
class HasSpaced s t a b | s -> a, t -> b, s b -> t, t a -> s
spaced :: HasSpaced s t a b => Lens s t (Spaced a) (Spaced b)
after :: (HasSpaced s t a b, (s ~ t)) => Lens s t Spaces Spaces
before :: (HasSpaced s t a b, (s ~ t)) => Lens s t Spaces Spaces
spacedValue :: HasSpaced s t a b => Lens s t a b
after :: (HasSpaced s t a b, s ~ t, a ~ b) => Lens s t Spaces Spaces
before :: (HasSpaced s t a b, s ~ t, a ~ b) => Lens s t Spaces Spaces
spacedValue :: (HasSpaced s t a b, s ~ t, a ~ b) => Lens s t a b

-- | <a>betwixt</a> is just the constructor for <a>Spaced</a> with a
--   different argument order, which is sometimes useful.
betwixt :: Spaces -> a -> Spaces -> Spaced a

-- | <a>uniform</a> puts the same spacing both before and after something.
uniform :: Spaces -> a -> Spaced a

-- | Places its argument in a <a>Spaced</a> with no spaces.
unspaced :: a -> Spaced a

-- | Remove spaces from the argument
removeSpaces :: Spaced a -> Spaced a
instance GHC.Generics.Generic (Data.Svfactor.Text.Space.Spaced a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Svfactor.Text.Space.Spaced a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Svfactor.Text.Space.Spaced a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Svfactor.Text.Space.Spaced a)
instance GHC.Show.Show Data.Svfactor.Text.Space.HorizontalSpace
instance GHC.Classes.Ord Data.Svfactor.Text.Space.HorizontalSpace
instance GHC.Classes.Eq Data.Svfactor.Text.Space.HorizontalSpace
instance Data.Svfactor.Text.Space.HasSpaced (Data.Svfactor.Text.Space.Spaced a) (Data.Svfactor.Text.Space.Spaced b) a b
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Data.Svfactor.Text.Space.Spaced a)
instance GHC.Base.Functor Data.Svfactor.Text.Space.Spaced
instance GHC.Base.Applicative Data.Svfactor.Text.Space.Spaced
instance Data.Foldable.Foldable Data.Svfactor.Text.Space.Spaced
instance Data.Traversable.Traversable Data.Svfactor.Text.Space.Spaced
instance Data.Svfactor.Text.Space.AsHorizontalSpace Data.Svfactor.Text.Space.HorizontalSpace
instance Data.Svfactor.Text.Space.AsHorizontalSpace GHC.Types.Char
instance Control.DeepSeq.NFData Data.Svfactor.Text.Space.HorizontalSpace


module Data.Svfactor.Syntax.Field

-- | A <a>Field</a> is a single cell from a CSV document.
--   
--   Its value is either <a>Quoted</a>, which indicates the type of quote
--   surrounding the value, or it is <a>Unquoted</a>, containing only the
--   value.
data Field s
Unquoted :: s -> Field s
Quoted :: Quote -> (Unescaped s) -> Field s

-- | <a>Field</a>s are often surrounded by spaces
type SpacedField a = Spaced (Field a)

-- | <a>Spaced</a> is a value with zero or many horizontal spaces around it
--   on both sides.
data Spaced a
Spaced :: Spaces -> Spaces -> a -> Spaced a

-- | Classy <a>Traversal</a> for things containing <a>Field</a>s
class HasFields c d s t | c -> s, d -> t, c t -> d, d s -> c
fields :: HasFields c d s t => Traversal c d (Field s) (Field t)

-- | Classy prisms for <a>Field</a>
class (HasFields s s a a) => AsField s a | s -> a
_Field :: AsField s a => Prism' s (Field a)
_Unquoted :: AsField s a => Prism' s a
_Quoted :: AsField s a => Prism' s (Quote, Unescaped a)

-- | Build a quoted field with a normal string
unescapedField :: Quote -> s -> Field s

-- | The catamorphism for <tt>Field'</tt>
foldField :: (s -> b) -> (Quote -> Unescaped s -> b) -> Field s -> b

-- | Lens into the contents of a Field, regardless of whether it's quoted
--   or unquoted
fieldContents :: Lens (Field s) (Field t) s t
instance GHC.Generics.Generic (Data.Svfactor.Syntax.Field.Field s)
instance GHC.Show.Show s => GHC.Show.Show (Data.Svfactor.Syntax.Field.Field s)
instance GHC.Classes.Ord s => GHC.Classes.Ord (Data.Svfactor.Syntax.Field.Field s)
instance GHC.Classes.Eq s => GHC.Classes.Eq (Data.Svfactor.Syntax.Field.Field s)
instance Data.Svfactor.Syntax.Field.AsField (Data.Svfactor.Syntax.Field.Field a) a
instance Data.Svfactor.Syntax.Field.HasFields (Data.Svfactor.Syntax.Field.Field s) (Data.Svfactor.Syntax.Field.Field t) s t
instance Control.DeepSeq.NFData s => Control.DeepSeq.NFData (Data.Svfactor.Syntax.Field.Field s)
instance GHC.Base.Functor Data.Svfactor.Syntax.Field.Field
instance Data.Foldable.Foldable Data.Svfactor.Syntax.Field.Field
instance Data.Traversable.Traversable Data.Svfactor.Syntax.Field.Field


module Data.Svfactor.Vector.NonEmpty

-- | A non-empty value of <a>Vector</a>
data NonEmptyVector a
NonEmptyVector :: a -> (Vector a) -> NonEmptyVector a

-- | Convert a <a>NonEmpty</a> list to a <a>NonEmptyVector</a>
fromNel :: NonEmpty a -> NonEmptyVector a

-- | Convert a <a>NonEmptyVector</a> to a <a>NonEmpty</a> list
toNel :: NonEmptyVector a -> NonEmpty a

-- | Convert a <a>NonEmptyVector</a> back to a <a>Vector</a>
toVector :: NonEmptyVector a -> Vector a

-- | Get or set the head of a <a>NonEmptyVector</a>
headNev :: Lens' (NonEmptyVector a) a

-- | Get or set the head of a <a>NonEmptyVector</a>
tailNev :: Lens' (NonEmptyVector a) (Vector a)
instance GHC.Generics.Generic (Data.Svfactor.Vector.NonEmpty.NonEmptyVector a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Svfactor.Vector.NonEmpty.NonEmptyVector a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Svfactor.Vector.NonEmpty.NonEmptyVector a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Svfactor.Vector.NonEmpty.NonEmptyVector a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Data.Svfactor.Vector.NonEmpty.NonEmptyVector a)
instance GHC.Base.Functor Data.Svfactor.Vector.NonEmpty.NonEmptyVector
instance Data.Functor.Bind.Class.Apply Data.Svfactor.Vector.NonEmpty.NonEmptyVector
instance GHC.Base.Applicative Data.Svfactor.Vector.NonEmpty.NonEmptyVector
instance Data.Foldable.Foldable Data.Svfactor.Vector.NonEmpty.NonEmptyVector
instance Data.Semigroup.Foldable.Class.Foldable1 Data.Svfactor.Vector.NonEmpty.NonEmptyVector
instance Data.Traversable.Traversable Data.Svfactor.Vector.NonEmpty.NonEmptyVector
instance Data.Semigroup.Traversable.Class.Traversable1 Data.Svfactor.Vector.NonEmpty.NonEmptyVector
instance GHC.Base.Semigroup (Data.Svfactor.Vector.NonEmpty.NonEmptyVector a)


-- | This module contains datatypes for Records. A record is a "line" or
--   "row" of a CSV document
module Data.Svfactor.Syntax.Record

-- | A <tt>Record</tt> is a non-empty collection of Fields, implicitly
--   separated by a separator (often a comma).
newtype Record s
Record :: NonEmptyVector (Spaced (Field s)) -> Record s
[_fields] :: Record s -> NonEmptyVector (Spaced (Field s))

-- | Classy lenses for <a>Record</a>
class HasRecord s t a b | s -> a, t -> b
record :: HasRecord s t a b => Lens s t (Record a) (Record b)
spacedFields :: HasRecord s t a b => Lens s t (NonEmptyVector (Spaced (Field a))) (NonEmptyVector (Spaced (Field b)))

-- | A <a>Record</a> is isomorphic to a <a>NonEmpty</a> list of
--   <a>SpacedField</a>s
recordSpacedFieldsIso :: Iso (Record s) (Record a) (NonEmptyVector (Spaced (Field s))) (NonEmptyVector (Spaced (Field a)))

-- | Build an empty record.
--   
--   According to RFC 4180, a record must have at least one field. But a
--   field can be the empty string. So this is the closest we can get to an
--   empty record.
--   
--   Note that this does not make <a>Record</a> a <a>Monoid</a>. It is not
--   a lawful unit for the <a>Semigroup</a> operation.
emptyRecord :: Monoid s => Record s

-- | Build a <a>Record</a> with just one <a>Field</a>
singleField :: Field s -> Record s

-- | Build a <a>Record</a> given a <a>NonEmpty</a> list of its fields
recordNel :: NonEmpty (SpacedField s) -> Record s

-- | A collection of records, separated by newlines.
data Records s
EmptyRecords :: Records s
Records :: (Record s) -> (Vector (Newline, Record s)) -> Records s

-- | Classy lenses for <a>Records</a>
class HasRecords c s | c -> s
records :: HasRecords c s => Lens' c (Records s)
traverseRecords :: HasRecords c s => Traversal' c (Record s)
traverseNewlines :: HasRecords c s => Traversal' c Newline

-- | Prism for an empty <a>Records</a>
_EmptyRecords :: Prism' (Records s) ()

-- | Prism for a non-empty <a>Records</a>
_NonEmptyRecords :: Prism (Records s) (Records t) (Record s, Vector (Newline, Record s)) (Record t, Vector (Newline, Record t))

-- | Convenience constructor for <a>Records</a>.
--   
--   This puts the same newline between all the records.
mkRecords :: Newline -> NonEmpty (Record s) -> Records s

-- | A record collection conaining one record
singleRecord :: Record s -> Records s

-- | Collect the list of <a>Record</a>s from anything that
--   <a>HasRecords</a>
recordList :: HasRecords c s => c -> [Record s]
instance GHC.Generics.Generic (Data.Svfactor.Syntax.Record.Records s)
instance GHC.Show.Show s => GHC.Show.Show (Data.Svfactor.Syntax.Record.Records s)
instance GHC.Classes.Ord s => GHC.Classes.Ord (Data.Svfactor.Syntax.Record.Records s)
instance GHC.Classes.Eq s => GHC.Classes.Eq (Data.Svfactor.Syntax.Record.Records s)
instance GHC.Generics.Generic (Data.Svfactor.Syntax.Record.Record s)
instance GHC.Base.Semigroup (Data.Svfactor.Syntax.Record.Record s)
instance GHC.Show.Show s => GHC.Show.Show (Data.Svfactor.Syntax.Record.Record s)
instance GHC.Classes.Ord s => GHC.Classes.Ord (Data.Svfactor.Syntax.Record.Record s)
instance GHC.Classes.Eq s => GHC.Classes.Eq (Data.Svfactor.Syntax.Record.Record s)
instance Data.Svfactor.Syntax.Record.HasRecords (Data.Svfactor.Syntax.Record.Records s) s
instance Control.DeepSeq.NFData s => Control.DeepSeq.NFData (Data.Svfactor.Syntax.Record.Records s)
instance GHC.Base.Functor Data.Svfactor.Syntax.Record.Records
instance Data.Foldable.Foldable Data.Svfactor.Syntax.Record.Records
instance Data.Traversable.Traversable Data.Svfactor.Syntax.Record.Records
instance Data.Svfactor.Syntax.Record.HasRecord (Data.Svfactor.Syntax.Record.Record a) (Data.Svfactor.Syntax.Record.Record b) a b
instance Data.Svfactor.Syntax.Field.HasFields (Data.Svfactor.Syntax.Record.Record a) (Data.Svfactor.Syntax.Record.Record b) a b
instance Control.DeepSeq.NFData s => Control.DeepSeq.NFData (Data.Svfactor.Syntax.Record.Record s)
instance GHC.Base.Functor Data.Svfactor.Syntax.Record.Record
instance Data.Foldable.Foldable Data.Svfactor.Syntax.Record.Record
instance Data.Traversable.Traversable Data.Svfactor.Syntax.Record.Record


-- | 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 <a>Requote.hs</a>
module Data.Svfactor.Syntax.Sv

-- | <a>Sv</a> 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.
data Sv s
Sv :: Separator -> Maybe (Header s) -> Records s -> [Newline] -> Sv s
[_separatorSv] :: Sv s -> Separator
[_maybeHeader] :: Sv s -> Maybe (Header s)
[_records] :: Sv s -> Records s
[_finalNewlines] :: Sv s -> [Newline]

-- | Classy lenses for <a>Sv</a>
class (HasRecords c s, HasSeparator c) => HasSv c s | c -> s
sv :: HasSv c s => Lens' c (Sv s)
maybeHeader :: HasSv c s => Lens' c (Maybe (Header s))
traverseHeader :: HasSv c s => Traversal' c (Header s)
finalNewlines :: HasSv c s => Lens' c [Newline]

-- | Classy lenses for <a>Records</a>
class HasRecords c s | c -> s
records :: HasRecords c s => Lens' c (Records s)
traverseRecords :: HasRecords c s => Traversal' c (Record s)
traverseNewlines :: HasRecords c s => Traversal' c Newline

-- | Convenience constructor for Sv
mkSv :: Separator -> Maybe (Header s) -> [Newline] -> Records s -> Sv s

-- | An empty Sv
emptySv :: Separator -> Sv s

-- | Collect the list of <a>Record</a>s from anything that
--   <a>HasRecords</a>
recordList :: HasRecords c s => c -> [Record s]

-- | A <a>Header</a> is present in many CSV documents, usually listing the
--   names of the columns. We keep this separate from the regular records.
data Header s
Header :: Record s -> Newline -> Header s

-- | Classy lenses for <a>Header</a>
class HasHeader s t a b | s -> a, t -> b, s b -> t, t a -> s
header :: HasHeader s t a b => Lens s t (Header a) (Header b)
headerNewline :: (HasHeader s t a b, (s ~ t)) => Lens s t Newline Newline
headerRecord :: HasHeader s t a b => Lens s t (Record a) (Record b)
headerNewline :: (HasHeader s t a b, (a ~ b)) => Lens s t Newline Newline

-- | Used to build <a>Sv</a>s that don't have a header
noHeader :: Maybe (Header s)

-- | Convenience constructor for <a>Header</a>, usually when you're
--   building <a>Sv</a>s
mkHeader :: Record s -> Newline -> Maybe (Header s)

-- | Does the <tt>Sv</tt> have a <tt>Header</tt> 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.
data Headedness
Unheaded :: Headedness
Headed :: Headedness

-- | Classy lens for <a>Headedness</a>
class HasHeadedness c
headedness :: HasHeadedness c => Lens' c Headedness

-- | Determine the <a>Headedness</a> of an <a>Sv</a>
getHeadedness :: Sv s -> Headedness

-- | By what are your values separated? The answer is often <a>comma</a>,
--   but not always.
--   
--   A <a>Separator</a> is just a <a>Char</a>. 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.
type Separator = Char

-- | Classy lens for <a>Separator</a>
class HasSeparator c
separator :: HasSeparator c => Lens' c Separator

-- | The venerable comma separator. Used for CSV documents.
comma :: Separator

-- | The pipe separator. Used for PSV documents.
pipe :: Separator

-- | Tab is a separator too - why not?
tab :: Separator
instance GHC.Generics.Generic (Data.Svfactor.Syntax.Sv.Sv s)
instance GHC.Show.Show s => GHC.Show.Show (Data.Svfactor.Syntax.Sv.Sv s)
instance GHC.Classes.Ord s => GHC.Classes.Ord (Data.Svfactor.Syntax.Sv.Sv s)
instance GHC.Classes.Eq s => GHC.Classes.Eq (Data.Svfactor.Syntax.Sv.Sv s)
instance GHC.Generics.Generic (Data.Svfactor.Syntax.Sv.Header s)
instance Data.Traversable.Traversable Data.Svfactor.Syntax.Sv.Header
instance Data.Foldable.Foldable Data.Svfactor.Syntax.Sv.Header
instance GHC.Base.Functor Data.Svfactor.Syntax.Sv.Header
instance GHC.Show.Show s => GHC.Show.Show (Data.Svfactor.Syntax.Sv.Header s)
instance GHC.Classes.Ord s => GHC.Classes.Ord (Data.Svfactor.Syntax.Sv.Header s)
instance GHC.Classes.Eq s => GHC.Classes.Eq (Data.Svfactor.Syntax.Sv.Header s)
instance Data.Svfactor.Syntax.Sv.HasHeader (Data.Svfactor.Syntax.Sv.Header a) (Data.Svfactor.Syntax.Sv.Header b) a b
instance Data.Svfactor.Syntax.Record.HasRecord (Data.Svfactor.Syntax.Sv.Header a) (Data.Svfactor.Syntax.Sv.Header b) a b
instance Data.Svfactor.Syntax.Field.HasFields (Data.Svfactor.Syntax.Sv.Header a) (Data.Svfactor.Syntax.Sv.Header b) a b
instance Data.Svfactor.Syntax.Sv.HasSv (Data.Svfactor.Syntax.Sv.Sv s) s
instance Control.DeepSeq.NFData s => Control.DeepSeq.NFData (Data.Svfactor.Syntax.Sv.Sv s)
instance Data.Svfactor.Syntax.Record.HasRecords (Data.Svfactor.Syntax.Sv.Sv s) s
instance GHC.Base.Functor Data.Svfactor.Syntax.Sv.Sv
instance Data.Foldable.Foldable Data.Svfactor.Syntax.Sv.Sv
instance Data.Traversable.Traversable Data.Svfactor.Syntax.Sv.Sv
instance Data.Svfactor.Text.Separator.HasSeparator (Data.Svfactor.Syntax.Sv.Sv s)
instance Control.DeepSeq.NFData s => Control.DeepSeq.NFData (Data.Svfactor.Syntax.Sv.Header s)


-- | Configuration to tell the parser what your file looks like.
module Data.Svfactor.Parse.Options

-- | An <a>ParseOptions</a> informs the parser how to parse your file. The
--   type parameter will be some sort of string; often <a>ByteString</a>.
--   
--   A default is provided as <a>defaultParseOptions</a>, seen below.
data ParseOptions s
ParseOptions :: Separator -> Headedness -> Bool -> String -> s -> ParseOptions s

-- | Which separator does the file use? Usually this is <a>comma</a>, but
--   it can also be <tt>pipe</tt>, or any other <a>Char</a>
--   (<a>Separator</a> = <a>Char</a>)
[_parseSeparator] :: ParseOptions s -> Separator

-- | Whether there is a header row with column names or not.
[_headedness] :: ParseOptions s -> Headedness

-- | If a blank line is encountered, should the parse finish, or treat it
--   as an empty row and continue?
[_endOnBlankLine] :: ParseOptions s -> Bool

-- | How should I turn a String into this type? This is a detail used by
--   the parser.
[_encodeString] :: ParseOptions s -> String -> s

-- | Classy lenses for <a>ParseOptions</a>
class (HasSeparator s, HasHeadedness s) => HasParseOptions s t a b | s -> a, t -> b, s b -> t, t a -> s
parseOptions :: HasParseOptions s t a b => Lens s t (ParseOptions a) (ParseOptions b)
encodeString :: HasParseOptions s t a b => Lens s t (String -> a) (String -> b)
endOnBlankLine :: (HasParseOptions s t a b, s ~ t) => Lens s t Bool Bool
endOnBlankLine :: (HasParseOptions s t a b, s ~ t, a ~ b) => Lens s t Bool Bool

-- | Classy lens for <a>Separator</a>
class HasSeparator c
separator :: HasSeparator c => Lens' c Separator

-- | Classy lens for <a>Headedness</a>
class HasHeadedness c
headedness :: HasHeadedness c => Lens' c Headedness

-- | <a>defaultParseOptions</a> is used to parse a CSV file featuring a
--   header row, using Trifecta as the parsing library. It uses UTF-8
--   <a>ByteString</a>s
defaultParseOptions :: ParseOptions ByteString

-- | The default is that a header is present.
defaultHeadedness :: Headedness

-- | The default separator. Alias for <a>comma</a>.
defaultSeparator :: Separator
instance Data.Svfactor.Parse.Options.HasParseOptions (Data.Svfactor.Parse.Options.ParseOptions a) (Data.Svfactor.Parse.Options.ParseOptions b) a b
instance GHC.Base.Functor Data.Svfactor.Parse.Options.ParseOptions
instance Data.Svfactor.Text.Separator.HasSeparator (Data.Svfactor.Parse.Options.ParseOptions s)
instance Data.Svfactor.Structure.Headedness.HasHeadedness (Data.Svfactor.Parse.Options.ParseOptions s)


module Data.Svfactor.Syntax


-- | This module is considered an implementation detail. As the
--   <a>Internal</a> module name suggests, this module is exempt from the
--   PVP, so depend on it at your own risk! These functions exist to be
--   called by <a>Data.Svfactor.Print</a>.
module Data.Svfactor.Print.Internal

-- | Convert a <a>Newline</a> to a ByteString <a>Builder</a>
printNewline :: Newline -> Builder

-- | Convert a <a>Field</a> to a ByteString <a>Builder</a>
printField :: PrintOptions s -> Field s -> Builder

-- | Convert a <a>SpacedField</a> to a ByteString <a>Builder</a>
printSpaced :: PrintOptions s -> SpacedField s -> Builder

-- | Convert a <a>Record</a> to a ByteString <a>Builder</a>
printRecord :: PrintOptions s -> Separator -> Record s -> Builder

-- | Convert <a>Records</a> to a ByteString <a>Builder</a>.
printRecords :: PrintOptions s -> Separator -> Records s -> Builder

-- | Convert <a>Header</a> to a ByteString <a>Builder</a>.
printHeader :: PrintOptions s -> Separator -> Header s -> Builder


-- | Printing is the process of turning an <a>Sv</a> into a textual
--   representation, such as a <a>ByteString</a>.
--   
--   If you want to turn your data type into a textual representation, you
--   should look instead at <a>Data.Svfactor.Encode</a>
module Data.Svfactor.Print

-- | Print an Sv to a <a>ByteString</a> value.
printSv :: Sv ByteString -> ByteString

-- | Print an Sv to a lazy <a>ByteString</a> value.
printSvLazy :: Sv ByteString -> ByteString

-- | Converts the given <a>Sv</a> into a strict <a>ByteString</a>
printSv' :: PrintOptions s -> Sv s -> ByteString

-- | Converts the given <a>Sv</a> into a lazy <a>ByteString</a>
printSvLazy' :: PrintOptions s -> Sv s -> ByteString

-- | Print an Sv containing <a>Text</a> to a <a>ByteString</a>
printSvText :: Sv Text -> ByteString

-- | Print an Sv containing <a>Text</a> to a <a>ByteString</a>
printSvTextLazy :: Sv Text -> ByteString

-- | Writes an sv to a file. This goes directly from a <a>Builder</a>, so
--   it is more efficient than calling <a>printSv</a> or <a>printSvLazy</a>
--   and writing the result to a file.
writeSvToFile :: FilePath -> Sv ByteString -> IO ()

-- | Writes an sv to a file handle. This goes directly from a
--   <a>Builder</a>, so it is more efficient than calling <a>printSv</a> or
--   <a>printSvLazy</a> and writing the result to the handle.
writeSvToHandle :: Handle -> Sv ByteString -> IO ()

-- | Writes an sv to a file. This goes directly from a <a>Builder</a>, so
--   it is more efficient than calling <a>printSv</a> or <a>printSvLazy</a>
--   and writing the result to a file.
--   
--   This version is polymorphic, but as a penalty you have to tell me how
--   to get a Bytestring <a>Builder</a>.
writeSvToFile' :: PrintOptions s -> FilePath -> Sv s -> IO ()

-- | Writes an sv to a file handle. This goes directly from a
--   <a>Builder</a>, so it is more efficient than calling <a>printSv</a> or
--   <a>printSvLazy</a> and writing the result to the handle.
--   
--   This version is polymorphic, but as a penalty you have to tell me how
--   to get a Bytestring <a>Builder</a>.
writeSvToHandle' :: PrintOptions s -> Handle -> Sv s -> IO ()


-- | This module contains internal implementation details of svfactor's
--   parser. As the Internal name suggests, this file is exempt from the
--   PVP. Depend on this module at your own risk!
module Data.Svfactor.Parse.Internal

-- | Parse an <a>Sv</a>
separatedValues :: CharParsing m => ParseOptions s -> m (Sv s)

-- | Maybe parse the header row of a CSV file, depending on the given
--   <a>Headedness</a>
header :: CharParsing m => ParseOptions s -> m (Maybe (Header s))

-- | Parse a field, be it quoted or unquoted
field :: CharParsing m => Separator -> (String -> s) -> m (Field s)

-- | Parse a field surrounded by single quotes
singleQuotedField :: CharParsing m => (String -> s) -> m (Field s)

-- | Parse a field surrounded by double quotes
doubleQuotedField :: CharParsing m => (String -> s) -> m (Field s)

-- | Parse a field that is not surrounded by quotes
unquotedField :: CharParsing m => Separator -> (String -> s) -> m (Field s)

-- | Combinator to parse some data surrounded by spaces
spaced :: CharParsing m => Separator -> m a -> m (Spaced a)

-- | Parse a field with its surrounding spacing
spacedField :: CharParsing m => Separator -> (String -> s) -> m (Spaced (Field s))

-- | Parse an entire record, or "row"
record :: CharParsing m => ParseOptions s -> m (Record s)

-- | Parse many records, or "rows"
records :: CharParsing m => ParseOptions s -> m (Records s)

-- | Parse zero or many newlines
ending :: CharParsing m => ParseOptions s -> m [Newline]


module Data.Svfactor.Parse

-- | Parse a <a>ByteString</a> as an Sv.
--   
--   This version uses Trifecta, hence it assumes its input is UTF-8
--   encoded.
parseSv :: ParseOptions ByteString -> ByteString -> Either ByteString (Sv ByteString)

-- | Parse some text as an Sv.
--   
--   This version lets you choose which parsing library to use by providing
--   an <a>SvParser</a>. Common selections are <a>trifecta</a> and
--   <a>attoparsecByteString</a>.
parseSv' :: SvParser s -> ParseOptions s -> s -> Either s (Sv s)

-- | Load a file and parse it as an <a>Sv</a>.
--   
--   This version uses Trifecta, hence it assumes its input is UTF-8
--   encoded.
parseSvFromFile :: MonadIO m => ParseOptions ByteString -> FilePath -> m (Either ByteString (Sv ByteString))

-- | Load a file and parse it as an <a>Sv</a>.
--   
--   This version lets you choose which parsing library to use by providing
--   an <a>SvParser</a>. Common selections are <a>trifecta</a> and
--   <a>attoparsecByteString</a>.
parseSvFromFile' :: MonadIO m => SvParser s -> ParseOptions s -> FilePath -> m (Either s (Sv s))

-- | Parse an <a>Sv</a>
separatedValues :: CharParsing m => ParseOptions s -> m (Sv s)

-- | Which parsing library should be used to parse the document?
--   
--   The parser is written in terms of the <tt>parsers</tt> library,
--   meaning it can be instantiated to several different parsing libraries.
--   By default, we use <a>trifecta</a>, because <a>Text.Trifecta</a>s
--   error messages are so helpful. <a>attoparsecByteString</a> is faster
--   though, if your input is ASCII and you care a lot about speed.
--   
--   It is worth noting that Trifecta assumes UTF-8 encoding of the input
--   data. UTF-8 is backwards-compatible with 7-bit ASCII, so this will
--   work for many documents. However, not all documents are ASCII or
--   UTF-8. For example, our <a>species.csv</a> test file is Windows-1252,
--   which is a non-ISO extension of latin1 8-bit ASCII. For documents
--   encoded as Windows-1252, Trifecta's assumption is invalid and parse
--   errors result. <tt>Attoparsec</tt> works fine for this character
--   encoding, but it wouldn't work well on a UTF-8 encoded document
--   including non-ASCII characters.
data SvParser s
SvParser :: ParseOptions s -> s -> Either String (Sv s) -> ParseOptions s -> FilePath -> IO (Either String (Sv s)) -> SvParser s
[runSvParser] :: SvParser s -> ParseOptions s -> s -> Either String (Sv s)
[runSvParserFromFile] :: SvParser s -> ParseOptions s -> FilePath -> IO (Either String (Sv s))

-- | An <a>SvParser</a> that uses <a>Text.Trifecta</a>. Trifecta assumes
--   its input is UTF-8, and provides helpful clang-style error messages.
trifecta :: SvParser ByteString

-- | Helper to convert <a>Text.Trifecta</a> <a>Result</a> to <a>Either</a>.
trifectaResultToEither :: Result a -> Either String a

-- | An <a>SvParser</a> that uses <a>Data.Attoparsec.ByteString</a>. This
--   is the fastest provided <a>SvParser</a>, but it has poorer error
--   messages.
attoparsecByteString :: SvParser ByteString

-- | An <a>SvParser</a> that uses <a>Data.Attoparsec.Text</a>. This is
--   helpful if your input is in the form of <a>Text</a>.
attoparsecText :: SvParser Text


module Data.Svfactor