!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh i j k l m n o p q r s t u v w x y z { | } ~                                   ! " # $%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone6A non-empty value of  Convert a  list to a  Convert a  to a  listGet or set the head of a Get or set the head of a (C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone3456K4&DA function that, given a char, escapes all occurrences of that char.'DA 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.(9Wrapper for text that is known to be in an unescaped form+wReplaces all occurrences of the given character with two occurrences of that character, non-recursively, in the given .!escapeString ''' "hello 'string'""hello ''string''",eReplaces all occurrences of the given character with two occurrences of that character in the given  <{- LANGUAGE OverloadedStrings -} >>> escapeText ''' "hello text " "hello '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. ;{- LANGUAGE OverloadedStrings -} >>> escapeUtf8 ''' "hello  bytestring " "hello ' 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. o{- LANGUAGE OverloadedStrings -} >>> escapeUtf8Lazy ''' "hello 'lazy bytestring'" "hello ''lazy bytestring''" //Escape a character, which must return a string.escapeChar ''' '''"''"escapeChar ''' 'z'"z" &'()*+,-./ ()*'&+,-./()*(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone;=>?A> :Classy optics for >>)Options to configure the printing process@.How do I convert these values into ByteString Gs? This depends not only on type, but on character encoding. Default: CA<How do I escape quotes which appear in this value? Default: -BPrint options for Svs containing UTF-8 bytestringsCPrint options for Svs containing UTF-8 bytestringsDPrint options for Sv#s containing UTF-8 lazy bytestringsEPrint options for Sv s containing FPrint options for Sv s containing s :<;=>?@ABCDEF >?@A:;<=BCDEF:;<=>?@A(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableSafeCHH is a classy prism for MMM is a sum type for line endingsN "\r"O "\n"P "\rn"Q Convert a M to a . Since this uses ', it works for other data types, like  or .RTry to parse text into a M HIJKLMNOPQR MNOPHIJKLQRHIJKLMNOP(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableSafe;=>?FTIYClassy prisms for ]]@A sum type for quote characters. Either single or double quotes.`*Convert a Quote to the Char it represents.a Convert a ] to a . Since this uses ', it works for other data types, like  or . YZ[\]^_`a ]^_YZ[\`aYZ[\]^_ (C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone 67;=>?AFTYhClassy lenses for mmmI is a value with zero or many horizontal spaces around it on both sides.rHelpful alias for lists of xssClassy prisms for wsww is a subset of (. To move back and forth betwen it and , , or , use tz One space{As many spaces as you'd like|One tab}Turn a x into a . To go the other way, see ~~Try to turn a ( into a Space. To go the other way, see }Parse  into r, or turn spaces into Parse  into r , or convert r into  is just the constructor for m= with a different argument order, which is sometimes useful.Places its argument in a m with no spaces.7 puts the same spacing both before and after something.Remove spaces from the argument?Appends the right parameter on the inside of the left parameter SSpaced " " () " " *> Spaced "\t\t\t" () "\t \t" == Spaced " \t\t\t" () "\t \t "hilkjmnopqrstuvwxyz{|}~ wxystuvrz{|}~mnopqhijkljklhijkljklmnopqstuvwxy (C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone 6;=>?AFTcClassy  Traversal' for things containing sClassy prisms for  s are often surrounded by spacesA & is a single cell from a CSV document.Its value is either E, which indicates the type of quote surrounding the value, or it is , containing only the value.)Build a quoted field with a normal stringThe catamorphism for Field'PLens into the contents of a Field, regardless of whether it's quoted or unquotedmnmn (C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone6;=>?AKNr Classy lenses for /A collection of records, separated by newlines.Classy lenses for A Record[ is a non-empty collection of Fields, implicitly separated by a separator (often a comma).A  is isomorphic to a  list of sBuild 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 #. It is not a lawful unit for the   operation.Build a  with just one Build a  given a  list of its fieldsPrism for an empty Prism for a non-empty Convenience constructor for .3This puts the same newline between all the records.(A record collection conaining one recordCollect the list of s from anything that  (C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone34567;=>?AFTVClassy lens for 7By what are your values separated? The answer is often , but not always.A  is just 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.Classy lens for  Does the  have a n or not? A header is a row at the beginning of a file which contains the string names of each of the columns.IIf a header is present, it must not be decoded with the rest of the data.Classy lenses for A } is present in many CSV documents, usually listing the names of the columns. We keep this separate from the regular records.Classy lenses for  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.Convenience constructor for Sv An empty SvDetermine the  of an Used to build s that don't have a headerConvenience constructor for , usually when you're building s6The venerable comma separator. Used for CSV documents.+The pipe separator. Used for PSV documents.!Tab is a separator too - why not?'(  (C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone 7;=>?AFT7 Classy lenses for An c informs the parser how to parse your file. The type parameter will be some sort of string; often .A default is provided as  , seen below.3Which separator does the file use? Usually this is , but it can also be pipe, or any other  ( = )7Whether there is a header row with column names or not.cIf a blank line is encountered, should the parse finish, or treat it as an empty row and continue?OHow should I turn a String into this type? This is a detail used by the parser.k is used to parse a CSV file featuring a header row, using Trifecta as the parsing library. It uses UTF-8  s!The default separator. Alias for .(The default is that a header is present.(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNoneGmn(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone6KN$$ is the error-accumulating   underlying 3%% is a   full of '%. It is used as the error side of a $6. When multiple errors occur, they will be collected.'' is a value indicating what went wrong during a parse or decode. Its constructor indictates the type of error which occured, and there is usually an associated string with more finely-grained details.(?I was looking for another field, but I am at the end of the row);I should be at the end of the row, but I found extra fields*!This decoder was built using the  categorical primitive for categorical data+<The parser failed, meaning decoding proper didn't even begin,+Some other kind of decoding failure occured-)Newtype for indices into the field vector/0As we decode a row of data, we walk through its s. This   keeps track of our remaining s.22 is 3y with the input and error types the same. You usually want them to be the same, and most primitives are set up this way.3JA 'Decode e s a' is for decoding some fields from a CSV row into our type a.The second type parameter (s%) is the input string type (usually  ByteString or Text). The first type parameter (e) is the type of strings which occur in errors. Under most circumstances you want these type paraters to coincide, but they don't have to. They are two separate type parameters instead of one so that 3 can have a  instance.There are primitive 3Qs, and combinators for composing or otherwise manipulating them. In particular, 3 is an   functor and an   from the semigroupoids package.3 is not a  7, but we can perform monad-like operations on it with  and 6Convenient constructor for 3, that handles all the newtype noise for you.7(Convenient function to run a DecodeState$%&'()*+,-./0123456734526/017-.'()*+,%&$%&'()*+,-./01345(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNonen RBuild a failing $S Fail with (T Fail with )K. This takes the rest of the row, so that it can be displayed to the user.U Fail with *F. It takes the unknown value and the list of good categorical values.%This mostly exists to be used by the  function.V Fail with +b with the given message. This is for when the parse step fails, and decoding does not even begin.W Fail with ,d with the given message. This is something of a generic error for when decoding a field goes wrong.XBuild a $ from an YBuild a $ from an &, given a function to build the error.ZBuild a $ from a -. You have to supply an error to use in the  case[Build a $ from a function that returns a , You have to supply an error to use in the  case\Helper to convert  Text.Trifecta  ! to .] Convert a  Text.Trifecta  ! to a $%&'()*+,RSTUVWXYZ[\]'()*+,%&RSTUVWXYZ[\](C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone^ Convert a M to a ByteString _ Convert a  to a ByteString ` Convert a  to a ByteString a Convert a  to a ByteString bConvert  to a ByteString .cConvert  to a ByteString .^_`abc^_`abc(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone}  Converts an  to a ByteString @. Useful if you want to concatenate other text before or after.d9Writes an sv to a file handle. This goes directly from a (, so it is more efficient than calling h or i' and writing the result to the handle.e2Writes an sv to a file. This goes directly from a (, so it is more efficient than calling h or i# and writing the result to a file.f9Writes an sv to a file handle. This goes directly from a (, so it is more efficient than calling h or i' 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 .g2Writes an sv to a file. This goes directly from a (, so it is more efficient than calling h or i# 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 .hPrint an Sv to a   value.iPrint an Sv to a lazy " value.jConverts the given  into a strict  kConverts the given  into a lazy "lPrint an Sv containing  to a  mPrint an Sv containing  to a ":<;=>?@ABCDEFdefghijklm hijklmedgf(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone This function is in newer versions of the parsers package, but in order to maintain compatibility with older versions I've left it here.n)Parse a field surrounded by single quoteso)Parse a field surrounded by double quotesBGiven a quote, parse its escaped form (which is it repeated twice)p.Parse a field that is not surrounded by quotesq'Parse a field, be it quoted or unquotedr*Parse a field with its surrounding spacings2Combinator to parse some data surrounded by spacest Parse an entire record, or "row"uParse many records, or "rows"vParse zero or many newlineswAMaybe parse the header row of a CSV file, depending on the given x Parse an  nopqrstuvwx xwqnopsrtuv(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone y;Which parsing library should be used to parse the document?&The parser is written in terms of the parsersf library, meaning it can be instantiated to several different parsing libraries. By default, we use  , because  Text.Trifecta"s error messages are so helpful. J 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  ?https://github.com/qfpl/sv/blob/master/examples/csv/species.csv species.csv 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.  Attoparsec works fine for this character encoding, but it wouldn't work well on a UTF-8 encoded document including non-ASCII characters.}Parse a   as an Sv.HThis version uses Trifecta, hence it assumes its input is UTF-8 encoded.~Parse some text as an Sv.KThis version lets you choose which parsing library to use by providing an y. Common selections are  and .Load a file and parse it as an .HThis version uses Trifecta, hence it assumes its input is UTF-8 encoded.Load a file and parse it as an .KThis version lets you choose which parsing library to use by providing an y. Common selections are  and .An y that uses  Text.TrifectaX. Trifecta assumes its input is UTF-8, and provides helpful clang-style error messages.An y that uses Data.Attoparsec.ByteString . This is the fastest provided y#, but it has poorer error messages.An y that uses Data.Attoparsec.Text3. This is helpful if your input is in the form of .xyz{|}~ }~xyz{|yz{|(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNone Classy lenses for  Wimport Control.Lens defaultEncodeOptinons & quote .~ Just DoubleQuote & newline .~ LF CThese are options to configure encoding. A default is provided as .LAre your values separated by commas, tabs, or something else? Default: commaTBetween a comma and the next value, would you like some spacing? Default: no spacingTBetween a value and the next comma, would you like some spacing? Default: no spacing`Would you like quotes around your values? If so, double quotes or single? Deafult: Double quotes2What kind of newline would you like? Default: CRLF9Should the file be terminated with a newline? Default: No!The default options for encoding.pThe default is a CSV file with double-quotes, CRLF lines, no spacing around fields, and no terminating newline.(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNoneK rAn R converts its argument into one or more textual fields, to be written out as CSV.It is  , Contravariant', , and  <, allowing for composition of these values to build bigger s from smaller ones.(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNoneV[s+Make an ! from a function that builds one .Make an ! from a function that builds one .;Make an encode from any function that returns a ByteString Builder.%Encode the given list with the given , configured by the given .,Encode, writing the output to a file handle.MEncode, writing to a file. This is way is more efficient than encoding to a  ByteString and then writing to file.Encode to a ByteString BuilderE, which is useful if you are going to combine the output with other  ByteStrings.Encode one row only%Encode one row only, as a ByteString Builder Build an  rather than going straight to  ByteString8. This allows you to query the Sv or run sanity checks. Encode this  every time, ignoring the input. Build an  using a type's  instance.Don't encode anything.$Encode anything as the empty string.$Lift an Encode to be able to hanlde ,, by using the empty string in the case of  Build an  for  given a  and a  encode. Build an  for  given a  and a  encode. Build an  for  given a  encode and a # for the  case. Build an  for  given a # for the  case and a  encode.5Encode a list as a whole row at once, using the same  for every elementEncode a single  Encode an  Encode an  Encode a  Encode a  Encode a  Encode a Encode a strict Encode a lazy " Encode a  as False or True Encode a  as false or true Encode a  as no or yes Encode a  as No or Yes Encode a  as N or Y Encode a  as 0 or 1Given an optic from s to a#, Try to use it to build an encode. 2encodeOf :: Iso' s a -> Encode a -> Encode s encodeOf :: Lens' s a -> Encode a -> Encode s encodeOf :: Prism' s a -> Encode a -> Encode s encodeOf :: Traversal' s a -> Encode a -> Encode s encodeOf :: Fold s a -> Encode a -> Encode s encodeOf :: Getter s a -> Encode a -> Encode s `This is very useful when you have a prism for each constructor of your type. You can define an  as follows: myEitherEncode :: Encode a -> Encode b -> Encode (Either a b) myEitherEncode encA encB = encodeOf _Left encA <> encodeOf _Right encB /In this example, when the prism lookup returns ., the empty encoder is returned. This is the  for the } monoid, so it won't add a field to the resulting CSV. This is the behaviour you want for combining a collection of prisms.But this encoder also works with lenses (or weaker optics), which will never fail their lookup, in which case it never returns H. So this actually does the right thing for both sum and product types.Like , but you can handle  however you'd like. In Y, it is handled by the Encode which does nothing, but for example you might like to use  to encode an empty field. Encode a z really quickly. If the string has quotes in it, they will not be escaped properly, so the result maybe not be valid CSVEncode x really quickly. If the text has quotes in it, they will not be escaped properly, so the result maybe not be valid CSVEncode ByteString $% really quickly. If the builder builds a string with quotes in it, they will not be escaped properly, so the result maybe not be valid CSV Encode a z really quickly. If the string has quotes in it, they will not be escaped properly, so the result maybe not be valid CSV Encode a "z really quickly. If the string has quotes in it, they will not be escaped properly, so the result maybe not be valid CSV Encode this  really quickly every time, ignoring the input. If the string has quotes in it, they will not be escaped properly, so the result maybe not be valid CSV@.(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNoneQV9:Decodes a sv into a list of its values using the provided 3Parse a  5 as an Sv, and then decode it with the given decoder.This version uses  & to parse the  N, which is assumed to be UTF-8 encoded. If you want a different library, use .?Parse text as an Sv, and then decode it with the given decoder.KThis version lets you choose which parsing library to use by providing an y. Common selections are  and .%Load a file, parse it, and decode it.TThis version uses Trifecta to parse the file, which is assumed to be UTF-8 encoded.%Load a file, parse it, and decode it.KThis version lets you choose which parsing library to use by providing an y. Common selections are  and .Build a 3 , given a function that returns ./Return the given error if the function returns .Build a 3 , given a function that returns .Build a 3 , given a function that returns %, and a function to build the error.RSucceeds with the whole field structure, including spacing and quoting informationLReturns the field contents. This keeps the spacing around an unquoted field.IGet the contents of a field without doing any decoding. This never fails.Grab the whole row as a IGrab the whole row, including all spacing and quoting information, as a `Get a field that's a single char. This will fail if there are mulitple characters in the field.,Get the contents of a field as a bytestring. Alias for -Get the contents of a UTF-8 encoded field as AThis will also work for ASCII text, as ASCII is a subset of UTF-8&Get the contents of a field as a lazy '&Get the contents of a field as a lazy "!Get the contents of a field as a PThrow away the contents of a field. This is useful for skipping unneeded fields.?Throw away the contents of a field, and return the given value..Decode exactly the given string, or else fail.Decode a UTF-8   field as an Decode a UTF-8   field as an Decode a UTF-8   field as a Decode a UTF-8   field as a Decode a field as a AThis aims to be tolerant to different forms a boolean might take.Decode a field as a U. This version lets you provide the fromString function that's right for you, since  on a  Q will do the wrong thing in the case of many encodings such as UTF-16 or UTF-32.AThis aims to be tolerant to different forms a boolean might take.6Succeed only when the given field is the empty string.JThe empty string surrounded in quotes or spaces is still the empty string.Choose the leftmost 3 that succeeds. Alias for Choose the leftmost 3 that succeeds. Alias for Try the given 3$. If it fails, instead succeed with ./If the field is the empty string, succeed with . Otherwise try the given 3.Try the given 32. If it fails, succeed without consuming anything."This usually isn't what you want.  and % are more likely what you are after.>Try the first, then try the second, and wrap the winner in an .=This is left-biased, meaning if they both succeed, left wins.>Try the given decoder, otherwise succeed with the given value.JTry the given decoder, or if it fails succeed with the given value, in an .UDecode categorical data, given a list of the values and the strings which match them.>Usually this is used with sum types with nullary constructors. fdata TrafficLight = Red | Amber | Green categorical [(Red, "red"), (Amber, "amber"), (Green, "green")][Decode categorical data, given a list of the values and lists of strings which match them.This version allows for multiple strings to match each value, which is useful for when the categories are inconsistently labelled. data TrafficLight = Red | Amber | Green categorical' [(Red, ["red", "R"]), (Amber, ["amber", "orange", "A"]), (Green, ["green", "G"])]5For another example of its usage, see the source for .Use the + instance to try to decode the given value.Use the R instance to try to decode the given value, or fail with the given error message.Use the X instance to try to decode the given value, or use the value to build an error message.1Given the name of a type, try to decode it using , Map over the errors of a 3.To map over the other two parameters, use the () instance.This transforms a  Decode' s a into a  Decode' t a`. It needs functions in both directions because the errors can include fragments of the input. @alterInput :: (s -> t) -> (t -> s) -> Decode' s a -> Decode' t aBuild a 3 from a Trifecta parserBuild a 3 from an Attoparsec parserBuild a 3 from a Parsec parserKConvenience to get the underlying function out of a Decode in a useful formThis can be used to build a 3/ whose value depends on the result of another 3". This is especially useful since 3 is not a  .=If you need something like this but with more power, look at flipped Bind through a 3."This bind does not agree with the  \ instance because it does not accumulate multiple error values. This is a violation of the   laws, meaning 3 is not a  .bThat is not to say that there is anything wrong with using this function. It can be quite useful.Run a 3&, and based on its errors build a new 3.Build a 3 from a function.{This version gives you just the contents of the field, with no information about the spacing or quoting around that field.Build a 3 from a function.+This version gives you access to the whole S, which includes information about whether quotes were used, and if so which ones.Build a 3 from a function.+This version gives you access to the whole q, which includes information about spacing both before and after the field, and about quotes if they were used.%promotes a Decode to work on a whole D at once. This does not need to be called by the user. Instead use .S$%&'()*+,23456RSTUVWXYZ[S3452$'()*+,%&RSTUVWXYZ[611(C) CSIRO 2017-2018BSD3-George Wilson <george.wilson@data61.csiro.au> experimental non-portableNoneg   :<;=>?@ABCDEFmn$%&'()*+,-./01234567RSTUVWXYZ[\]defghijklmxyz{|}~     *+,*+-*./*.0*.1*.2*.3*.4*.5*.6*+789:89;89<89=>?@>?A>?B>?CDDEFGHIJKLMNOPQRSTUVWXXYZ[\]^_`abcdefghijklmmnopqrstuvwxyz{|}~                                                         ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > > ? @ A B C D E F G H IJKKLMNOPQRRSSTUVVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      % !" #$%&'())*+,-./0123456789:8;<=>?@Asv-0.1-LEjGD2ajzYS6ZNIUObPicZData.SvData.Sv.Decode.ErrorData.Sv.Decode.TypeData.Vector.NonEmpty Text.EscapeData.Sv.Print.Options Text.Newline Text.Quote Text.SpaceData.Sv.Syntax.FieldData.Sv.Syntax.RecordData.Sv.Syntax.SvData.Sv.Parse.OptionsData.Sv.Print.Internal Data.Sv.PrintData.Sv.Parse.Internal Data.Sv.ParseData.Sv.Encode.OptionsData.Sv.Encode.TypeData.Sv.EncodeData.Sv.DecodeData.ByteString ByteString Data.TextTextData.Sv.SyntaxFieldData.Sv.Decode.Field>>== bindDecode categorical Text.TrifectaResultData.ByteString.LazyData.ByteString.StrictData.ByteString.BuilderBuilderTrifectaData.Text.LazyData.Profunctor Profunctor*contravariant-1.4.1-CYWzzu80yDdA8aFlw2qb60Data.Functor.Contravariant contramap Contravariant$Data.Functor.Contravariant.Divisiblechosendividedconquerdivide Divisiblechooselose Decidable>$*semigroupoids-5.2.2-5uc1QUebalH8WT72XFUbVFData.Functor.AltAltmanysome#validation-1-7Kn73lcYUHq7dRZmAdNKfWData.ValidationbindValidationSuccessFailure ValidationNonEmptyVectorfromNeltoNelheadNevtailNev$fSemigroupNonEmptyVector$fTraversable1NonEmptyVector$fTraversableNonEmptyVector$fFoldable1NonEmptyVector$fFoldableNonEmptyVector$fApplicativeNonEmptyVector$fApplyNonEmptyVector$fFunctorNonEmptyVector$fNFDataNonEmptyVector$fEqNonEmptyVector$fOrdNonEmptyVector$fShowNonEmptyVector$fGenericNonEmptyVectorEscaper'Escaper UnescapedgetRawUnescaped escapeString escapeText escapeUtf8escapeUtf8Lazy escapeChar$fNFDataUnescaped $fEqUnescaped$fOrdUnescaped$fShowUnescaped$fSemigroupUnescaped$fMonoidUnescaped$fFunctorUnescaped$fFoldableUnescaped$fTraversableUnescaped$fGenericUnescapedHasPrintOptions printOptionsbuildescape PrintOptions_build_escapedefaultPrintOptionsutf8PrintOptionsutf8LazyPrintOptionstextPrintOptionsstringPrintOptions$fHasPrintOptionsPrintOptionsa AsNewline_Newline_CR_LF_CRLFNewlineCRLFCRLFnewlineToString parseNewline$fNFDataNewline$fAsNewlineText$fAsNewlineNewline $fEqNewline $fOrdNewline $fShowNewlineAsQuote_Quote _SingleQuote _DoubleQuoteQuote SingleQuote DoubleQuote quoteChar quoteToString $fNFDataQuote $fAsQuoteChar$fAsQuoteQuote $fEqQuote $fOrdQuote $fShowQuote HasSpacedspacedafterbefore spacedValueSpaced_before_after_valueSpacesAsHorizontalSpace_HorizontalSpace_Space_TabHorizontalSpaceSpaceTabsingle manySpacestab spaceToChar charToSpace spacesText spacesStringbetwixtunspaceduniform removeSpaces$fNFDataHorizontalSpace$fAsHorizontalSpaceChar"$fAsHorizontalSpaceHorizontalSpace$fTraversableSpaced$fFoldableSpaced$fApplicativeSpaced$fFunctorSpaced$fNFDataSpaced$fHasSpacedSpacedSpacedab$fEqHorizontalSpace$fOrdHorizontalSpace$fShowHorizontalSpace $fEqSpaced $fOrdSpaced $fShowSpaced$fGenericSpaced HasFieldsfieldsAsField_Field _Unquoted_Quoted SpacedFieldUnquotedQuotedunescapedField foldField fieldContents$fTraversableField$fFoldableField$fFunctorField $fNFDataField$fHasFieldsFieldFieldst$fAsFieldFielda $fEqField $fOrdField $fShowField$fGenericField HasRecordsrecordstraverseRecordstraverseNewlinesRecords EmptyRecords HasRecordrecord spacedFieldsRecord_fieldsrecordSpacedFieldsIso emptyRecord singleField recordNel _EmptyRecords_NonEmptyRecords mkRecords singleRecord recordList$fTraversableRecord$fFoldableRecord$fFunctorRecord$fNFDataRecord$fHasFieldsRecordRecordab$fHasRecordRecordRecordab$fTraversableRecords$fFoldableRecords$fFunctorRecords$fNFDataRecords$fHasRecordsRecordss $fEqRecord $fOrdRecord $fShowRecord$fSemigroupRecord$fGenericRecord $fEqRecords $fOrdRecords $fShowRecords$fGenericRecords HasSeparator separator Separator HasHeadedness headedness HeadednessUnheadedHeaded HasHeaderheader headerNewline headerRecordHeader _headerRecordHasSvsv maybeHeadertraverseHeader finalNewlinesSv _separatorSv _maybeHeader_records_finalNewlinesmkSvemptySv getHeadednessnoHeadermkHeadercommapipe$fNFDataHeader$fHasFieldsHeaderHeaderab$fHasRecordHeaderHeaderab$fHasHeaderHeaderHeaderab$fHasHeadednessHeadedness$fTraversableSv $fFoldableSv $fFunctorSv$fHasRecordsSvs $fNFDataSv$fHasSeparatorSv$fHasSeparatorChar $fHasSvSvs $fEqHeader $fOrdHeader $fShowHeader$fFunctorHeader$fFoldableHeader$fTraversableHeader$fGenericHeader$fEqHeadedness$fOrdHeadedness$fShowHeadedness$fEqSv$fOrdSv$fShowSv $fGenericSvHasParseOptions parseOptions encodeStringendOnBlankLine ParseOptions_parseSeparator _headedness_endOnBlankLine _encodeStringdefaultParseOptionsdefaultSeparatordefaultHeadedness$fHasHeadednessParseOptions$fHasSeparatorParseOptions$fFunctorParseOptions+$fHasParseOptionsParseOptionsParseOptionsabDecodeValidation DecodeErrors DecodeErrorUnexpectedEndOfRowExpectedEndOfRowUnknownCategoricalValueBadParse BadDecodeInd DecodeStategetDecodeStateDecode'Decode unwrapDecode buildDecoderunDecodeState$fProfunctorDecodeState$fBindDecodeState$fNFDataDecodeError$fFunctorDecodeError$fNFDataDecodeErrors$fFunctorDecodeErrors$fProfunctorDecode $fAltDecode$fFunctorDecodeState$fApplyDecodeState$fApplicativeDecodeState$fMonadDecodeState$fMonadReaderDecodeState$fMonadStateDecodeState$fEqDecodeError$fOrdDecodeError$fShowDecodeError$fGenericDecodeError$fEqDecodeErrors$fOrdDecodeErrors$fShowDecodeErrors$fSemigroupDecodeErrors$fGenericDecodeErrors$fFunctorDecode $fApplyDecode$fApplicativeDecode decodeErrorunexpectedEndOfRowexpectedEndOfRowunknownCategoricalValuebadParse badDecodevalidateEithervalidateEither' validateMaybevalidateMaybe'trifectaResultToEithervalidateTrifectaResult printNewline printField printSpaced printRecord printRecords printHeaderwriteSvToHandle writeSvToFilewriteSvToHandle'writeSvToFile'printSv printSvLazyprintSv' printSvLazy' printSvTextprintSvTextLazysingleQuotedFielddoubleQuotedField unquotedFieldfield spacedFieldendingseparatedValuesSvParser runSvParserrunSvParserFromFileparseSvparseSv'parseSvFromFileparseSvFromFile'trifectaattoparsecByteStringattoparsecTextHasEncodeOptions encodeOptionsnewlinequote spacingAfter spacingBeforeterminalNewline EncodeOptions_encodeSeparator_spacingBefore _spacingAfter_quote_newline_terminalNewlinedefaultEncodeOptions$fHasSeparatorEncodeOptions$fHasEncodeOptionsEncodeOptionsEncode getEncode$fDecidableEncode$fDivisibleEncode$fContravariantEncode$fSemigroupEncode$fMonoidEncode mkEncodeBSmkEncodeWithOpts unsafeBuilderencodeencodeToHandle encodeToFile encodeBuilder encodeRowencodeRowBuilderencodeSvconstshownopemptyorEmpty?>><