G      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFNone $DLORT(Streaming versions of /Data.Conduit.Combinators.Internal.initReplicate)Streaming versions of ,Data.Conduit.Combinators.Internal.initRepeatGUtility function+HIJKLMNOPQRSTUVmaximum allowed size !"#$%&'()G !"#$%&'() !"#$%&'() HIJKLMNOPQRSTUV !"#$%&'()GNoneOTW[Acquire the seed value and perform the given action with it n times, yielding each result.Subject to fusion Since 0.2.1*[Acquire the seed value and perform the given action with it n times, yielding each result.Subject to fusion Since 0.2.1+NOptimized version of initReplicate for the special case of connecting with a Sink. Since 0.2.1X[Acquire the seed value and perform the given action with it forever, yielding each result.Subject to fusion Since 0.2.1,[Acquire the seed value and perform the given action with it forever, yielding each result.Subject to fusion Since 0.2.1-KOptimized version of initRepeat for the special case of connecting with a Sink. Since 0.2.1W*+X,-*+,-*+,-W*+X,-None %&:<=OTY0Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors.Subject to fusion Since 1.0.0.0Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors.Subject to fusion Since 1.0.0/&Generate a producer from a seed value.Subject to fusion Since 1.0.008Enumerate from a value to a final value, inclusive, via Z.,This is generally more efficient than using Prelude's  enumFromTo and combining with  sourceList5 since this avoids any intermediate data structures.Subject to fusion Since 1.0.01?Produces an infinite stream of repeated applications of f to x.Subject to fusion Since 1.0.02BProduce an infinite stream consisting entirely of the given value.Subject to fusion Since 1.0.03BProduce a finite stream consisting of n copies of the given value.Subject to fusion Since 1.0.04?Generate a producer by yielding each of the strict chunks in a  LazySequence.For more information, see [.Subject to fusion Since 1.0.0\ARepeatedly run the given action and yield all values it produces.Subject to fusion Since 1.0.05ARepeatedly run the given action and yield all values it produces.Subject to fusion Since 1.0.0]hRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusion Since 1.0.06hRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusion Since 1.0.077Perform the given action n times, yielding each result.Subject to fusion Since 1.0.08"Read all data from the given file.`This function automatically opens and closes the file handle, and ensures exception safety via  MonadResource . It works for all instances of IOData , including  ByteString and Text. Since 1.0.098 specialized to ^ to help with type inference._Read all data from the given Handle.Does not close the Handle at any point.Subject to fusion Since 1.0.0:Read all data from the given Handle.Does not close the Handle at any point.Subject to fusion Since 1.0.0;Open a Handle2 using the given function and stream data from it.,Automatically closes the file at completion. Since 1.0.0< sourceHandle applied to stdin.Subject to fusion Since 1.0.0=SCreate an infinite stream of random values, seeding from the system random number.Subject to fusion Since 1.0.0>UCreate a stream of random values of length n, seeding from the system random number.Subject to fusion Since 1.0.0?UCreate an infinite stream of random values, using the given random number generator.Subject to fusion Since 1.0.0@UCreate a stream of random values of length n, seeding from the system random number.Subject to fusion Since 1.0.0ArCreate an infinite stream of random values from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3BtCreate a stream of random values of length n from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3CtCreate an infinite stream of random values from an arbitrary distribution, using the given random number generator.Subject to fusion Since 1.0.3DtCreate a stream of random values of length n from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3EFStream the contents of the given directory, without traversing deeply.This function will return allL of the contents of the directory, whether they be files, directories, etc.}Note that the generated filepaths will be the complete path, not just the filename. In other words, if you have a directory foo containing files bar and baz, and you use sourceDirectory on foo, the results will be foo/bar and foo/baz. Since 1.0.0F2Deeply stream the contents of the given directory.This works the same as sourceDirectory, but will not return directories at all. This function also takes an extra parameter to indicate whether symlinks will be followed. Since 1.0.0G0Ignore a certain number of values in the stream. Since 1.0.0H8Drop a certain number of elements from a chunked stream. Since 1.0.0I0Drop all values which match the given predicate. Since 1.0.0JHDrop all elements in the chunked stream which match the given predicate. Since 1.0.0K,Monoidally combine all values in the stream.Subject to fusion Since 1.0.0L6Monoidally combine all elements in the chunked stream.Subject to fusion Since 1.0.0MA strict left fold.Subject to fusion Since 1.0.0N'A strict left fold on a chunked stream.Subject to fusion Since 1.0.0ODApply the provided mapping function and monoidal combine all values.Subject to fusion Since 1.0.0P\Apply the provided mapping function and monoidal combine all elements of the chunked stream.Subject to fusion Since 1.0.0`4A strict left fold with no starting value. Returns a when the stream is empty.Subject to fusionQ4A strict left fold with no starting value. Returns a when the stream is empty.Subject to fusionbIA strict left fold on a chunked stream, with no starting value. Returns a when the stream is empty.Subject to fusion Since 1.0.0c0Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusion Since 1.0.0R0Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusion Since 1.0.0S:Check that all elements in the chunked stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusion Since 1.0.0d9Check that at least one value in the stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop.Subject to fusion Since 1.0.0T9Check that at least one value in the stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop.Subject to fusion Since 1.0.0UCCheck that at least one element in the chunked stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop.Subject to fusion Since 1.0.0V"Are all values in the stream True?6Consumption stops once the first False is encountered.Subject to fusion Since 1.0.0W,Are all elements in the chunked stream True?6Consumption stops once the first False is encountered.Subject to fusion Since 1.0.0X"Are any values in the stream True?5Consumption stops once the first True is encountered.Subject to fusion Since 1.0.0Y,Are any elements in the chunked stream True?5Consumption stops once the first True is encountered.Subject to fusion Since 1.0.0Z6Are any values in the stream equal to the given value?,Stops consuming as soon as a match is found.Subject to fusion Since 1.0.0[BAre any elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.Subject to fusion Since 1.0.0\5Are no values in the stream equal to the given value?,Stops consuming as soon as a match is found.Subject to fusion Since 1.0.0]AAre no elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.Subject to fusion Since 1.0.0e|Consume all incoming strict chunks into a lazy sequence. Note that the entirety of the sequence will be resident at memory.`This can be used to consume a stream of strict ByteStrings into a lazy ByteString, for example.Subject to fusion Since 1.0.0^|Consume all incoming strict chunks into a lazy sequence. Note that the entirety of the sequence will be resident at memory.`This can be used to consume a stream of strict ByteStrings into a lazy ByteString, for example.Subject to fusion Since 1.0.0_jConsume all values from the stream and return as a list. Note that this will pull all values into memory.Subject to fusion Since 1.0.0fZSink incoming values into a vector, growing the vector as necessary to fit more elements.<Note that using this function is more memory efficient than sinkList and then converting to a Vector., as it avoids intermediate list constructors.Subject to fusion Since 1.0.0`ZSink incoming values into a vector, growing the vector as necessary to fit more elements.<Note that using this function is more memory efficient than sinkList and then converting to a Vector., as it avoids intermediate list constructors.Subject to fusion Since 1.0.0g2Sink incoming values into a vector, up until size maxSizeI. Subsequent values will be left in the stream. If there are less than maxSize values present, returns a Vector of smaller size.<Note that using this function is more memory efficient than sinkList and then converting to a Vector., as it avoids intermediate list constructors.Subject to fusion Since 1.0.0a2Sink incoming values into a vector, up until size maxSizeI. Subsequent values will be left in the stream. If there are less than maxSize values present, returns a Vector of smaller size.<Note that using this function is more memory efficient than sinkList and then converting to a Vector., as it avoids intermediate list constructors.Subject to fusion Since 1.0.0bJConvert incoming values to a builder and fold together all builder values. Defined as: foldMap toBuilder.Subject to fusion Since 1.0.0hSame as  sinkBuilderA, but afterwards convert the builder to its lazy representation.:Alternatively, this could be considered an alternative to sinkLazy", with the following differences:bThis function will allow multiple input types, not just the strict version of the lazy structure..Some buffer copying may occur in this version.Subject to fusion Since 1.0.0cSame as  sinkBuilderA, but afterwards convert the builder to its lazy representation.:Alternatively, this could be considered an alternative to sinkLazy", with the following differences:bThis function will allow multiple input types, not just the strict version of the lazy structure..Some buffer copying may occur in this version.Subject to fusion Since 1.0.0d7Consume and discard all remaining values in the stream.Subject to fusion Since 1.0.0eSame as await, but discards any leading i values. Since 1.0.0f2Take a single value from the stream, if available. Since 1.0.5gSame as fD, but returns a default value if none are available from the stream. Since 1.0.5h+Get the next element in the chunked stream. Since 1.0.0i7View the next value in the stream without consuming it. Since 1.0.0jAView the next element in the chunked stream without consuming it. Since 1.0.0j2Retrieve the last value in the stream, if present.Subject to fusion Since 1.0.0k2Retrieve the last value in the stream, if present.Subject to fusion Since 1.0.0lSame as kD, but returns a default value if none are available from the stream. Since 1.0.5k<Retrieve the last element in the chunked stream, if present.Subject to fusion Since 1.0.0m<Retrieve the last element in the chunked stream, if present.Subject to fusion Since 1.0.0n(Count how many values are in the stream.Subject to fusion Since 1.0.0o2Count how many elements are in the chunked stream.Subject to fusion Since 1.0.0p=Count how many values in the stream pass the given predicate.Subject to fusion Since 1.0.0qGCount how many elements in the chunked stream pass the given predicate.Subject to fusion Since 1.0.0r0Get the largest value in the stream, if present.Subject to fusion Since 1.0.0s:Get the largest element in the chunked stream, if present.Subject to fusion Since 1.0.0t1Get the smallest value in the stream, if present.Subject to fusion Since 1.0.0u;Get the smallest element in the chunked stream, if present.Subject to fusion Since 1.0.0v*True if there are no values in the stream.)This function does not modify the stream. Since 1.0.0w4True if there are no elements in the chunked stream.aThis function may remove empty leading chunks from the stream, but otherwise will not modify it. Since 1.0.0x(Get the sum of all values in the stream.Subject to fusion Since 1.0.0y2Get the sum of all elements in the chunked stream.Subject to fusion Since 1.0.0z,Get the product of all values in the stream.Subject to fusion Since 1.0.0{6Get the product of all elements in the chunked stream.Subject to fusion Since 1.0.0lFind the first matching value.Subject to fusion Since 1.0.0|Find the first matching value.Subject to fusion Since 1.0.0}-Apply the action to all values in the stream.Subject to fusion Since 1.0.0~7Apply the action to all elements in the chunked stream.Subject to fusion Since 1.0.0A monadic strict left fold.Subject to fusion Since 1.0.0/A monadic strict left fold on a chunked stream.Subject to fusion Since 1.0.0LApply the provided monadic mapping function and monoidal combine all values.Subject to fusion Since 1.0.0eApply the provided monadic mapping function and monoidal combine all elements in the chunked stream.Subject to fusion Since 1.0.0!Write all data to the given file.`This function automatically opens and closes the file handle, and ensures exception safety via  MonadResource . It works for all instances of IOData , including  ByteString and Text. Since 1.0.0 specialized to ^ to help with type inference.$Print all incoming values to stdout.Subject to fusion Since 1.0.0 sinkHandle applied to stdout.Subject to fusion Since 1.0.0 sinkHandle applied to stderr.Subject to fusion Since 1.0.0Write all data to the given Handle.Does not close the Handle at any point.Subject to fusion Since 1.0.0Open a Handle0 using the given function and stream data to it.,Automatically closes the file at completion. Since 1.0.01Apply a transformation to all values in a stream.Subject to fusion Since 1.0.0;Apply a transformation to all elements in a chunked stream.Subject to fusion Since 1.0.0GApply a monomorphic transformation to all elements in a chunked stream.Unlike mapE, this will work on types like  ByteString and Text which are  MonoFunctor but not Functor.Subject to fusion Since 1.0.0mApply the function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.1Generalizes concatMap, mapMaybe, and mapFoldable.Subject to fusion Since 1.0.0Apply the function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.1Generalizes concatMap, mapMaybe, and mapFoldable.Subject to fusion Since 1.0.0Apply the function to each element in the chunked stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.1Generalizes concatMap, mapMaybe, and mapFoldable.Subject to fusion Since 1.0.0+Stream up to n number of values downstream.bNote that, if downstream terminates early, not all values will be consumed. If you want to force exactly1 the given number of values to be consumed, see .Subject to fusion Since 1.0.0AStream up to n number of elements downstream in a chunked stream.bNote that, if downstream terminates early, not all values will be consumed. If you want to force exactly1 the given number of values to be consumed, see . Since 1.0.0<Stream all values downstream that match the given predicate.<Same caveats regarding downstream termination apply as with . Since 1.0.0RStream all elements downstream that match the given predicate in a chunked stream.<Same caveats regarding downstream termination apply as with . Since 1.0.0FConsume precisely the given number of values and feed them downstream. This function is in contrast to , which will only consume up to the given number of values, and will terminate early if downstream terminates early. This function will discard any additional values in the stream if they are unconsumed.+Note that this function takes a downstream ConduitMW as a parameter, as opposed to working with normal fusion. For more information, see  <http://www.yesodweb.com/blog/2013/10/core-flaw-pipes-conduit3, the section titled "pipes and conduit: isolate". Since 1.0.0Same as , but for chunked streams. Since 1.0.0nFFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values.Subject to fusion Since 1.0.0FFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values.Subject to fusion Since 1.0.09Keep only values in the stream passing a given predicate.Subject to fusion Since 1.0.0CKeep only elements in the chunked stream passing a given predicate.Subject to fusion Since 1.0.0$Map values as long as the result is Just. Since 1.0.0Break up a stream of values into vectors of size n. The final vector may be smaller than n if the total number of values is not a strict multiple of n. No empty vectors will be yielded. Since 1.0.0o Analog of p for lists.Subject to fusion Since 1.0.6 Analog of p for lists.Subject to fusion Since 1.0.6qJ with a break condition dependent on a strict accumulator. Equivalently, r as long as the result is Righta. Instead of producing a leftover, the breaking input determines the resulting accumulator via Left.Subject to fusionJ with a break condition dependent on a strict accumulator. Equivalently, r as long as the result is Righta. Instead of producing a leftover, the breaking input determines the resulting accumulator via Left.Subject to fusion with an accumulator.Subject to fusion Since 1.0.0s=Insert the given value between each two values in the stream.Subject to fusion Since 1.0.0=Insert the given value between each two values in the stream.Subject to fusion Since 1.0.0tUSliding window of values 1,2,3,4,5 with window size 2 gives [1,2],[2,3],[3,4],[4,5]1Best used with structures that support O(1) snoc.Subject to fusion Since 1.0.0USliding window of values 1,2,3,4,5 with window size 2 gives [1,2],[2,3],[3,4],[4,5]1Best used with structures that support O(1) snoc.Subject to fusion Since 1.0.0$Apply base64-encoding to the stream. Since 1.0.0TApply base64-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.0!Apply URL-encoding to the stream. Since 1.0.0_Apply lenient base64URL-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.0$Apply base16-encoding to the stream.Subject to fusion Since 1.0.0TApply base16-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.09Apply a monadic transformation to all values in a stream.vIf you do not need the transformed values, and instead just want the monadic side-effects of running the action, see }.Subject to fusion Since 1.0.0CApply a monadic transformation to all elements in a chunked stream.Subject to fusion Since 1.0.0OApply a monadic monomorphic transformation to all elements in a chunked stream.Unlike mapME, this will work on types like  ByteString and Text which are  MonoFunctor but not Functor.Subject to fusion Since 1.0.0uApply the monadic function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.4Generalizes concatMapM, mapMaybeM, and mapFoldableM.Subject to fusion Since 1.0.0Apply the monadic function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.4Generalizes concatMapM, mapMaybeM, and mapFoldableM.Subject to fusion Since 1.0.0vAKeep only values in the stream passing a given monadic predicate.Subject to fusion Since 1.0.0AKeep only values in the stream passing a given monadic predicate.Subject to fusion Since 1.0.0KKeep only elements in the chunked stream passing a given monadic predicate.Subject to fusion Since 1.0.01Apply a monadic action on all values in a stream.This Conduite can be used to perform a monadic side-effect for every value, whilst passing the value through the Conduit as-is. .iterM f = mapM (\a -> f a >>= \() -> return a)Subject to fusion Since 1.0.0w Analog of p for lists, monadic.Subject to fusion Since 1.0.6 Analog of p for lists, monadic.Subject to fusion Since 1.0.6xMonadic .Subject to fusionMonadic .Subject to fusion with an accumulator.Subject to fusion Since 1.0.0 Encode a stream of text as UTF8.Subject to fusion Since 1.0.0'Decode a stream of binary data as UTF8. Since 1.0.0lDecode a stream of binary data as UTF8, replacing any invalid bytes with the Unicode replacement character. Since 1.0.0(Stream in the entirety of a single line.Like  takeExactly^, this will consume the entirety of the line regardless of the behavior of the inner Conduit. Since 1.0.0Same as $, but operates on ASCII/binary data. Since 1.0.0AStream in the chunked input until an element matches a predicate.Like  takeExactly`, this will consume the entirety of the prefix regardless of the behavior of the inner Conduit.=Insert a newline character after each incoming chunk of data.Subject to fusion Since 1.0.0Same as $, but operates on ASCII/binary data.Subject to fusion Since 1.0.0ySplit a stream of arbitrarily-chunked data, based on a predicate on elements. Elements that satisfy the predicate will cause chunks to be split, and aren't included in these output chunks. Note that, if you have unknown or untrusted input, this function is unsafeX, since it would allow an attacker to form chunks of massive length and exhaust memory.Split a stream of arbitrarily-chunked data, based on a predicate on elements. Elements that satisfy the predicate will cause chunks to be split, and aren't included in these output chunks. Note that, if you have unknown or untrusted input, this function is unsafeX, since it would allow an attacker to form chunks of massive length and exhaust memory.Convert a stream of arbitrarily-chunked textual data into a stream of data where each chunk represents a single line. Note that, if you have unknown or untrusted input, this function is unsafeW, since it would allow an attacker to form lines of massive length and exhaust memory.Subject to fusion Since 1.0.0Same as , but for ASCII/binary data.Subject to fusion Since 1.0.0Generally speaking, yielding values from inside a Conduit requires some allocation for constructors. This can introduce an overhead, similar to the overhead needed to represent a list of values instead of a vector. This overhead is even more severe when talking about unboxed values.!This combinator allows you to overcome this overhead, and efficiently fill up vectors. It takes two parameters. The first is the size of each mutable vector to be allocated. The second is a function. The function takes an argument which will yield the next value into a mutable vector.Under the surface, this function uses a number of tricks to get high performance. For more information on both usage and implementation, please see: Lhttps://www.fpcomplete.com/user/snoyberg/library-documentation/vectorbuilder Since 1.0.0Consume a source with a strict accumulator, in a way piecewise defined by a controlling stream. The latter will be evaluated until it terminates./let f a s = liftM (:s) $ mapC (*a) =$ CL.take aLreverse $ runIdentity $ yieldMany [0..3] $$ mapAccumS f [] (yieldMany [1..])$[[],[1],[4,6],[12,15,18]] :: [[Int]]fRun a consuming conduit repeatedly, only stopping when there is no more data available from upstream. Since 1.0.0fRun a consuming conduit repeatedly, only stopping when there is no more data available from upstream.In contrast to j, this function will ignore empty chunks of data. So for example, if a stream of data contains an empty  ByteStringJ, it is still treated as empty, and the consuming function is not called.z{Y./01234\5]6789_:;<=>count?@countABcountCDcountEFFollow directory symlinksRoot directoryGHIJKLMN|OP`Qb}cRSdTUVWXYZ[\]e^_f`gmaximum allowed sizeamaximum allowed sizebhcdefghijjklkmnopqrstuvwxyz{l|}~mnmaximum allowed sizeoqst~uvwxysize./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~./0123456789:;<=>?@ABCDEFGHIJKLMQNOPRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~z{Y./01234\5]6789_:;<=>?@ABCDEFGHIJKLMN|OP`Qb}cRSdTUVWXYZ[\]e^_f`gabhcdefghijjklkmnopqrstuvwxyz{l|}~mnoqst~uvwxyNone %&:<=OT0Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors. Since 1.0.0&Generate a producer from a seed value. Since 1.0.08Enumerate from a value to a final value, inclusive, via succ.,This is generally more efficient than using Prelude's  enumFromTo and combining with  sourceList5 since this avoids any intermediate data structures. Since 1.0.0?Produces an infinite stream of repeated applications of f to x. Since 1.0.0BProduce an infinite stream consisting entirely of the given value. Since 1.0.0BProduce a finite stream consisting of n copies of the given value. Since 1.0.0?Generate a producer by yielding each of the strict chunks in a  LazySequence.For more information, see [. Since 1.0.0ARepeatedly run the given action and yield all values it produces. Since 1.0.0hRepeatedly run the given action and yield all values it produces, until the provided predicate returns False. Since 1.0.07Perform the given action n times, yielding each result. Since 1.0.0"Read all data from the given file.`This function automatically opens and closes the file handle, and ensures exception safety via -MonadResource. It works for all instances of IOData , including  ByteString and Text@. Since 1.0.0Read all data from the given Handle.Does not close the Handle at any point. Since 1.0.0Open a Handle2 using the given function and stream data from it.,Automatically closes the file at completion. Since 1.0.0 sourceHandle applied to stdin. Since 1.0.0SCreate an infinite stream of random values, seeding from the system random number. Since 1.0.0UCreate a stream of random values of length n, seeding from the system random number. Since 1.0.0UCreate an infinite stream of random values, using the given random number generator. Since 1.0.0UCreate a stream of random values of length n, seeding from the system random number. Since 1.0.0rCreate an infinite stream of random values from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3tCreate a stream of random values of length n from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3tCreate an infinite stream of random values from an arbitrary distribution, using the given random number generator.Subject to fusion Since 1.0.3tCreate a stream of random values of length n from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3FStream the contents of the given directory, without traversing deeply.This function will return allL of the contents of the directory, whether they be files, directories, etc.}Note that the generated filepaths will be the complete path, not just the filename. In other words, if you have a directory foo containing files bar and baz, and you use sourceDirectory on foo, the results will be foo/bar and foo/baz. Since 1.0.02Deeply stream the contents of the given directory.This works the same as sourceDirectory, but will not return directories at all. This function also takes an extra parameter to indicate whether symlinks will be followed. Since 1.0.00Ignore a certain number of values in the stream. Since 1.0.08Drop a certain number of elements from a chunked stream. Since 1.0.00Drop all values which match the given predicate. Since 1.0.0HDrop all elements in the chunked stream which match the given predicate. Since 1.0.0,Monoidally combine all values in the stream. Since 1.0.06Monoidally combine all elements in the chunked stream. Since 1.0.0A strict left fold. Since 1.0.0'A strict left fold on a chunked stream. Since 1.0.0DApply the provided mapping function and monoidal combine all values. Since 1.0.0\Apply the provided mapping function and monoidal combine all elements of the chunked stream. Since 1.0.00Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop. Since 1.0.0:Check that all elements in the chunked stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop. Since 1.0.09Check that at least one value in the stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop. Since 1.0.0CCheck that at least one element in the chunked stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop. Since 1.0.0"Are all values in the stream True?6Consumption stops once the first False is encountered. Since 1.0.0,Are all elements in the chunked stream True?6Consumption stops once the first False is encountered. Since 1.0.0"Are any values in the stream True?5Consumption stops once the first True is encountered. Since 1.0.0,Are any elements in the chunked stream True?5Consumption stops once the first True is encountered. Since 1.0.06Are any values in the stream equal to the given value?,Stops consuming as soon as a match is found. Since 1.0.0BAre any elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found. Since 1.0.05Are no values in the stream equal to the given value?,Stops consuming as soon as a match is found. Since 1.0.0AAre no elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found. Since 1.0.0|Consume all incoming strict chunks into a lazy sequence. Note that the entirety of the sequence will be resident at memory.`This can be used to consume a stream of strict ByteStrings into a lazy ByteString, for example. Since 1.0.0jConsume all values from the stream and return as a list. Note that this will pull all values into memory. Since 1.0.0ZSink incoming values into a vector, growing the vector as necessary to fit more elements.<Note that using this function is more memory efficient than sinkList and then converting to a Vector., as it avoids intermediate list constructors. Since 1.0.02Sink incoming values into a vector, up until size maxSizeI. Subsequent values will be left in the stream. If there are less than maxSize values present, returns a Vector of smaller size.<Note that using this function is more memory efficient than sinkList and then converting to a Vector., as it avoids intermediate list constructors. Since 1.0.0JConvert incoming values to a builder and fold together all builder values. Defined as: foldMap toBuilder. Since 1.0.0Same as  sinkBuilderA, but afterwards convert the builder to its lazy representation.:Alternatively, this could be considered an alternative to sinkLazy", with the following differences:bThis function will allow multiple input types, not just the strict version of the lazy structure..Some buffer copying may occur in this version. Since 1.0.07Consume and discard all remaining values in the stream. Since 1.0.0Same as await, but discards any leading i values. Since 1.0.02Take a single value from the stream, if available. Since 1.0.5Same as D, but returns a default value if none are available from the stream. Since 1.0.5+Get the next element in the chunked stream. Since 1.0.07View the next value in the stream without consuming it. Since 1.0.0AView the next element in the chunked stream without consuming it. Since 1.0.02Retrieve the last value in the stream, if present. Since 1.0.0Same as D, but returns a default value if none are available from the stream. Since 1.0.5<Retrieve the last element in the chunked stream, if present. Since 1.0.0(Count how many values are in the stream. Since 1.0.02Count how many elements are in the chunked stream. Since 1.0.0=Count how many values in the stream pass the given predicate. Since 1.0.0GCount how many elements in the chunked stream pass the given predicate. Since 1.0.00Get the largest value in the stream, if present. Since 1.0.0:Get the largest element in the chunked stream, if present. Since 1.0.01Get the smallest value in the stream, if present. Since 1.0.0;Get the smallest element in the chunked stream, if present. Since 1.0.0*True if there are no values in the stream.)This function does not modify the stream. Since 1.0.04True if there are no elements in the chunked stream.aThis function may remove empty leading chunks from the stream, but otherwise will not modify it. Since 1.0.0(Get the sum of all values in the stream. Since 1.0.02Get the sum of all elements in the chunked stream. Since 1.0.0,Get the product of all values in the stream. Since 1.0.0 6Get the product of all elements in the chunked stream. Since 1.0.0 Find the first matching value. Since 1.0.0 -Apply the action to all values in the stream. Since 1.0.0 7Apply the action to all elements in the chunked stream. Since 1.0.0 A monadic strict left fold. Since 1.0.0/A monadic strict left fold on a chunked stream. Since 1.0.0LApply the provided monadic mapping function and monoidal combine all values. Since 1.0.0eApply the provided monadic mapping function and monoidal combine all elements in the chunked stream. Since 1.0.0!Write all data to the given file.`This function automatically opens and closes the file handle, and ensures exception safety via -MonadResource. It works for all instances of IOData , including  ByteString and Text@. Since 1.0.0Write all data to the given Handle.Does not close the Handle at any point. Since 1.0.0Open a Handle0 using the given function and stream data to it.,Automatically closes the file at completion. Since 1.0.0$Print all incoming values to stdout. Since 1.0.0 sinkHandle applied to stdout. Since 1.0.0 sinkHandle applied to stderr. Since 1.0.01Apply a transformation to all values in a stream. Since 1.0.0;Apply a transformation to all elements in a chunked stream. Since 1.0.0GApply a monomorphic transformation to all elements in a chunked stream.Unlike mapE, this will work on types like  ByteString and Text which are  MonoFunctor but not Functor. Since 1.0.0Apply the function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.1Generalizes concatMap, mapMaybe, and mapFoldable. Since 1.0.0Apply the function to each element in the chunked stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.1Generalizes concatMap, mapMaybe, and mapFoldable. Since 1.0.0+Stream up to n number of values downstream.bNote that, if downstream terminates early, not all values will be consumed. If you want to force exactly1 the given number of values to be consumed, see  takeExactly. Since 1.0.0AStream up to n number of elements downstream in a chunked stream.bNote that, if downstream terminates early, not all values will be consumed. If you want to force exactly1 the given number of values to be consumed, see  takeExactlyE. Since 1.0.0<Stream all values downstream that match the given predicate.<Same caveats regarding downstream termination apply as with take. Since 1.0.0RStream all elements downstream that match the given predicate in a chunked stream.<Same caveats regarding downstream termination apply as with takeE. Since 1.0.0 FConsume precisely the given number of values and feed them downstream. This function is in contrast to take, which will only consume up to the given number of values, and will terminate early if downstream terminates early. This function will discard any additional values in the stream if they are unconsumed.+Note that this function takes a downstream ConduitMW as a parameter, as opposed to working with normal fusion. For more information, see  <http://www.yesodweb.com/blog/2013/10/core-flaw-pipes-conduit3, the section titled "pipes and conduit: isolate". Since 1.0.0!Same as  takeExactly, but for chunked streams. Since 1.0.0"FFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values. Since 1.0.0#9Keep only values in the stream passing a given predicate. Since 1.0.0$CKeep only elements in the chunked stream passing a given predicate. Since 1.0.0%$Map values as long as the result is Just. Since 1.0.0&Break up a stream of values into vectors of size n. The final vector may be smaller than n if the total number of values is not a strict multiple of n. No empty vectors will be yielded. Since 1.0.0' Analog of p for lists. Since 1.0.6(%J with a break condition dependent on a strict accumulator. Equivalently, r as long as the result is Righta. Instead of producing a leftover, the breaking input determines the resulting accumulator via Left.) concatMap with an accumulator. Since 1.0.0*=Insert the given value between each two values in the stream. Since 1.0.0+USliding window of values 1,2,3,4,5 with window size 2 gives [1,2],[2,3],[3,4],[4,5]1Best used with structures that support O(1) snoc. Since 1.0.0,$Apply base64-encoding to the stream. Since 1.0.0-TApply base64-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.0.!Apply URL-encoding to the stream. Since 1.0.0/_Apply lenient base64URL-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.00$Apply base16-encoding to the stream. Since 1.0.01TApply base16-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.029Apply a monadic transformation to all values in a stream.vIf you do not need the transformed values, and instead just want the monadic side-effects of running the action, see mapM_. Since 1.0.03CApply a monadic transformation to all elements in a chunked stream. Since 1.0.04OApply a monadic monomorphic transformation to all elements in a chunked stream.Unlike mapME, this will work on types like  ByteString and Text which are  MonoFunctor but not Functor. Since 1.0.05Apply the monadic function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.4Generalizes concatMapM, mapMaybeM, and mapFoldableM. Since 1.0.06AKeep only values in the stream passing a given monadic predicate. Since 1.0.07KKeep only elements in the chunked stream passing a given monadic predicate. Since 1.0.081Apply a monadic action on all values in a stream.This Conduite can be used to perform a monadic side-effect for every value, whilst passing the value through the Conduit as-is. .iterM f = mapM (\a -> f a >>= \() -> return a) Since 1.0.09 Analog of p for lists, monadic. Since 1.0.6:Monadic (.; concatMapM with an accumulator. Since 1.0.0< Encode a stream of text as UTF8. Since 1.0.0='Decode a stream of binary data as UTF8. Since 1.0.0>lDecode a stream of binary data as UTF8, replacing any invalid bytes with the Unicode replacement character. Since 1.0.0?(Stream in the entirety of a single line.Like  takeExactly^, this will consume the entirety of the line regardless of the behavior of the inner Conduit. Since 1.0.0@Same as line$, but operates on ASCII/binary data. Since 1.0.0A=Insert a newline character after each incoming chunk of data. Since 1.0.0BSame as unlines$, but operates on ASCII/binary data. Since 1.0.0CConvert a stream of arbitrarily-chunked textual data into a stream of data where each chunk represents a single line. Note that, if you have unknown"untrusted input, this function is ^unsafe/, since it would allow an attacker to form lines of massive length and exhaust memory. Since 1.0.0DSame as linesUnbounded, but for ASCII/binary data. Since 1.0.0EGenerally speaking, yielding values from inside a Conduit requires some allocation for constructors. This can introduce an overhead, similar to the overhead needed to represent a list of values instead of a vector. This overhead is even more severe when talking about unboxed values.!This combinator allows you to overcome this overhead, and efficiently fill up vectors. It takes two parameters. The first is the size of each mutable vector to be allocated. The second is a function. The function takes an argument which will yield the next value into a mutable vector.Under the surface, this function uses a number of tricks to get high performance. For more information on both usage and implementation, please see: Lhttps://www.fpcomplete.com/user/snoyberg/library-documentation/vectorbuilder Since 1.0.0countcountcountcountFollow directory symlinksRoot directorymaximum allowed size      !"#$%&maximum allowed size'()*+,-./0123456789:;<=>?@ABCDEsize9      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE      !"#$%&'()*+,-./0123456789:;<=>?@ABCDENone:F   9      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF9      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE  FF       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~AGKMNPQRSTUVWXYqrstuvwx      !"#$%&'()*+,-./0123456789:;<=>?@AB@CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aSbcde fgh"#-.12ijjklmnopfqrfqsfqtfqufqvfqwfqxfqyfqzfq{fq|fq}fq~fqfqfqfqfqfqfqfqfqfqfqfqfqfqfqfqfqfqfqffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0conduit-combinators-1.0.7-Kqe0PK79sY97djdIQq8MKSConduitData.Conduit.Combinators.Stream!Data.Conduit.Combinators.InternalData.Conduit.Combinators$Data.Conduit.Combinators.UnqualifiedbaseData.Functor.Identity runIdentityIdentityControl.Monad.IO.ClassliftIOMonadIO'exceptions-0.8.3-5OTPYzRazb4DJ75sPncYEhControl.Monad.CatchthrowM,monad-control-1.0.1.0-1xoC3YihUKYHLar1SsWtYeControl.Monad.Trans.ControlMonadBaseControl MonadThrowtransformers-0.5.2.0Control.Monad.Trans.Class MonadTranslift.transformers-base-0.4.4-FMTbgPqmqMsCiOz3biyAGxControl.Monad.Base MonadBase(resourcet-1.1.8.1-5khMMQmfOko5MjMvLjxM1gControl.Monad.Trans.Resource runResourceT%Control.Monad.Trans.Resource.Internal MonadResource ResourceTliftBase yieldManySrepeatMS repeatWhileMS sourceHandleSfoldl1SallSanyS sinkLazyS sinkVectorS sinkVectorNSsinkLazyBuilderSlastSlastESfindS concatMapS concatMapMSconcatSscanlSscanlMSmapAccumWhileSmapAccumWhileMS intersperseSslidingWindowSfilterMSsplitOnUnboundedESinitReplicateS initRepeatS initReplicateinitReplicateConnect initRepeatinitRepeatConnect yieldManyunfold enumFromToiteraterepeat replicate sourceLazyrepeatM repeatWhileM replicateM sourceFile sourceFileBS sourceHandlesourceIOHandlestdin sourceRandom sourceRandomNsourceRandomGensourceRandomNGensourceRandomWithsourceRandomNWithsourceRandomGenWithsourceRandomNGenWithsourceDirectorysourceDirectoryDeepdropdropE dropWhile dropWhileEfoldfoldEfoldlfoldlEfoldMapfoldMapEfoldl1allallEanyanyEandandEororEelemelemEnotElemnotElemEsinkLazysinkList sinkVector sinkVectorN sinkBuildersinkLazyBuildersinkNull awaitNonNullheadheadDefheadEpeekpeekElastlastDeflastElengthlengthElengthIf lengthIfEmaximummaximumEminimumminimumEnullnullEsumsumEproductproductEfindmapM_mapM_EfoldMfoldMEfoldMapM foldMapMEsinkFile sinkFileBSprintstdoutstderr sinkHandle sinkIOHandlemapmapEomapE concatMap concatMapEtaketakeE takeWhile takeWhileE takeExactly takeExactlyEconcatfilterfilterEmapWhile conduitVectorscanl mapAccumWhileconcatMapAccum intersperse slidingWindow encodeBase64 decodeBase64encodeBase64URLdecodeBase64URL encodeBase16 decodeBase16mapMmapMEomapME concatMapMfilterMfilterMEiterMscanlMmapAccumWhileMconcatMapAccumM encodeUtf8 decodeUtf8decodeUtf8Lenientline lineAsciitakeExactlyUntilEunlines unlinesAsciisplitOnUnboundedElinesUnboundedlinesUnboundedAscii vectorBuilder mapAccumS peekForever peekForeverEunfoldC enumFromToCiterateCrepeatC replicateCrepeatMC repeatWhileMC replicateMCstdinCdropCdropCE dropWhileC dropWhileCEfoldCfoldCEfoldlCfoldlCEfoldMapC foldMapCEallCallCEanyCanyCEandCandCEorCorCEelemCelemCEnotElemC notElemCEheadCheadDefCheadCEpeekCpeekCElastClastDefClastCElengthClengthCE lengthIfC lengthIfCEmaximumC maximumCEminimumC minimumCEnullCnullCEsumCsumCEproductC productCEfindCmapM_CmapM_CEfoldMCfoldMCE foldMapMC foldMapMCEprintCstdoutCstderrCmapCmapCEomapCE concatMapC concatMapCEtakeCtakeCE takeWhileC takeWhileCE takeExactlyC takeExactlyCEconcatCfilterCfilterCE mapWhileCscanlCmapAccumWhileCconcatMapAccumC intersperseCslidingWindowC encodeBase64C decodeBase64CencodeBase64URLCdecodeBase64URLC encodeBase16C decodeBase16CmapMCmapMCEomapMCE concatMapMCfilterMC filterMCEiterMCscanlMCmapAccumWhileMCconcatMapAccumMC encodeUtf8C decodeUtf8CdecodeUtf8LenientClineC lineAsciiCunlinesC unlinesAsciiClinesUnboundedClinesUnboundedAsciiCvectorBuilderC withAcquirefmapS SplitState SplitDone SplitNoSepSlidingWindowState SWInitial SWSliding SWEarlyExitIntersperseState IFirstValue IGotValue IEmitValue ScanState ScanEnded ScanContinuesinitReplicateC initRepeatC yieldManyCGHC.Enumsucc-mono-traversable-1.0.1-4P30CHMQYuF2IaSUkf2u6ZData.SequencestoChunksbytestring-0.10.8.1Data.ByteString.Internal ByteString sourceHandleCfoldl1CGHC.BaseNothingfoldl1E sinkLazyC sinkVectorC sinkVectorNCsinkLazyBuilderCData.MonoTraversableonulllastECGHC.List$conduit-1.2.8-2ZP0h0MHA9uL2QibPReXc8Data.Conduit.ListmapAccumsplitOnUnboundedECS ofoldlPrime foldMaybeNullcodeWithonAwaityieldSaddEData.Conduit.LiftexecRWSCevalRWSCrunRWSCrwsC execRWSLC evalRWSLCrunRWSLCrwsLC execWriterC runWriterCwriterC execWriterLC runWriterLCwriterLC execStateC evalStateC runStateCstateC execStateLC evalStateLC runStateLCstateLC runReaderCreaderC runMaybeCmaybeC catchCatchC runCatchC catchErrorC runErrorCerrorC distribute Data.Conduit runConduitResrunConduitPure.|fuseconnectData.Conduit.Internal.Conduit fuseUpstream fuseBothMaybefuseBothsequenceConduits=$$+-=$$++=$$+ sequenceSinkssequenceSourcescloseResumableSource$=+$$+-$$++$$+mapInputmapOutputMaybe mapOutput transPipe awaitForeveryieldOr addCleanupbracketP runConduitleftoveryieldMyieldawait=$==$$=$$ sourceToListpassthroughSink mergeSourcenewResumableConduitunwrapResumableConduit fuseLeftoversfuseReturnLeftoverstryChandleCcatchC toConsumer toProducernewResumableSourceunwrapResumableConduitMSourceProducerSinkConsumerResumableSourceResumableConduitFlushChunk ZipSource getZipSourceZipSink getZipSink ZipConduit getZipConduit Data.AcquireallocateAcquireData.Acquire.InternalwithEx mkAcquireType mkAcquire ReleaseType ReleaseEarly ReleaseNormalReleaseExceptionAcquire