zmE      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~88A computation that produces values and puts them into a  is called . *A computation that consumes values from a  is called . A  is the write-only end of a  communication channel. A  is the read-only end of a  communication channel. m represents the type of monadic computations that can be split into co-routining computations using function  . The context7 type parameter delimits the scope of the computation.  Function 3 lifts a value of the underlying monad type into a  computation.  Function J runs the given computation involving pipes and returns the final result.  The contextF argument ensures that no suspended computation can escape its scope. The < function splits the computation into two concurrent parts, producer and consumer. The producer is  given a  to put values into, and consumer a 7 to get those values from. Once producer and consumer  both complete,  returns their paired results. The  function is same as +, with an additional description argument. The   function is equivalent to  , except the producer and consumer" are run in parallel if resources  allow. The / function is the actual worker function of the  family.  Function  % tries to get a value from the given  argument. The intervening  computations suspend  all the way to the < function invocation that created the source. The result of   is  iff the  argument source is empty. Success continuation  Function  _ assumes that the argument source is not empty and returns the value the source yields. If the 0 source is empty, the function throws an error.  Function  ; tries to put a value into the given sink. The intervening  computations suspend up to the  > invocation that has created the argument sink. The result of  + indicates whether the operation succeded.  Function = checks if the argument sink accepts values, i.e., whether a   operation would succeed on the  sink.  copies all data from the source argument into the sink0 argument, as long as there is anything to copy  and the sink accepts it.  is like  that applies the function f- to each argument before passing it into the sink.  is to  like Data.Maybe.mapMaybe is to  Data.List.Map.  is similar to 2 except it distributes every input value from the source arguments into both sink1  and sink2.  puts entire list into its sinkB argument, as long as the sink accepts it. The remainder that wasn't + accepted by the sink is the result value. 9 returns the list of all values generated by the source. > consumes the entire source ignoring the values it generates. SA utility function wrapping if-then-else, useful for handling monadic truth values [A utility function, useful for handling monadic list values where empty list means success Like +, except it puts the contents of the given  into the sink.     WO is a type class representing all components that can act as consumers, namely >=,  0/, and )(. & is used to combine two components in  class into one, using the  given >= binary combinator. The \ class applies to two types where a first type value may contain values of the second type.  returns a pair of a )(7 that determines which containers are non-empty, and a 0/ that  unwraps the contained values.  returns a 0/7 that puts the unwrapped values into containers again. !"#$A "!$ value is produced to mark either a ' and && of a region of data, or an arbitrary  % in data. A %! is semantically equivalent to a ' immediately followed by &. The # $ constructor wraps the actual data. %&'(The )(a type represents computations that distribute data acording to some criteria. A splitter should q 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'W arguments of a splitter are the same, the splitter must act as an identity transform. )*+,-./The 0/H type represents computations that transform data and return no result. a A transducer must continue consuming the given source and feeding the sink while there is data. 01234566A component that produces values and puts them into a  is called 76. 789:;<=(A component that consumes values from a  is called >=. e data Consumer m x r = Consumer {consumerData :: ComponentData (forall c. Source c x -> Pipe c m r), P consume :: forall c. Source c x -> Pipe c m r} >?@ABCDHA component that performs a computation with no inputs nor outputs is a ED. EFGHIJKLMNOP The types of PQ class carry metadata and can be configured to use a specific number of threads. QR-Returns the list of all children components. SIReturns the maximum number of threads that can be used by the component. TWConfigures the component to use the specified number of threads. This function affects U, V,  and R methods of the result, while Q and S remain the same. UcThe number of threads that the component is configured to use. By default the number is usually 1. V/The cost of using the component as configured. WXW) is an existential type wrapper around a P. XY#Show details of the given component's configuration. Z Function ZG takes a component name, maximum number of threads it can use, and its T  method, and returns a ED component. [ Function [G takes a component name, maximum number of threads it can use, and its T  method, and returns a >= component. \ Function \G takes a component name, maximum number of threads it can use, and its T  method, and returns a 76 component. ] Function ]G takes a component name, maximum number of threads it can use, and its T  method, and returns a 0/ component. ^ Function ^ lifts a single-threaded C function into a >= component. _ Function _ lifts a single-threaded < function into a 76 component. ` Function ` lifts a single-threaded 5 function into a 0/ component. a Function aX takes a function that maps one input value to one output value each, and lifts it into  a 0/. b Function bN takes a function that maps one input value into a list of output values, and  lifts it into a 0/. c Function cW creates a stateful transducer that produces only one output value after consuming the  entire input. Similar to Data.List.foldl d Function d constructs a 0/2 from a state-transition function and the initial U state. The transition function may produce arbitrary output at any transition step. e Function eT takes a function that assigns a Boolean value to each input item and lifts it into  a )(. f Function fS takes a state-converting function that also assigns a Boolean value to each input  item and lifts it into a )(. g Function g' lifts a splitter function into a full )(. h Function h lifts a single-threaded . function into a )( component. i Function jI configures two components, both of them with the full thread count, and  returns the components and a LK6 that can be used to build a new component from them. j Function jA configures two components assuming they can be run in parallel, Y splitting the given thread count between them, and returns the configured components, a LK 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. k Function kC configures three components assuming they can be run in parallel, N splitting the given thread count between them, and returns the components, a LK that can be u used to build a new component from them, and a flag per component that indicates if it should be run in parallel or * sequentially for optimal resource usage. lGiven a )(, a  , and three consumer functions, l! runs the splitter on the source  and feeds the splitter's outputs to its true, false, and edge. sinks, respectively, to the three consumers. mGiven a )(, a , and two consumer functions, m! runs the splitter on the source  and feeds the splitter's true and false. outputs, respectively, to the two consumers. U !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmUPQRSTUVWXDEFGHIJ=>?@ABC6789:;<()*+,-./012345KLMNO$'&%!#" Z[^\_]`abcdghefYjiklmU !#""#$'&%%&'()*+,-.)*+,-./0123450123456789:;<789:;<=>?@ABC>?@ABCDEFGHIJEFGHIJKLMNOLMNOPQRSTUVQRSTUVWXXYZ[\]^_`abcdefghijklm.nClass nT 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 o3 method may apply the components in any order, the p& method makes sure its first argument 1 has completed before using the second one. opqClass qT 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. rs Converts a >= into a 0/ with no output. t Combinator t` converts the given producer to transducer that passes all its input through unmodified, except = | for prepending the output of the argument producer to it.  | t prefix = o (v prefix) asis u Combinator ua converts the given producer to transducer that passes all its input through unmodified, finally 8 | appending to it the output of the argument producer.  | u suffix = o asis (v suffix) vThe v` combinator converts its argument producer to a transducer that produces the same output, while / | consuming its entire input and ignoring it. wThe wR (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. xThe x 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. yA y combinator's input value can reach its false3 sink only by going through both argument splitters' false  sinks. z Combinator zW 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. |}~#Converts a 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 T combines two splitters into a mutually recursive loop acting as a single splitter. z The true sink of one of the argument splitters and false sink of the other become the true and false sinks of the loop. 4 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 c a flat sequence of values, and assuming both component splitters are deterministic and stateless, G 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. 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. The result of the combinator . 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  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 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. The  combinator feeds its trueB sink only the prefix of the input that its argument feeds to its true 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 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 6 | splitter, otherwise the entire input goes into its false sink.  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.  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.  Converts a )( into a  0/. Every input value x) that the argument splitter sends to its  true sink is converted to Left (x, True), every y sent to the splitter's false sink becomes  Left (y,  False), and any value e the splitter puts in its edge sink becomes Right e. [Runs the second argument on every contiguous region of input source (typically produced by )  whose all values either match Left (_, True) or Left (_, False). &nopqrstuvwxyz{|}~&stuvqrnopwxyz{|}~&nopopqrrstuvwxyz{|}~&Used by 0 to distinguish between overlapping substrings. The constant cost of each I/O-performing component.  Consumer & copies the given source into a list. 3 produces 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.  Producer B opens the named file and feeds the given sink from its contents.  Producer ) feeds the given sink from the open file handle. The argument doClose determines if  | handleB should be closed when the handle is consumed or the sink closed.  Consumer ; opens the named file and copies the given source into it.  Consumer 9 opens the name file and appends the given source to it.  Consumer , copies the given source into the open file handle. The argument doClose determines if  | handleA should be closed once the entire source is consumed and copied.  Transducer & passes its input through unmodified.  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 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 P 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 "! 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. %%%%?Escapes a character for inclusion into an XML attribute value. =Escapes a character for inclusion into the XML data content. ?Converts an XML entity name into the text value it represents:  expandEntity "lt" = "<". The D splitter distinguishes 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 ( )', 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.  Behaves like 8, but the right-hand splitter works on plain instead of % marked-up text. This allows regular  ( splitters to be applied to parsed XML.  Behaves like 8, but the right-hand splitter works on plain instead of % marked-up text. This allows regular  ( splitters to be applied to parsed XML.        !"#$%&''()*+,--./012334567899:;<=>??@ABCDEEFGHIJKKLMNOPQRSTUVVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~9?scc-0.3!Control.Concurrent.SCC.Foundation%Control.Concurrent.SCC.ComponentTypes"Control.Concurrent.SCC.Combinators!Control.Concurrent.SCC.Components$Control.Concurrent.SCC.XMLComponentsSinkSourcePipeParallelizableMonad parallelizeliftPiperunPipespipepipeDpipePget getSuccessget'putcanPutpourpourMap pourMapMaybeteeputListgetListconsumeAndSuppresscondwhenNullputQueueBranchComponentcombineBranchesLiftableComponent liftComponent ContainerunwraprewrapParserMarkupContentBoundaryPointEndStartSplitter splitterNamesplitterMaxThreadssplitterConfigurationsplitterUsingThreadssplit TransducertransducerNametransducerMaxThreadstransducerConfigurationtransducerUsingThreads transduceProducer producerNameproducerMaxThreadsproducerConfigurationproducerUsingThreadsproduceConsumer consumerNameconsumerMaxThreadsconsumerConfigurationconsumerUsingThreadsconsume Performer performerNameperformerMaxThreadsperformerConfigurationperformerUsingThreadsperformComponentConfigurationcomponentChildrencomponentThreads componentCost Componentname subComponentsmaxUsableThreads usingThreads usedThreadscost AnyComponentshowComponentTree liftPerformer liftConsumer liftProducerliftTransducerliftAtomicConsumerliftAtomicProducerliftAtomicTransducerlift121TransducerliftStatelessTransducerliftFoldTransducerliftStatefulTransducerliftStatelessSplitterliftStatefulSplitter liftSplitterliftAtomicSplitter"optimalTwoSequentialConfigurations optimalTwoParallelConfigurations"optimalThreeParallelConfigurationssplitToConsumerssplitInputToConsumersJoinableComponentPairjoinsequencePipeableComponentPair>-> consumeByprependappend substitutesnot>&>|&&||ifswhereverunlessselect parseRegionsparseNestedRegionswhilenestedInforeachhaving havingOnlyfirst uptoFirstlast lastAndAfterprefixsuffixevenstartOfendOf followedBy...splitterToMarker groupMarks OccurenceTagioCosttoListfromListtoStdOut fromStdInfromFile fromHandletoFile appendFiletoHandleasisunparseparsesuppress erroneous lowercase uppercasecounttoStringgroup concatenateconcatSeparate whitespacelettersdigits nonEmptyLineline everythingnothingonemarked markedContent markedWithcontentMarkedWithparseSubstring substringToken ErrorTokenEndMarkedSectionStartMarkedSectionCDATA CommentTextCommentProcessingInstructionTextProcessingInstruction EntityNameEntityReferenceTokenAttributeValue AttributeName ElementNameEmptyTagEndTagStartTagescapeAttributeCharacterescapeContentCharacter expandEntitytokens parseTokenselementelementContentelementHavingTag attribute elementName attributeNameattributeValue havingTexthavingOnlyTextSuspendedContinuationCanPutPutGet Suspension targetLevelstate description continuationPipeRendezvousDoneSuspend PipeStatelevelclockproceed postApplypipePrimreducemergedelaydelay'synchronizeStatebase Data.MaybeNothingtrackcontainers-0.3.0.0 Data.SequenceSeqshowIndentedComponentshowRightAlignedTransducerType ProducerType ConsumerType PerformerType AnyListOrUnitCompatibleSignaturesplittersToPairMarkerzipSplittersWith OccurencedispatchOnStringgetElementNamegetRestOfRegionpourRestOfRegion pourRestOfTag findEndTag findStartTagghc-prim GHC.TypesChar