-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Streaming component combinators
--   
--   SCC is a layered library of Streaming Component Combinators. The
--   lowest layer defines a Pipe monad transformer that enables building of
--   producer-consumer coroutine pairs. The next layer adds streaming
--   component types, a number of primitive streaming components and a set
--   of component combinators. Finally, there is an executable that exposes
--   all functionality in a command-line shell.
--   
--   The original library design is based on paper
--   <a>http://conferences.idealliance.org/extreme/html/2006/Blazevic01/EML2006Blazevic01.html</a>
--   
--   Mario Blažević, Streaming component combinators, Extreme Markup
--   Languages, 2006.
@package scc
@version 0.3


-- | Module <a>Foundation</a> defines the pipe computations and their basic
--   building blocks.
module Control.Concurrent.SCC.Foundation
class (Monad m) => ParallelizableMonad m
parallelize :: (ParallelizableMonad m) => m a -> m b -> m (a, b)

-- | <a>Pipe</a> represents the type of monadic computations that can be
--   split into co-routining computations using function <a>pipe</a>. The
--   <i>context</i> type parameter delimits the scope of the computation.
data Pipe context m r

-- | A <a>Source</a> is the read-only end of a <a>Pipe</a> communication
--   channel.
data Source context x

-- | A <a>Sink</a> is the write-only end of a <a>Pipe</a> communication
--   channel.
data Sink context x

-- | The <a>pipe</a> function splits the computation into two concurrent
--   parts, <i>producer</i> and <i>consumer</i>. The <i>producer</i> is
--   given a <a>Sink</a> to put values into, and <i>consumer</i> a
--   <a>Source</a> to get those values from. Once producer and consumer
--   both complete, <a>pipe</a> returns their paired results.
pipe :: (Monad m) => Producer context m x r1 -> Consumer context m x r2 -> Pipe context m (r1, r2)

-- | The <a>pipeD</a> function is same as <a>pipe</a>, with an additional
--   description argument.
pipeD :: (Monad m) => String -> Producer c m x r1 -> Consumer c m x r2 -> Pipe c m (r1, r2)

-- | The <a>pipeP</a> function is equivalent to <a>pipe</a>, except the
--   <i>producer</i> and <i>consumer</i> are run in parallel if resources
--   allow.
pipeP :: (ParallelizableMonad m) => Producer c m x r1 -> Consumer c m x r2 -> Pipe c m (r1, r2)

-- | Function <a>get</a> tries to get a value from the given <a>Source</a>
--   argument. The intervening <a>Pipe</a> computations suspend all the way
--   to the <a>pipe</a> function invocation that created the source. The
--   result of <a>get</a> is <a>Nothing</a> iff the argument source is
--   empty.
get :: (Monad m, Typeable x) => Source context x -> Pipe context m (Maybe x)
getSuccess :: (Monad m, Typeable x) => Source context x -> (x -> Pipe context m ()) -> Pipe context m ()

-- | Function <a>get'</a> assumes that the argument source is not empty and
--   returns the value the source yields. If the source is empty, the
--   function throws an error.
get' :: (Monad m, Typeable x) => Source context x -> Pipe context m x

-- | Function <a>canPut</a> checks if the argument sink accepts values,
--   i.e., whether a <a>put</a> operation would succeed on the sink.
canPut :: (Monad m, Typeable x) => Sink context x -> Pipe context m Bool

-- | Function <a>put</a> tries to put a value into the given sink. The
--   intervening <a>Pipe</a> computations suspend up to the <a>pipe</a>
--   invocation that has created the argument sink. The result of
--   <a>put</a> indicates whether the operation succeded.
put :: (Monad m, Typeable x) => Sink context x -> x -> Pipe context m Bool

-- | Function <a>liftPipe</a> lifts a value of the underlying monad type
--   into a <a>Pipe</a> computation.
liftPipe :: (Monad m) => m r -> Pipe context m r

-- | Function <a>runPipes</a> runs the given computation involving pipes
--   and returns the final result. The <i>context</i> argument ensures that
--   no suspended computation can escape its scope.
runPipes :: (Monad m) => (forall context. Pipe context m r) -> m r

-- | A utility function wrapping if-then-else, useful for handling monadic
--   truth values
cond :: a -> a -> Bool -> a

-- | A utility function, useful for handling monadic list values where
--   empty list means success
whenNull :: (Monad m) => m [a] -> [a] -> m [a]

-- | <a>pour</a> copies all data from the <i>source</i> argument into the
--   <i>sink</i> argument, as long as there is anything to copy and the
--   sink accepts it.
pour :: (Monad m, Typeable x) => Source c x -> Sink c x -> Pipe c m ()

-- | <a>pourMap</a> is like <a>pour</a> that applies the function <i>f</i>
--   to each argument before passing it into the <i>sink</i>.
pourMap :: (Monad m, Typeable x, Typeable y) => (x -> y) -> Source c x -> Sink c y -> Pipe c m ()

-- | <a>pourMapMaybe</a> is to <a>pourMap</a> like
--   <tt>Data.Maybe.mapMaybe</tt> is to <tt>Data.List.Map</tt>.
pourMapMaybe :: (Monad m, Typeable x, Typeable y) => (x -> Maybe y) -> Source c x -> Sink c y -> Pipe c m ()

-- | <a>tee</a> is similar to <a>pour</a> except it distributes every input
--   value from the <i>source</i> arguments into both <i>sink1</i> and
--   <i>sink2</i>.
tee :: (Monad m, Typeable x) => Source c x -> Sink c x -> Sink c x -> Pipe c m ()

-- | <a>getList</a> returns the list of all values generated by the source.
getList :: (Monad m, Typeable x) => Source c x -> Pipe c m [x]

-- | <a>putList</a> puts entire list into its <i>sink</i> argument, as long
--   as the sink accepts it. The remainder that wasn't accepted by the sink
--   is the result value.
putList :: (Monad m, Typeable x) => [x] -> Sink c x -> Pipe c m [x]

-- | Like <a>putList</a>, except it puts the contents of the given
--   <a>Seq</a> into the sink.
putQueue :: (Monad m, Typeable x) => Seq x -> Sink c x -> Pipe c m [x]

-- | <a>consumeAndSuppress</a> consumes the entire source ignoring the
--   values it generates.
consumeAndSuppress :: (Monad m, Typeable x) => Source c x -> Pipe c m ()
instance Show (Suspension context m r)
instance (ParallelizableMonad m) => ParallelizableMonad (Pipe context m)
instance (Monad m) => Monad (Pipe context m)
instance ParallelizableMonad IO
instance ParallelizableMonad Maybe
instance ParallelizableMonad Identity

module Control.Concurrent.SCC.ComponentTypes

-- | The types of <a>Component</a> class carry metadata and can be
--   configured to use a specific number of threads.
class Component c
name :: (Component c) => c -> String
subComponents :: (Component c) => c -> [AnyComponent]
maxUsableThreads :: (Component c) => c -> Int
usingThreads :: (Component c) => Int -> c -> c
usedThreads :: (Component c) => c -> Int
cost :: (Component c) => c -> Int

-- | <a>BranchComponent</a> is a type class representing all components
--   that can act as consumers, namely <a>Consumer</a>, <a>Transducer</a>,
--   and <a>Splitter</a>.
class BranchComponent cc m x r | cc -> m x
combineBranches :: (BranchComponent cc m x r) => String -> Int -> (forall c. Bool -> (Source c x -> Pipe c m r) -> (Source c x -> Pipe c m r) -> (Source c x -> Pipe c m r)) -> cc -> cc -> cc
class LiftableComponent cx cy x y | cx -> x, cy -> y, cx y -> cy, cy x -> cx
liftComponent :: (LiftableComponent cx cy x y) => cy -> cx

-- | The <a>Container</a> class applies to two types where a first type
--   value may contain values of the second type.
class Container x y
unwrap :: (Container x y, ParallelizableMonad m) => (Splitter m x (), Transducer m x y)
rewrap :: (Container x y, ParallelizableMonad m) => Transducer m y x

-- | <a>AnyComponent</a> is an existential type wrapper around a
--   <a>Component</a>.
data AnyComponent
AnyComponent :: a -> AnyComponent

-- | A component that performs a computation with no inputs nor outputs is
--   a <a>Performer</a>.
data Performer m r
Performer :: String -> Int -> ComponentConfiguration -> (Int -> (ComponentConfiguration, forall c. Pipe c m r)) -> (forall c. Pipe c m r) -> Performer m r
performerName :: Performer m r -> String
performerMaxThreads :: Performer m r -> Int
performerConfiguration :: Performer m r -> ComponentConfiguration
performerUsingThreads :: Performer m r -> Int -> (ComponentConfiguration, forall c. Pipe c m r)
perform :: Performer m r -> forall c. Pipe c m r

-- | A component that consumes values from a <a>Source</a> is called
--   <a>Consumer</a>. data Consumer m x r = Consumer {consumerData ::
--   ComponentData (forall c. Source c x -&gt; Pipe c m r), consume ::
--   forall c. Source c x -&gt; Pipe c m r}
data Consumer m x r
Consumer :: String -> Int -> ComponentConfiguration -> (Int -> (ComponentConfiguration, forall c. Source c x -> Pipe c m r)) -> (forall c. Source c x -> Pipe c m r) -> Consumer m x r
consumerName :: Consumer m x r -> String
consumerMaxThreads :: Consumer m x r -> Int
consumerConfiguration :: Consumer m x r -> ComponentConfiguration
consumerUsingThreads :: Consumer m x r -> Int -> (ComponentConfiguration, forall c. Source c x -> Pipe c m r)
consume :: Consumer m x r -> forall c. Source c x -> Pipe c m r

-- | A component that produces values and puts them into a <a>Sink</a> is
--   called <a>Producer</a>.
data Producer m x r
Producer :: String -> Int -> ComponentConfiguration -> (Int -> (ComponentConfiguration, forall c. Sink c x -> Pipe c m r)) -> (forall c. Sink c x -> Pipe c m r) -> Producer m x r
producerName :: Producer m x r -> String
producerMaxThreads :: Producer m x r -> Int
producerConfiguration :: Producer m x r -> ComponentConfiguration
producerUsingThreads :: Producer m x r -> Int -> (ComponentConfiguration, forall c. Sink c x -> Pipe c m r)
produce :: Producer m x r -> forall c. Sink c x -> Pipe c m r

-- | The <a>Splitter</a> 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.
data Splitter m x b
Splitter :: String -> Int -> ComponentConfiguration -> (Int -> (ComponentConfiguration, forall c. Source c x -> Sink c x -> Sink c x -> Sink c b -> Pipe c m [x])) -> (forall c. Source c x -> Sink c x -> Sink c x -> Sink c b -> Pipe c m [x]) -> Splitter m x b
splitterName :: Splitter m x b -> String
splitterMaxThreads :: Splitter m x b -> Int
splitterConfiguration :: Splitter m x b -> ComponentConfiguration
splitterUsingThreads :: Splitter m x b -> Int -> (ComponentConfiguration, forall c. Source c x -> Sink c x -> Sink c x -> Sink c b -> Pipe c m [x])
split :: Splitter m x b -> forall c. Source c x -> Sink c x -> Sink c x -> Sink c b -> Pipe c m [x]

-- | The <a>Transducer</a> type represents computations that transform data
--   and return no result. A transducer must continue consuming the given
--   source and feeding the sink while there is data.
data Transducer m x y
Transducer :: String -> Int -> ComponentConfiguration -> (Int -> (ComponentConfiguration, forall c. Source c x -> Sink c y -> Pipe c m [x])) -> (forall c. Source c x -> Sink c y -> Pipe c m [x]) -> Transducer m x y
transducerName :: Transducer m x y -> String
transducerMaxThreads :: Transducer m x y -> Int
transducerConfiguration :: Transducer m x y -> ComponentConfiguration
transducerUsingThreads :: Transducer m x y -> Int -> (ComponentConfiguration, forall c. Source c x -> Sink c y -> Pipe c m [x])
transduce :: Transducer m x y -> forall c. Source c x -> Sink c y -> Pipe c m [x]
data ComponentConfiguration
ComponentConfiguration :: [AnyComponent] -> Int -> Int -> ComponentConfiguration
componentChildren :: ComponentConfiguration -> [AnyComponent]
componentThreads :: ComponentConfiguration -> Int
componentCost :: ComponentConfiguration -> Int

-- | A <a>Markup</a> value is produced to mark either a <a>Start</a> and
--   <a>End</a> of a region of data, or an arbitrary <a>Point</a> in data.
--   A <a>Point</a> is semantically equivalent to a <a>Start</a>
--   immediately followed by <a>End</a>. The <a>Content</a> constructor
--   wraps the actual data.
data Boundary y
Start :: y -> Boundary y
End :: y -> Boundary y
Point :: y -> Boundary y
data Markup x y
Content :: x -> Markup x y
Markup :: (Boundary y) -> Markup x y
type Parser m x b = Transducer m x (Markup x b)

-- | Function <a>liftPerformer</a> takes a component name, maximum number
--   of threads it can use, and its <a>usingThreads</a> method, and returns
--   a <a>Performer</a> component.
liftPerformer :: String -> Int -> (Int -> (ComponentConfiguration, forall c. Pipe c m r)) -> Performer m r

-- | Function <a>liftConsumer</a> takes a component name, maximum number of
--   threads it can use, and its <a>usingThreads</a> method, and returns a
--   <a>Consumer</a> component.
liftConsumer :: String -> Int -> (Int -> (ComponentConfiguration, forall c. Source c x -> Pipe c m r)) -> Consumer m x r

-- | Function <a>liftAtomicConsumer</a> lifts a single-threaded
--   <a>consume</a> function into a <a>Consumer</a> component.
liftAtomicConsumer :: String -> Int -> (forall c. Source c x -> Pipe c m r) -> Consumer m x r

-- | Function <a>liftProducer</a> takes a component name, maximum number of
--   threads it can use, and its <a>usingThreads</a> method, and returns a
--   <a>Producer</a> component.
liftProducer :: String -> Int -> (Int -> (ComponentConfiguration, forall c. Sink c x -> Pipe c m r)) -> Producer m x r

-- | Function <a>liftAtomicProducer</a> lifts a single-threaded
--   <a>produce</a> function into a <a>Producer</a> component.
liftAtomicProducer :: String -> Int -> (forall c. Sink c x -> Pipe c m r) -> Producer m x r

-- | Function <a>liftTransducer</a> takes a component name, maximum number
--   of threads it can use, and its <a>usingThreads</a> method, and returns
--   a <a>Transducer</a> component.
liftTransducer :: String -> Int -> (Int -> (ComponentConfiguration, forall c. Source c x -> Sink c y -> Pipe c m [x])) -> Transducer m x y

-- | Function <a>liftAtomicTransducer</a> lifts a single-threaded
--   <a>transduce</a> function into a <a>Transducer</a> component.
liftAtomicTransducer :: String -> Int -> (forall c. Source c x -> Sink c y -> Pipe c m [x]) -> Transducer m x y

-- | Function <a>lift121Transducer</a> takes a function that maps one input
--   value to one output value each, and lifts it into a <a>Transducer</a>.
lift121Transducer :: (Monad m, Typeable x, Typeable y) => String -> (x -> y) -> Transducer m x y

-- | Function <a>liftStatelessTransducer</a> takes a function that maps one
--   input value into a list of output values, and lifts it into a
--   <a>Transducer</a>.
liftStatelessTransducer :: (Monad m, Typeable x, Typeable y) => String -> (x -> [y]) -> Transducer m x y

-- | Function <a>liftFoldTransducer</a> creates a stateful transducer that
--   produces only one output value after consuming the entire input.
--   Similar to <tt>Data.List.foldl</tt>
liftFoldTransducer :: (Monad m, Typeable x, Typeable y) => String -> (s -> x -> s) -> s -> (s -> y) -> Transducer m x y

-- | Function <a>liftStatefulTransducer</a> constructs a <a>Transducer</a>
--   from a state-transition function and the initial state. The transition
--   function may produce arbitrary output at any transition step.
liftStatefulTransducer :: (Monad m, Typeable x, Typeable y) => String -> (state -> x -> (state, [y])) -> state -> Transducer m x y

-- | Function <a>liftSplitter</a> lifts a splitter function into a full
--   <a>Splitter</a>.
liftSplitter :: (Monad m, Typeable x) => String -> Int -> (Int -> (ComponentConfiguration, forall c. Source c x -> Sink c x -> Sink c x -> Sink c b -> Pipe c m [x])) -> Splitter m x b

-- | Function <a>liftAtomicSplitter</a> lifts a single-threaded
--   <a>split</a> function into a <a>Splitter</a> component.
liftAtomicSplitter :: (Monad m, Typeable x) => String -> Int -> (forall c. Source c x -> Sink c x -> Sink c x -> Sink c b -> Pipe c m [x]) -> Splitter m x b

-- | Function <a>liftStatelessSplitter</a> takes a function that assigns a
--   Boolean value to each input item and lifts it into a <a>Splitter</a>.
liftStatelessSplitter :: (ParallelizableMonad m, Typeable x) => String -> (x -> Bool) -> Splitter m x b

-- | Function <a>liftStatefulSplitter</a> takes a state-converting function
--   that also assigns a Boolean value to each input item and lifts it into
--   a <a>Splitter</a>.
liftStatefulSplitter :: (ParallelizableMonad m, Typeable x) => String -> (state -> x -> (state, Bool)) -> state -> Splitter m x ()

-- | Show details of the given component's configuration.
showComponentTree :: (Component c) => c -> String

-- | Function <a>optimalTwoParallelConfigurations</a> configures two
--   components assuming they can be run in parallel, splitting the given
--   thread count between them, and returns the configured components, a
--   <a>ComponentConfiguration</a> that 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.
optimalTwoParallelConfigurations :: (Component c1, Component c2) => Int -> c1 -> c2 -> (ComponentConfiguration, c1, c2, Bool)

-- | Function <a>optimalTwoParallelConfigurations</a> configures two
--   components, both of them with the full thread count, and returns the
--   components and a <a>ComponentConfiguration</a> that can be used to
--   build a new component from them.
optimalTwoSequentialConfigurations :: (Component c1, Component c2) => Int -> c1 -> c2 -> (ComponentConfiguration, c1, c2)

-- | Function <a>optimalThreeParallelConfigurations</a> configures three
--   components assuming they can be run in parallel, splitting the given
--   thread count between them, and returns the components, a
--   <a>ComponentConfiguration</a> that can be 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.
optimalThreeParallelConfigurations :: (Component c1, Component c2, Component c3) => Int -> c1 -> c2 -> c3 -> (ComponentConfiguration, (c1, Bool), (c2, Bool), (c3, Bool))

-- | Given a <a>Splitter</a>, a <a>Source</a>, and three consumer
--   functions, <a>splitToConsumers</a> runs the splitter on the source and
--   feeds the splitter's outputs to its <i>true</i>, <i>false</i>, and
--   <i>edge</i> sinks, respectively, to the three consumers.
splitToConsumers :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Source c x -> (Source c x -> Pipe c m r1) -> (Source c x -> Pipe c m r2) -> (Source c b -> Pipe c m r3) -> Pipe c m ([x], r1, r2, r3)

-- | Given a <a>Splitter</a>, a <a>Source</a>, and two consumer functions,
--   <a>splitInputToConsumers</a> runs the splitter on the source and feeds
--   the splitter's <i>true</i> and <i>false</i> outputs, respectively, to
--   the two consumers.
splitInputToConsumers :: (ParallelizableMonad m, Typeable x, Typeable b) => Bool -> Splitter m x b -> Source c x -> (Source c x -> Pipe c m [x]) -> (Source c x -> Pipe c m [x]) -> Pipe c m [x]
instance Typeable2 Markup
instance Typeable1 Boundary
instance (Eq x, Eq y) => Eq (Markup x y)
instance (Eq y) => Eq (Boundary y)
instance (Show y) => Show (Boundary y)
instance (ParallelizableMonad m, Typeable x) => BranchComponent (Splitter m x b) m x [x]
instance BranchComponent (Transducer m x y) m x [x]
instance (Monad m) => BranchComponent (Consumer m x ()) m x [x]
instance (Monad m) => BranchComponent (Consumer m x r) m x r
instance Component (Splitter m x b)
instance Component (Transducer m x y)
instance Component (Producer m x r)
instance Component (Consumer m x r)
instance Component (Performer m r)
instance (Container x y, ParallelizableMonad m, Typeable x, Typeable y) => LiftableComponent (Splitter m x ()) (Splitter m y ()) x y
instance (Container x y, ParallelizableMonad m, Typeable x, Typeable y) => LiftableComponent (Transducer m x x) (Transducer m y y) x y
instance (Typeable x, Typeable y) => Container (Markup x y) x
instance (Show y) => Show (Markup Char y)
instance Functor Boundary
instance Component AnyComponent


-- | The <a>Combinators</a> module defines combinators applicable to
--   <a>Transducer</a> and <a>Splitter</a> components defined in the
--   <a>Control.Concurrent.SCC.ComponentTypes</a> module.
module Control.Concurrent.SCC.Combinators

-- | Converts a <a>Splitter</a> into a <a>Transducer</a>. Every input value
--   <tt>x</tt> that the argument splitter sends to its <i>true</i> sink is
--   converted to <tt>Left (x, True)</tt>, every <tt>y</tt> sent to the
--   splitter's <i>false</i> sink becomes <tt>Left (y, False)</tt>, and any
--   value <tt>e</tt> the splitter puts in its <i>edge</i> sink becomes
--   <tt>Right e</tt>.
splitterToMarker :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Transducer m x (Either (x, Bool) b)

-- | Converts a <a>Consumer</a> into a <a>Transducer</a> with no output.
consumeBy :: (Monad m, Typeable x) => Consumer m x r -> Transducer m x y

-- | Combinator <a>prepend</a> converts the given producer to transducer
--   that passes all its input through unmodified, except | for prepending
--   the output of the argument producer to it. | <a>prepend</a>
--   <i>prefix</i> = <a>join</a> (<a>substitute</a> <i>prefix</i>)
--   <tt>asis</tt>
prepend :: (Monad m, Typeable x) => Producer m x r -> Transducer m x x

-- | Combinator <a>append</a> converts the given producer to transducer
--   that passes all its input through unmodified, finally | appending to
--   it the output of the argument producer. | <a>append</a> <i>suffix</i>
--   = <a>join</a> <tt>asis</tt> (<a>substitute</a> <i>suffix</i>)
append :: (Monad m, Typeable x) => Producer m x r -> Transducer m x x

-- | The <a>substitute</a> combinator converts its argument producer to a
--   transducer that produces the same output, while | consuming its entire
--   input and ignoring it.
substitute :: (Monad m, Typeable x, Typeable y) => Producer m y r -> Transducer m x y

-- | Class <a>PipeableComponentPair</a> applies to any two components that
--   can be combined into a third component with the following properties:
--   
--   <ul>
--   <li>The input of the result, if any, becomes the input of the first
--   component.</li>
--   <li>The output produced by the first child component is consumed by
--   the second child component.</li>
--   <li>The result output, if any, is the output of the second
--   component.</li>
--   </ul>
class PipeableComponentPair m :: (* -> *) w c1 c2 c3 | c1 c2 -> c3, c1 c3 -> c2, c2 c3 -> c2, c1 -> m w, c2 -> m w, c3 -> m
(>->) :: (PipeableComponentPair m w c1 c2 c3) => c1 -> c2 -> c3

-- | Class <a>JoinableComponentPair</a> applies to any two components that
--   can be combined into a third component with the following properties:
--   
--   <ul>
--   <li>if both argument components consume input, the input of the
--   combined component gets distributed to both components in
--   parallel,</li>
--   <li>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, and</li>
--   <li>the <a>join</a> method may apply the components in any order, the
--   <a>sequence</a> method makes sure its first argument has completed
--   before using the second one.</li>
--   </ul>
class (Monad m, CompatibleSignature c1 t1 m x y, CompatibleSignature c2 t2 m x y, CompatibleSignature c3 t3 m x y) => JoinableComponentPair t1 t2 t3 m x y c1 c2 c3 | c1 c2 -> c3, c1 -> t1 m, c2 -> t2 m, c3 -> t3 m x y, t1 m x y -> c1, t2 m x y -> c2, t3 m x y -> c3
join :: (JoinableComponentPair t1 t2 t3 m x y c1 c2 c3) => c1 -> c2 -> c3
sequence :: (JoinableComponentPair t1 t2 t3 m x y c1 c2 c3) => c1 -> c2 -> c3

-- | The <a>snot</a> (streaming not) combinator simply reverses the outputs
--   of the argument splitter. In other words, data that the argument
--   splitter sends to its <i>true</i> sink goes to the <i>false</i> sink
--   of the result, and vice versa.
snot :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Splitter m x b

-- | The <a>&gt;&amp;</a> combinator sends the <i>true</i> sink output of
--   its left operand to the input of its right operand for further
--   splitting. Both operands' <i>false</i> sinks are connected to the
--   <i>false</i> sink of the combined splitter, but any input value to
--   reach the <i>true</i> sink of the combined component data must be
--   deemed true by both splitters.
(>&) :: (ParallelizableMonad m, Typeable x, Typeable b1, Typeable b2) => Splitter m x b1 -> Splitter m x b2 -> Splitter m x (b1, b2)

-- | A <a>&gt;|</a> combinator's input value can reach its <i>false</i>
--   sink only by going through both argument splitters' <i>false</i>
--   sinks.
(>|) :: (ParallelizableMonad m, Typeable x, Typeable b1, Typeable b2) => Splitter m x b1 -> Splitter m x b2 -> Splitter m x (Either b1 b2)

-- | Combinator <a>&amp;&amp;</a> is a pairwise logical conjunction of two
--   splitters run in parallel on the same input.
(&&) :: (ParallelizableMonad m, Typeable x, Typeable b1, Typeable b2) => Splitter m x b1 -> Splitter m x b2 -> Splitter m x (b1, b2)

-- | Combinator <a>||</a> is a pairwise logical disjunction of two
--   splitters run in parallel on the same input.
(||) :: (ParallelizableMonad m, Typeable x, Typeable b1, Typeable b2) => Splitter m x b1 -> Splitter m x b2 -> Splitter m x (Either b1 b2)
ifs :: (ParallelizableMonad m, Typeable x, Typeable b, BranchComponent cc m x [x]) => Splitter m x b -> cc -> cc -> cc
wherever :: (ParallelizableMonad m, Typeable x, Typeable b) => Transducer m x x -> Splitter m x b -> Transducer m x x
unless :: (ParallelizableMonad m, Typeable x, Typeable b) => Transducer m x x -> Splitter m x b -> Transducer m x x
select :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Transducer m x x

-- | The recursive combinator <a>while</a> 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.
while :: (ParallelizableMonad m, Typeable x, Typeable b) => Transducer m x x -> Splitter m x b -> Transducer m x x

-- | The recursive combinator <a>nestedIn</a> 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 <a>nestedIn</a> 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.
nestedIn :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Splitter m x b -> Splitter m x b

-- | The <a>foreach</a> combinator is similar to the combinator <a>ifs</a>
--   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.
foreach :: (ParallelizableMonad m, Typeable x, Typeable b, BranchComponent cc m x [x]) => Splitter m x b -> cc -> cc -> cc

-- | The <a>having</a> combinator combines two pure splitters into a pure
--   splitter. One splitter is used to chunk the input into contiguous
--   portions. Its <i>false</i> sink is routed directly to the <i>false</i>
--   sink of the combined splitter. The second splitter is instantiated and
--   run on each portion of the input that goes to first splitter's
--   <i>true</i> sink. If the second splitter sends any output at all to
--   its <i>true</i> sink, the whole input portion is passed on to the
--   <i>true</i> sink of the combined splitter, otherwise it goes to its
--   <i>false</i> sink.
having :: (ParallelizableMonad m, Typeable x, Typeable b1, Typeable b2) => Splitter m x b1 -> Splitter m x b2 -> Splitter m x b1

-- | The <a>havingOnly</a> combinator is analogous to the <a>having</a>
--   combinator, but it succeeds and passes each chunk of the input to its
--   <i>true</i> sink only if the second splitter sends no part of it to
--   its <i>false</i> sink.
havingOnly :: (ParallelizableMonad m, Typeable x, Typeable b1, Typeable b2) => Splitter m x b1 -> Splitter m x b2 -> Splitter m x b1

-- | Combinator <a>followedBy</a> treats its argument <a>Splitter</a>s as
--   patterns components and returns a <a>Splitter</a> that matches their
--   concatenation. A section of input is considered <i>true</i> by the
--   result iff its prefix is considered <i>true</i> by argument <i>s1</i>
--   and the rest of the section is considered <i>true</i> by <i>s2</i>.
--   The splitter <i>s2</i> is started anew after every section split to
--   <i>true</i> sink by <i>s1</i>.
followedBy :: (ParallelizableMonad m, Typeable x, Typeable b1, Typeable b2) => Splitter m x b1 -> Splitter m x b2 -> Splitter m x (b1, b2)

-- | The <a>even</a> combinator takes every input section that its argument
--   <i>splitter</i> deems <i>true</i>, and feeds even ones into its
--   <i>true</i> sink. The odd sections and parts of input that are
--   <i>false</i> according to its argument splitter are fed to <a>even</a>
--   splitter's <i>false</i> sink.
even :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Splitter m x b

-- | The result of combinator <a>first</a> behaves the same as the argument
--   splitter up to and including the first portion of the input which goes
--   into the argument's <i>true</i> sink. All input following the first
--   true portion goes into the <i>false</i> sink.
first :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Splitter m x b

-- | The result of combinator <a>uptoFirst</a> takes all input up to and
--   including the first portion of the input which goes into the
--   argument's <i>true</i> sink and feeds it to the result splitter's
--   <i>true</i> sink. All the rest of the input goes into the <i>false</i>
--   sink. The only difference between <a>first</a> and <a>uptoFirst</a>
--   combinators is in where they direct the <i>false</i> portion of the
--   input preceding the first <i>true</i> part.
uptoFirst :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Splitter m x b

-- | The <a>prefix</a> combinator feeds its <i>true</i> sink only the
--   prefix of the input that its argument feeds to its <i>true</i> sink.
--   All the rest of the input is dumped into the <i>false</i> sink of the
--   result.
prefix :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Splitter m x b

-- | The result of the combinator <a>last</a> is a splitter which directs
--   all input to its <i>false</i> sink, up to the last portion of the
--   input which goes to its argument's <i>true</i> sink. That portion of
--   the input is the only one that goes to the resulting component's
--   <i>true</i> sink. The splitter returned by the combinator <a>last</a>
--   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.
last :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Splitter m x b

-- | The result of the combinator <a>lastAndAfter</a> is a splitter which
--   directs all input to its <i>false</i> sink, up to the last portion of
--   the input which goes to its argument's <i>true</i> sink. That portion
--   and the remainder of the input is fed to the resulting component's
--   <i>true</i> sink. The difference between <a>last</a> and
--   <a>lastAndAfter</a> combinators is where they feed the <i>false</i>
--   portion of the input, if any, remaining after the last <i>true</i>
--   part.
lastAndAfter :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Splitter m x b

-- | The <a>suffix</a> combinator feeds its <i>true</i> sink only the
--   suffix of the input that its argument feeds to its <i>true</i> sink.
--   All the rest of the input is dumped into the <i>false</i> sink of the
--   result.
suffix :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Splitter m x b

-- | Splitter <a>startOf</a> issues an empty <i>true</i> section at the
--   beginning of every section considered <i>true</i> by its | argument
--   splitter, otherwise the entire input goes into its <i>false</i> sink.
startOf :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Splitter m x (Maybe b)

-- | Splitter <a>endOf</a> issues an empty <i>true</i> section at the end
--   of every section considered <i>true</i> by its argument | splitter,
--   otherwise the entire input goes into its <i>false</i> sink.
endOf :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Splitter m x (Maybe b)

-- | Combinator <a>...</a> tracks the running balance of difference between
--   the number of preceding starts of sections considered <i>true</i>
--   according to its first argument and the ones according to its second
--   argument. The combinator passes to <i>true</i> all input values for
--   which the difference balance is positive. This combinator is typically
--   used with <a>startOf</a> and <a>endOf</a> in order to count entire
--   input sections and ignore their lengths.
(...) :: (ParallelizableMonad m, Typeable x, Typeable b1, Typeable b2) => Splitter m x b1 -> Splitter m x b2 -> Splitter m x b1

-- | Converts a splitter into a parser.
parseRegions :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x b -> Parser m x b

-- | Converts a boundary-marking splitter into a parser.
parseNestedRegions :: (ParallelizableMonad m, Typeable x, Typeable b) => Splitter m x (Boundary b) -> Parser m x b

-- | Runs the second argument on every contiguous region of input source
--   (typically produced by <a>splitterToMarker</a>) whose all values
--   either match <tt>Left (_, True)</tt> or <tt>Left (_, False)</tt>.
groupMarks :: (ParallelizableMonad m, Typeable x, Typeable b) => Source c (Either (x, Bool) b) -> (Maybe (Maybe b) -> Source c x -> Pipe c m r) -> Pipe c m ()
instance (ParallelizableMonad m, Typeable x, Typeable y) => JoinableComponentPair (ConsumerType ()) (ProducerType ()) TransducerType m [x] [y] (Consumer m x ()) (Producer m y ()) (Transducer m x y)
instance (ParallelizableMonad m, Typeable x, Typeable y) => JoinableComponentPair (ProducerType ()) (ConsumerType ()) TransducerType m [x] [y] (Producer m y ()) (Consumer m x ()) (Transducer m x y)
instance (ParallelizableMonad m, Typeable x, Typeable y) => JoinableComponentPair TransducerType (ConsumerType ()) TransducerType m [x] [y] (Transducer m x y) (Consumer m x ()) (Transducer m x y)
instance (ParallelizableMonad m, Typeable x, Typeable y) => JoinableComponentPair (ConsumerType ()) TransducerType TransducerType m [x] [y] (Consumer m x ()) (Transducer m x y) (Transducer m x y)
instance (ParallelizableMonad m, Typeable x, Typeable y) => JoinableComponentPair TransducerType (ProducerType ()) TransducerType m [x] [y] (Transducer m x y) (Producer m y ()) (Transducer m x y)
instance (ParallelizableMonad m, Typeable x, Typeable y) => JoinableComponentPair (ProducerType ()) TransducerType TransducerType m [x] [y] (Producer m y ()) (Transducer m x y) (Transducer m x y)
instance (ParallelizableMonad m, Typeable x, Typeable y) => JoinableComponentPair TransducerType (PerformerType r) TransducerType m [x] [y] (Transducer m x y) (Performer m r) (Transducer m x y)
instance (ParallelizableMonad m, Typeable x, Typeable y) => JoinableComponentPair (PerformerType r) TransducerType TransducerType m [x] [y] (Performer m r) (Transducer m x y) (Transducer m x y)
instance (ParallelizableMonad m, Typeable x) => JoinableComponentPair (ConsumerType r1) (PerformerType r2) (ConsumerType r2) m [x] () (Consumer m x r1) (Performer m r2) (Consumer m x r2)
instance (ParallelizableMonad m, Typeable x) => JoinableComponentPair (PerformerType r1) (ConsumerType r2) (ConsumerType r2) m [x] () (Performer m r1) (Consumer m x r2) (Consumer m x r2)
instance (ParallelizableMonad m, Typeable x) => JoinableComponentPair (ProducerType r1) (PerformerType r2) (ProducerType r2) m () [x] (Producer m x r1) (Performer m r2) (Producer m x r2)
instance (ParallelizableMonad m, Typeable x) => JoinableComponentPair (PerformerType r1) (ProducerType r2) (ProducerType r2) m () [x] (Performer m r1) (Producer m x r2) (Producer m x r2)
instance (ParallelizableMonad m) => JoinableComponentPair (PerformerType r1) (PerformerType r2) (PerformerType r2) m () () (Performer m r1) (Performer m r2) (Performer m r2)
instance (ParallelizableMonad m, Typeable x, Typeable y) => JoinableComponentPair TransducerType TransducerType TransducerType m [x] [y] (Transducer m x y) (Transducer m x y) (Transducer m x y)
instance (ParallelizableMonad m, Typeable x) => JoinableComponentPair (ConsumerType ()) (ConsumerType ()) (ConsumerType ()) m [x] () (Consumer m x ()) (Consumer m x ()) (Consumer m x ())
instance (Monad m, Typeable x) => JoinableComponentPair (ProducerType r1) (ProducerType r2) (ProducerType r2) m () [x] (Producer m x r1) (Producer m x r2) (Producer m x r2)
instance CompatibleSignature (Transducer m x y) TransducerType m [x] [y]
instance (AnyListOrUnit y) => CompatibleSignature (Producer m x r) (ProducerType r) m y [x]
instance (AnyListOrUnit y) => CompatibleSignature (Consumer m x r) (ConsumerType r) m [x] y
instance (AnyListOrUnit x, AnyListOrUnit y) => CompatibleSignature (Performer m r) (PerformerType r) m x y
instance AnyListOrUnit ()
instance AnyListOrUnit [x]
instance (ParallelizableMonad m) => PipeableComponentPair m y (Transducer m x y) (Transducer m y z) (Transducer m x z)
instance (ParallelizableMonad m, Typeable x, Typeable y) => PipeableComponentPair m x (Producer m x r) (Transducer m x y) (Producer m y r)
instance (ParallelizableMonad m, Typeable x, Typeable y) => PipeableComponentPair m y (Transducer m x y) (Consumer m y r) (Consumer m x r)
instance (ParallelizableMonad m, Typeable x) => PipeableComponentPair m x (Producer m x ()) (Consumer m x ()) (Performer m ())


-- | Module <a>Components</a> defines primitive components of
--   <a>Producer</a>, <a>Consumer</a>, <a>Transducer</a> and
--   <a>Splitter</a> types, defined in the <a>Foundation</a> and
--   <a>ComponentTypes</a> modules.
module Control.Concurrent.SCC.Components

-- | Used by <a>parseSubstring</a> to distinguish between overlapping
--   substrings.
data OccurenceTag

-- | <a>fromList</a> produces the contents of the given list argument.
fromList :: (Monad m, Typeable x) => [x] -> Producer m x [x]

-- | Consumer <a>toList</a> copies the given source into a list.
toList :: (Monad m, Typeable x) => Consumer m x [x]

-- | Producer <a>fromFile</a> opens the named file and feeds the given sink
--   from its contents.
fromFile :: String -> Producer IO Char ()

-- | Producer <a>fromHandle</a> feeds the given sink from the open file
--   <i>handle</i>. The argument <i>doClose</i> determines if |
--   <i>handle</i> should be closed when the handle is consumed or the sink
--   closed.
fromHandle :: Handle -> Bool -> Producer IO Char ()

-- | Producer <a>fromStdIn</a> feeds the given sink from the standard
--   input.
fromStdIn :: Producer IO Char ()

-- | Consumer <a>appendFile</a> opens the name file and appends the given
--   source to it.
appendFile :: String -> Consumer IO Char ()

-- | Consumer <a>toFile</a> opens the named file and copies the given
--   source into it.
toFile :: String -> Consumer IO Char ()

-- | Consumer <a>toHandle</a> copies the given source into the open file
--   <i>handle</i>. The argument <i>doClose</i> determines if |
--   <i>handle</i> should be closed once the entire source is consumed and
--   copied.
toHandle :: Handle -> Bool -> Consumer IO Char ()

-- | Consumer <a>toStdOut</a> copies the given source into the standard
--   output.
toStdOut :: Consumer IO Char ()

-- | The <a>suppress</a> consumer suppresses all input it receives. It is
--   equivalent to <tt>substitute</tt> []
suppress :: (Monad m, Typeable x) => Consumer m x ()

-- | The <a>erroneous</a> consumer reports an error if any input reaches
--   it.
erroneous :: (Monad m, Typeable x) => String -> Consumer m x ()

-- | Transducer <a>asis</a> passes its input through unmodified.
asis :: (Monad m, Typeable x) => Transducer m x x

-- | Transducer <a>parse</a> prepares input content for subsequent parsing.
parse :: (Monad m, Typeable x, Typeable y) => Transducer m x (Markup x y)

-- | Transducer <a>unparse</a> removes all markup from its input and passes
--   the content through.
unparse :: (Monad m, Typeable x, Typeable y) => Transducer m (Markup x y) x

-- | Performs the same task as the <a>substring</a> splitter, but instead
--   of splitting it outputs the input as <tt><a>Markup</a> x
--   <a>OccurenceTag</a></tt> in order to distinguish overlapping strings.
parseSubstring :: (ParallelizableMonad m, Eq x, Typeable x) => [x] -> Parser m x OccurenceTag

-- | Splitter <a>everything</a> feeds its entire input into its <i>true</i>
--   sink.
everything :: (ParallelizableMonad m, Typeable x) => Splitter m x ()

-- | Splitter <a>nothing</a> feeds its entire input into its <i>false</i>
--   sink.
nothing :: (ParallelizableMonad m, Typeable x) => Splitter m x ()

-- | Splitter <a>marked</a> passes all marked-up input sections to its
--   <i>true</i> sink, and all unmarked input to its <i>false</i> sink.
marked :: (ParallelizableMonad m, Typeable x, Typeable y, Eq y) => Splitter m (Markup x y) ()

-- | Splitter <a>markedContent</a> passes the content of all marked-up
--   input sections to its <i>true</i> sink, while the outermost tags and
--   all unmarked input go to its <i>false</i> sink.
markedContent :: (ParallelizableMonad m, Typeable x, Typeable y, Eq y) => Splitter m (Markup x y) ()

-- | Splitter <a>markedWith</a> passes input sections marked-up with the
--   appropriate tag to its <i>true</i> sink, and the rest of the input to
--   its <i>false</i> sink. The argument <i>select</i> determines if the
--   tag is appropriate.
markedWith :: (ParallelizableMonad m, Typeable x, Typeable y, Eq y) => (y -> Bool) -> Splitter m (Markup x y) ()

-- | Splitter <a>contentMarkedWith</a> passes the content of input sections
--   marked-up with the appropriate tag to its <i>true</i> sink, and the
--   rest of the input to its <i>false</i> sink. The argument <i>select</i>
--   determines if the tag is appropriate.
contentMarkedWith :: (ParallelizableMonad m, Typeable x, Typeable y, Eq y) => (y -> Bool) -> Splitter m (Markup x y) ()

-- | Splitter <a>one</a> feeds all input values to its <i>true</i> sink,
--   treating every value as a separate section.
one :: (ParallelizableMonad m, Typeable x) => Splitter m x ()

-- | Splitter <a>substring</a> feeds to its <i>true</i> 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 <i>true</i> and each is preceded by an edge.
substring :: (ParallelizableMonad m, Eq x, Typeable x) => [x] -> Splitter m x ()

-- | Transducer <a>group</a> collects all its input values into a single
--   list.
group :: (Monad m, Typeable x) => Transducer m x [x]

-- | Transducer <a>concatenate</a> flattens the input stream of lists of
--   values into the output stream of values.
concatenate :: (Monad m, Typeable x) => Transducer m [x] x

-- | Same as <a>concatenate</a> except it inserts the given separator list
--   between every two input lists.
concatSeparate :: (Monad m, Typeable x) => [x] -> Transducer m [x] x

-- | The <a>lowercase</a> transforms all uppercase letters in the input to
--   lowercase, leaving the rest unchanged.
lowercase :: (Monad m) => Transducer m Char Char

-- | The <a>uppercase</a> transforms all lowercase letters in the input to
--   uppercase, leaving the rest unchanged.
uppercase :: (Monad m) => Transducer m Char Char

-- | Splitter <a>whitespace</a> feeds all white-space characters into its
--   <i>true</i> sink, all others into <i>false</i>.
whitespace :: (ParallelizableMonad m) => Splitter m Char ()

-- | Splitter <a>letters</a> feeds all alphabetical characters into its
--   <i>true</i> sink, all other characters into <i>false</i>.
letters :: (ParallelizableMonad m) => Splitter m Char ()

-- | Splitter <a>digits</a> feeds all digits into its <i>true</i> sink, all
--   other characters into <i>false</i>.
digits :: (ParallelizableMonad m) => Splitter m Char ()

-- | The sectioning splitter <a>line</a> feeds line-ends into its
--   <i>false</i> sink, and line contents into <i>true</i>. A single
--   line-end can be formed by any of the character sequences "\n", "\r",
--   "\r\n", or "\n\r".
line :: (ParallelizableMonad m) => Splitter m Char ()

-- | Splitter <a>nonEmptyLine</a> feeds line-ends into its <i>false</i>
--   sink, and all other characters into <i>true</i>.
nonEmptyLine :: (ParallelizableMonad m) => Splitter m Char ()

-- | The <a>count</a> transducer counts all its input values and outputs
--   the final tally.
count :: (Monad m, Typeable x) => Transducer m x Integer

-- | Converts each input value <tt>x</tt> to <tt>show x</tt>.
toString :: (Monad m, Show x, Typeable x) => Transducer m x String

-- | The constant cost of each I/O-performing component.
ioCost :: Int
instance Typeable OccurenceTag
instance Eq OccurenceTag
instance Show OccurenceTag
instance Enum OccurenceTag


-- | Module <a>XMLComponents</a> defines primitive components for parsing
--   and manipulating XML.
module Control.Concurrent.SCC.XMLComponents
data Token
StartTag :: Token
EndTag :: Token
EmptyTag :: Token
ElementName :: Token
AttributeName :: Token
AttributeValue :: Token
EntityReferenceToken :: Token
EntityName :: Token
ProcessingInstruction :: Token
ProcessingInstructionText :: Token
Comment :: Token
CommentText :: Token
StartMarkedSectionCDATA :: Token
EndMarkedSection :: Token
ErrorToken :: String -> Token

-- | The <a>tokens</a> splitter distinguishes XML markup from data content.
--   It is used by <a>parseTokens</a>.
tokens :: (ParallelizableMonad m) => Splitter m Char (Boundary Token)

-- | The XML token parser. This parser converts plain text to parsed text,
--   which is a precondition for using the remaining XML components.
parseTokens :: (ParallelizableMonad m) => Parser m Char Token

-- | Converts an XML entity name into the text value it represents:
--   <tt>expandEntity "lt" = "&lt;"</tt>.
expandEntity :: String -> String

-- | Escapes a character for inclusion into an XML attribute value.
escapeAttributeCharacter :: Char -> String

-- | Escapes a character for inclusion into the XML data content.
escapeContentCharacter :: Char -> String

-- | Splits all top-level elements with all their content to <i>true</i>,
--   all other input to <i>false</i>.
element :: (Monad m) => Splitter m (Markup Char Token) ()

-- | Splits the content of all top-level elements to <i>true</i>, their
--   tags and intervening input to <i>false</i>.
elementContent :: (Monad m) => Splitter m (Markup Char Token) ()

-- | Splits every element name, including the names of nested elements and
--   names in end tags, to <i>true</i>, all the rest of input to
--   <i>false</i>.
elementName :: (ParallelizableMonad m) => Splitter m (Markup Char Token) ()

-- | Splits every attribute specification to <i>true</i>, everything else
--   to <i>false</i>.
attribute :: (ParallelizableMonad m) => Splitter m (Markup Char Token) ()

-- | Splits every attribute name to <i>true</i>, all the rest of input to
--   <i>false</i>.
attributeName :: (ParallelizableMonad m) => Splitter m (Markup Char Token) ()

-- | Splits every attribute value, excluding the quote delimiters, to
--   <i>true</i>, all the rest of input to <i>false</i>.
attributeValue :: (ParallelizableMonad m) => Splitter m (Markup Char Token) ()

-- | Similiar to <tt>(<a>having</a> <a>element</a>)</tt>, except it runs
--   the argument splitter only on each element's start tag, not on the
--   entire element with its content.
elementHavingTag :: (ParallelizableMonad m, Typeable b) => Splitter m (Markup Char Token) b -> Splitter m (Markup Char Token) b

-- | Behaves like <a>having</a>, but the right-hand splitter works on plain
--   instead of marked-up text. This allows regular <a>Char</a> splitters
--   to be applied to parsed XML.
havingText :: (ParallelizableMonad m, Typeable b1, Typeable b2) => Splitter m (Markup Char Token) b1 -> Splitter m Char b2 -> Splitter m (Markup Char Token) b1

-- | Behaves like <a>havingOnly</a>, but the right-hand splitter works on
--   plain instead of marked-up text. This allows regular <a>Char</a>
--   splitters to be applied to parsed XML.
havingOnlyText :: (ParallelizableMonad m, Typeable b1, Typeable b2) => Splitter m (Markup Char Token) b1 -> Splitter m Char b2 -> Splitter m (Markup Char Token) b1
instance Typeable Token
instance Eq Token
instance Show Token