!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~   Safe,DQRConstraint that every element of a promoted list is equal to a particular type. That is, the list of types is a single type repeated some number of times.None6[This class relates a universe of possible column types to Haskell types, and provides a mechanism to infer which type best represents some textual data.Values that can be read from a # with more or less discrimination. Returns  if a value of the given type can not be read; returns 'Just Possibly' if a value can be read, but is likely ambiguous (e.g. an empty string); returns 'Just Definitely' if a value can be read and is unlikely to be ambiguous." ,Discard any estimate of a parse's ambiguity.Acts just like  : tries to parse a value from a 5 and discards any estimate of the parse's ambiguity.        None,DIQRT;Used only for a show instance that parenthesizes the value.KA column's type includes a textual name and the data type of each element.Helper for making a None$%&*,9:;<=DOQRTb)The ability to pretty print a Rec' s fields.*7A constraint that a field can be deleted from a record.+YRemove the column name phantom types from a record, leaving you with an unadorned Vinyl ..8Enforce a constraint on the payload type of each column./CStrip the column information from each element of a list of types.0A type function to convert a Record to a . ColFun f (Rec rs) = Rec f rs.2%Return the column names for a record.5"Add a column to the head of a row.6'Add a pure column to the head of a row.=Separate the first element of a row from the rest of the row.7MAdd a column to the tail of a row. Note that the supplied value should be a  to work with the Frames tooling.1Map a function across a homogeneous, monomorphic .81Map a function across a homogeneous, monomorphic . Map a typeclass method across a 7 each of whose fields have instances of the typeclass.9 Map a typeclass method across a 8 each of whose fields has an instance of the typeclass.:N-ary version of ! over functorial frame rows. See .;N-ary version of  over pure frame rows. See .<-Lift an N-ary function to work over a row of  computations. See .=%Lift an N-ary function over types in g to work over a record of d * computations. A more general version of <.>Delete a field from a record?Pretty printing of  values.@VBuild a record whose elements are derived solely from a constraint satisfied by each.")*+,-./0123456789:;<=>?@ABCDEF)*+,-./0123456789:;<=>?@>*56734./+,-89:;=<)?0122@)*+,-./0123456789:;<=>?@ABCDEFNone%&*,-9:;<=DOQRT[ GOA universe of common column variants. These are the default column types that Frames can infer. See the  &http://acowley.github.io/Frames/#sec-4Tutorial> for an example of extending the default types with your own.HADefine a set of variants that captures all possible column types.ICommon column typesFInformation necessary for synthesizing row types and comparing types.A , tagged with the type it is associated with.WExtract a function to test whether some value of a given type could be read from some .Helper to call  on variants of a .TPreserving the outermost two functor layers, replace each element with its TypeRep.We use a join semi-lattice on types for representations. The bottom of the lattice is effectively an error (we have nothing to represent),  Bool < Int,  Int < Double, and forall n. n <= Text.OThe high-level goal here is that we will pick the "greater" of two choices in . A  # parse result is preferred over a  ' parse result. If we have two distinct  5 parse results, we give up. If we have two distinct  G parse results, we are in dangerous waters: all data is parseable at both types, so which do we default to? The defaulting choices made here are described in the previous paragraph. If there is no defaulting rule, we give up (i.e. use  as a representation).Find the best (i.e. smallest) p variant to represent a parsed value. For inspection in GHCi after loading this module, consider this example::set -XTypeApplications:set -XOverloadedStrings#import Data.Vinyl.CoRec (foldCoRec)6foldCoRec parsedTypeRep (bestRep @CommonColumns "2.3")Definitely DoubleGHIJKLGHIJGHIJGHIJKLNone%&*+,9:;<=?DQRTabN(A record with unadorned values. This is Vinyl's  E. We give this type a name as it is used pervasively for records in Frames.OA cons function for building N values.P Separate the first element of a N from the rest of the row.Q Undistribute  from a  $. This is just a specific usage of , but it is quite common.RShow each field of a N without its column name.MNOPQRMNOPQRNOMPQRMNOPQRO5None %&*:QRSpreview src n f prints out the first n results of piping src through f.Tselect (Proxy::Proxy [A,B,C]) extracts columns A, B, and CY, from a larger record. Note, this is just a way of pinning down the type of a usage of .Ulenses (Proxy::Proxy [A,B,C]) provides a lens onto columns A, B, and C2. This is just a way of pinning down the type of .V>A proxy value quasiquoter; a way of passing types as values. [pr|T|] will splice an expression Proxy::Proxy T , while  [pr|A,B,C|] will splice in a value of Proxy :: Proxy [A,B,C] . If we have a record type with Name and Age# among other fields, we can write select P[pr|Name,Age|]@ for a function that extracts those fields from a larger record.WLike V7, but takes a single type, which is used to produce a  for a single-element list containing only that type. This is useful for passing a single type to a function that wants a list of types.Split on a delimiter.'Remove white space from both ends of a .STUVWXSTUVWXSTUXVWSTUVWX NoneQRYA Z whose rows are N values.ZA Z+ is a finite collection of rows indexed by .^Build a Z from any . This simply uses a boxed / to hold each row. If you have a collection of Ns, consider using  ._ Horizontal Z concatenation. That is, zipFrames f1 f2 will return a Z% with as many rows as the smaller of f1 and f28 whose rows are the result of appending the columns of f2 to those of f1.cThe  instance for Z5 provides a mechanism for vertical concatenation of Z s. That is, f1 <> f2 will return a new Z with the rows of f1 followed by the rows of f2. YZ[\]^_`abcdeYZ[\]^_ Z[\]Ye^dcba`_ YZ[\]^_`abcde None,9;DLQRTa fPTooling to allocate, grow, write to, freeze, and index into records of vectors.m0Immutable vector types for each column in a row.n.Mutable vector types for each column in a row.oThe mutable version of p a particular type.p9The most efficient vector type for each column data type.qSince we stream into the in-memory representation, we use an exponential growth strategy to resize arrays as more data is read in. This is the initial capacity of each column.rbStream a finite sequence of rows into an efficient in-memory representation for further manipulation. Each column of the input table will be stored optimally based on its type, making use of the resulting generators a matter of indexing into a densely packed representation. Returns the number of rows and a record of column indexing functions. See u to convert the result to a Z_ which provides an easier-to-use function that indexes into the table in a row-major fashion.s!Stream a finite sequence of rows into an efficient in-memory representation for further manipulation. Each column of the input table will be stored optimally based on its type, making use of the resulting generators a matter of indexing into a densely packed representation. Returns a Z3 that provides a function to index into the table.tLike sR, but applies the provided function to the record of columns before building the Z.uqConvert a structure-of-arrays to an array-of-structures. This can simplify usage of an in-memory representation.vStream a finite sequence of rows into an efficient in-memory representation for further manipulation. Each column of the input table will be stored optimally based on its type, making use of the resulting generator a matter of indexing into a densely packed representation.wBuild a Z from a collection of N(s using efficient column-based storage.xKeep only those rows of a Y that satisfy a predicate.fghijklmnopqrstuvwxyzfghijklmnopqrstuvwxpoqnmfghijklzyrstuvwxfghijklmnopqrstuvwxyz None*+,9:;<=DQRTdTransform a record into a list of its fields, retaining proof that each field is part of the whole.This is K, but the variables are at the front of the record, which reads a bit odd.'Turn a cons into a snoc after the fact.Like melt in the reshape2 package for the R language. It stacks multiple columns into a single column over multiple rows. Takes a specification of the id columns that remain unchanged. The remaining columns will be stacked.Suppose we have a record, r :: Record [Name,Age,Weight]. If we apply melt [pr1|Name|] r, we get two values with type 7Record [Name, "value" :-> CoRec Identity [Age,Weight]]. The first will contain Age in the value& column, and the second will contain Weight in the value column.Applies  to each row of a Y.{|}~{|}~~}{|{|}~ None*,9:;<=DOQRT Getter for a  field Setter for a  field.)Create a lens for accessing a field of a N. Getter for a N field. Setter for a N field. None!",9;<=DOQRT[,5Control how row and named column types are generated.aUse these column names. If empty, expect a header row in the data file to provide column names.8A common prefix to use for every generated declaration.0The string that separates the columns on a row.*The row type that enumerates all columns.A type that identifies all the types that can be used to classify a column. This is essentially a type-level list of types. See .!A producer of lines of T.Text xsParsing each component of a RecF= from a list of text chunks, one chunk per record component.:No quoting enabled. The separator may not appear in valuesQuoted values with the given quoting character. Quotes are escaped by doubling them. Mostly RFC4180 compliant, except doesn't support newlines in valuesDefault  ParseOptionsJ get column names from a header line, and use commas to separate columns.Default separator string.Helper to split a P on commas and strip leading and trailing whitespace from each resulting chunk.qPost processing applied to a list of tokens split by the separator which should have quoted sections reassembeldCInfer column types from a prefix (up to 1000 lines) of a CSV file.8Extract column names and inferred types from a CSV file.Produce the lines of a latin1 (or ISO8859 Part 1) encoded file as T.Text  values. Similar to PT.readFileLn  that uses the system locale for decoding, but built on the PT.decodeIso8859_1  decoder.Read a RecF from one line of CSV.5Produce rows where any given entry can fail to parse.cStream lines of CSV data into rows of Rec  values values where any given entry can fail to parse.5Produce rows where any given entry can fail to parse.\Stream lines of CSV data into rows of Rec  values where any given entry can fail to parse.JReturns a producer of rows for which each column was successfully parsed.PPipe lines of CSV text into rows for which each column was successfully parsed.JReturns a producer of rows for which each column was successfully parsed.PPipe lines of CSV text into rows for which each column was successfully parsed.Generate a column type.!Capitalize the first letter of a .LMassage a column name from a CSV file into a valid Haskell type identifier.$Declare a type synonym for a column.\Declare a singleton value of the given column type and lenses for working with that column.YFor each column, we declare a type synonym for its type, and a Proxy value of that type.FSplice for manually declaring a column of a given type. For example, declareColumn "x2" ''Double will declare a type synonym type X2 = "x2" :-> Double and a lens x2.Shorthand for a  value of H! applied to the given type list. A default . This instructs the type inference engine to get column names from the data file, use the default column separator (a comma), infer column types from the default G1 set of types, and produce a row type with name Row.FGenerate a type for each row of a table. This will be something like (Record ["x" :-> a, "y" :-> b, "z" :-> c].Like , but additionally generates a type synonym for each column, and a proxy value of that type. If the CSV file has column names "foo", "bar", and "baz", then this will declare type Foo = "foo" :-> Int, for example, !foo = rlens (Proxy :: Proxy Foo), and "foo' = rlens' (Proxy :: Proxy Foo).AInspect no more than this many lines when inferring column types.CGenerate a type for a row of a table. This will be something like (Record ["x" :-> a, "y" :-> b, "z" :-> c]. Column type synonyms are not generated (see ).*Tokenize the first line of a P.Producer .KGenerate a type for a row of a table all of whose columns remain unparsed Text values.Like , but additionally generates a type synonym for each column, and a proxy value of that type. If the CSV file has column names "foo", "bar", and "baz", then this will declare type Foo = "foo" :-> Int, for example, !foo = rlens (Proxy :: Proxy Foo), and "foo' = rlens' (Proxy :: Proxy Foo).E a header row with column names followed by a line of text for each N& with each field separated by a comma.JWrite a header row with column names followed by a line of text for each N to the given file.;7;-NoneDRhRun a self-contained Pipes.Effect  and execute the finalizers associated with the SafeT  transformer.!Stream a finite sequence of rows into an efficient in-memory representation for further manipulation. Each column of the input table will be stored optimally based on its type, making use of the resulting generators a matter of indexing into a densely packed representation. Returns a Z3 that provides a function to index into the table.Like R, but applies the provided function to the record of columns before building the Z.Stream a finite sequence of rows into an efficient in-memory representation for further manipulation. Each column of the input table will be stored optimally based on its type, making use of the resulting generator a matter of indexing into a densely packed representation.bStream a finite sequence of rows into an efficient in-memory representation for further manipulation. Each column of the input table will be stored optimally based on its type, making use of the resulting generators a matter of indexing into a densely packed representation. Returns the number of rows and a record of column indexing functions. See toAoS to convert the result to a Z_ which provides an easier-to-use function that indexes into the table in a row-major fashion.g     )*+,-./0123456789:;<=>?@GHIJMNOPQRSTUVWXYZ[\]^_uwx uwx !"#$%&'()*+,,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk l m m n o p q r s t u v w x y z { | } ~                        MNP      !"#$%&'()*+*,*-.%Frames-0.3.0.2-2Pn56I2PBah73KCCGhU5jwFramesFrames.ColumnUniverse Frames.RecFFrames.TypeLevelFrames.ColumnTypeable Frames.Col Frames.RecFrames.Exploration Frames.Frame Frames.InCore Frames.MeltFrames.RecLens Frames.CSVtoFrame#text-1.2.2.2-KC7dWoG09dA1F6jKj5GSqhData.Text.InternalText"vinyl-0.7.0-H8oogfTSrh9IdQECC3OuU0Data.Vinyl.CoRecCoRecData.Vinyl.Core rtraverserappendAllAreColumnTypeablecolType inferType ParseableparseParsedPossibly DefinitelydiscardConfidenceparse'$fParseableText$fParseableDouble$fParseableFloat$fParseableInt$fParseableBool$fFunctorParsed $fEqParsed $fOrdParsed $fShowParsedCol':->ColgetColcol' $fShowCol' $fShow:->$fEq:->$fOrd:->$fNum:-> $fMonoid:-> $fReal:->$fRealFloat:-> $fRealFrac:->$fFractional:-> $fFloating:->ShowRec CanDeleteAsVinyltoVinyl fromVinylAllColsUnColumnColFun ColumnHeaders columnHeaders:&Nil frameCons frameConsA frameSnocmapMono mapMethodruncurry runcurry' runcurryA' runcurryArdelshowRec reifyDict $fShowRecf: $fShowRecf[] $fAsVinyl: $fAsVinyl[]$fColumnHeaders:$fColumnHeaders[]ColumnsColumnUniverse CommonColumns parsedTypeRep$fColumnTypeableCoRec $fMonoidCoRec RecordColumnsRecord&: recUnconsrecMaybe showFields pipePreviewselectlensesprpr1 recToListFrameRecFrame frameLengthframeRow boxedFrame zipFrames $fMonadFrame$fApplicativeFrame$fFoldableFrame $fMonoidFrame $fEqFrame$fFunctorFrameRecVecallocRec freezeRecgrowRecwriteRecindexRec produceRecVectorsVectorMs VectorMFor VectorForinitialCapacity inCoreSoA inCoreAoS inCoreAoS'toAoSinCore filterFrame $fRecVec: $fRecVec[] HasLength hasLength RDeleteAll RowToColumnrowToColumnAuxElemOfDisjointNotOrElem rowToColumnmeltAuxmeltRow' retroSnocmeltRowmelt $fHasLengthk:$fHasLengthk[]$fRowToColumnats:$fRowToColumnkts[]rlens'rget'rput'rlensrgetrputRowGen columnNames tablePrefix separator rowTypeNamecolumnUniverse lineReaderReadRecreadRec ParserOptionsheaderOverridecolumnSeparator quotingMode QuotingMode NoQuotingRFC4180Quoting QuoteChar Separator defaultParser defaultSep tokenizeRowreassembleRFC4180QuotedPartsprefixInferencereadColHeadersreadFileLatin1LnreadRowreadTableMaybeOptpipeTableMaybeOptreadTableMaybepipeTableMaybe readTableOpt pipeTableOpt readTable pipeTablerecDec capitalize1sanitizeTypeName mkColTDec mkColPDec lowerHeadcolDec declareColumncolQrowGen tableType tableTypes prefixSize tableType' colNamesPtableTypesText' tableTypes' produceCSVwriteCSV $fReadRec: $fReadRec[]$fLiftParserOptions$fLiftQuotingMode$fEqQuotingMode$fShowQuotingMode$fEqParserOptions$fShowParserOptions runSafeEffectbaseGHC.BaseNothing$readable-0.3.1-nw2ABqMhtM9aCyNMllbrg Data.ReadablefromTextRec frameUnconsmapMonoV mapMethodV Data.TupleuncurryData.Vinyl.Curry ApplicativeData.Vinyl.FunctorComposeshowRec'ColInfoTypedData.Typeable.InternalTypeRepinferParseableinferParseable' elementTypes lubTypeRepsbestRepmkTyped quoteType tryParseAllIdentityMaybeData.Vinyl.Lensrcastrsubset Data.ProxyProxysplitOnstripStringghc-prim GHC.TypesInt Data.FoldableFoldable&vector-0.12.0.1-BtK5bVORdhu8bC6gqUfFYi Data.VectorVectorMonoid"pipes-4.3.7-3ABQW9Xu3yJDhYluwWykyTPipesyield'pipes-safe-2.2.6-2ArdPSnytOi8eNjgNasDu6 Pipes.SaferunSafePrunSafeTSafeT MonadSafeonFieldonCoRecFieldRElemRSubsetrreplace REquivalent∈⊆≅<::~:<+>Data.Vinyl.TypeLevelAllConstrained AllSatisfied AllAllSat