h$ib      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ ] ^ _ ` 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 { | } ~                                      None /3FramesReplaceColumns x ys, keeps the textual name of each element of ys", but replaces its data type with x. Frames;Used only for a show instance that parenthesizes the value.$Frames&Get the data payload of a named field.%FramesHelper for making a   !"#$%"#$ !%None9 0'FramesThis class relates a universe of possible column types to Haskell types, and provides a mechanism to infer which type best represents some textual data.*FramesValues that can be read from a # with more or less discrimination.+FramesReturns  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.",FramesCombine two parse results such that the combination can fail. Useful when we have two / parsed values that are different enough to suggest the parse of each should be considered a failure. The default implementation is to  the first argument.2Frames,Discard any estimate of a parse's ambiguity.3FramesActs just like  : tries to parse a value from a 5 and discards any estimate of the parse's ambiguity.')(*-,+.0/1234.0/1*-,+234')(None'(-./>?BFrames(A record with unadorned values. This is Vinyl's  . We give this type a name as it is used pervasively for records in Frames.CFramesA cons function for building B values.DFrames Separate the first element of a B from the rest of the row.EFrames Undistribute  from a  $. This is just a specific usage of , but it is quite common.FFramesShow each field of a B without its column name.GFramesGet the value of a field of a B!. This is intended for use with TypeApplications, as compared to rgetv that is intended for use with OverloadedLabels.HFrames"Replace the value of a field of a B!. This is intended for use with TypeApplications, as compared to  that is intended for use with OverloadedLabels.ABCDEFGHBCADEFGHC5 Safe-Inferred9IFramesControl the way values of a type are printed when serializing to a CSV stream.IJIJ Safe-Inferred./OFramesReplace the second component of every tuple in a type-level list with a constant.PFramesReplaceAll x ys3 produces a type-level list of the same length as ys where each element is x/. In other words, it replaces each element of ys with x. This would be map (const x) ys in value-level Haskell.QFramesConstraint 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.OPQQPONone&'(-./>?ERFrames7A constraint that a field can be deleted from a record.SFrames8Enforce a constraint on the payload type of each column.TFramesStrip the column information from each element of a list of types.UFrames:A type function to convert a 'Rec f' to a 'Rec (g :. f)'. -ColFun f (Record rs) = Rec (f :. ElField) rs.WFrames%Return the column names for a record.XFrames$Map a function across a homogeneous / of named values. This is a thin wrapper over .YFramesDelete a field from a record RSTUVWXYYRST XUVW None\FramesA ] whose rows are B values.]FramesA ]+ is a finite collection of rows indexed by .aFramesBuild a ] from any . This simply uses a boxed / to hold each row. If you have a collection of Bs, consider using  .bFrames Horizontal ] concatenation. That is, zipFrames f1 f2 will return a ]% 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.gFramesThe  instance for ]5 provides a mechanism for vertical concatenation of ] s. That is, f1 <> f2 will return a new ] with the rows of f1 followed by the rows of f2.\]^`_ab]^`_\ab None-./>?YtFramesTransform a record into a list of its fields, retaining proof that each field is part of the whole.vFramesThis is y, but the variables are at the front of the record, which reads a bit odd.wFrames'Turn a cons into a snoc after the fact.xFramesLike 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.yFramesApplies x to each row of a \.jklmnopqrstuvwxysrqpomntulvwxjky None./>$ ~FramesTooling to allocate, grow, write to, freeze, and index into records of vectors.Frames0Immutable vector types for each column in a row.Frames.Mutable vector types for each column in a row.FramesThe mutable version of  a particular type.Frames9The most efficient vector type for each column data type.FramesSince 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.FramesStream 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  to convert the result to a ] which provides an easier-to-use function that indexes into the table in a row-major fashion.FramesStream 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 ]3 that provides a function to index into the table.FramesLike , but applies the provided function to the record of columns before building the ].FramesConvert a structure-of-arrays to an array-of-structures. This can simplify usage of an in-memory representation.FramesStream 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.FramesBuild a ] from a collection of B(s using efficient column-based storage.FramesKeep only those rows of a \ that satisfy a predicate.FramesProcess a stream of Bs into a stream of ]?s that each contains no more than the given number of records.FramesSplit a ] into chunks of no more than the given number of records. The underlying memory is shared with the original ].~~ None-./>?0Frames.Perform an inner join operation on two frames. Requires the language extension TypeApplications( for specifying the columns to join on.Joins can be done on on one or more columns provided the matched columns have a Grouping instance, most simple types do.Presently join columns must be present and named identically in both left and right frames. Basic usage: :innerJoin @'[JoinCol1, ..., JoinColN] leftFrame rightFrameFramesPerform an outer join ( FULL JOIN) operation on two frames.)Requires the use the language extension TypeApplications( for specifying the columns to join on.Joins can be done on on one or more columns provided the columns have a Grouping instance, most simple types do.Presently join columns must be present and named identically in both left and right frames.Returns a list of Records in the Maybe interpretation functor. If a key in the left table is missing from the right table, non-key columns from the right table are filled with Nothing. If a key in the right table is missing from the left table, non-key columns from the right table are filled with Nothing. Basic usage: :outerJoin @'[JoinCol1, ..., JoinColN] leftFrame rightFrameFrames.Perform an right join operation on two frames. Requires the language extension TypeApplications( for specifying the columns to join on.Joins can be done on on one or more columns provided the columns have a Grouping instance, most simple types do.Presently join columns must be present and named identically in both left and right frames.Returns a list of Records in the Maybe interpretation functor. If a key in the right table is missing from the left table, non-key columns from the right table are filled with Nothing. Basic usage: :rightJoin @'[JoinCol1, ..., JoinColN] leftFrame rightFrameFrames-Perform an left join operation on two frames. Requires the language extension TypeApplications( for specifying the columns to join on.Joins can be done on on one or more columns provided the columns have a Grouping instance, most simple types do.Presently join columns must be present and named identically in both left and right frames.Returns a list of Records in the Maybe interpretation functor. If a key in the left table is missing from the right table, non-key columns from the right table are filled with Nothing. Basic usage: 9leftJoin @'[JoinCol1, ..., JoinColN] leftFrame rightFrameFramesThe left frameFramesThe right frameFramesThe joined frameFramesThe left frameFramesThe right frameFrames6A list of the merged records, now in the Maybe functorFramesThe left frameFramesThe right frameFrames6A list of the merged records, now in the Maybe functorFramesThe left frameFramesThe right frameFrames6A list of the merged records, now in the Maybe functor None-./>?0None'(-/>?7g Framespreview src n f prints out the first n results of piping src through f.Framesselect (Proxy::Proxy [A,B,C]) extracts columns A, B, and C, from a larger record. Note, this is just a way of pinning down the type of a usage of .Frameslenses (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 .Frames>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 [pr|Name,Age|]@ for a function that extracts those fields from a larger record.FramesLike 7, 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.FramestakeRows n frame produces a new ] made up of the first n rows of frame.FramesdropRows n frame produces a new ] just like frame, but not including its first n rows.Frames Format a ] to a .FramesPrint a ] to .FramesSeparator between fieldsFramesThe ] to be formatted to a FramesSeparator between fieldsFramesThe ] to be printed to stdout  None '(/0;>?EzFramesParsing each component of a RecF= from a list of text chunks, one chunk per record component.Frames:No quoting enabled. The separator may not appear in valuesFramesQuoted values with the given quoting character. Quotes are escaped by doubling them. Mostly RFC4180 compliant, except doesn't support newlines in valuesFramesDefault  ParseOptions get column names from a header line, and use commas to separate columns.FramesDefault separator string.FramesHelper to split a  on commas and strip leading and trailing whitespace from each resulting chunk.FramesPost processing applied to a list of tokens split by the separator which should have quoted sections reassembeldFramesInfer column types from a prefix (up to 1000 lines) of a CSV file.Frames8Extract column names and inferred types from a CSV file.FramesOpens a file (in 4) and repeatedly applies the given function to the  to obtain lines to yield. Adapted from the moribund pipes-text package.FramesProduce lines of .FramesProduce lines of tokens that were separated by the given separator.FramesConsume lines of , writing them to a file.FramesProduce the lines of a latin1 (or ISO8859 Part 1) encoded file as @T.Text@ values.FramesRead a RecF from one line of CSV.Frames5Produce rows where any given entry can fail to parse.FramesStream lines of CSV data into rows of @Rec@ values values where any given entry can fail to parse.FramesStream lines of CSV data into rows of @Rec@ values values where any given entry can fail to parse. In the case of a parse failure, the raw  of that entry is retained.Frames5Produce rows where any given entry can fail to parse.FramesStream lines of CSV data into rows of @Rec@ values where any given entry can fail to parse.FramesStream lines of CSV data into rows of @Rec@ values where any given entry can fail to parse. In the case of a parse failure, the raw  of that entry is retained.FramesReturns a producer of rows for which each column was successfully parsed.FramesPipe lines of CSV text into rows for which each column was successfully parsed.FramesReturns a producer of rows for which each column was successfully parsed.Frames Similar to 5 except that rows that fail to parse are printed to stderr/ with columns that failed to parse printed as "Left rawtext"9 while those that were successfully parsed are shown as  "Right text".FramesPipe lines of CSV text into rows for which each column was successfully parsed.Frames a header row with column names followed by a line of text for each B: with each field separated by a comma. If your source of B values is a , consider using  to keep everything streaming.Frames a header row with column names followed by a line of text for each B< with each field separated by a comma. This is the same as , but adapated for cases where you have streaming input that you wish to use to produce streaming output.FramesWrite a header row with column names followed by a line of text for each B to the given file.FramesWrite a header row with column names followed by a line of text for each B to the given file.** Safe-Inferred FFrames!Capitalize the first letter of a .FramesMassage a column name from a CSV file into a valid Haskell type identifier.None &/JFramesA categorical variable can take on one of a finite number of textual names. Any value of type  Categorical n has no more than n variants.Frames Ensure the first character of a  is uppercase.FramesHelper for working with . Takes the name of the type and the number of variants in the sum type in order to determine a compact representation.FramesGenerate a splice with data type declaration and associated instances for type suitable for representing a categorical variable. This is a type that maps between a finite set of textual names and Haskell data constructors. Usage: ;declareCategorical typeName optionalConPrefix variantNames% will produce a data type with name typeName; and data constructors whose names are a concatenation of optionalConPrefix and each element of  variantNames.None '(-/0>?MFramesA 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.FramesDefine a set of variants that captures all possible column types.Frames0Common column types including categorical types.FramesCommon column types: , , , FramesInformation necessary for synthesizing row types and comparing types.  None #$'(/[FramesControl how row and named column types are generated. The type argument is a type-level list of the possible column types.FramesUse these column names. If empty, expect a header row in the data file to provide column names.Frames8A common prefix to use for every generated declaration.Frames0The string that separates the columns on a row.Frames*The row type that enumerates all columns.FramesA record field that mentions the phantom type list of possible column types. Having this field prevents record update syntax from losing track of the type argument.FramesNumber of rows to inspect to infer a type for each column. Defaults to 1000.FramesA producer of rows of @T.Text@ values that were separated by a  value.FramesGenerate a column type.Frames$Declare a type synonym for a column.Frames)Declare lenses for working with a column.FramesFor each column, we declare a type synonym for its type, and a Proxy value of that type.FramesSplice 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.FramesSplice for manually declaring a column of a given type in which the generated type synonym's name has a prefix applied to the column name. For example, )declarePrefixedColumn "x2" "my" ''Double will declare a type synonym type MyX2 = "x2" :-> Double and a lens myX2.Frames 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 1 set of types, and produce a row type with name Row.FramesLike 0, but will also generate custom data types for  Categorical* variables with up to 8 distinct variants.FramesLike  tableType, 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 @Foo, and foo' = rlens' @Foo.FramesInspect no more than this many lines when inferring column types.FramesGenerate 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 ). tableType' :: forall a. (ColumnTypeable a, Monoid a) => RowGen a -> DecsQ tableType' (RowGen {..}) = pure . TySynD (mkName rowTypeName) []  $ (runIO (P.runSafeT (readColHeaders opts lineSource)) >>= recDec') where recDec' = recDec . map (second colType) :: [(T.Text, a)] -> Q Type colNames' | null columnNames = Nothing | otherwise = Just (map T.pack columnNames) opts = ParserOptions colNames' separator (RFC4180Quoting '"') lineSource = lineReader separator >-> P.take prefixSize*Tokenize the first line of a @P.Producer@.FramesGenerate a type for a row of a table all of whose columns remain unparsed Text values.FramesGenerate a type for a row of a table. This will be something like (Record ["x" :-> a, "y" :-> b, "z" :-> c]. 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 @Foo, and foo' = rlens' @Foo.NoneaFramesRun a self-contained @Pipes.Effect@ and execute the finalizers associated with the @SafeT@ transformer.FramesStream 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 ]3 that provides a function to index into the table.FramesLike , but applies the provided function to the record of columns before building the ].FramesStream 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.FramesStream 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 ] which provides an easier-to-use function that indexes into the table in a row-major fashion.  "#ABCDEFGHOPQRSTUVWXY\]^_`abxy4 "#xyABCDEFGH !"#$%&$%'$%($%)$*+$*,$*-$*.$*/$*0$12$13$45$46$47$48$9:$9;$9<$9=$9>$?@$?ABCCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} ~                                                                       $*$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1#Frames-0.7.2-El1B5XgDbf8JcPE6yKZvY8FramesFrames.ColumnUniverse Frames.RecF Frames.ColFrames.ColumnTypeable Frames.RecFrames.ShowCSVFrames.TypeLevel Frames.Frame Frames.Melt Frames.InCore Frames.JoinsFrames.ExtraInstancesFrames.Exploration Frames.CSV Frames.UtilsFrames.Categorical Frames.THtoFrame System.IOstdout'pipes-safe-2.3.3-9hXiRgxPDHu5yzMcSB07W5 Pipes.SaferunSafePrunSafeTSafeT MonadSafe%readable-0.3.1-2woGQEAELxWFVGTY1YAten Data.ReadablefromBSfromTextReadable text-1.2.3.2Data.Text.InternalText"vinyl-0.13.2-C4h8hTiXMR3xKP9txvNcbData.Vinyl.CoReconFieldonCoRecCoRecFieldData.Vinyl.Derivedrfield withNames' withNames stripNames' stripNamesStripFieldNamesData.Vinyl.LensrcastrsubsetData.Vinyl.Core rtraverse<+>rappendRecData.Vinyl.TypeLevelRDeleteRecAllAllConstrained AllSatisfied AllAllSatData.Vinyl.Functor:.ElFieldReplaceColumnsCol':->ColgetColcol' $fShowCol'ColumnTypeablecolType inferType Parseableparse parseCombinerepresentableAsTypeParsedPossibly Definitely parsedValuediscardConfidenceparse' parseIntish$fFunctorParsed$fParseableText$fParseableDouble$fParseableFloat$fParseableInteger$fParseableInt64$fParseableInt32$fParseableInt$fParseableBool $fEqParsed $fOrdParsed $fShowParsed RecordColumnsRecord&: recUnconsrecMaybe showFields rgetField rputFieldShowCSVshowCSV $fShowCSVText$fShowCSVDouble $fShowCSVInt $fShowCSVBool ReplaceAllSnd ReplaceAllAllAre CanDeleteAllColsUnColumnColFun ColumnHeaders columnHeadersmapMonordel$fColumnHeaders:$fColumnHeaders[]FrameRecFrame frameLengthframeRow boxedFrame zipFrames $fMonadFrame$fApplicativeFrame$fFoldableFrame$fSemigroupFrame $fMonoidFrame $fEqFrame$fFunctorFrame HasLength hasLength RDeleteAll RowToColumnrowToColumnAuxElemOfDisjointNotOrElem rowToColumnmeltAuxmeltRow' retroSnocmeltRowmelt$fRowToColumnats:$fRowToColumnkts[] $fHasLengthk:$fHasLengthk[]RecVecallocRec freezeRecgrowRecwriteRecindexRec produceRecVectorsVectorMs VectorMFor VectorForinitialCapacity inCoreSoA inCoreAoS inCoreAoS'toAoSinCore filterFrameproduceFrameChunks frameChunks $fRecVec: $fRecVec[] innerJoin outerJoin rightJoinleftJoin$fNFDataElField $fNFDataFrame$fNFDataCompose$fNFData1Compose $fNFDataRec$fNFData1Identity$fNFDataIdentity$fGroupingText$fGroupingElField $fGroupingRec$fGroupingRec0 pipePreviewselectlensesprpr1 recToListtakeRowsdropRows showFrame printFrameReadRecreadRec ParserOptionsheaderOverridecolumnSeparator quotingMode QuotingMode NoQuotingRFC4180Quoting QuoteChar Separator defaultParser defaultSep tokenizeRowreassembleRFC4180QuotedPartsprefixInferencereadColHeaders pipeLinesproduceTextLines produceTokensconsumeTextLinesreadFileLatin1LnreadRowreadTableMaybeOptpipeTableMaybeOptpipeTableEitherOptreadTableMaybepipeTableMaybepipeTableEither readTableOpt pipeTableOpt readTable readRecEitherreadTableDebug pipeTable showFieldsCSV produceCSV produceDSV pipeToCSVwriteCSVwriteDSV$fLiftLiftedRepParserOptions $fReadRec: $fReadRec[]$fEqParserOptions$fShowParserOptions$fEqQuotingMode$fShowQuotingMode$fLiftLiftedRepQuotingMode capitalize1sanitizeTypeName Categorical categoriescap unboxDeclsdeclareCategorical$fParseableCategorical$fEqCategorical$fShowCategoricalColumnsColumnUniverseCommonColumnsCat CommonColumnsColInfo parsedTypeRep$fColumnTypeableCoRec$fSemigroupCoRec $fMonoidCoRec $fShowColInfoRowGen columnNames tablePrefix separator rowTypeNamecolumnUniverseinferencePrefix lineReaderrecDec mkColSynDec mkColLensDec lowerHeadcolDec declareColumndeclarePrefixedColumnrowGen rowGenCat tableTypes prefixSize colNamesPtableTypesText' tableTypes' runSafeEffectbase GHC.MaybeNothingGHC.BasereturnMayberputfmapMonoVghc-prim GHC.TypesInt Data.FoldableFoldable&vector-0.12.3.0-Iq8W8y7X87B1xSQfAcXis3 Data.VectorVectorMonoid Data.ProxyProxyStringGHC.IO.Handle.TypesHandle#pipes-4.3.16-4NoIkh0OXloKKe0ZGd7GS6Pipesyield Pipes.CoreProducer.vector-th-unbox-0.2.1.9-ItvMwdtNXvqEtihiTQY3AoData.Vector.Unboxed.Deriving derivingUnboxBoolDouble rdowncastrreplacerlensrlens'rputrput'rget RecElemFCtxRecElemrputCrgetCrlensCRElem RecSubsetFCtx RecSubset rreplaceCrcastCrsubsetCRSubset REquivalent∈⊆≅<::~: