D/      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-.None  =EHKM%Streaming versions of /Data.Conduit.Combinators.Internal.initReplicate&Streaming versions of ,Data.Conduit.Combinators.Internal.initRepeat/Utility function)0123456789:;<=>maximum allowed size !"#$%&/ !"#$%& !"#$%&032147658;:9<>= !"#$%&/NoneHM?[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.1@[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.1?'(@)*'()*'()*?'(@)*None !"36HMA0Yield 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.0.8Enumerate from a value to a final value, inclusive, via B.,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.0/?Produces an infinite stream of repeated applications of f to x.Subject to fusion Since 1.0.00BProduce an infinite stream consisting entirely of the given value.Subject to fusion Since 1.0.01BProduce a finite stream consisting of n copies of the given value.Subject to fusion Since 1.0.02?Generate a producer by yielding each of the strict chunks in a  LazySequence.For more information, see C.Subject to fusion Since 1.0.0DARepeatedly run the given action and yield all values it produces.Subject to fusion Since 1.0.03ARepeatedly run the given action and yield all values it produces.Subject to fusion Since 1.0.0EhRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusion Since 1.0.04hRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusion Since 1.0.057Perform the given action n times, yielding each result.Subject to fusion Since 1.0.06"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.0FRead all data from the given Handle.Does not close the Handle at any point.Subject to fusion Since 1.0.07Read all data from the given Handle.Does not close the Handle at any point.Subject to fusion Since 1.0.08Open a Handle2 using the given function and stream data from it.,Automatically closes the file at completion. Since 1.0.09 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.0>FStream 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.0?2Deeply 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.0@0Ignore a certain number of values in the stream. Since 1.0.0A8Drop a certain number of elements from a chunked stream. Since 1.0.0B0Drop all values which match the given predicate. Since 1.0.0CHDrop all elements in the chunked stream which match the given predicate. Since 1.0.0D,Monoidally combine all values in the stream.Subject to fusion Since 1.0.0E6Monoidally combine all elements in the chunked stream.Subject to fusion Since 1.0.0FA strict left fold.Subject to fusion Since 1.0.0G'A strict left fold on a chunked stream.Subject to fusion Since 1.0.0HDApply the provided mapping function and monoidal combine all values.Subject to fusion Since 1.0.0I\Apply the provided mapping function and monoidal combine all elements of the chunked stream.Subject to fusion Since 1.0.0G4A strict left fold with no starting value. Returns H when the stream is empty.Subject to fusionJ4A strict left fold with no starting value. Returns H when the stream is empty.Subject to fusionIIA strict left fold on a chunked stream, with no starting value. Returns H when the stream is empty.Subject to fusion Since 1.0.0J0Check 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.0K0Check 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.0L: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.0K9Check 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.0M9Check 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.0NCCheck 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.0O"Are all values in the stream True?6Consumption stops once the first False is encountered.Subject to fusion Since 1.0.0P,Are all elements in the chunked stream True?6Consumption stops once the first False is encountered.Subject to fusion Since 1.0.0Q"Are any values in the stream True?5Consumption stops once the first True is encountered.Subject to fusion Since 1.0.0R,Are any elements in the chunked stream True?5Consumption stops once the first True is encountered.Subject to fusion Since 1.0.0S6Are 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.0TBAre 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.0U5Are 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.0VAAre 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.0L|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.0W|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.0XjConsume 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.0MZSink 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.0YZSink 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.0N2Sink 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.0Z2Sink 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.0[JConvert incoming values to a builder and fold together all builder values. Defined as: foldMap toBuilder.Subject to fusion Since 1.0.0OSame 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.0\Same 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.0]7Consume and discard all remaining values in the stream.Subject to fusion Since 1.0.0^Same as await, but discards any leading P values. Since 1.0.0_+Get the next element in the chunked stream. Since 1.0.0`7View the next value in the stream without consuming it. Since 1.0.0aAView the next element in the chunked stream without consuming it. Since 1.0.0Q2Retrieve the last value in the stream, if present.Subject to fusion Since 1.0.0b2Retrieve the last value in the stream, if present.Subject to fusion Since 1.0.0R<Retrieve the last element in the chunked stream, if present.Subject to fusion Since 1.0.0c<Retrieve the last element in the chunked stream, if present.Subject to fusion Since 1.0.0d(Count how many values are in the stream.Subject to fusion Since 1.0.0e2Count how many elements are in the chunked stream.Subject to fusion Since 1.0.0f=Count how many values in the stream pass the given predicate.Subject to fusion Since 1.0.0gGCount how many elements in the chunked stream pass the given predicate.Subject to fusion Since 1.0.0h0Get the largest value in the stream, if present.Subject to fusion Since 1.0.0i:Get the largest element in the chunked stream, if present.Subject to fusion Since 1.0.0j1Get the smallest value in the stream, if present.Subject to fusion Since 1.0.0k;Get the smallest element in the chunked stream, if present.Subject to fusion Since 1.0.0l*True if there are no values in the stream.)This function does not modify the stream. Since 1.0.0m4True 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.0n(Get the sum of all values in the stream.Subject to fusion Since 1.0.0o2Get the sum of all elements in the chunked stream.Subject to fusion Since 1.0.0p,Get the product of all values in the stream.Subject to fusion Since 1.0.0q6Get the product of all elements in the chunked stream.Subject to fusion Since 1.0.0SFind the first matching value.Subject to fusion Since 1.0.0rFind the first matching value.Subject to fusion Since 1.0.0s-Apply the action to all values in the stream.Subject to fusion Since 1.0.0t7Apply the action to all elements in the chunked stream.Subject to fusion Since 1.0.0uA monadic strict left fold.Subject to fusion Since 1.0.0v/A monadic strict left fold on a chunked stream.Subject to fusion Since 1.0.0wLApply the provided monadic mapping function and monoidal combine all values.Subject to fusion Since 1.0.0xeApply the provided monadic mapping function and monoidal combine all elements in the chunked stream.Subject to fusion Since 1.0.0y!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.0z$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.0}Write all data to the given Handle.Does not close the Handle at any point.Subject to fusion Since 1.0.0~Open 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.0TApply 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.0UFFlatten 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.0V Analog of W for lists.Subject to fusion Since 1.0.6 Analog of W for lists.Subject to fusion Since 1.0.6 with an accumulator.Subject to fusion Since 1.0.0X=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.0YUSliding 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 s.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.0ZApply 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.0[AKeep 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.0\ Analog of W for lists, monadic.Subject to fusion Since 1.0.6 Analog of W for lists, monadic.Subject to fusion Since 1.0.6 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.0]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.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.0fRun a consuming conduit repeatedly, only stopping when there is no more data available from upstream. Since 1.0.0^_A,-./012D3E456F789:;count<=count>?Follow directory symlinksRoot directory@ABCDEFG`HIGJIaJKLKMNOPQRSTUVLWXMYNmaximum allowed sizeZmaximum allowed size[O\]^_`aQbRcdefghijklmnopqSrstuvwxyz{|}~TUmaximum allowed sizeVXYbZ[\]sizecde,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~,-./0123456789:;<=>?@ABCDEFJGHIKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy}~z{|^_A,-./012D3E456F789:;<=>?@ABCDEFG`HIGJIaJKLKMNOPQRSTUVLWXMYNZ[O\]^_`aQbRcdefghijklmnopqSrstuvwxyz{|}~TUVXYbZ[\]cdeNone !"36HM0Yield 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 B.,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 C. 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.0FStream 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 P values. Since 1.0.0+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.0<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.06Get the product of all elements in the chunked stream. Since 1.0.0Find the first matching value. Since 1.0.0-Apply the action to all values in the stream. Since 1.0.07Apply the action to all elements in the chunked stream. Since 1.0.0A 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.0 RStream 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.0CKeep 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.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.0 Analog of W for lists. Since 1.0.6 concatMap with an accumulator. Since 1.0.0=Insert the given value between each two values in the stream. 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. 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. 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 mapM_. Since 1.0.0CApply a monadic transformation to all elements in a chunked stream. 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. 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. Since 1.0.0AKeep only values in the stream passing a given monadic predicate. Since 1.0.0 KKeep only elements in the chunked stream passing a given monadic predicate. Since 1.0.0!1Apply 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.0" Analog of W for lists, monadic. Since 1.0.6# 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.0)=Insert a newline character after each incoming chunk of data. Since 1.0.0*Same as unlines$, but operates on ASCII/binary data. Since 1.0.0+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"untrusted input, this function is ^unsafe/, since it would allow an attacker to form lines of massive length and exhaust memory. Since 1.0.0,Same as linesUnbounded, but for ASCII/binary data. Since 1.0.0-Generally 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.0countcountFollow directory symlinksRoot directorymaximum allowed size     maximum allowed size !"#$%&'()*+,-size      !"#$%&'()*+,-      !"#$%&'()*+,-None3.fghijk lmnopqrstuvwxyz{|}~+      !"#$%&'()*+,-.      !"#$%&'()*+,- +..        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~>DHIJLMNOPQijklmnop      !"#$%&'()*++,-./0123456789:;<=>?@ABC<DEFGHIJKLMN <OPQQRSTUVWXYZXY[XY\XY]XY^_`XYaXYbXYbXYcXYdXYdXYeXYfXYfXYgXYhXYiXYjXYkXYlXYkXYmXYXYnXYoXYpXYqXYrXYsXYtXYuXYvXYwXYxXYyXYzXY{XY|XY}XY~XYXYXYXYXYXYXYXYXYXYXYXYXYXYXYXYXYXYXYXYXYXYXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX_______conduit-combinators-0.3.1ConduitData.Conduit.Combinators.Stream!Data.Conduit.Combinators.InternalData.Conduit.Combinators$Data.Conduit.Combinators.Unqualifiedtransformers-0.3.0.0Control.Monad.IO.ClassliftIOMonadIOControl.Monad.Trans.Classlift MonadTransData.Functor.Identity runIdentityIdentitytransformers-base-0.4.4Control.Monad.BaseliftBase MonadBaseexceptions-0.8.0.2Control.Monad.CatchthrowM MonadThrowmonad-control-1.0.0.4Control.Monad.Trans.ControlMonadBaseControlresourcet-1.1.4.1%Control.Monad.Trans.Resource.Internal ResourceT MonadResource yieldManySrepeatMS repeatWhileMS sourceHandleSfoldl1SallSanyS sinkLazyS sinkVectorS sinkVectorNSsinkLazyBuilderSlastSlastESfindS concatMapS concatMapMSconcatSscanlSscanlMS intersperseSslidingWindowSfilterMSsplitOnUnboundedESinitReplicateS initRepeatS initReplicateinitReplicateConnect initRepeatinitRepeatConnectControl.Monad.Trans.Resource runResourceT yieldManyunfold enumFromToiteraterepeat replicate sourceLazyrepeatM repeatWhileM replicateM sourceFile sourceHandlesourceIOHandlestdin sourceRandom sourceRandomNsourceRandomGensourceRandomNGensourceDirectorysourceDirectoryDeepdropdropE dropWhile dropWhileEfoldfoldEfoldlfoldlEfoldMapfoldMapEfoldl1allallEanyanyEandandEororEelemelemEnotElemnotElemEsinkLazysinkList sinkVector sinkVectorN sinkBuildersinkLazyBuildersinkNull awaitNonNullheadEpeekpeekElastlastElengthlengthElengthIf lengthIfEmaximummaximumEminimumminimumEnullnullEsumsumEproductproductEfindmapM_mapM_EfoldMfoldMEfoldMapM foldMapMEsinkFileprintstdoutstderr sinkHandle sinkIOHandlemapmapEomapE concatMap concatMapEtaketakeE takeWhile takeWhileE takeExactly takeExactlyEconcatfilterfilterEmapWhile conduitVectorscanlconcatMapAccum intersperse slidingWindow encodeBase64 decodeBase64encodeBase64URLdecodeBase64URL encodeBase16 decodeBase16mapMmapMEomapME concatMapMfilterMfilterMEiterMscanlMconcatMapAccumM encodeUtf8 decodeUtf8decodeUtf8Lenientline lineAsciitakeExactlyUntilEunlines unlinesAsciisplitOnUnboundedElinesUnboundedlinesUnboundedAscii vectorBuilder peekForeverunfoldC enumFromToCiterateCrepeatC replicateCrepeatMC repeatWhileMC replicateMCstdinCdropCdropCE dropWhileC dropWhileCEfoldCfoldCEfoldlCfoldlCEfoldMapC foldMapCEallCallCEanyCanyCEandCandCEorCorCEelemCelemCEnotElemC notElemCEheadCEpeekCpeekCElastClastCElengthClengthCE lengthIfC lengthIfCEmaximumC maximumCEminimumC minimumCEnullCnullCEsumCsumCEproductC productCEfindCmapM_CmapM_CEfoldMCfoldMCE foldMapMC foldMapMCEprintCstdoutCstderrCmapCmapCEomapCE concatMapC concatMapCEtakeCtakeCE takeWhileC takeWhileCE takeExactlyC takeExactlyCEconcatCfilterCfilterCE mapWhileCscanlCconcatMapAccumC intersperseCslidingWindowC encodeBase64C decodeBase64CencodeBase64URLCdecodeBase64URLC encodeBase16C decodeBase16CmapMCmapMCEomapMCE concatMapMCfilterMC filterMCEiterMCscanlMCconcatMapAccumMC encodeUtf8C decodeUtf8CdecodeUtf8LenientClineC lineAsciiCunlinesC unlinesAsciiClinesUnboundedClinesUnboundedAsciiCvectorBuilderC withAcquirefmapS SplitState SplitNoSep SplitDoneSlidingWindowState SWEarlyExit SWSliding SWInitialIntersperseState IEmitValue IGotValue IFirstValue ScanState ScanContinues ScanEndedinitReplicateC initRepeatC yieldManyCbaseGHC.Enumsuccchunked-data-0.1.0.1Data.Sequences.LazytoChunks sourceHandleCfoldl1C Data.MaybeNothingfoldl1E sinkLazyC sinkVectorC sinkVectorNCsinkLazyBuilderCmono-traversable-0.9.1Data.MonoTraversableonulllastECGHC.ListsplitOnUnboundedECS ofoldlPrime foldMaybeNullcodeWithonAwaityieldSaddE conduit-1.2.4Data.Conduit.Internal.Conduit runConduitSink$$=$=ConduitMData.Acquire.Internal ReleaseType getZipSource ZipSource getZipSinkZipSink getZipConduit ZipConduitSourceResumableSourceResumableConduitProducerFlushChunkConsumeryieldOryieldunwrapResumableConduitunwrapResumabletryC transPipe toProducer toConsumersequenceSources sequenceSinkssequenceConduitspassthroughSinknewResumableSourcenewResumableConduitmapOutputMaybe mapOutputmapInputleftoverhandleC fuseUpstreamfuseReturnLeftovers fuseLeftovers fuseBothMaybefuseBothcloseResumableSourcecatchCbracketP awaitForeverawait addCleanup=$$+-=$$++=$$+=$$=+$=$$+-$$++$$+ Data.ConduitfuseconnectData.Conduit.LiftwriterLCwriterCstateLCstateCrwsLCrwsC runWriterLC runWriterC runStateLC runStateC runReaderCrunRWSLCrunRWSC runMaybeC runErrorC runCatchCreaderCmaybeC execWriterLC execWriterC execStateLC execStateC execRWSLCexecRWSC evalStateLC evalStateC evalRWSLCevalRWSCerrorC distribute catchErrorC catchCatchC ReleaseNormalReleaseException ReleaseEarlyAcquirewithEx mkAcquireType mkAcquire Data.AcquireallocateAcquire