h$'a      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None>?u sccA   carries a value and metadata about the value. It can be configured to use a specific number of threads.sccReadable component name.scc,Returns the list of all children components.sccReturns the maximum number of threads that can be used by the component.sccConfigures the component to use the specified number of threads. This function affects , , and  methods of the result, while  and  remain the same.sccThe number of threads that the component is configured to use. The default number is usually 1.sccThe cost of using the component as configured. The cost is a rough approximation of time it would take to do the job given the .scc The content.scc4Show details of the given component's configuration. scc Function   takes the component name and its cost creates a single-threaded component with no subcomponents.sccApplies a unary  combinator to the component payload. The resulting component has the original one as its  , and its 5 is the sum of the original component's cost and the combinator cost.scc+Combines two components into one, applying  combinator to their contents. The  and  of the result assume the sequential execution of the argument components.scc+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  of the result assume the parallel execution of the argument components.sccCombines three components into one. The first component runs in parallel with the latter two, which are considered alternative to each other.sccBuilds a tree of recursive components. The combinator takes a list of pairs of a boolean flag denoting whether the level should be run in parallel and the value.scccombinator cost sccname scc combinator   None+4 sccA  + can be used to read input into any nested ? computation whose functor provably descends from the functor a?. It's the read-only end of a communication channel created by . sccA  - can be used to yield output from any nested ? computation whose functor provably descends from the functor a. It's the write-only end of a communication channel created by . scc=This method puts a portion of the producer's output into the  . The intervening ! computations suspend up to the  invocation that has created the argument sink. The method returns the suffix of the argument that could not make it into the sink because of the sibling coroutine's death.scc7A disconnected sink that consumes and ignores all data > into it.scc Converts a   on the ancestor functor a' into a sink on the descendant functor d.scc Converts a   on the ancestor functor a) into a source on the descendant functor d.sccA sink mark-up transformation: every chunk going into the sink is accompanied by the given value.sccA sink mark-down transformation: the marks get removed off each chunk.sccThe < function splits the computation into two concurrent parts, producer and consumer. The producer is given a   to put values into, and consumer a   to get those values from. Once producer and consumer both complete,  returns their paired results.sccThe  function is equivalent to , except it runs the producer and the consumer in parallel.sccA generic version of >. The first argument is used to combine two computation steps.scc Function , tries to get a single value from the given   argument. The intervening * computations suspend all the way to the  function invocation that created the source. The function returns ! if the argument source is empty.sccTries to get a minimal, i.e., prime, prefix from the given   argument. The intervening * computations suspend all the way to the  function invocation that created the source. The function returns ! if the argument source is empty.sccInvokes its first argument with the value it gets from the source, if there is any to get.scc Function  acts the same way as , but doesn't actually consume the value from the source; sequential calls to # will always return the same value.scc7 consumes and returns all data generated by the source.sccConsumes inputs from the source as long as the parser accepts it.sccConsumes input from the source as long as the reader accepts it.sccConsumes values from the source as long as each satisfies the predicate, then returns their list. sccConsumes values from the source until one of them satisfies the predicate or the source is emptied, then returns the pair of the list of preceding values and maybe the one value that satisfied the predicate. The latter is not consumed.!sccCopies all data from the source argument into the sink argument. The result indicates if there was any chunk to copy."sccCopies all data from the source argument into the sink argument, like ! but ignoring the result.#sccLike !, copies data from the source to the sink1, but only as long as it satisfies the predicate.$sccParses the input data using the given parser and copies the results to output.%sccLike !, copies data from the source to the sink1, but only as long as it satisfies the predicate.&sccLike !, copies data from the source to the sink, but only until one value satisfies the predicate. That value is returned rather than copied.'scc' is like ! that applies the function f- to each argument before passing it into the sink.(sccAn equivalent of  that works on a   instead of a list. The argument function is applied to every value vefore it's written to the sink argument.)scc) is to ' like  is to .*scc* is to ' like   is to .+scc+ is similar to # except it reads the values from a  8 instead of a list and writes the mapped values into a  # instead of returning another list.,scc, is a love child of * and +: it threads the accumulator like the latter, but its argument function returns not a single value, but a list of values to write into the sink.-sccLike ' except it runs the argument function on whole chunks read from the input..sccLike + except it runs the argument function on whole chunks read from the input./scc/ is similar to . It draws the values from a  3 instead of a list, writes the mapped values to a  , and returns a .0scc0 is similar to # except it draws the values from a  # instead of a list and works with  instead of an arbitrary monad.1sccLike 0 except it runs the argument function on whole chunks read from the input.2sccAn equivalent of . Draws the values from a  5 instead of a list, writes the filtered values to a  , and returns a .3scc Similar to  , but reads the values from a   instead of a list.4scc4 is similar to # except it draws the values from a  # instead of a list and works with  instead of an arbitrary monad.5scc A variant of 4& that discards the final result value.6scc6 is a version of  ) that writes the generated values into a   instead of returning a list.7scc7 is opposite of 0 ; it takes a   instead of a  3 argument and writes the generated values into it.8sccLike 7 but writing whole chunks of generated data into the argument sink.9sccEquivalent to   . Takes a   instead of a list argument and partitions its contents into the two   arguments.:scc: is similar to % except it draws the values from two  ; arguments instead of two lists, sends the results into a  , and works with  instead of an arbitrary monad.;scc; is equivalent to :., but it consumes the two sources in parallel.<scc< is similar to ! except it distributes every input value from its source argument into its both sink arguments.=scc 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   method returns the list of values that couldn't fit into the second sink.>scc*This function puts a value into the given  . The intervening ! computations suspend up to the / invocation that has created the argument sink.?sccLike >, but returns a Bool that determines if the sink is still active.@scc@ puts an entire list into its sink' argument. If the coroutine fed by the sink7 dies, the remainder of the argument list is returned.?  !"#$%&'()*+,-./0123456789:;<=>?@? >?!"<=@  #$%&(')*-.3+,9/01245678:;None >?:wAsccA is a type class representing all types that can act as consumers, namely V, P, and M.BsccB" is used to combine two values of Branch! class into one, using the given V binary combinator.CsccClass C applies to any two components that can be combined into a third component with the following properties: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.The result output, if any, is the output of the second component.Escc1A parser is a transducer that marks up its input.Fscc*Type of values in a markup-up stream. The G# constructor wraps the actual data.IsccA I$ value is produced to mark either a J and K& of a region of data, or an arbitrary L in data. A L! is semantically equivalent to a J immediately followed by K.MsccThe M type represents coroutines that distribute the input stream acording to some criteria. A splitter should distribute only the original input data, and feed it into the sinks in the same order it has been read from the source. Furthermore, the input source should be entirely consumed and fed into the two sinks.A splitter can be used in two ways: as a predicate to determine which portions of its input stream satisfy a certain property, or as a chunker to divide the input stream into chunks. In the former case, the predicate is considered true for exactly those parts of the input that are written to its true sink. In the latter case, a chunk is a contiguous section of the input stream that is written exclusively to one sink, either true or false. A  value written to either of the two sinks can also terminate the chunk written to the other sink.PsccThe P type represents coroutines that transform a data stream. Execution of R$ must continue consuming the given   and feeding the  - as long as there is any data in the source.Sscc6A coroutine that produces values and puts them into a  .Vscc(A coroutine that consumes values from a  .YsccA coroutine that has no inputs nor outputs - and therefore may not suspend at all, which means it's not really a coroutine.`sccCreates a proper V8 from a function that is, but can't be proven to be, an _.asccCreates a proper S8 from a function that is, but can't be proven to be, an ^.bsccCreates a proper P8 from a function that is, but can't be proven to be, an ].csccCreates a proper M8 from a function that is, but can't be proven to be, an \.dscc Function d takes a function that maps one input value to one output value each, and lifts it into a P.escc Function e takes a function that maps one input value into a list of output values, and lifts it into a P.fscc Function e takes a function that maps one input value into a list of output values, and lifts it into a P.gscc Function g constructs a P from a state-transition function and the initial state. The transition function may produce arbitrary output at any transition step.hscc Function h takes a function that assigns a Boolean value to each input item and lifts it into a M.iscc Function i takes a state-converting function that also assigns a Boolean value to each input item and lifts it into a M.)ABCDEFHGIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi)YZ[_VWX^STU]PQR\MNOIJKLFHGECDAB`abcdefghi NoneKA%ysccUsed by / to distinguish between overlapping substrings.zscc7Collects the entire input source into the return value.{scc,Produces the contents of the given argument.|scc Consumer |2 copies the given source into the standard output.}scc Producer }. feeds the given sink from the standard input.~sccReads the named file and feeds the given sink from its contents.scc-Feeds the given sink from the open text file handle.scc/Feeds the given sink from the open binary file handle. The argument  chunkSize9 determines the size of the chunks read from the handle.sccCreates the named text file and writes the entire given source to it.scc0Appends the given source to the named text file.scc0Copies the given source into the open text file handle.scc2Copies the given source into the open binary file handle.scc Transducer  removes all markup from its input and passes the content through.scc Transducer / prepares input content for subsequent parsing.sccThe  consumer suppresses all input it receives. It is equivalent to  substitute []sccThe 3 consumer reports an error if any input reaches it.sccThe  transforms all uppercase letters in the input to lowercase, leaving the rest unchanged.sccThe  transforms all lowercase letters in the input to uppercase, leaving the rest unchanged.sccThe  transducer counts all its input values and outputs the final tally.sccConverts each input value x to show x.scc Transducer 0 collects all its input into a single list item.scc Transducer  flattens the input stream of lists of values into the output stream of values.sccSame as  except it inserts the given separator list between every two input lists.scc Splitter + feeds all white-space characters into its true sink, all others into false.scc Splitter , feeds all alphabetical characters into its true$ sink, all other characters into | false.scc Splitter  feeds all digits into its true! sink, all other characters into false.scc Splitter  feeds line-ends into its false% sink, and all other characters into true.sccThe 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".scc Splitter ! feeds its entire input into its true sink.scc Splitter ! feeds its entire input into its false sink.scc Splitter  feeds all input values to its true2 sink, treating every value as a separate section.scc Splitter , passes all marked-up input sections to its true& sink, and all unmarked input to its false sink.scc Splitter ; passes the content of all marked-up input sections to its true sink, takeWhile the outermost tags and all unmarked input go to its false sink.scc Splitter  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.scc Splitter  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.sccPerforms the same task as the < splitter, but instead of splitting it outputs the input as F x y- in order to distinguish overlapping strings.scc 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 empty chunk on false.%yz{|}~None >?LsccTwo streams of 4 types can be unambigously converted one to another.sccA P/ that converts a stream of one type to another.sccAdjusts the argument splitter to split the stream of a data type  Isomorphic# to the type it was meant to split.None >?nsccClass  applies to any two components that can be combined into a third component with the following properties:if both argument components consume input, the input of the combined component gets distributed to both components in parallel, andif both argument components produce output, the output of the combined component is a concatenation of the complete output from the first component followed by the complete output of the second component.sccThe 2 combinator may apply the components in any order.sccThe  combinator makes sure its first argument has completed before using the second one.scc Converts a V into a P with no output.scc Combinator " converts the given producer to a P that passes all its input through unmodified, except for prepending the output of the argument producer to it. The following law holds:   prefix =  ( prefix)  scc Combinator " converts the given producer to a P that passes all its input through unmodified, finally appending the output of the argument producer to it. The following law holds:   suffix =   ( suffix) sccThe 0 combinator converts its argument producer to a P that produces the same output, while consuming its entire input and ignoring it.sccThe  (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.sccThe  combinator sends the true 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 true sink of the combined component data must be deemed true by both splitters.sccA ( combinator's input value can reach its false5 sink only by going through both argument splitters' false sinks.scc Combinator  is a pairwise logical conjunction of two splitters run in parallel on the same input.scc Combinator  is a pairwise logical disjunction of two splitters run in parallel on the same input.scc"Converts a splitter into a parser.sccThe recursive combinator  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.sccThe recursive combinator  combines two splitters into a mutually recursive loop acting as a single splitter. The true sink of one of the argument splitters and false sink of the other become the true and false sinks of the loop. The other two sinks are bound to the other splitter's source. The use of  makes sense only on hierarchically structured streams. If we gave it some input containing a flat sequence of values, and assuming both component splitters are deterministic and stateless, an input value would either not loop at all or it would loop forever.sccThe ) combinator is similar to the combinator  in that it combines a splitter and two transducers into another transducer. However, in this case the transducers are re-instantiated for each consecutive portion of the input as the splitter chunks it up. Each contiguous portion of the input that the splitter sends to one of its two sinks gets transducered through the appropriate argument transducer as that transducer's whole input. As soon as the contiguous portion is finished, the transducer gets terminated.sccThe  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 second splitter is instantiated and run on each portion of the input that goes to first splitter's true> sink. If the second splitter sends any output at all to its true3 sink, the whole input portion is passed on to the true: sink of the combined splitter, otherwise it goes to its false sink.sccThe  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.sccThe result of combinator  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.sccThe result of combinator  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 true0 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.sccThe result of the combinator . is a splitter which directs all input to its false sink, up to the last 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  has to buffer the previous two 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.sccThe result of the combinator . is a splitter which directs all input to its false sink, up to the last portion of the input which goes to its argument's true sink. That portion and the remainder of the input is fed to the resulting component's true sink. The difference between  and % combinators is where they feed the false8 portion of the input, if any, remaining after the last true part.sccThe  combinator feeds its true sink only the prefix of the input that its argument feeds to its true6 sink. All the rest of the input is dumped into the false sink of the result.sccThe  combinator feeds its true sink only the suffix of the input that its argument feeds to its true6 sink. All the rest of the input is dumped into the false sink of the result.sccThe 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 false0 according to its argument splitter are fed to  splitter's false sink.scc 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.scc Splitter  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.scc Combinator  treats its argument M's as patterns components and returns a M 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.scc 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 true all input values for which the difference balance is positive. This combinator is typically used with  and  in order to count entire input sections and ignore their lengths.sccRuns the second argument on every contiguous region of input source (typically produced by !) whose all values either match Left (_, True) or Left (_, False).(None ?s scc?Converts an XML entity name into the text value it represents: expandXMLEntity "lt" = "<".sccXML markup splitter wrapping .sccThe XML token parser. This parser converts plain text to parsed text, which is a precondition for using the remaining XML components.scc8Splits all top-level elements with all their content to true, all other input to false.scc0Splits the content of all top-level elements to true&, their tags and intervening input to false.scc Similiar to ( element), except it runs the argument splitter only on each element's start tag, not on the entire element with its content.scc(Splits every attribute specification to true, everything else to false.sccSplits every element name, including the names of nested elements and names in end tags, to true, all the rest of input to false.sccSplits every attribute name to true, all the rest of input to false.sccSplits every attribute value, excluding the quote delimiters, to true, all the rest of input to false.None >?*sccThe  type represents computations that distribute data acording to some criteria. A splitter 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' arguments of a splitter are the same, the splitter must act as an identity transform.sccThe ; type represents computations that transform a data stream.scc6A component that produces values and puts them into a   is called .scc(A component that consumes values from a   is called .sccA component that performs a computation with no inputs nor outputs is a .scc3The constant cost of each I/O-performing component.sccA / that converts a stream of one type to another.sccAdjusts the argument consumer to consume the stream of a data type coercible to the type it was meant to consume.sccAdjusts the argument producer to produce the stream of a data type coercible from the type it was meant to produce.sccAdjusts the argument splitter to split the stream of a data type isomorphic to the type it was meant to split.sccProducerComponent . feeds the given sink from the standard input.sccProducerComponent  opens the named file and feeds the given sink from its contents.sccProducerComponent ) feeds the given sink from the open file handle.sccConsumerComponent 2 copies the given source into the standard output.sccConsumerComponent : opens the named file and copies the given source into it.sccConsumerComponent 8 opens the name file and appends the given source to it.sccConsumerComponent , copies the given source into the open file handle.scc- produces the contents of the given argument.sccConsumerComponent 1 collects the given source into the return value.sccThe  consumer suppresses all input it receives. It is equivalent to  []sccThe 3 consumer reports an error if any input reaches it.sccTransducerComponent % passes its input through unmodified.sccTransducerComponent  removes all markup from its input and passes the content through.sccTransducerComponent / prepares input content for subsequent parsing.sccThe  transforms all uppercase letters in the input to lowercase, leaving the rest unchanged.sccThe  transforms all lowercase letters in the input to uppercase, leaving the rest unchanged.sccThe  transducer counts all its input values and outputs the final tally.sccConverts each input value x to show x.sccPerforms the same task as the < splitter, but instead of splitting it outputs the input as F x y- in order to distinguish overlapping strings.sccTransducerComponent 0 collects all its input into a single list item.sccTransducerComponent  flattens the input stream of lists of values into the output stream of values.sccSame as  except it inserts the given separator list between every two input lists.sccSplitterComponent ! feeds its entire input into its true sink.sccSplitterComponent ! feeds its entire input into its false sink.sccSplitterComponent , passes all marked-up input sections to its true& sink, and all unmarked input to its false sink.sccSplitterComponent ; passes the content of all marked-up input sections to its true sink, while the outermost tags and all unmarked input go to its false sink.sccSplitterComponent  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.sccSplitterComponent  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.sccSplitterComponent  feeds all input values to its true2 sink, treating every value as a separate section.sccSplitterComponent  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 empty chunk on false.sccSplitterComponent + feeds all white-space characters into its true sink, all others into false.sccSplitterComponent , feeds all alphabetical characters into its true$ sink, all other characters into | false.sccSplitterComponent  feeds all digits into its true! sink, all other characters into false.sccSplitterComponent  feeds line-ends into its false% sink, and all other characters into true.sccThe 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".scc Converts a  into a  with no output.sccClass C applies to any two components that can be combined into a third component with the following properties: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.The result output, if any, is the output of the second component.sccClass JoinableComponentPair applies to any two components that can be combined into a third component with the following properties:if both argument components consume input, the input of the combined component gets distributed to both components in parallel,if both argument components produce output, the output of the combined component is a concatenation of the complete output from the first component followed by the complete output of the second component, andThe 2 combinator may apply the components in any order.sccThe  combinator makes sure its first argument has completed before using the second one.scc 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) asisscc Combinator  converts the given producer to transducer that passes all its input through unmodified, finally | appending to it the output of the argument producer. |  suffix =  asis ( suffix)sccThe  combinator converts its argument producer to a transducer that produces the same output, while | consuming its entire input and ignoring it.sccThe  (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.sccThe  combinator sends the true 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 true sink of the combined component data must be deemed true by both splitters.sccA ( combinator's input value can reach its false5 sink only by going through both argument splitters' false sinks.scc Combinator  is a pairwise logical conjunction of two splitters run in parallel on the same input.scc Combinator  is a pairwise logical disjunction of two splitters run in parallel on the same input.sccThe recursive combinator  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.sccThe recursive combinator  combines two splitters into a mutually recursive loop acting as a single splitter. The true sink of one of the argument splitters and false sink of the other become the true and false sinks of the loop. The other two sinks are bound to the other splitter's source. The use of  makes sense only on hierarchically structured streams. If we gave it some input containing a flat sequence of values, and assuming both component splitters are deterministic and stateless, an input value would either not loop at all or it would loop forever.sccThe ) combinator is similar to the combinator  in that it combines a splitter and two transducers into another transducer. However, in this case the transducers are re-instantiated for each consecutive portion of the input as the splitter chunks it up. Each contiguous portion of the input that the splitter sends to one of its two sinks gets transducered through the appropriate argument transducer as that transducer's whole input. As soon as the contiguous portion is finished, the transducer gets terminated.sccThe  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 second splitter is instantiated and run on each portion of the input that goes to first splitter's true> sink. If the second splitter sends any output at all to its true3 sink, the whole input portion is passed on to the true: sink of the combined splitter, otherwise it goes to its false sink.sccThe  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.scc Combinator  treats its argument (s as patterns components and returns a  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.sccThe 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 false0 according to its argument splitter are fed to  splitter's false sink.sccThe result of combinator  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.sccThe result of combinator  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 true0 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.sccThe  combinator feeds its true sink only the prefix of the input that its argument feeds to its true6 sink. All the rest of the input is dumped into the false sink of the result.sccThe result of the combinator . is a splitter which directs all input to its false sink, up to the last 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  has to buffer the previous two 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.sccThe result of the combinator . is a splitter which directs all input to its false sink, up to the last portion of the input which goes to its argument's true sink. That portion and the remainder of the input is fed to the resulting component's true sink. The difference between  and % combinators is where they feed the false8 portion of the input, if any, remaining after the last true part.sccThe  combinator feeds its true sink only the suffix of the input that its argument feeds to its true6 sink. All the rest of the input is dumped into the false sink of the result.sccSplitterComponent  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.sccSplitterComponent  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.scc 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 true all input values for which the difference balance is positive. This combinator is typically used with  and  in order to count entire input sections and ignore their lengths.scc"Converts a splitter into a parser.sccThis splitter splits XML markup from data content. It is used by parseXMLTokens.sccThe XML token parser. This parser converts plain text to parsed text, which is a precondition for using the remaining XML components.scc8Splits all top-level elements with all their content to true, all other input to false.scc0Splits the content of all top-level elements to true&, their tags and intervening input to false.scc Similiar to ( element), except it runs the argument splitter only on each element's start tag, not on the entire element with its content.scc(Splits every attribute specification to true, everything else to false.sccSplits every element name, including the names of nested elements and names in end tags, to true, all the rest of input to false.sccSplits every attribute name to true, all the rest of input to false.sccSplits every attribute value, excluding the quote delimiters, to true, all the rest of input to false.  None?³ sccClass C applies to any two components that can be combined into a third component with the following properties: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.The result output, if any, is the output of the second component.sccThe 2 combinator may apply the components in any order.sccThe  combinator sends the true 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 true sink of the combined component data must be deemed true by both splitters.sccA ( combinator's input value can reach its false5 sink only by going through both argument splitters' false sinks.scc Combinator  is a pairwise logical conjunction of two splitters run in parallel on the same input.scc Combinator  is a pairwise logical disjunction of two splitters run in parallel on the same input.sccThe recursive combinator  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.sccThe recursive combinator  combines two splitters into a mutually recursive loop acting as a single splitter. The true sink of one of the argument splitters and false sink of the other become the true and false sinks of the loop. The other two sinks are bound to the other splitter's source. The use of  makes sense only on hierarchically structured streams. If we gave it some input containing a flat sequence of values, and assuming both component splitters are deterministic and stateless, an input value would either not loop at all or it would loop forever.sccThe ) combinator is similar to the combinator  in that it combines a splitter and two transducers into another transducer. However, in this case the transducers are re-instantiated for each consecutive portion of the input as the splitter chunks it up. Each contiguous portion of the input that the splitter sends to one of its two sinks gets transducered through the appropriate argument transducer as that transducer's whole input. As soon as the contiguous portion is finished, the transducer gets terminated.sccThe  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 second splitter is instantiated and run on each portion of the input that goes to first splitter's true> sink. If the second splitter sends any output at all to its true3 sink, the whole input portion is passed on to the true: sink of the combined splitter, otherwise it goes to its false sink.sccThe  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.scc Combinator  treats its argument M's as patterns components and returns a M 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.scc 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 true all input values for which the difference balance is positive. This combinator is typically used with startOf and endOf in order to count entire input sections and ignore their lengths.$CNoneCyz{|}~~}|{zyCNone?a sccClass C applies to any two components that can be combined into a third component with the following properties: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.The result output, if any, is the output of the second component.sccThe 2 combinator may apply the components in any order.sccThe  combinator sends the true 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 true sink of the combined component data must be deemed true by both splitters.sccA ( combinator's input value can reach its false5 sink only by going through both argument splitters' false sinks.scc Combinator  is a pairwise logical conjunction of two splitters run in parallel on the same input.scc Combinator  is a pairwise logical disjunction of two splitters run in parallel on the same input.sccThe recursive combinator  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.sccThe recursive combinator  combines two splitters into a mutually recursive loop acting as a single splitter. The true sink of one of the argument splitters and false sink of the other become the true and false sinks of the loop. The other two sinks are bound to the other splitter's source. The use of  makes sense only on hierarchically structured streams. If we gave it some input containing a flat sequence of values, and assuming both component splitters are deterministic and stateless, an input value would either not loop at all or it would loop forever.sccThe ) combinator is similar to the combinator  in that it combines a splitter and two transducers into another transducer. However, in this case the transducers are re-instantiated for each consecutive portion of the input as the splitter chunks it up. Each contiguous portion of the input that the splitter sends to one of its two sinks gets transducered through the appropriate argument transducer as that transducer's whole input. As soon as the contiguous portion is finished, the transducer gets terminated.sccThe  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 second splitter is instantiated and run on each portion of the input that goes to first splitter's true> sink. If the second splitter sends any output at all to its true3 sink, the whole input portion is passed on to the true: sink of the combined splitter, otherwise it goes to its false sink.sccThe  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.scc Combinator  treats its argument M's as patterns components and returns a M 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.scc 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 true all input values for which the difference balance is positive. This combinator is typically used with startOf and endOf in order to count entire input sections and ignore their lengths.$CNoneCyz{|}~~}|{zyC !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`_abcdeefgghiijkklmmnopqrstuvwxyz{|}~                                     " scc-0.8.3-A4L9rVNSYwoBwdA16WdqO9Control.Concurrent.SCC.Streams#Control.Concurrent.SCC.ConfigurableControl.Concurrent.SCC.Types!Control.Concurrent.SCC.SequentialControl.Concurrent.SCC.Parallel Control.Concurrent.Configuration Data.Listmap concatMapfoldlunfoldr partition!Control.Concurrent.SCC.Primitives Control.Concurrent.SCC.Coercions"Control.Concurrent.SCC.CombinatorsControl.CategoryidControl.Concurrent.SCC.XMLhaving-Control.Concurrent.SCC.Combinators.Sequential+Control.Concurrent.SCC.Combinators.Parallel,monad-coroutine-0.9.1-B5dNvdeVblaHosDDv5FGas*Control.Monad.Coroutine.SuspensionFunctorsDeferredAdvanceFinalReading FinalResult ResultPart ReadingResultReaderControl.Monad.Coroutine.NestedAncestorFunctor ComponentatomicSourceSinkputChunk SinkFunctor SourceFunctornullSinkliftSink liftSource markUpWithmarkDownpipepipePpipeGgetgetPrimegetWithpeekgetAll getParsedgetReadgetWhilegetUntilpourpour_pourRead pourParsed pourWhile pourUntil mapStreammapSinkmapMaybeStreamconcatMapStreammapAccumStreamconcatMapAccumStreammapStreamChunksmapAccumStreamChunks mapMStream mapMStream_mapMStreamChunks_ filterMStream foldStream foldMStream foldMStream_ unfoldMStream unmapMStream_unmapMStreamChunks_partitionStreamzipWithMStreamparZipWithMStreamteeteeSinkputtryPutputAll BranchingcombineBranchesPipeableComponentPaircomposeParserMarkupContentBoundaryStartEndPointSplittersplit Transducer transduceProducerproduceConsumerconsume Performerperform OpenSplitterOpenTransducer OpenProducer OpenConsumerisolateConsumerisolateProducerisolateTransducerisolateSplitteroneToOneTransducerstatelessTransducerstatelessChunkTransducerstatefulTransducerstatelessSplitterstatefulSplitter$fFunctorBoundary $fShowMarkup$fFunctorMarkup7$fPipeableComponentPairmyTransducerTransducerTransducer3$fPipeableComponentPairmxProducerTransducerProducer3$fPipeableComponentPairmyTransducerConsumerConsumer2$fPipeableComponentPairmxProducerConsumerPerformer3$fPipeableComponentPairmxProducerConsumerPerformer03$fPipeableComponentPairmxProducerConsumerPerformer1$fBranchingSplittermx()$fBranchingTransducermx()$fBranchingConsumermxr $fEqMarkup $fEqBoundary$fShowBoundary OccurenceTag consumeInto produceFromtoStdOut fromStdInfromFile fromHandlefromBinaryHandletoFile appendFiletoHandletoBinaryHandleunparseparsesuppress erroneous lowercase uppercasecounttoStringgroup concatenateconcatSeparate whitespacelettersdigits nonEmptyLineline everythingnothingonemarked markedContent markedWithcontentMarkedWithparseSubstring substring Coerciblecoerce adaptConsumer adaptProducer adaptSplitterJoinableComponentPairsequence consumeByprependappend substitutesNotselect parseRegionsfirst uptoFirstlast lastAndAfterprefixsuffixevenstartOfendOfsplitterToMarkerXMLTokenStartTagEndTagEmptyTag ElementName AttributeNameAttributeValueEntityReference EntityNameProcessingInstructionProcessingInstructionTextComment CommentTextStartMarkedSectionCDATAEndMarkedSectionDoctypeDeclaration ErrorTokenexpandXMLEntity xmlTokensparseXMLTokens xmlElementxmlElementContentxmlElementHavingTagWith xmlAttributexmlElementNamexmlAttributeNamexmlAttributeValueTransducerType ProducerType ConsumerType PerformerType AnyListOrUnitCompatibleSignatureSplitterComponentParserComponentTransducerComponentProducerComponentConsumerComponentPerformerComponentioCost>->joinsnot>&>|&&||ifswhereverunlesswhilenestedInforeach havingOnly followedBy...xmlParseTokensliftParallelPairparallelRouterAndBranches chooseBinderrecursiveComponentTree$fAnyListOrUnit()$fAnyListOrUnit[].$fCompatibleSignaturePerformerPerformerTypemxy-$fCompatibleSignatureConsumerConsumerTypem[]y-$fCompatibleSignatureProducerProducerTypemy[]2$fCompatibleSignatureTransducerTransducerTypem[][]name subComponentsmaxUsableThreads usingThreads usedThreadscostwithshowComponentTreeliftliftSequentialPairControl.Monad.Coroutine Coroutinebase GHC.MaybeNothingGHC.Basemempty Data.MaybemapMaybeData.Traversable mapAccumLmapM Data.FoldablemapM_ Control.MonadfilterMfoldMzipWithMsAndsOrpAndpOrbetween groupMarksparserToSplittersplittersToPairMarker findsTrueIn findsFalseIn teeConsumers