$IF      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE FGHIJA ` carries a value and metadata about the value. It can be configured to use a specific number of  threads. Readable component name. -Returns the list of all children components. IReturns the maximum number of threads that can be used by the component. WConfigures the component to use the specified number of threads. This function affects , ,  and  methods of the result, while  and  remain the same. `The number of threads that the component is configured to use. The default number is usually 1. qThe cost of using the component as configured. The cost is a rough approximation of time it would take to do the  job given the .  The content. KLK) is an existential type wrapper around a . LM #Show details of the given component's configuration. NOPQ Function QG takes a component name, maximum number of threads it can use, and its   method, and returns a .  Function  b takes the component name and its cost creates a single-threaded component with no subcomponents. R Function RE configures two components that are meant to alternate in processing  of the data stream. S Function TI configures two components, both of them with the full thread count, and  returns the components and a GF6 that can be used to build a new component from them. T Function TA configures two components assuming they can be run in parallel, Y splitting the given thread count between them, and returns the configured components, a GF that p can be used to build a new component from them, and a flag that indicates if they should be run in parallel or * sequentially for optimal resource usage. Applies a unary  combinatorO to the component payload. The resulting component has the original one as its   , and its % is the sum of the original component's cost and the combinator cost. combinator cost name  combinator +Combines two components into one, applying  combinator to their contents. The  and  of the D result assume the sequential execution of the argument components. +Combines two components into one, applying  combinator to their contents. The  combinator takes a flag denoting . if its arguments should run in parallel. The  and 0 of the result assume the parallel execution of  the argument components. sCombines three components into one. The first component runs in parallel with the latter two, which are considered  alternative to each other. sBuilds a tree of recursive components. The combinator takes a list of pairs of a boolean flag denoting whether the 0 level should be run in parallel and the value.      8A , can be used to read values into any nested UV2 computation whose functor provably descends from  the functor a. It':s the read-only end of a communication channel created by . WX+This method gets a list of values from the 9, as well as an indication of the next value if any. The t first argument is a function that determines how many values should be consumed from the source. The function will $ keep being called until it returns FalseH or the current chunk gets completely consumed. If the current chunk is G empty on call, a new one is obtained from the source. The intervening UV" computations suspend all the way  to the . function invocation that created the source. A - can be used to yield values from any nested UV2 computation whose functor provably descends from  the functor a. It';s the write-only end of a communication channel created by . YZ+This method puts a list of values into the . The intervening UV computations suspend up to the  j invocation that has created the argument sink. The method returns all values that could not make it into * the sink because of the sibling coroutine' s death. ,A disconnected sink that ignores all values > into it. An empty source whose  always returns Nothing.  Converts a  on the ancestor functor a' into a sink on the descendant functor d.  Converts a  on the ancestor functor a) into a source on the descendant functor d. The < function splits the computation into two concurrent parts, producer and consumer. The producer is  given a  to put values into, and consumer a 6 to get those values from. Once producer and consumer  both complete,  returns their paired results. The  function is equivalent to , except it runs the producer and the consumer in parallel. A generic version of ?. The first argument is used to combine two computation steps.  Function % tries to get a value from the given  argument. The intervening UV computations  suspend all the way to the C function invocation that created the source. The function returns [ if  the argument source is empty.  Function  acts the same way as  , but doesn'9t actually consume the value from the source; sequential  calls to $ will always return the same value. 9 returns the list of all values generated by the source. [Invokes its first argument with the value it gets from the source, if there is any to get. Consumes values from the source as long as the ticker accepts them. !Consumes values from the sourceC as long as each satisfies the predicate, then returns their list. "Consumes values from the sourceR until one of them satisfies the predicate or the source is emptied, then returns r the pair of the list of preceding values and maybe the one value that satisfied the predicate. The latter is not  consumed. #Copies all data from the source argument into the sink argument. $Like #, copies data from the source to the sink2, but only as long as it satisfies the predicate. %Like #, copies data from the source to the sink2, but only as long as it satisfies the predicate. &Like #, copies data from the source to the sink9, but only until one value satisfies the predicate. That ' value is returned rather than copied. '' is like # that applies the function f- to each argument before passing it into the sink. (An equivalent of \ that works on a 8 instead of a list. The argument function is applied to  every value vefore it' s written to the sink argument. )) is to ' like ] is to \. ** is to ' like ^ is to \. ++ is similar to _# except it reads the values from a  instead of a list % and writes the mapped values into a $ instead of returning another list. ,, is a love child of * and +": it threads the accumulator like p the latter, but its argument function returns not a single value, but a list of values to write into the sink. -Like 'K except it runs the argument function on whole chunks read from the input. .. is similar to `. It draws the values from a  instead of a list, writes the  mapped values to a , and returns a UV. // is similar to a# except it draws the values from a  instead of a list and  works with UV instead of an arbitrary monad. 0Like /K except it runs the argument function on whole chunks read from the input. 1An equivalent of b. Draws the values from a ( instead of a list, writes the filtered  values to a , and returns a UV. 2 Similar to c, but reads the values from a  instead of a list. 33 is similar to d# except it draws the values from a  instead of a list and  works with UV instead of an arbitrary monad. 4 A variant of 3' that discards the final result value. eLike 37 but working on whole chunks from the argument source. 55 is a version of f) that writes the generated values into a  instead of  returning a list. 66 is opposite of / ; it takes a  instead of a  argument and writes the  generated values into it. 7Like 6D but writing whole chunks of generated data into the argument sink. 8Equivalent to g . Takes a = instead of a list argument and partitions its contents into  the two  arguments. 99 is similar to h% except it draws the values from two  arguments 0 instead of two lists, sends the results into a , and works with UV instead of an arbitrary monad. :: is equivalent to 9/, but it consumes the two sources in parallel. ;; is similar to #U except it distributes every input value from its source argument into its both sink  arguments. < Every value > into a <0 result sink goes into its both argument sinks: put (teeSink s1 s2) x is  equivalent to put s1 x >> put s2 x. The Z. method returns the list of values that couldn't fit into the  second sink. =The  returned by =P writes every value read from its argument source into the argument sink before  providing it back. >*This function puts a value into the given . The intervening UV computations suspend up  to the 0 invocation that has created the argument sink. ?Like >B, but returns a Bool that determines if the sink is still active. @@ puts an entire list into its sink' argument. If the coroutine fed by the sink dies, the remainder of  the argument list is returned. iALike @+, except it puts the contents of the given j into the sink. k2 !"#$%&'()*+,-./0123456789:;<=>?@A1 !"#$%&'()*+,-./0123456789:;<=>?@A&BBJ is a type class representing all types that can act as consumers, namely VU,  PO, and ML. CC" is used to combine two values of Branch! class into one, using the given VU binary  combinator. D2A parser is a transducer that marks up its input. E*Type of values in a markup-up stream. The G$ constructor wraps the actual data. FGHA H$ value is produced to mark either a K and J& of a region of data, or an arbitrary I in  data. A I! is semantically equivalent to a K immediately followed by J. IJKLThe MLc type represents coroutines that distribute the input stream acording to some criteria. A splitter t should distribute only the original input data, and feed it into the sinks in the same order it has been read from s the source. Furthermore, the input source should be entirely consumed and fed into the first two sinks. The third P sink can be used to supply extra information at arbitrary points in the input. uA splitter can be used in two ways: as a predicate to determine which portions of its input stream satisfy a certain s property, or as a chunker to divide the input stream into chunks. In the former case, the predicate is considered C true for exactly those parts of the input that are written to its true( sink. In the latter case, a chunk is a p contiguous section of the input stream that is written exclusively to one sink, either true or false. Anything 6 written to the third sink also terminates the chunk. MNOThe POH type represents coroutines that transform a data stream. Execution of Q must continue  consuming the given  and feeding the  as * long as there is any data in the source. PQR6A coroutine that produces values and puts them into a . STU(A coroutine that consumes values from a . VWXaA coroutine that has no inputs nor outputs - and therefore may not suspend at all, which means it's not really a  co routine. YZ[\]^_Creates a proper VU! from a function that is, but can't be proven to be, an ^. `Creates a proper SR! from a function that is, but can't be proven to be, an ]. aCreates a proper PO! from a function that is, but can't be proven to be, an \. bCreates a proper ML! from a function that is, but can't be proven to be, an [. c Function cS takes a function that maps one input value to one output value each, and lifts it  into a PO. d Function dN takes a function that maps one input value into a list of output values, and  lifts it into a PO. e Function e constructs a PO2 from a state-transition function and the initial U state. The transition function may produce arbitrary output at any transition step. f Function fT takes a function that assigns a Boolean value to each input item and lifts it into  a ML. g Function gS takes a state-converting function that also assigns a Boolean value to each input  item and lifts it into a ML. &BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg&BCCDEGFFGHKJIIJKLMNMNOPQPQRSTSTUVWVWXYZYZ[\]^_`abcdefghTwo streams of h5 types can be unambigously converted one to another. iA PO0 that converts a stream of one type to another. jklAAdjusts the argument splitter to split the stream of a data type  Isomorphic$ to the type it was meant to split. hijklhijkijkl6mClass mT applies to any two components that can be combined into a third component with the  following properties: i if both argument components consume input, the input of the combined component gets distributed to both " components in parallel, and l if both argument components produce output, the output of the combined component is a concatenation of the h complete output from the first component followed by the complete output of the second component. lThe l3 combinator may apply the components in any order. nThe nU combinator makes sure its first argument has completed before using the second one. mnopqroClass oT applies to any two components that can be combined into a third component with the  following properties: L The input of the result, if any, becomes the input of the first component. ] The output produced by the first child component is consumed by the second child component. C The result output, if any, is the output of the second component. sp Converts a VU into a PO with no output. q Combinator q" converts the given producer to a PO that passes all its u input through unmodified, except for prepending the output of the argument producer to it. The following law holds:   q prefix = l (s prefix) Control.Category.id  r Combinator r" converts the given producer to a PO that passes all its q input through unmodified, finally appending the output of the argument producer to it. The following law holds:   r suffix = l Control.Category.id (s suffix)  sThe s0 combinator converts its argument producer to a PO that M produces the same output, while consuming its entire input and ignoring it. tThe tg (streaming not) combinator simply reverses the outputs of the argument splitter. In other words, data ) that the argument splitter sends to its true sink goes to the false% sink of the result, and vice versa. tThe t combinator sends the trueG sink output of its left operand to the input of its right operand for ! further splitting. Both operands' false sinks are connected to the false( sink of the combined splitter, but any  input value to reach the trueL sink of the combined component data must be deemed true by both splitters. uA u combinator's input value can reach its false3 sink only by going through both argument splitters' false  sinks. v Combinator vW is a pairwise logical conjunction of two splitters run in parallel on the same input. w Combinator wW is a pairwise logical disjunction of two splitters run in parallel on the same input. xyzuv#Converts a splitter into a parser. w4Converts a boundary-marking splitter into a parser. {4Converts a boundary-marking splitter into a parser. |The recursive combinator |N feeds the true sink of the argument splitter back to itself, modified by the . argument transducer. Data fed to the splitter'&s false sink is passed on unmodified. }The recursive combinator }J combines two splitters into a mutually recursive loop acting as a single v splitter. The true sink of one of the argument splitters and false sink of the other become the true and false sinks A of the loop. The other two sinks are bound to the other splitter's source. The use of } makes sense only on u hierarchically structured streams. If we gave it some input containing a flat sequence of values, and assuming both s component splitters are deterministic and stateless, an input value would either not loop at all or it would loop  forever. ~The ~) combinator is similar to the combinator x9 in that it combines a splitter and two transducers into s another transducer. However, in this case the transducers are re-instantiated for each consecutive portion of the t input as the splitter chunks it up. Each contiguous portion of the input that the splitter sends to one of its two W sinks gets transducered through the appropriate argument transducer as that transducer's whole input. As soon as the A contiguous portion is finished, the transducer gets terminated. The f combinator combines two pure splitters into a pure splitter. One splitter is used to chunk the input  into contiguous portions. Its false sink is routed directly to the false$ sink of the combined splitter. The a second splitter is instantiated and run on each portion of the input that goes to first splitter's true sink. If 4 the second splitter sends any output at all to its true3 sink, the whole input portion is passed on to the true 9 sink of the combined splitter, otherwise it goes to its false sink. The  combinator is analogous to the : combinator, but it succeeds and passes each chunk of the  input to its true= sink only if the second splitter sends no part of it to its false sink. xThe result of combinator xT behaves the same as the argument splitter up to and including the first portion of ' the input which goes into the argument's true@ sink. All input following the first true portion goes into the  false sink. yThe result of combinator yO takes all input up to and including the first portion of the input which goes  into the argument's true) sink and feeds it to the result splitter's true& sink. All the rest of the input goes  into the false# sink. The only difference between x and y) combinators is in where they direct the  false* portion of the input preceding the first true part. zThe result of the combinator z. is a splitter which directs all input to its false sink, up to the last 0 portion of the input which goes to its argument's true> sink. That portion of the input is the only one that goes to  the resulting component's true0 sink. The splitter returned by the combinator z has to buffer the previous two w portions of its input, because it cannot know if a true portion of the input is the last one until it sees the end of ; the input or another portion succeeding the previous one. {The result of the combinator {. is a splitter which directs all input to its false sink, up to the 5 last portion of the input which goes to its argument's true6 sink. That portion and the remainder of the input is  fed to the resulting component's true sink. The difference between z and { combinators is where  they feed the false8 portion of the input, if any, remaining after the last true part. |The | combinator feeds its trueB sink only the prefix of the input that its argument feeds to its true 5 sink. All the rest of the input is dumped into the false sink of the result. }The } combinator feeds its trueB sink only the suffix of the input that its argument feeds to its true 5 sink. All the rest of the input is dumped into the false sink of the result. ~The ~8 combinator takes every input section that its argument splitter deems true, and feeds even ones into  its true4 sink. The odd sections and parts of input that are false/ according to its argument splitter are fed to  ~ splitter's false sink.  Splitter  issues an empty true6 section at the beginning of every section considered true by its = argument splitter, otherwise the entire input goes into its false sink.  Splitter  issues an empty true0 section at the end of every section considered true by its argument 4 splitter, otherwise the entire input goes into its false sink.  Combinator  treats its argument ML's as patterns components and returns a ML that ? matches their concatenation. A section of input is considered true, by the result iff its prefix is considered  true by argument s1+ and the rest of the section is considered true by s2. The splitter s2 is started anew  after every section split to true sink by s1.  Combinator ] tracks the running balance of difference between the number of preceding starts of sections  considered true_ according to its first argument and the ones according to its second argument. The combinator  passes to trueb all input values for which the difference balance is positive. This combinator is typically used  with  and C in order to count entire input sections and ignore their lengths. [Runs the second argument on every contiguous region of input source (typically produced by )  whose all values either match Left (_, True) or Left (_, False).  runs the producer2 argument with a new sink, suppressing everything > in the sink. Given a ML, a , and two consumer functions, ! runs the splitter on the source  and feeds the splitter's true and false. outputs, respectively, to the two consumers. *mlnospqrsttuvwxyzuvw{|}~xyz{|}~*mlnlnosspqrsttuvwxyzuvw{|}~xyz{|}~ 'Used by 0 to distinguish between overlapping substrings. .Collects the entire input source into a list. 2Produces the contents of the given list argument.  Consumer 3 copies the given source into the standard output.  Producer / feeds the given sink from the standard input. AReads the named file and feeds the given sink from its contents. -Feeds the given sink from the open text file handle. /Feeds the given sink from the open binary file handle. The argument  chunkSize# determines the size of the chunks  read from the handle. FCreates the named text file and writes the entire given source to it. 1Appends the given source to the named text file. 0Copies the given source into the open text file handle. 2Copies the given source into the open binary file handle.  Transducer C removes all markup from its input and passes the content through.  Transducer 0 prepares input content for subsequent parsing. The @ consumer suppresses all input it receives. It is equivalent to  substitute [] The 4 consumer reports an error if any input reaches it. The Y transforms all uppercase letters in the input to lowercase, leaving the rest unchanged. The Y transforms all lowercase letters in the input to uppercase, leaving the rest unchanged. The E transducer counts all its input values and outputs the final tally. Converts each input value x to show x.  Transducer 3 collects all its input values into a single list.  Transducer P flattens the input stream of lists of values into the output stream of values. Same as K except it inserts the given separator list between every two input lists.  Splitter + feeds all white-space characters into its true sink, all others into false.  Splitter , feeds all alphabetical characters into its true! sink, all other characters into  | false.  Splitter  feeds all digits into its true! sink, all other characters into false.  Splitter  feeds line-ends into its false% sink, and all other characters into true. The sectioning splitter  feeds line-ends into its false sink, and line contents into true . A single : line-end can be formed by any of the character sequences "\n", "\r", "\r\n", or "\n\r".  Splitter ! feeds its entire input into its true sink.  Splitter ! feeds its entire input into its false sink.  Splitter  feeds all input values to its true3 sink, treating every value as a separate section.  Splitter , passes all marked-up input sections to its true% sink, and all unmarked input to its  false sink.  Splitter ; passes the content of all marked-up input sections to its true sink, while the 1 outermost tags and all unmarked input go to its false sink.  Splitter A passes input sections marked-up with the appropriate tag to its true sink, and the  rest of the input to its false sink. The argument select' determines if the tag is appropriate.  Splitter L passes the content of input sections marked-up with the appropriate tag to  its true( sink, and the rest of the input to its false sink. The argument select determines if the tag is  appropriate. Performs the same task as the < splitter, but instead of splitting it outputs the input as FE x  . in order to distinguish overlapping strings.  Splitter  feeds to its true@ sink all input parts that match the contents of the given list [ argument. If two overlapping parts of the input both match the argument, both are sent to true and each is preceded  by an edge. SA utility function wrapping if-then-else, useful for handling monadic truth values %% "?Converts an XML entity name into the text value it represents: expandXMLEntity "lt" = "<". AThis splitter splits XML markup from data content. It is used by . lThe XML token parser. This parser converts plain text to parsed text, which is a precondition for using the  remaining XML components. 8Splits all top-level elements with all their content to true, all other input to false. 0Splits the content of all top-level elements to true&, their tags and intervening input to false.  Similiar to ()Control.Concurrent.SCC.Combinators.having element)', except it runs the argument splitter  only on each element'9s start tag, not on the entire element with its content. (Splits every attribute specification to true, everything else to false. \Splits every element name, including the names of nested elements and names in end tags, to true, all the rest of  input to false. Splits every attribute name to true, all the rest of input to false. ASplits every attribute value, excluding the quote delimiters, to true, all the rest of input to false.  Class PipeableComponentPairT applies to any two components that can be combined into a third component with the  following properties: L The input of the result, if any, becomes the input of the first component. ] The output produced by the first child component is consumed by the second child component. C The result output, if any, is the output of the second component. The 3 combinator may apply the components in any order. The  combinator sends the trueO sink output of its left operand to the input of its right operand for further  splitting. Both operands' false sinks are connected to the false. sink of the combined splitter, but any input  value to reach the trueL sink of the combined component data must be deemed true by both splitters. A  combinator's input value can reach its false3 sink only by going through both argument splitters' false  sinks.  Combinator W is a pairwise logical conjunction of two splitters run in parallel on the same input.  Combinator W is a pairwise logical disjunction of two splitters run in parallel on the same input. 4Converts a boundary-marking splitter into a parser. The recursive combinator N feeds the true sink of the argument splitter back to itself, modified by the . argument transducer. Data fed to the splitter'&s false sink is passed on unmodified. The recursive combinator J combines two splitters into a mutually recursive loop acting as a single v splitter. The true sink of one of the argument splitters and false sink of the other become the true and false sinks A of the loop. The other two sinks are bound to the other splitter's source. The use of  makes sense only on u hierarchically structured streams. If we gave it some input containing a flat sequence of values, and assuming both s component splitters are deterministic and stateless, an input value would either not loop at all or it would loop  forever. The ) combinator is similar to the combinator 9 in that it combines a splitter and two transducers into s another transducer. However, in this case the transducers are re-instantiated for each consecutive portion of the t input as the splitter chunks it up. Each contiguous portion of the input that the splitter sends to one of its two W sinks gets transducered through the appropriate argument transducer as that transducer's whole input. As soon as the A contiguous portion is finished, the transducer gets terminated. The f combinator combines two pure splitters into a pure splitter. One splitter is used to chunk the input  into contiguous portions. Its false sink is routed directly to the false$ sink of the combined splitter. The a second splitter is instantiated and run on each portion of the input that goes to first splitter's true sink. If 4 the second splitter sends any output at all to its true3 sink, the whole input portion is passed on to the true 9 sink of the combined splitter, otherwise it goes to its false sink. The  combinator is analogous to the : combinator, but it succeeds and passes each chunk of the  input to its true= sink only if the second splitter sends no part of it to its false sink.  Combinator  treats its argument ML's as patterns components and returns a ML that ? matches their concatenation. A section of input is considered true, by the result iff its prefix is considered  true by argument s1+ and the rest of the section is considered true by s2. The splitter s2 is started anew  after every section split to true sink by s1.  Combinator ] tracks the running balance of difference between the number of preceding starts of sections  considered true_ according to its first argument and the ones according to its second argument. The combinator  passes to trueb all input values for which the difference balance is positive. This combinator is typically used  with startOf and endOfC in order to count entire input sections and ignore their lengths. &mnopqrstuvwxyz{|}~ Class PipeableComponentPairT applies to any two components that can be combined into a third component with the  following properties: L The input of the result, if any, becomes the input of the first component. ] The output produced by the first child component is consumed by the second child component. C The result output, if any, is the output of the second component. The 3 combinator may apply the components in any order. The  combinator sends the trueO sink output of its left operand to the input of its right operand for further  splitting. Both operands' false sinks are connected to the false. sink of the combined splitter, but any input  value to reach the trueL sink of the combined component data must be deemed true by both splitters. A  combinator's input value can reach its false3 sink only by going through both argument splitters' false  sinks.  Combinator W is a pairwise logical conjunction of two splitters run in parallel on the same input.  Combinator W is a pairwise logical disjunction of two splitters run in parallel on the same input. 4Converts a boundary-marking splitter into a parser. The recursive combinator N feeds the true sink of the argument splitter back to itself, modified by the . argument transducer. Data fed to the splitter'&s false sink is passed on unmodified. The recursive combinator J combines two splitters into a mutually recursive loop acting as a single v splitter. The true sink of one of the argument splitters and false sink of the other become the true and false sinks A of the loop. The other two sinks are bound to the other splitter's source. The use of  makes sense only on u hierarchically structured streams. If we gave it some input containing a flat sequence of values, and assuming both s component splitters are deterministic and stateless, an input value would either not loop at all or it would loop  forever. The ) combinator is similar to the combinator 9 in that it combines a splitter and two transducers into s another transducer. However, in this case the transducers are re-instantiated for each consecutive portion of the t input as the splitter chunks it up. Each contiguous portion of the input that the splitter sends to one of its two W sinks gets transducered through the appropriate argument transducer as that transducer's whole input. As soon as the A contiguous portion is finished, the transducer gets terminated. The f combinator combines two pure splitters into a pure splitter. One splitter is used to chunk the input  into contiguous portions. Its false sink is routed directly to the false$ sink of the combined splitter. The a second splitter is instantiated and run on each portion of the input that goes to first splitter's true sink. If 4 the second splitter sends any output at all to its true3 sink, the whole input portion is passed on to the true 9 sink of the combined splitter, otherwise it goes to its false sink. The  combinator is analogous to the : combinator, but it succeeds and passes each chunk of the  input to its true= sink only if the second splitter sends no part of it to its false sink.  Combinator  treats its argument ML's as patterns components and returns a ML that ? matches their concatenation. A section of input is considered true, by the result iff its prefix is considered  true by argument s1+ and the rest of the section is considered true by s2. The splitter s2 is started anew  after every section split to true sink by s1.  Combinator ] tracks the running balance of difference between the number of preceding starts of sections  considered true_ according to its first argument and the ones according to its second argument. The combinator  passes to trueb all input values for which the difference balance is positive. This combinator is typically used  with startOf and endOfC in order to count entire input sections and ignore their lengths. &mnopqrstuvwxyz{|}~cThe Z type represents computations that distribute data acording to some criteria. A splitter t should distribute only the original input data, and feed it into the sinks in the same order it has been read from  the source. If the two 'Sink c x'L arguments of a splitter are the same, the splitter must act as an identity  transform. The < type represents computations that transform a data stream. 6A component that produces values and puts them into a Sink is called . (A component that consumes values from a Source is called . HA component that performs a computation with no inputs nor outputs is a . The constant cost of each I/O-performing component. A 0 that converts a stream of one type to another. rAdjusts the argument consumer to consume the stream of a data type coercible to the type it was meant to consume. tAdjusts the argument producer to produce the stream of a data type coercible from the type it was meant to produce. oAdjusts the argument splitter to split the stream of a data type isomorphic to the type it was meant to split. ProducerComponent / feeds the given sink from the standard input. ProducerComponent B opens the named file and feeds the given sink from its contents. ProducerComponent ) feeds the given sink from the open file handle. ConsumerComponent 3 copies the given source into the standard output. ConsumerComponent ; opens the named file and copies the given source into it. ConsumerComponent 9 opens the name file and appends the given source to it. ConsumerComponent , copies the given source into the open file handle. 3 produces the contents of the given list argument. ConsumerComponent & copies the given source into a list. The @ consumer suppresses all input it receives. It is equivalent to  [] The 4 consumer reports an error if any input reaches it. TransducerComponent & passes its input through unmodified. TransducerComponent C removes all markup from its input and passes the content through. TransducerComponent 0 prepares input content for subsequent parsing. The Y transforms all uppercase letters in the input to lowercase, leaving the rest unchanged. The Y transforms all lowercase letters in the input to uppercase, leaving the rest unchanged. The E transducer counts all its input values and outputs the final tally. Converts each input value x to show x. Performs the same task as the < splitter, but instead of splitting it outputs the input as FE x  . in order to distinguish overlapping strings. TransducerComponent 3 collects all its input values into a single list. TransducerComponent P flattens the input stream of lists of values into the output stream of values.  Same as K except it inserts the given separator list between every two input lists.  SplitterComponent  ! feeds its entire input into its true sink.  SplitterComponent  ! feeds its entire input into its false sink.  SplitterComponent  , passes all marked-up input sections to its true% sink, and all unmarked input to its  false sink.  SplitterComponent  ; passes the content of all marked-up input sections to its true sink, while the 1 outermost tags and all unmarked input go to its false sink. SplitterComponent A passes input sections marked-up with the appropriate tag to its true sink, and the  rest of the input to its false sink. The argument select' determines if the tag is appropriate. SplitterComponent L passes the content of input sections marked-up with the appropriate tag to  its true( sink, and the rest of the input to its false sink. The argument select determines if the tag is  appropriate. SplitterComponent  feeds all input values to its true3 sink, treating every value as a separate section. SplitterComponent  feeds to its true@ sink all input parts that match the contents of the given list [ argument. If two overlapping parts of the input both match the argument, both are sent to true and each is preceded  by an edge. SplitterComponent + feeds all white-space characters into its true sink, all others into false. SplitterComponent , feeds all alphabetical characters into its true! sink, all other characters into  | false. SplitterComponent  feeds all digits into its true! sink, all other characters into false. SplitterComponent  feeds line-ends into its false% sink, and all other characters into true. The sectioning splitter  feeds line-ends into its false sink, and line contents into true . A single : line-end can be formed by any of the character sequences "\n", "\r", "\r\n", or "\n\r".  Converts a  into a  with no output. Class PipeableComponentPairT applies to any two components that can be combined into a third component with the  following properties: L The input of the result, if any, becomes the input of the first component. ] The output produced by the first child component is consumed by the second child component. C The result output, if any, is the output of the second component. Class JoinableComponentPairT applies to any two components that can be combined into a third component with the  following properties: i if both argument components consume input, the input of the combined component gets distributed to both  components in parallel, l if both argument components produce output, the output of the combined component is a concatenation of the l complete output from the first component followed by the complete output of the second component, and The 3 combinator may apply the components in any order. The U combinator makes sure its first argument has completed before using the second one.  Combinator ` converts the given producer to transducer that passes all its input through unmodified, except = | for prepending the output of the argument producer to it.  |  prefix =  ( prefix) asis  Combinator a converts the given producer to transducer that passes all its input through unmodified, finally 8 | appending to it the output of the argument producer.  |  suffix =  asis ( suffix) The ` combinator converts its argument producer to a transducer that produces the same output, while / | consuming its entire input and ignoring it. The g (streaming not) combinator simply reverses the outputs of the argument splitter. In other words, data ) that the argument splitter sends to its true sink goes to the false% sink of the result, and vice versa. The  combinator sends the trueO sink output of its left operand to the input of its right operand for further  splitting. Both operands' false sinks are connected to the false. sink of the combined splitter, but any input  value to reach the trueL sink of the combined component data must be deemed true by both splitters.  A   combinator's input value can reach its false3 sink only by going through both argument splitters' false  sinks. ! Combinator !W is a pairwise logical conjunction of two splitters run in parallel on the same input. " Combinator "W is a pairwise logical disjunction of two splitters run in parallel on the same input. #$%&'The recursive combinator 'N feeds the true sink of the argument splitter back to itself, modified by the . argument transducer. Data fed to the splitter'&s false sink is passed on unmodified. (The recursive combinator (J combines two splitters into a mutually recursive loop acting as a single w splitter. The true sink of one of the argument splitters and false sink of the other become the true and false sinks B of the loop. The other two sinks are bound to the other splitter's source. The use of ( makes sense only s on hierarchically structured streams. If we gave it some input containing a flat sequence of values, and assuming s both component splitters are deterministic and stateless, an input value would either not loop at all or it would  loop forever. )The )) combinator is similar to the combinator #9 in that it combines a splitter and two transducers into s another transducer. However, in this case the transducers are re-instantiated for each consecutive portion of the t input as the splitter chunks it up. Each contiguous portion of the input that the splitter sends to one of its two W sinks gets transducered through the appropriate argument transducer as that transducer's whole input. As soon as the A contiguous portion is finished, the transducer gets terminated. *The *f combinator combines two pure splitters into a pure splitter. One splitter is used to chunk the input  into contiguous portions. Its false sink is routed directly to the false$ sink of the combined splitter. The a second splitter is instantiated and run on each portion of the input that goes to first splitter's true sink. If 4 the second splitter sends any output at all to its true3 sink, the whole input portion is passed on to the true 9 sink of the combined splitter, otherwise it goes to its false sink. +The + combinator is analogous to the *: combinator, but it succeeds and passes each chunk of the  input to its true= sink only if the second splitter sends no part of it to its false sink. , Combinator , treats its argument 's as patterns components and returns a  D that matches their concatenation. A section of input is considered true by the result iff its  prefix is considered true by argument s1+ and the rest of the section is considered true by s2. The splitter  s2. is started anew after every section split to true sink by s1. -The -8 combinator takes every input section that its argument splitter deems true, and feeds even ones into  its true4 sink. The odd sections and parts of input that are false/ according to its argument splitter are fed to  - splitter's false sink. .The result of combinator .T behaves the same as the argument splitter up to and including the first portion of ' the input which goes into the argument's true@ sink. All input following the first true portion goes into the  false sink. /The result of combinator /O takes all input up to and including the first portion of the input which goes  into the argument's true) sink and feeds it to the result splitter's true& sink. All the rest of the input goes  into the false# sink. The only difference between . and /) combinators is in where they direct the  false* portion of the input preceding the first true part. 0The 0 combinator feeds its trueB sink only the prefix of the input that its argument feeds to its true 5 sink. All the rest of the input is dumped into the false sink of the result. 1The result of the combinator 1. is a splitter which directs all input to its false sink, up to the last 0 portion of the input which goes to its argument's true> sink. That portion of the input is the only one that goes to  the resulting component's true0 sink. The splitter returned by the combinator 1 has to buffer the previous two w portions of its input, because it cannot know if a true portion of the input is the last one until it sees the end of ; the input or another portion succeeding the previous one. 2The result of the combinator 2. is a splitter which directs all input to its false sink, up to the 5 last portion of the input which goes to its argument's true6 sink. That portion and the remainder of the input is  fed to the resulting component's true sink. The difference between 1 and 2 combinators is where  they feed the false8 portion of the input, if any, remaining after the last true part. 3The 3 combinator feeds its trueB sink only the suffix of the input that its argument feeds to its true 5 sink. All the rest of the input is dumped into the false sink of the result. 4SplitterComponent 4 issues an empty true6 section at the beginning of every section considered true by A its argument splitter, otherwise the entire input goes into its false sink. 5SplitterComponent 5 issues an empty true0 section at the end of every section considered true by its = argument splitter, otherwise the entire input goes into its false sink. 6 Combinator 6] tracks the running balance of difference between the number of preceding starts of sections  considered true_ according to its first argument and the ones according to its second argument. The combinator  passes to trueb all input values for which the difference balance is positive. This combinator is typically used  with 4 and 5C in order to count entire input sections and ignore their lengths. 7#Converts a splitter into a parser. 84Converts a boundary-marking splitter into a parser. 9AThis splitter splits XML markup from data content. It is used by parseXMLTokens. :lThe XML token parser. This parser converts plain text to parsed text, which is a precondition for using the  remaining XML components. ;8Splits all top-level elements with all their content to true, all other input to false. <0Splits the content of all top-level elements to true&, their tags and intervening input to false. = Similiar to ()Control.Concurrent.SCC.Combinators.having element)', except it runs the argument splitter  only on each element'9s start tag, not on the entire element with its content. >(Splits every attribute specification to true, everything else to false. ?\Splits every element name, including the names of nested elements and names in end tags, to true, all the rest of  input to false. @Splits every attribute name to true, all the rest of input to false. AASplits every attribute value, excluding the quote delimiters, to true, all the rest of input to false. BCDEBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE>?#;<=@A !"$%&(')*-2+,8./01345679:XYZ^UVW]RST\OPQ[LMNHKJIEGFDBC_`abcdefg      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEc      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~>?#;<=@A !"$%&(')*-2+,8./01345679:XYZ^UVW]RST\OPQ[LMNHKJIEGFDBC_`abcdefghijklpqrsomntu~xy|z{}vw !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~>?#;<=@A !"$%&(')*-2+,8./01345679:XYZ^UVW]RST\OPQ[LMNHKJIEGFDBC_`abcdefghijklpqrsomntu~xy|z{}vw  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSSTUVWXYYZ[[\]]^__`aabcdefghijklmnopqrstuvwxyz{|}~                  qrstxvyz{}~         !"#$ % & ' ( ) * + , - ./scc-0.6#Control.Concurrent.SCC.Configurable Control.Concurrent.ConfigurationControl.Concurrent.SCC.Parallel!Control.Concurrent.SCC.SequentialControl.Concurrent.SCC.StreamsControl.Concurrent.SCC.Types Control.Concurrent.SCC.Coercions"Control.Concurrent.SCC.Combinators!Control.Concurrent.SCC.PrimitivesControl.Concurrent.SCC.XML+Control.Concurrent.SCC.Combinators.Parallel-Control.Concurrent.SCC.Combinators.Sequentialmonad-coroutine-0.6Control.Monad.Coroutine.NestedAncestorFunctor Componentname subComponentsmaxUsableThreads usingThreads usedThreadscostwithshowComponentTreeatomicliftliftSequentialPairliftParallelPairparallelRouterAndBranchesrecursiveComponentTreeSourceSink SinkFunctor SourceFunctornullSink nullSourceliftSink liftSourcepipepipePpipeGgetpeekgetListgetWith getTickedgetWhilegetUntilpour pourTicked pourWhile pourUntil mapStreammapSinkmapMaybeStreamconcatMapStreammapAccumStreamconcatMapAccumStreammapStreamChunks mapMStream mapMStream_mapMStreamChunks_ filterMStream foldStream foldMStream foldMStream_ unfoldMStream unmapMStream_unmapMStreamChunks_partitionStreamzipWithMStreamparZipWithMStreamteeteeSink teeSourceputtryPutputListputQueue BranchingcombineBranchesParserMarkupContentBoundaryPointEndStartSplittersplit Transducer transduceProducerproduceConsumerconsume Performerperform OpenSplitterOpenTransducer OpenProducer OpenConsumerisolateConsumerisolateProducerisolateTransducerisolateSplitteroneToOneTransducerstatelessTransducerstatefulTransducerstatelessSplitterstatefulSplitter Coerciblecoerce adaptConsumer adaptProducer adaptSplitterJoinableComponentPairsequencePipeableComponentPair consumeByprependappend substitutesNotselect parseRegionsparseNestedRegionsfirst uptoFirstlast lastAndAfterprefixsuffixevenstartOfendOfsplitterToMarker OccurenceTagtoListfromListtoStdOut fromStdInfromFile fromHandlefromBinaryHandletoFile appendFiletoHandletoBinaryHandleunparseparsesuppress erroneous lowercase uppercasecounttoStringgroup concatenateconcatSeparate whitespacelettersdigits nonEmptyLineline everythingnothingonemarked markedContent markedWithcontentMarkedWithparseSubstring substringXMLToken ErrorTokenEndMarkedSectionStartMarkedSectionCDATA CommentTextCommentProcessingInstructionTextProcessingInstruction EntityNameEntityReferenceTokenAttributeValue AttributeName ElementNameEmptyTagEndTagStartTagexpandXMLEntity xmlTokensparseXMLTokens xmlElementxmlElementContentxmlElementHavingTagWith xmlAttributexmlElementNamexmlAttributeNamexmlAttributeValue>->join>&>|&&||ifswhereverunlessparseEachNestedRegionwhilenestedInforeachhaving havingOnly followedBy...TransducerType ProducerType ConsumerType PerformerType AnyListOrUnitCompatibleSignatureSplitterComponentParserComponentTransducerComponentProducerComponentConsumerComponentPerformerComponentioCostidsnotxmlParseTokens chooseBinderComponentConfigurationcomponentChildrencomponentThreads componentCost AnyComponent componentshowIndentedComponentshowIndentedAnyComponentshowRightAligned toComponent#optimalTwoAlternatingConfigurations"optimalTwoSequentialConfigurations optimalTwoParallelConfigurationsControl.Monad.Coroutine Coroutine foldChunkputChunkbase Data.MaybeNothingGHC.BasemapmapMaybeGHC.List concatMap Data.List mapAccumL Control.MonadmapMmapM_filterMfoldlfoldMfoldMStreamChunksunfoldr partitionzipWithMgetChunkcontainers-0.4.0.0 Data.SequenceSeq nullOrElsecomposesAndsOrpAndpOrbetweenwrapMarkedSplittersplittersToPairMarkerzipSplittersWith groupMarkssuppressProducer splitInput findsTrueIn findsFalseIn teeConsumerssplitInputToConsumers OccurenceconddispatchOnStringgetElementNamegetRestOfRegionpourRestOfRegion pourRestOfTag findEndTag findStartTagmapJoinM