scc 0.8.4 → 0.8.4.1
raw patch · 1 files changed
+10/−13 lines, 1 filesdep ~bytestringdep ~incremental-parserdep ~monad-coroutinePVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependency ranges changed: bytestring, incremental-parser, monad-coroutine, monoid-subclasses, text, transformers, transformers-compat
API changes (from Hackage documentation)
- Control.Concurrent.SCC.Configurable: (&&) :: (MonadParallel m, FactorialMonoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: (&&) :: forall (m :: Type -> Type) x. (MonadParallel m, FactorialMonoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: (...) :: (MonadParallel m, FactorialMonoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: (...) :: forall (m :: Type -> Type) x. (MonadParallel m, FactorialMonoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: (>&) :: (MonadParallel m, Monoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: (>&) :: forall (m :: Type -> Type) x. (MonadParallel m, Monoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: (>->) :: (MonadParallel m, PipeableComponentPair m w c1 c2 c3) => Component c1 -> Component c2 -> Component c3
+ Control.Concurrent.SCC.Configurable: (>->) :: forall (m :: Type -> Type) w c1 c2 c3. (MonadParallel m, PipeableComponentPair m w c1 c2 c3) => Component c1 -> Component c2 -> Component c3
- Control.Concurrent.SCC.Configurable: (>|) :: (MonadParallel m, Monoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: (>|) :: forall (m :: Type -> Type) x. (MonadParallel m, Monoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: (||) :: (MonadParallel m, FactorialMonoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: (||) :: forall (m :: Type -> Type) x. (MonadParallel m, FactorialMonoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: adaptConsumer :: (Monad m, Monoid x, Monoid y, Coercible x y) => ConsumerComponent m y r -> ConsumerComponent m x r
+ Control.Concurrent.SCC.Configurable: adaptConsumer :: forall (m :: Type -> Type) x y r. (Monad m, Monoid x, Monoid y, Coercible x y) => ConsumerComponent m y r -> ConsumerComponent m x r
- Control.Concurrent.SCC.Configurable: adaptProducer :: (Monad m, Monoid x, Monoid y, Coercible x y) => ProducerComponent m x r -> ProducerComponent m y r
+ Control.Concurrent.SCC.Configurable: adaptProducer :: forall (m :: Type -> Type) x y r. (Monad m, Monoid x, Monoid y, Coercible x y) => ProducerComponent m x r -> ProducerComponent m y r
- Control.Concurrent.SCC.Configurable: adaptSplitter :: (Monad m, Monoid x, Monoid y, Coercible x y, Coercible y x) => SplitterComponent m x -> SplitterComponent m y
+ Control.Concurrent.SCC.Configurable: adaptSplitter :: forall (m :: Type -> Type) x y. (Monad m, Monoid x, Monoid y, Coercible x y, Coercible y x) => SplitterComponent m x -> SplitterComponent m y
- Control.Concurrent.SCC.Configurable: append :: Monad m => ProducerComponent m x r -> TransducerComponent m x x
+ Control.Concurrent.SCC.Configurable: append :: forall (m :: Type -> Type) x r. Monad m => ProducerComponent m x r -> TransducerComponent m x x
- Control.Concurrent.SCC.Configurable: coerce :: (Monad m, Coercible x y) => TransducerComponent m x y
+ Control.Concurrent.SCC.Configurable: coerce :: forall (m :: Type -> Type) x y. (Monad m, Coercible x y) => TransducerComponent m x y
- Control.Concurrent.SCC.Configurable: concatSeparate :: (Monad m, MonoidNull x) => x -> TransducerComponent m [x] x
+ Control.Concurrent.SCC.Configurable: concatSeparate :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => x -> TransducerComponent m [x] x
- Control.Concurrent.SCC.Configurable: concatenate :: (Monad m, Monoid x) => TransducerComponent m [x] x
+ Control.Concurrent.SCC.Configurable: concatenate :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => TransducerComponent m [x] x
- Control.Concurrent.SCC.Configurable: consumeBy :: Monad m => ConsumerComponent m x r -> TransducerComponent m x y
+ Control.Concurrent.SCC.Configurable: consumeBy :: forall (m :: Type -> Type) x r y. Monad m => ConsumerComponent m x r -> TransducerComponent m x y
- Control.Concurrent.SCC.Configurable: consumeInto :: (Monad m, Monoid x) => ConsumerComponent m x x
+ Control.Concurrent.SCC.Configurable: consumeInto :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => ConsumerComponent m x x
- Control.Concurrent.SCC.Configurable: contentMarkedWith :: (Monad m, Eq y) => (y -> Bool) -> SplitterComponent m [Markup y x]
+ Control.Concurrent.SCC.Configurable: contentMarkedWith :: forall (m :: Type -> Type) y x. (Monad m, Eq y) => (y -> Bool) -> SplitterComponent m [Markup y x]
- Control.Concurrent.SCC.Configurable: count :: (Monad m, FactorialMonoid x) => TransducerComponent m x [Integer]
+ Control.Concurrent.SCC.Configurable: count :: forall (m :: Type -> Type) x. (Monad m, FactorialMonoid x) => TransducerComponent m x [Integer]
- Control.Concurrent.SCC.Configurable: digits :: Monad m => SplitterComponent m String
+ Control.Concurrent.SCC.Configurable: digits :: forall (m :: Type -> Type). Monad m => SplitterComponent m String
- Control.Concurrent.SCC.Configurable: endOf :: (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: endOf :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: erroneous :: (Monad m, MonoidNull x) => String -> ConsumerComponent m x ()
+ Control.Concurrent.SCC.Configurable: erroneous :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => String -> ConsumerComponent m x ()
- Control.Concurrent.SCC.Configurable: even :: (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: even :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: everything :: Monad m => SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: everything :: forall (m :: Type -> Type) x. Monad m => SplitterComponent m x
- Control.Concurrent.SCC.Configurable: first :: (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: first :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: followedBy :: (MonadParallel m, FactorialMonoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: followedBy :: forall (m :: Type -> Type) x. (MonadParallel m, FactorialMonoid x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: foreach :: (MonadParallel m, MonoidNull x, Branching c m x ()) => SplitterComponent m x -> Component c -> Component c -> Component c
+ Control.Concurrent.SCC.Configurable: foreach :: forall (m :: Type -> Type) x c. (MonadParallel m, MonoidNull x, Branching c m x ()) => SplitterComponent m x -> Component c -> Component c -> Component c
- Control.Concurrent.SCC.Configurable: group :: (Monad m, Monoid x) => TransducerComponent m x [x]
+ Control.Concurrent.SCC.Configurable: group :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => TransducerComponent m x [x]
- Control.Concurrent.SCC.Configurable: having :: (MonadParallel m, MonoidNull x, MonoidNull y, Coercible x y) => SplitterComponent m x -> SplitterComponent m y -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: having :: forall (m :: Type -> Type) x y. (MonadParallel m, MonoidNull x, MonoidNull y, Coercible x y) => SplitterComponent m x -> SplitterComponent m y -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: havingOnly :: (MonadParallel m, MonoidNull x, MonoidNull y, Coercible x y) => SplitterComponent m x -> SplitterComponent m y -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: havingOnly :: forall (m :: Type -> Type) x y. (MonadParallel m, MonoidNull x, MonoidNull y, Coercible x y) => SplitterComponent m x -> SplitterComponent m y -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: id :: (Monad m, Monoid x) => TransducerComponent m x x
+ Control.Concurrent.SCC.Configurable: id :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => TransducerComponent m x x
- Control.Concurrent.SCC.Configurable: join :: (MonadParallel m, JoinableComponentPair t1 t2 t3 m x y c1 c2 c3) => Component c1 -> Component c2 -> Component c3
+ Control.Concurrent.SCC.Configurable: join :: forall (m :: Type -> Type) t1 t2 t3 x y c1 c2 c3. (MonadParallel m, JoinableComponentPair t1 t2 t3 m x y c1 c2 c3) => Component c1 -> Component c2 -> Component c3
- Control.Concurrent.SCC.Configurable: last :: (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: last :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: lastAndAfter :: (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: lastAndAfter :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: letters :: Monad m => SplitterComponent m String
+ Control.Concurrent.SCC.Configurable: letters :: forall (m :: Type -> Type). Monad m => SplitterComponent m String
- Control.Concurrent.SCC.Configurable: line :: Monad m => SplitterComponent m String
+ Control.Concurrent.SCC.Configurable: line :: forall (m :: Type -> Type). Monad m => SplitterComponent m String
- Control.Concurrent.SCC.Configurable: lowercase :: Monad m => TransducerComponent m String String
+ Control.Concurrent.SCC.Configurable: lowercase :: forall (m :: Type -> Type). Monad m => TransducerComponent m String String
- Control.Concurrent.SCC.Configurable: marked :: (Monad m, Eq y) => SplitterComponent m [Markup y x]
+ Control.Concurrent.SCC.Configurable: marked :: forall (m :: Type -> Type) y x. (Monad m, Eq y) => SplitterComponent m [Markup y x]
- Control.Concurrent.SCC.Configurable: markedContent :: (Monad m, Eq y) => SplitterComponent m [Markup y x]
+ Control.Concurrent.SCC.Configurable: markedContent :: forall (m :: Type -> Type) y x. (Monad m, Eq y) => SplitterComponent m [Markup y x]
- Control.Concurrent.SCC.Configurable: markedWith :: (Monad m, Eq y) => (y -> Bool) -> SplitterComponent m [Markup y x]
+ Control.Concurrent.SCC.Configurable: markedWith :: forall (m :: Type -> Type) y x. (Monad m, Eq y) => (y -> Bool) -> SplitterComponent m [Markup y x]
- Control.Concurrent.SCC.Configurable: nestedIn :: (MonadParallel m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: nestedIn :: forall (m :: Type -> Type) x. (MonadParallel m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: nonEmptyLine :: Monad m => SplitterComponent m String
+ Control.Concurrent.SCC.Configurable: nonEmptyLine :: forall (m :: Type -> Type). Monad m => SplitterComponent m String
- Control.Concurrent.SCC.Configurable: nothing :: (Monad m, Monoid x) => SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: nothing :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => SplitterComponent m x
- Control.Concurrent.SCC.Configurable: one :: (Monad m, FactorialMonoid x) => SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: one :: forall (m :: Type -> Type) x. (Monad m, FactorialMonoid x) => SplitterComponent m x
- Control.Concurrent.SCC.Configurable: parse :: (Monad m, Monoid x) => ParserComponent m x y
+ Control.Concurrent.SCC.Configurable: parse :: forall (m :: Type -> Type) x y. (Monad m, Monoid x) => ParserComponent m x y
- Control.Concurrent.SCC.Configurable: parseRegions :: (Monad m, MonoidNull x) => SplitterComponent m x -> ParserComponent m x ()
+ Control.Concurrent.SCC.Configurable: parseRegions :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => SplitterComponent m x -> ParserComponent m x ()
- Control.Concurrent.SCC.Configurable: parseSubstring :: (Monad m, Eq x, LeftCancellativeMonoid x, FactorialMonoid x) => x -> ParserComponent m x OccurenceTag
+ Control.Concurrent.SCC.Configurable: parseSubstring :: forall (m :: Type -> Type) x. (Monad m, Eq x, LeftCancellativeMonoid x, FactorialMonoid x) => x -> ParserComponent m x OccurenceTag
- Control.Concurrent.SCC.Configurable: prefix :: (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: prefix :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: prepend :: Monad m => ProducerComponent m x r -> TransducerComponent m x x
+ Control.Concurrent.SCC.Configurable: prepend :: forall (m :: Type -> Type) x r. Monad m => ProducerComponent m x r -> TransducerComponent m x x
- Control.Concurrent.SCC.Configurable: produceFrom :: (Monad m, MonoidNull x) => x -> ProducerComponent m x ()
+ Control.Concurrent.SCC.Configurable: produceFrom :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => x -> ProducerComponent m x ()
- Control.Concurrent.SCC.Configurable: sequence :: JoinableComponentPair t1 t2 t3 m x y c1 c2 c3 => Component c1 -> Component c2 -> Component c3
+ Control.Concurrent.SCC.Configurable: sequence :: forall t1 t2 t3 (m :: Type -> Type) x y c1 c2 c3. JoinableComponentPair t1 t2 t3 m x y c1 c2 c3 => Component c1 -> Component c2 -> Component c3
- Control.Concurrent.SCC.Configurable: snot :: (Monad m, Monoid x) => SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: snot :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: startOf :: (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: startOf :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: substitute :: (Monad m, Monoid x) => ProducerComponent m y r -> TransducerComponent m x y
+ Control.Concurrent.SCC.Configurable: substitute :: forall (m :: Type -> Type) x y r. (Monad m, Monoid x) => ProducerComponent m y r -> TransducerComponent m x y
- Control.Concurrent.SCC.Configurable: substring :: (Monad m, Eq x, LeftCancellativeMonoid x, FactorialMonoid x) => x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: substring :: forall (m :: Type -> Type) x. (Monad m, Eq x, LeftCancellativeMonoid x, FactorialMonoid x) => x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: suffix :: (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: suffix :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: suppress :: Monad m => ConsumerComponent m x ()
+ Control.Concurrent.SCC.Configurable: suppress :: forall (m :: Type -> Type) x. Monad m => ConsumerComponent m x ()
- Control.Concurrent.SCC.Configurable: toString :: (Monad m, Show x) => TransducerComponent m [x] [String]
+ Control.Concurrent.SCC.Configurable: toString :: forall (m :: Type -> Type) x. (Monad m, Show x) => TransducerComponent m [x] [String]
- Control.Concurrent.SCC.Configurable: type ConsumerComponent m x r = Component (Consumer m x r)
+ Control.Concurrent.SCC.Configurable: type ConsumerComponent (m :: Type -> Type) x r = Component Consumer m x r
- Control.Concurrent.SCC.Configurable: type PerformerComponent m r = Component (Performer m r)
+ Control.Concurrent.SCC.Configurable: type PerformerComponent (m :: Type -> Type) r = Component Performer m r
- Control.Concurrent.SCC.Configurable: type ProducerComponent m x r = Component (Producer m x r)
+ Control.Concurrent.SCC.Configurable: type ProducerComponent (m :: Type -> Type) x r = Component Producer m x r
- Control.Concurrent.SCC.Configurable: type SplitterComponent m x = Component (Splitter m x)
+ Control.Concurrent.SCC.Configurable: type SplitterComponent (m :: Type -> Type) x = Component Splitter m x
- Control.Concurrent.SCC.Configurable: type TransducerComponent m x y = Component (Transducer m x y)
+ Control.Concurrent.SCC.Configurable: type TransducerComponent (m :: Type -> Type) x y = Component Transducer m x y
- Control.Concurrent.SCC.Configurable: unparse :: (Monad m, Monoid x) => TransducerComponent m [Markup b x] x
+ Control.Concurrent.SCC.Configurable: unparse :: forall (m :: Type -> Type) x b. (Monad m, Monoid x) => TransducerComponent m [Markup b x] x
- Control.Concurrent.SCC.Configurable: uppercase :: Monad m => TransducerComponent m String String
+ Control.Concurrent.SCC.Configurable: uppercase :: forall (m :: Type -> Type). Monad m => TransducerComponent m String String
- Control.Concurrent.SCC.Configurable: uptoFirst :: (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
+ Control.Concurrent.SCC.Configurable: uptoFirst :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => SplitterComponent m x -> SplitterComponent m x
- Control.Concurrent.SCC.Configurable: while :: (MonadParallel m, MonoidNull x) => TransducerComponent m x x -> SplitterComponent m x -> TransducerComponent m x x
+ Control.Concurrent.SCC.Configurable: while :: forall (m :: Type -> Type) x. (MonadParallel m, MonoidNull x) => TransducerComponent m x x -> SplitterComponent m x -> TransducerComponent m x x
- Control.Concurrent.SCC.Configurable: whitespace :: Monad m => SplitterComponent m String
+ Control.Concurrent.SCC.Configurable: whitespace :: forall (m :: Type -> Type). Monad m => SplitterComponent m String
- Control.Concurrent.SCC.Configurable: xmlAttribute :: Monad m => SplitterComponent m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Configurable: xmlAttribute :: forall (m :: Type -> Type). Monad m => SplitterComponent m [Markup XMLToken Text]
- Control.Concurrent.SCC.Configurable: xmlAttributeName :: Monad m => SplitterComponent m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Configurable: xmlAttributeName :: forall (m :: Type -> Type). Monad m => SplitterComponent m [Markup XMLToken Text]
- Control.Concurrent.SCC.Configurable: xmlAttributeValue :: Monad m => SplitterComponent m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Configurable: xmlAttributeValue :: forall (m :: Type -> Type). Monad m => SplitterComponent m [Markup XMLToken Text]
- Control.Concurrent.SCC.Configurable: xmlElement :: Monad m => SplitterComponent m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Configurable: xmlElement :: forall (m :: Type -> Type). Monad m => SplitterComponent m [Markup XMLToken Text]
- Control.Concurrent.SCC.Configurable: xmlElementContent :: Monad m => SplitterComponent m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Configurable: xmlElementContent :: forall (m :: Type -> Type). Monad m => SplitterComponent m [Markup XMLToken Text]
- Control.Concurrent.SCC.Configurable: xmlElementHavingTagWith :: MonadParallel m => SplitterComponent m [Markup XMLToken Text] -> SplitterComponent m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Configurable: xmlElementHavingTagWith :: forall (m :: Type -> Type). MonadParallel m => SplitterComponent m [Markup XMLToken Text] -> SplitterComponent m [Markup XMLToken Text]
- Control.Concurrent.SCC.Configurable: xmlElementName :: Monad m => SplitterComponent m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Configurable: xmlElementName :: forall (m :: Type -> Type). Monad m => SplitterComponent m [Markup XMLToken Text]
- Control.Concurrent.SCC.Configurable: xmlParseTokens :: MonadParallel m => TransducerComponent m Text [Markup XMLToken Text]
+ Control.Concurrent.SCC.Configurable: xmlParseTokens :: forall (m :: Type -> Type). MonadParallel m => TransducerComponent m Text [Markup XMLToken Text]
- Control.Concurrent.SCC.Configurable: xmlTokens :: Monad m => SplitterComponent m Text
+ Control.Concurrent.SCC.Configurable: xmlTokens :: forall (m :: Type -> Type). Monad m => SplitterComponent m Text
- Control.Concurrent.SCC.Parallel: (&&) :: (MonadParallel m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: (&&) :: forall (m :: Type -> Type) x. (MonadParallel m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: (...) :: (MonadParallel m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: (...) :: forall (m :: Type -> Type) x. (MonadParallel m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: (>&) :: (MonadParallel m, Monoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: (>&) :: forall (m :: Type -> Type) x. (MonadParallel m, Monoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: (>->) :: (MonadParallel m, PipeableComponentPair m w c1 c2 c3) => c1 -> c2 -> c3
+ Control.Concurrent.SCC.Parallel: (>->) :: forall (m :: Type -> Type) w c1 c2 c3. (MonadParallel m, PipeableComponentPair m w c1 c2 c3) => c1 -> c2 -> c3
- Control.Concurrent.SCC.Parallel: (>|) :: (MonadParallel m, Monoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: (>|) :: forall (m :: Type -> Type) x. (MonadParallel m, Monoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: (||) :: (MonadParallel m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: (||) :: forall (m :: Type -> Type) x. (MonadParallel m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: adaptConsumer :: (Coercible x y, Monad m, Monoid x, Monoid y) => Consumer m y r -> Consumer m x r
+ Control.Concurrent.SCC.Parallel: adaptConsumer :: forall (m :: Type -> Type) r. (Coercible x y, Monad m, Monoid x, Monoid y) => Consumer m y r -> Consumer m x r
- Control.Concurrent.SCC.Parallel: adaptProducer :: (Coercible x y, Monad m, Monoid x, Monoid y) => Producer m x r -> Producer m y r
+ Control.Concurrent.SCC.Parallel: adaptProducer :: forall (m :: Type -> Type) r. (Coercible x y, Monad m, Monoid x, Monoid y) => Producer m x r -> Producer m y r
- Control.Concurrent.SCC.Parallel: adaptSplitter :: forall m x y b. (Monad m, Monoid x, Monoid y, Coercible x y, Coercible y x) => Splitter m x -> Splitter m y
+ Control.Concurrent.SCC.Parallel: adaptSplitter :: forall (m :: Type -> Type) x y b. (Monad m, Monoid x, Monoid y, Coercible x y, Coercible y x) => Splitter m x -> Splitter m y
- Control.Concurrent.SCC.Parallel: append :: forall m x r. Monad m => Producer m x r -> Transducer m x x
+ Control.Concurrent.SCC.Parallel: append :: forall (m :: Type -> Type) x r. Monad m => Producer m x r -> Transducer m x x
- Control.Concurrent.SCC.Parallel: 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
+ Control.Concurrent.SCC.Parallel: 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 :: Type -> Type) 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
- Control.Concurrent.SCC.Parallel: class PipeableComponentPair (m :: * -> *) w c1 c2 c3 | c1 c2 -> c3, c1 c3 -> c2, c2 c3 -> c2, c1 -> m w, c2 -> m w, c3 -> m
+ Control.Concurrent.SCC.Parallel: class PipeableComponentPair (m :: Type -> Type) w c1 c2 c3 | c1 c2 -> c3, c1 c3 -> c2, c2 c3 -> c2, c1 -> m w, c2 -> m w, c3 -> m
- Control.Concurrent.SCC.Parallel: coerce :: (Coercible x y, Monad m) => Transducer m x y
+ Control.Concurrent.SCC.Parallel: coerce :: forall (m :: Type -> Type). (Coercible x y, Monad m) => Transducer m x y
- Control.Concurrent.SCC.Parallel: concatSeparate :: forall m x. (Monad m, MonoidNull x) => x -> Transducer m [x] x
+ Control.Concurrent.SCC.Parallel: concatSeparate :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => x -> Transducer m [x] x
- Control.Concurrent.SCC.Parallel: concatenate :: forall m x. (Monad m, Monoid x) => Transducer m [x] x
+ Control.Concurrent.SCC.Parallel: concatenate :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Transducer m [x] x
- Control.Concurrent.SCC.Parallel: consumeBy :: forall m x y r. Monad m => Consumer m x r -> Transducer m x y
+ Control.Concurrent.SCC.Parallel: consumeBy :: forall (m :: Type -> Type) x y r. Monad m => Consumer m x r -> Transducer m x y
- Control.Concurrent.SCC.Parallel: consumeInto :: forall m x. (Monad m, Monoid x) => Consumer m x x
+ Control.Concurrent.SCC.Parallel: consumeInto :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Consumer m x x
- Control.Concurrent.SCC.Parallel: contentMarkedWith :: forall m x y. (Monad m, Eq y) => (y -> Bool) -> Splitter m [Markup y x]
+ Control.Concurrent.SCC.Parallel: contentMarkedWith :: forall (m :: Type -> Type) x y. (Monad m, Eq y) => (y -> Bool) -> Splitter m [Markup y x]
- Control.Concurrent.SCC.Parallel: count :: forall m x. (Monad m, FactorialMonoid x) => Transducer m x [Integer]
+ Control.Concurrent.SCC.Parallel: count :: forall (m :: Type -> Type) x. (Monad m, FactorialMonoid x) => Transducer m x [Integer]
- Control.Concurrent.SCC.Parallel: digits :: forall m. Monad m => Splitter m String
+ Control.Concurrent.SCC.Parallel: digits :: forall (m :: Type -> Type). Monad m => Splitter m String
- Control.Concurrent.SCC.Parallel: endOf :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: endOf :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: erroneous :: forall m x. (Monad m, MonoidNull x) => String -> Consumer m x ()
+ Control.Concurrent.SCC.Parallel: erroneous :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => String -> Consumer m x ()
- Control.Concurrent.SCC.Parallel: even :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: even :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: everything :: forall m x. Monad m => Splitter m x
+ Control.Concurrent.SCC.Parallel: everything :: forall (m :: Type -> Type) x. Monad m => Splitter m x
- Control.Concurrent.SCC.Parallel: first :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: first :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: followedBy :: (MonadParallel m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: followedBy :: forall (m :: Type -> Type) x. (MonadParallel m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: foreach :: (MonadParallel m, MonoidNull x, Branching c m x ()) => Splitter m x -> c -> c -> c
+ Control.Concurrent.SCC.Parallel: foreach :: forall (m :: Type -> Type) x c. (MonadParallel m, MonoidNull x, Branching c m x ()) => Splitter m x -> c -> c -> c
- Control.Concurrent.SCC.Parallel: group :: forall m x. (Monad m, Monoid x) => Transducer m x [x]
+ Control.Concurrent.SCC.Parallel: group :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Transducer m x [x]
- Control.Concurrent.SCC.Parallel: having :: (MonadParallel m, MonoidNull x, MonoidNull y, Coercible x y) => Splitter m x -> Splitter m y -> Splitter m x
+ Control.Concurrent.SCC.Parallel: having :: forall (m :: Type -> Type) x y. (MonadParallel m, MonoidNull x, MonoidNull y, Coercible x y) => Splitter m x -> Splitter m y -> Splitter m x
- Control.Concurrent.SCC.Parallel: havingOnly :: (MonadParallel m, MonoidNull x, MonoidNull y, Coercible x y) => Splitter m x -> Splitter m y -> Splitter m x
+ Control.Concurrent.SCC.Parallel: havingOnly :: forall (m :: Type -> Type) x y. (MonadParallel m, MonoidNull x, MonoidNull y, Coercible x y) => Splitter m x -> Splitter m y -> Splitter m x
- Control.Concurrent.SCC.Parallel: ifs :: (MonadParallel m, Monoid x, Branching c m x ()) => Splitter m x -> c -> c -> c
+ Control.Concurrent.SCC.Parallel: ifs :: forall (m :: Type -> Type) x c. (MonadParallel m, Monoid x, Branching c m x ()) => Splitter m x -> c -> c -> c
- Control.Concurrent.SCC.Parallel: join :: (MonadParallel m, JoinableComponentPair t1 t2 t3 m x y c1 c2 c3) => c1 -> c2 -> c3
+ Control.Concurrent.SCC.Parallel: join :: forall (m :: Type -> Type) t1 t2 t3 x y c1 c2 c3. (MonadParallel m, JoinableComponentPair t1 t2 t3 m x y c1 c2 c3) => c1 -> c2 -> c3
- Control.Concurrent.SCC.Parallel: last :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: last :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: lastAndAfter :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: lastAndAfter :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: letters :: forall m. Monad m => Splitter m String
+ Control.Concurrent.SCC.Parallel: letters :: forall (m :: Type -> Type). Monad m => Splitter m String
- Control.Concurrent.SCC.Parallel: line :: forall m. Monad m => Splitter m String
+ Control.Concurrent.SCC.Parallel: line :: forall (m :: Type -> Type). Monad m => Splitter m String
- Control.Concurrent.SCC.Parallel: lowercase :: forall m. Monad m => Transducer m String String
+ Control.Concurrent.SCC.Parallel: lowercase :: forall (m :: Type -> Type). Monad m => Transducer m String String
- Control.Concurrent.SCC.Parallel: marked :: forall m x y. (Monad m, Eq y) => Splitter m [Markup y x]
+ Control.Concurrent.SCC.Parallel: marked :: forall (m :: Type -> Type) x y. (Monad m, Eq y) => Splitter m [Markup y x]
- Control.Concurrent.SCC.Parallel: markedContent :: forall m x y. (Monad m, Eq y) => Splitter m [Markup y x]
+ Control.Concurrent.SCC.Parallel: markedContent :: forall (m :: Type -> Type) x y. (Monad m, Eq y) => Splitter m [Markup y x]
- Control.Concurrent.SCC.Parallel: markedWith :: forall m x y. (Monad m, Eq y) => (y -> Bool) -> Splitter m [Markup y x]
+ Control.Concurrent.SCC.Parallel: markedWith :: forall (m :: Type -> Type) x y. (Monad m, Eq y) => (y -> Bool) -> Splitter m [Markup y x]
- Control.Concurrent.SCC.Parallel: nestedIn :: (MonadParallel m, MonoidNull x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: nestedIn :: forall (m :: Type -> Type) x. (MonadParallel m, MonoidNull x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: nonEmptyLine :: forall m. Monad m => Splitter m String
+ Control.Concurrent.SCC.Parallel: nonEmptyLine :: forall (m :: Type -> Type). Monad m => Splitter m String
- Control.Concurrent.SCC.Parallel: nothing :: forall m x. (Monad m, Monoid x) => Splitter m x
+ Control.Concurrent.SCC.Parallel: nothing :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Splitter m x
- Control.Concurrent.SCC.Parallel: one :: forall m x. (Monad m, FactorialMonoid x) => Splitter m x
+ Control.Concurrent.SCC.Parallel: one :: forall (m :: Type -> Type) x. (Monad m, FactorialMonoid x) => Splitter m x
- Control.Concurrent.SCC.Parallel: parse :: forall m x y. (Monad m, Monoid x) => Parser m x y
+ Control.Concurrent.SCC.Parallel: parse :: forall (m :: Type -> Type) x y. (Monad m, Monoid x) => Parser m x y
- Control.Concurrent.SCC.Parallel: parseRegions :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Parser m x ()
+ Control.Concurrent.SCC.Parallel: parseRegions :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Parser m x ()
- Control.Concurrent.SCC.Parallel: parseSubstring :: forall m x. (Monad m, Eq x, LeftReductiveMonoid x, FactorialMonoid x) => x -> Parser m x OccurenceTag
+ Control.Concurrent.SCC.Parallel: parseSubstring :: forall (m :: Type -> Type) x. (Monad m, Eq x, LeftReductiveMonoid x, FactorialMonoid x) => x -> Parser m x OccurenceTag
- Control.Concurrent.SCC.Parallel: parseXMLTokens :: Monad m => Transducer m Text [Markup XMLToken Text]
+ Control.Concurrent.SCC.Parallel: parseXMLTokens :: forall (m :: Type -> Type). Monad m => Transducer m Text [Markup XMLToken Text]
- Control.Concurrent.SCC.Parallel: prefix :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: prefix :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: prepend :: forall m x r. Monad m => Producer m x r -> Transducer m x x
+ Control.Concurrent.SCC.Parallel: prepend :: forall (m :: Type -> Type) x r. Monad m => Producer m x r -> Transducer m x x
- Control.Concurrent.SCC.Parallel: produceFrom :: forall m x. (Monad m, MonoidNull x) => x -> Producer m x ()
+ Control.Concurrent.SCC.Parallel: produceFrom :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => x -> Producer m x ()
- Control.Concurrent.SCC.Parallel: sNot :: forall m x. (Monad m, Monoid x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: sNot :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: select :: forall m x. (Monad m, Monoid x) => Splitter m x -> Transducer m x x
+ Control.Concurrent.SCC.Parallel: select :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Splitter m x -> Transducer m x x
- Control.Concurrent.SCC.Parallel: splitterToMarker :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Transducer m x [(x, Bool)]
+ Control.Concurrent.SCC.Parallel: splitterToMarker :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Transducer m x [(x, Bool)]
- Control.Concurrent.SCC.Parallel: startOf :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: startOf :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: substitute :: forall m x y r. (Monad m, Monoid x) => Producer m y r -> Transducer m x y
+ Control.Concurrent.SCC.Parallel: substitute :: forall (m :: Type -> Type) x y r. (Monad m, Monoid x) => Producer m y r -> Transducer m x y
- Control.Concurrent.SCC.Parallel: substring :: forall m x. (Monad m, Eq x, LeftReductiveMonoid x, FactorialMonoid x) => x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: substring :: forall (m :: Type -> Type) x. (Monad m, Eq x, LeftReductiveMonoid x, FactorialMonoid x) => x -> Splitter m x
- Control.Concurrent.SCC.Parallel: suffix :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: suffix :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: suppress :: forall m x. Monad m => Consumer m x ()
+ Control.Concurrent.SCC.Parallel: suppress :: forall (m :: Type -> Type) x. Monad m => Consumer m x ()
- Control.Concurrent.SCC.Parallel: toString :: forall m x. (Monad m, Show x) => Transducer m [x] [String]
+ Control.Concurrent.SCC.Parallel: toString :: forall (m :: Type -> Type) x. (Monad m, Show x) => Transducer m [x] [String]
- Control.Concurrent.SCC.Parallel: unless :: (MonadParallel m, Monoid x) => Transducer m x x -> Splitter m x -> Transducer m x x
+ Control.Concurrent.SCC.Parallel: unless :: forall (m :: Type -> Type) x. (MonadParallel m, Monoid x) => Transducer m x x -> Splitter m x -> Transducer m x x
- Control.Concurrent.SCC.Parallel: unparse :: forall m x b. (Monad m, Monoid x) => Transducer m [Markup b x] x
+ Control.Concurrent.SCC.Parallel: unparse :: forall (m :: Type -> Type) x b. (Monad m, Monoid x) => Transducer m [Markup b x] x
- Control.Concurrent.SCC.Parallel: uppercase :: forall m. Monad m => Transducer m String String
+ Control.Concurrent.SCC.Parallel: uppercase :: forall (m :: Type -> Type). Monad m => Transducer m String String
- Control.Concurrent.SCC.Parallel: uptoFirst :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Parallel: uptoFirst :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Parallel: wherever :: (MonadParallel m, Monoid x) => Transducer m x x -> Splitter m x -> Transducer m x x
+ Control.Concurrent.SCC.Parallel: wherever :: forall (m :: Type -> Type) x. (MonadParallel m, Monoid x) => Transducer m x x -> Splitter m x -> Transducer m x x
- Control.Concurrent.SCC.Parallel: while :: (MonadParallel m, MonoidNull x) => Transducer m x x -> Splitter m x -> Transducer m x x
+ Control.Concurrent.SCC.Parallel: while :: forall (m :: Type -> Type) x. (MonadParallel m, MonoidNull x) => Transducer m x x -> Splitter m x -> Transducer m x x
- Control.Concurrent.SCC.Parallel: whitespace :: forall m. Monad m => Splitter m String
+ Control.Concurrent.SCC.Parallel: whitespace :: forall (m :: Type -> Type). Monad m => Splitter m String
- Control.Concurrent.SCC.Parallel: xmlAttribute :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Parallel: xmlAttribute :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Parallel: xmlAttributeName :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Parallel: xmlAttributeName :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Parallel: xmlAttributeValue :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Parallel: xmlAttributeValue :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Parallel: xmlElement :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Parallel: xmlElement :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Parallel: xmlElementContent :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Parallel: xmlElementContent :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Parallel: xmlElementHavingTagWith :: forall m b. Monad m => Splitter m [Markup XMLToken Text] -> Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Parallel: xmlElementHavingTagWith :: forall (m :: Type -> Type) b. Monad m => Splitter m [Markup XMLToken Text] -> Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Parallel: xmlElementName :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Parallel: xmlElementName :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Parallel: xmlTokens :: Monad m => Splitter m Text
+ Control.Concurrent.SCC.Parallel: xmlTokens :: forall (m :: Type -> Type). Monad m => Splitter m Text
- Control.Concurrent.SCC.Sequential: (&&) :: (Monad m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: (&&) :: forall (m :: Type -> Type) x. (Monad m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: (...) :: (Monad m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: (...) :: forall (m :: Type -> Type) x. (Monad m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: (>&) :: (Monad m, Monoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: (>&) :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: (>->) :: (Monad m, PipeableComponentPair m w c1 c2 c3) => c1 -> c2 -> c3
+ Control.Concurrent.SCC.Sequential: (>->) :: forall (m :: Type -> Type) w c1 c2 c3. (Monad m, PipeableComponentPair m w c1 c2 c3) => c1 -> c2 -> c3
- Control.Concurrent.SCC.Sequential: (>|) :: (Monad m, Monoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: (>|) :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: (||) :: (Monad m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: (||) :: forall (m :: Type -> Type) x. (Monad m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: adaptConsumer :: (Coercible x y, Monad m, Monoid x, Monoid y) => Consumer m y r -> Consumer m x r
+ Control.Concurrent.SCC.Sequential: adaptConsumer :: forall (m :: Type -> Type) r. (Coercible x y, Monad m, Monoid x, Monoid y) => Consumer m y r -> Consumer m x r
- Control.Concurrent.SCC.Sequential: adaptProducer :: (Coercible x y, Monad m, Monoid x, Monoid y) => Producer m x r -> Producer m y r
+ Control.Concurrent.SCC.Sequential: adaptProducer :: forall (m :: Type -> Type) r. (Coercible x y, Monad m, Monoid x, Monoid y) => Producer m x r -> Producer m y r
- Control.Concurrent.SCC.Sequential: adaptSplitter :: forall m x y b. (Monad m, Monoid x, Monoid y, Coercible x y, Coercible y x) => Splitter m x -> Splitter m y
+ Control.Concurrent.SCC.Sequential: adaptSplitter :: forall (m :: Type -> Type) x y b. (Monad m, Monoid x, Monoid y, Coercible x y, Coercible y x) => Splitter m x -> Splitter m y
- Control.Concurrent.SCC.Sequential: append :: forall m x r. Monad m => Producer m x r -> Transducer m x x
+ Control.Concurrent.SCC.Sequential: append :: forall (m :: Type -> Type) x r. Monad m => Producer m x r -> Transducer m x x
- Control.Concurrent.SCC.Sequential: 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
+ Control.Concurrent.SCC.Sequential: 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 :: Type -> Type) 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
- Control.Concurrent.SCC.Sequential: class PipeableComponentPair (m :: * -> *) w c1 c2 c3 | c1 c2 -> c3, c1 c3 -> c2, c2 c3 -> c2, c1 -> m w, c2 -> m w, c3 -> m
+ Control.Concurrent.SCC.Sequential: class PipeableComponentPair (m :: Type -> Type) w c1 c2 c3 | c1 c2 -> c3, c1 c3 -> c2, c2 c3 -> c2, c1 -> m w, c2 -> m w, c3 -> m
- Control.Concurrent.SCC.Sequential: coerce :: (Coercible x y, Monad m) => Transducer m x y
+ Control.Concurrent.SCC.Sequential: coerce :: forall (m :: Type -> Type). (Coercible x y, Monad m) => Transducer m x y
- Control.Concurrent.SCC.Sequential: concatSeparate :: forall m x. (Monad m, MonoidNull x) => x -> Transducer m [x] x
+ Control.Concurrent.SCC.Sequential: concatSeparate :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => x -> Transducer m [x] x
- Control.Concurrent.SCC.Sequential: concatenate :: forall m x. (Monad m, Monoid x) => Transducer m [x] x
+ Control.Concurrent.SCC.Sequential: concatenate :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Transducer m [x] x
- Control.Concurrent.SCC.Sequential: consumeBy :: forall m x y r. Monad m => Consumer m x r -> Transducer m x y
+ Control.Concurrent.SCC.Sequential: consumeBy :: forall (m :: Type -> Type) x y r. Monad m => Consumer m x r -> Transducer m x y
- Control.Concurrent.SCC.Sequential: consumeInto :: forall m x. (Monad m, Monoid x) => Consumer m x x
+ Control.Concurrent.SCC.Sequential: consumeInto :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Consumer m x x
- Control.Concurrent.SCC.Sequential: contentMarkedWith :: forall m x y. (Monad m, Eq y) => (y -> Bool) -> Splitter m [Markup y x]
+ Control.Concurrent.SCC.Sequential: contentMarkedWith :: forall (m :: Type -> Type) x y. (Monad m, Eq y) => (y -> Bool) -> Splitter m [Markup y x]
- Control.Concurrent.SCC.Sequential: count :: forall m x. (Monad m, FactorialMonoid x) => Transducer m x [Integer]
+ Control.Concurrent.SCC.Sequential: count :: forall (m :: Type -> Type) x. (Monad m, FactorialMonoid x) => Transducer m x [Integer]
- Control.Concurrent.SCC.Sequential: digits :: forall m. Monad m => Splitter m String
+ Control.Concurrent.SCC.Sequential: digits :: forall (m :: Type -> Type). Monad m => Splitter m String
- Control.Concurrent.SCC.Sequential: endOf :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: endOf :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: erroneous :: forall m x. (Monad m, MonoidNull x) => String -> Consumer m x ()
+ Control.Concurrent.SCC.Sequential: erroneous :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => String -> Consumer m x ()
- Control.Concurrent.SCC.Sequential: even :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: even :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: everything :: forall m x. Monad m => Splitter m x
+ Control.Concurrent.SCC.Sequential: everything :: forall (m :: Type -> Type) x. Monad m => Splitter m x
- Control.Concurrent.SCC.Sequential: first :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: first :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: followedBy :: (Monad m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: followedBy :: forall (m :: Type -> Type) x. (Monad m, FactorialMonoid x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: foreach :: (Monad m, MonoidNull x, Branching c m x ()) => Splitter m x -> c -> c -> c
+ Control.Concurrent.SCC.Sequential: foreach :: forall (m :: Type -> Type) x c. (Monad m, MonoidNull x, Branching c m x ()) => Splitter m x -> c -> c -> c
- Control.Concurrent.SCC.Sequential: group :: forall m x. (Monad m, Monoid x) => Transducer m x [x]
+ Control.Concurrent.SCC.Sequential: group :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Transducer m x [x]
- Control.Concurrent.SCC.Sequential: having :: (Monad m, MonoidNull x, MonoidNull y, Coercible x y) => Splitter m x -> Splitter m y -> Splitter m x
+ Control.Concurrent.SCC.Sequential: having :: forall (m :: Type -> Type) x y. (Monad m, MonoidNull x, MonoidNull y, Coercible x y) => Splitter m x -> Splitter m y -> Splitter m x
- Control.Concurrent.SCC.Sequential: havingOnly :: (Monad m, MonoidNull x, MonoidNull y, Coercible x y) => Splitter m x -> Splitter m y -> Splitter m x
+ Control.Concurrent.SCC.Sequential: havingOnly :: forall (m :: Type -> Type) x y. (Monad m, MonoidNull x, MonoidNull y, Coercible x y) => Splitter m x -> Splitter m y -> Splitter m x
- Control.Concurrent.SCC.Sequential: ifs :: (Monad m, Monoid x, Branching c m x ()) => Splitter m x -> c -> c -> c
+ Control.Concurrent.SCC.Sequential: ifs :: forall (m :: Type -> Type) x c. (Monad m, Monoid x, Branching c m x ()) => Splitter m x -> c -> c -> c
- Control.Concurrent.SCC.Sequential: join :: (Monad m, JoinableComponentPair t1 t2 t3 m x y c1 c2 c3) => c1 -> c2 -> c3
+ Control.Concurrent.SCC.Sequential: join :: forall (m :: Type -> Type) t1 t2 t3 x y c1 c2 c3. (Monad m, JoinableComponentPair t1 t2 t3 m x y c1 c2 c3) => c1 -> c2 -> c3
- Control.Concurrent.SCC.Sequential: last :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: last :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: lastAndAfter :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: lastAndAfter :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: letters :: forall m. Monad m => Splitter m String
+ Control.Concurrent.SCC.Sequential: letters :: forall (m :: Type -> Type). Monad m => Splitter m String
- Control.Concurrent.SCC.Sequential: line :: forall m. Monad m => Splitter m String
+ Control.Concurrent.SCC.Sequential: line :: forall (m :: Type -> Type). Monad m => Splitter m String
- Control.Concurrent.SCC.Sequential: lowercase :: forall m. Monad m => Transducer m String String
+ Control.Concurrent.SCC.Sequential: lowercase :: forall (m :: Type -> Type). Monad m => Transducer m String String
- Control.Concurrent.SCC.Sequential: marked :: forall m x y. (Monad m, Eq y) => Splitter m [Markup y x]
+ Control.Concurrent.SCC.Sequential: marked :: forall (m :: Type -> Type) x y. (Monad m, Eq y) => Splitter m [Markup y x]
- Control.Concurrent.SCC.Sequential: markedContent :: forall m x y. (Monad m, Eq y) => Splitter m [Markup y x]
+ Control.Concurrent.SCC.Sequential: markedContent :: forall (m :: Type -> Type) x y. (Monad m, Eq y) => Splitter m [Markup y x]
- Control.Concurrent.SCC.Sequential: markedWith :: forall m x y. (Monad m, Eq y) => (y -> Bool) -> Splitter m [Markup y x]
+ Control.Concurrent.SCC.Sequential: markedWith :: forall (m :: Type -> Type) x y. (Monad m, Eq y) => (y -> Bool) -> Splitter m [Markup y x]
- Control.Concurrent.SCC.Sequential: nestedIn :: (Monad m, MonoidNull x) => Splitter m x -> Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: nestedIn :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: nonEmptyLine :: forall m. Monad m => Splitter m String
+ Control.Concurrent.SCC.Sequential: nonEmptyLine :: forall (m :: Type -> Type). Monad m => Splitter m String
- Control.Concurrent.SCC.Sequential: nothing :: forall m x. (Monad m, Monoid x) => Splitter m x
+ Control.Concurrent.SCC.Sequential: nothing :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Splitter m x
- Control.Concurrent.SCC.Sequential: one :: forall m x. (Monad m, FactorialMonoid x) => Splitter m x
+ Control.Concurrent.SCC.Sequential: one :: forall (m :: Type -> Type) x. (Monad m, FactorialMonoid x) => Splitter m x
- Control.Concurrent.SCC.Sequential: parse :: forall m x y. (Monad m, Monoid x) => Parser m x y
+ Control.Concurrent.SCC.Sequential: parse :: forall (m :: Type -> Type) x y. (Monad m, Monoid x) => Parser m x y
- Control.Concurrent.SCC.Sequential: parseRegions :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Parser m x ()
+ Control.Concurrent.SCC.Sequential: parseRegions :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Parser m x ()
- Control.Concurrent.SCC.Sequential: parseSubstring :: forall m x. (Monad m, Eq x, LeftReductiveMonoid x, FactorialMonoid x) => x -> Parser m x OccurenceTag
+ Control.Concurrent.SCC.Sequential: parseSubstring :: forall (m :: Type -> Type) x. (Monad m, Eq x, LeftReductiveMonoid x, FactorialMonoid x) => x -> Parser m x OccurenceTag
- Control.Concurrent.SCC.Sequential: parseXMLTokens :: Monad m => Transducer m Text [Markup XMLToken Text]
+ Control.Concurrent.SCC.Sequential: parseXMLTokens :: forall (m :: Type -> Type). Monad m => Transducer m Text [Markup XMLToken Text]
- Control.Concurrent.SCC.Sequential: prefix :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: prefix :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: prepend :: forall m x r. Monad m => Producer m x r -> Transducer m x x
+ Control.Concurrent.SCC.Sequential: prepend :: forall (m :: Type -> Type) x r. Monad m => Producer m x r -> Transducer m x x
- Control.Concurrent.SCC.Sequential: produceFrom :: forall m x. (Monad m, MonoidNull x) => x -> Producer m x ()
+ Control.Concurrent.SCC.Sequential: produceFrom :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => x -> Producer m x ()
- Control.Concurrent.SCC.Sequential: sNot :: forall m x. (Monad m, Monoid x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: sNot :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: select :: forall m x. (Monad m, Monoid x) => Splitter m x -> Transducer m x x
+ Control.Concurrent.SCC.Sequential: select :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Splitter m x -> Transducer m x x
- Control.Concurrent.SCC.Sequential: splitterToMarker :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Transducer m x [(x, Bool)]
+ Control.Concurrent.SCC.Sequential: splitterToMarker :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Transducer m x [(x, Bool)]
- Control.Concurrent.SCC.Sequential: startOf :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: startOf :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: substitute :: forall m x y r. (Monad m, Monoid x) => Producer m y r -> Transducer m x y
+ Control.Concurrent.SCC.Sequential: substitute :: forall (m :: Type -> Type) x y r. (Monad m, Monoid x) => Producer m y r -> Transducer m x y
- Control.Concurrent.SCC.Sequential: substring :: forall m x. (Monad m, Eq x, LeftReductiveMonoid x, FactorialMonoid x) => x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: substring :: forall (m :: Type -> Type) x. (Monad m, Eq x, LeftReductiveMonoid x, FactorialMonoid x) => x -> Splitter m x
- Control.Concurrent.SCC.Sequential: suffix :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: suffix :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: suppress :: forall m x. Monad m => Consumer m x ()
+ Control.Concurrent.SCC.Sequential: suppress :: forall (m :: Type -> Type) x. Monad m => Consumer m x ()
- Control.Concurrent.SCC.Sequential: toString :: forall m x. (Monad m, Show x) => Transducer m [x] [String]
+ Control.Concurrent.SCC.Sequential: toString :: forall (m :: Type -> Type) x. (Monad m, Show x) => Transducer m [x] [String]
- Control.Concurrent.SCC.Sequential: unless :: (Monad m, Monoid x) => Transducer m x x -> Splitter m x -> Transducer m x x
+ Control.Concurrent.SCC.Sequential: unless :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Transducer m x x -> Splitter m x -> Transducer m x x
- Control.Concurrent.SCC.Sequential: unparse :: forall m x b. (Monad m, Monoid x) => Transducer m [Markup b x] x
+ Control.Concurrent.SCC.Sequential: unparse :: forall (m :: Type -> Type) x b. (Monad m, Monoid x) => Transducer m [Markup b x] x
- Control.Concurrent.SCC.Sequential: uppercase :: forall m. Monad m => Transducer m String String
+ Control.Concurrent.SCC.Sequential: uppercase :: forall (m :: Type -> Type). Monad m => Transducer m String String
- Control.Concurrent.SCC.Sequential: uptoFirst :: forall m x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
+ Control.Concurrent.SCC.Sequential: uptoFirst :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Splitter m x -> Splitter m x
- Control.Concurrent.SCC.Sequential: wherever :: (Monad m, Monoid x) => Transducer m x x -> Splitter m x -> Transducer m x x
+ Control.Concurrent.SCC.Sequential: wherever :: forall (m :: Type -> Type) x. (Monad m, Monoid x) => Transducer m x x -> Splitter m x -> Transducer m x x
- Control.Concurrent.SCC.Sequential: while :: (Monad m, MonoidNull x) => Transducer m x x -> Splitter m x -> Transducer m x x
+ Control.Concurrent.SCC.Sequential: while :: forall (m :: Type -> Type) x. (Monad m, MonoidNull x) => Transducer m x x -> Splitter m x -> Transducer m x x
- Control.Concurrent.SCC.Sequential: whitespace :: forall m. Monad m => Splitter m String
+ Control.Concurrent.SCC.Sequential: whitespace :: forall (m :: Type -> Type). Monad m => Splitter m String
- Control.Concurrent.SCC.Sequential: xmlAttribute :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Sequential: xmlAttribute :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Sequential: xmlAttributeName :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Sequential: xmlAttributeName :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Sequential: xmlAttributeValue :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Sequential: xmlAttributeValue :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Sequential: xmlElement :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Sequential: xmlElement :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Sequential: xmlElementContent :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Sequential: xmlElementContent :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Sequential: xmlElementHavingTagWith :: forall m b. Monad m => Splitter m [Markup XMLToken Text] -> Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Sequential: xmlElementHavingTagWith :: forall (m :: Type -> Type) b. Monad m => Splitter m [Markup XMLToken Text] -> Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Sequential: xmlElementName :: Monad m => Splitter m [Markup XMLToken Text]
+ Control.Concurrent.SCC.Sequential: xmlElementName :: forall (m :: Type -> Type). Monad m => Splitter m [Markup XMLToken Text]
- Control.Concurrent.SCC.Sequential: xmlTokens :: Monad m => Splitter m Text
+ Control.Concurrent.SCC.Sequential: xmlTokens :: forall (m :: Type -> Type). Monad m => Splitter m Text
- Control.Concurrent.SCC.Streams: concatMapAccumStream :: forall m a1 a2 d x y acc. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d) => (acc -> x -> (acc, [y])) -> acc -> Source m a1 [x] -> Sink m a2 [y] -> Coroutine d m acc
+ Control.Concurrent.SCC.Streams: concatMapAccumStream :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x y acc. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d) => (acc -> x -> (acc, [y])) -> acc -> Source m a1 [x] -> Sink m a2 [y] -> Coroutine d m acc
- Control.Concurrent.SCC.Streams: concatMapStream :: forall m a1 a2 d x y. (Monad m, Monoid y, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> y) -> Source m a1 [x] -> Sink m a2 y -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: concatMapStream :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x y. (Monad m, Monoid y, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> y) -> Source m a1 [x] -> Sink m a2 y -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: data () => Reading x py y
+ Control.Concurrent.SCC.Streams: data Reading x py y
- Control.Concurrent.SCC.Streams: data () => ReadingResult x py y
+ Control.Concurrent.SCC.Streams: data ReadingResult x py y
- Control.Concurrent.SCC.Streams: data Sink (m :: * -> *) a x
+ Control.Concurrent.SCC.Streams: data Sink (m :: Type -> Type) (a :: Type -> Type) x
- Control.Concurrent.SCC.Streams: data Source (m :: * -> *) a x
+ Control.Concurrent.SCC.Streams: data Source (m :: Type -> Type) (a :: Type -> Type) x
- Control.Concurrent.SCC.Streams: filterMStream :: forall m a1 a2 d x. (Monad m, FactorialMonoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> Coroutine d m Bool) -> Source m a1 x -> Sink m a2 x -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: filterMStream :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x. (Monad m, FactorialMonoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> Coroutine d m Bool) -> Source m a1 x -> Sink m a2 x -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: foldMStream :: forall m a d x acc. (Monad m, AncestorFunctor a d) => (acc -> x -> Coroutine d m acc) -> acc -> Source m a [x] -> Coroutine d m acc
+ Control.Concurrent.SCC.Streams: foldMStream :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x acc. (Monad m, AncestorFunctor a d) => (acc -> x -> Coroutine d m acc) -> acc -> Source m a [x] -> Coroutine d m acc
- Control.Concurrent.SCC.Streams: foldMStream_ :: forall m a d x acc. (Monad m, AncestorFunctor a d) => (acc -> x -> Coroutine d m acc) -> acc -> Source m a [x] -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: foldMStream_ :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x acc. (Monad m, AncestorFunctor a d) => (acc -> x -> Coroutine d m acc) -> acc -> Source m a [x] -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: foldStream :: forall m a d x acc. (Monad m, FactorialMonoid x, AncestorFunctor a d) => (acc -> x -> acc) -> acc -> Source m a x -> Coroutine d m acc
+ Control.Concurrent.SCC.Streams: foldStream :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x acc. (Monad m, FactorialMonoid x, AncestorFunctor a d) => (acc -> x -> acc) -> acc -> Source m a x -> Coroutine d m acc
- Control.Concurrent.SCC.Streams: get :: forall m a d x. (Monad m, AncestorFunctor a d) => Source m a [x] -> Coroutine d m (Maybe x)
+ Control.Concurrent.SCC.Streams: get :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, AncestorFunctor a d) => Source m a [x] -> Coroutine d m (Maybe x)
- Control.Concurrent.SCC.Streams: getAll :: forall m a d x. (Monad m, Monoid x, AncestorFunctor a d) => Source m a x -> Coroutine d m x
+ Control.Concurrent.SCC.Streams: getAll :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, Monoid x, AncestorFunctor a d) => Source m a x -> Coroutine d m x
- Control.Concurrent.SCC.Streams: getParsed :: forall m a d p x y. (Monad m, Monoid x, Monoid y, AncestorFunctor a d) => Parser p x y -> Source m a x -> Coroutine d m y
+ Control.Concurrent.SCC.Streams: getParsed :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) p x y. (Monad m, Monoid x, Monoid y, AncestorFunctor a d) => Parser p x y -> Source m a x -> Coroutine d m y
- Control.Concurrent.SCC.Streams: getPrime :: forall m a d x. (Monad m, FactorialMonoid x, AncestorFunctor a d) => Source m a x -> Coroutine d m x
+ Control.Concurrent.SCC.Streams: getPrime :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, FactorialMonoid x, AncestorFunctor a d) => Source m a x -> Coroutine d m x
- Control.Concurrent.SCC.Streams: getRead :: forall m a d x y. (Monad m, Monoid x, AncestorFunctor a d) => Reader x (y -> y) y -> Source m a x -> Coroutine d m y
+ Control.Concurrent.SCC.Streams: getRead :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x y. (Monad m, Monoid x, AncestorFunctor a d) => Reader x (y -> y) y -> Source m a x -> Coroutine d m y
- Control.Concurrent.SCC.Streams: getUntil :: forall m a d x. (Monad m, FactorialMonoid x, AncestorFunctor a d) => (x -> Bool) -> Source m a x -> Coroutine d m (x, Maybe x)
+ Control.Concurrent.SCC.Streams: getUntil :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, FactorialMonoid x, AncestorFunctor a d) => (x -> Bool) -> Source m a x -> Coroutine d m (x, Maybe x)
- Control.Concurrent.SCC.Streams: getWhile :: forall m a d x. (Monad m, FactorialMonoid x, AncestorFunctor a d) => (x -> Bool) -> Source m a x -> Coroutine d m x
+ Control.Concurrent.SCC.Streams: getWhile :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, FactorialMonoid x, AncestorFunctor a d) => (x -> Bool) -> Source m a x -> Coroutine d m x
- Control.Concurrent.SCC.Streams: getWith :: forall m a d x. (Monad m, FactorialMonoid x, AncestorFunctor a d) => Source m a x -> (x -> Coroutine d m ()) -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: getWith :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, FactorialMonoid x, AncestorFunctor a d) => Source m a x -> (x -> Coroutine d m ()) -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: liftSink :: forall m a d x. (Monad m, AncestorFunctor a d) => Sink m a x -> Sink m d x
+ Control.Concurrent.SCC.Streams: liftSink :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, AncestorFunctor a d) => Sink m a x -> Sink m d x
- Control.Concurrent.SCC.Streams: liftSource :: forall m a d x. (Monad m, AncestorFunctor a d) => Source m a x -> Source m d x
+ Control.Concurrent.SCC.Streams: liftSource :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, AncestorFunctor a d) => Source m a x -> Source m d x
- Control.Concurrent.SCC.Streams: mapAccumStream :: forall m a1 a2 d x y acc. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d) => (acc -> x -> (acc, y)) -> acc -> Source m a1 [x] -> Sink m a2 [y] -> Coroutine d m acc
+ Control.Concurrent.SCC.Streams: mapAccumStream :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x y acc. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d) => (acc -> x -> (acc, y)) -> acc -> Source m a1 [x] -> Sink m a2 [y] -> Coroutine d m acc
- Control.Concurrent.SCC.Streams: mapAccumStreamChunks :: forall m a1 a2 d x y acc. (Monad m, Monoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => (acc -> x -> (acc, y)) -> acc -> Source m a1 x -> Sink m a2 y -> Coroutine d m acc
+ Control.Concurrent.SCC.Streams: mapAccumStreamChunks :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x y acc. (Monad m, Monoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => (acc -> x -> (acc, y)) -> acc -> Source m a1 x -> Sink m a2 y -> Coroutine d m acc
- Control.Concurrent.SCC.Streams: mapMStream :: forall m a1 a2 d x y. (Monad m, FactorialMonoid x, Monoid y, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> Coroutine d m y) -> Source m a1 x -> Sink m a2 y -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: mapMStream :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x y. (Monad m, FactorialMonoid x, Monoid y, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> Coroutine d m y) -> Source m a1 x -> Sink m a2 y -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: mapMStreamChunks_ :: forall m a d x r. (Monad m, Monoid x, AncestorFunctor a d) => (x -> Coroutine d m r) -> Source m a x -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: mapMStreamChunks_ :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x r. (Monad m, Monoid x, AncestorFunctor a d) => (x -> Coroutine d m r) -> Source m a x -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: mapMStream_ :: forall m a d x r. (Monad m, FactorialMonoid x, AncestorFunctor a d) => (x -> Coroutine d m r) -> Source m a x -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: mapMStream_ :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x r. (Monad m, FactorialMonoid x, AncestorFunctor a d) => (x -> Coroutine d m r) -> Source m a x -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: mapMaybeStream :: forall m a1 a2 d x y. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> Maybe y) -> Source m a1 [x] -> Sink m a2 [y] -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: mapMaybeStream :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x y. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> Maybe y) -> Source m a1 [x] -> Sink m a2 [y] -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: mapSink :: forall m a x y. Monad m => (x -> y) -> Sink m a [y] -> Sink m a [x]
+ Control.Concurrent.SCC.Streams: mapSink :: forall (m :: Type -> Type) (a :: Type -> Type) x y. Monad m => (x -> y) -> Sink m a [y] -> Sink m a [x]
- Control.Concurrent.SCC.Streams: mapStream :: forall m a1 a2 d x y. (Monad m, FactorialMonoid x, Monoid y, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> y) -> Source m a1 x -> Sink m a2 y -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: mapStream :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x y. (Monad m, FactorialMonoid x, Monoid y, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> y) -> Source m a1 x -> Sink m a2 y -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: mapStreamChunks :: forall m a1 a2 d x y. (Monad m, Monoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> y) -> Source m a1 x -> Sink m a2 y -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: mapStreamChunks :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x y. (Monad m, Monoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> y) -> Source m a1 x -> Sink m a2 y -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: markDown :: forall m a x mark. (Monad m, MonoidNull x) => Sink m a x -> Sink m a [(x, mark)]
+ Control.Concurrent.SCC.Streams: markDown :: forall (m :: Type -> Type) (a :: Type -> Type) x mark. (Monad m, MonoidNull x) => Sink m a x -> Sink m a [(x, mark)]
- Control.Concurrent.SCC.Streams: markUpWith :: forall m a x mark. (Monad m, Monoid x) => mark -> Sink m a [(x, mark)] -> Sink m a x
+ Control.Concurrent.SCC.Streams: markUpWith :: forall (m :: Type -> Type) (a :: Type -> Type) x mark. (Monad m, Monoid x) => mark -> Sink m a [(x, mark)] -> Sink m a x
- Control.Concurrent.SCC.Streams: nullSink :: forall m a x. (Monad m, Monoid x) => Sink m a x
+ Control.Concurrent.SCC.Streams: nullSink :: forall (m :: Type -> Type) (a :: Type -> Type) x. (Monad m, Monoid x) => Sink m a x
- Control.Concurrent.SCC.Streams: parZipWithMStream :: forall m a1 a2 a3 d x y z. (MonadParallel m, AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d) => (x -> y -> Coroutine d m z) -> Source m a1 [x] -> Source m a2 [y] -> Sink m a3 [z] -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: parZipWithMStream :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (a3 :: Type -> Type) (d :: Type -> Type) x y z. (MonadParallel m, AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d) => (x -> y -> Coroutine d m z) -> Source m a1 [x] -> Source m a2 [y] -> Sink m a3 [z] -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: partitionStream :: forall m a1 a2 a3 d x. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d) => (x -> Bool) -> Source m a1 [x] -> Sink m a2 [x] -> Sink m a3 [x] -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: partitionStream :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (a3 :: Type -> Type) (d :: Type -> Type) x. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d) => (x -> Bool) -> Source m a1 [x] -> Sink m a2 [x] -> Sink m a3 [x] -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: peek :: forall m a d x. (Monad m, AncestorFunctor a d) => Source m a [x] -> Coroutine d m (Maybe x)
+ Control.Concurrent.SCC.Streams: peek :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, AncestorFunctor a d) => Source m a [x] -> Coroutine d m (Maybe x)
- Control.Concurrent.SCC.Streams: pipe :: forall m a a1 a2 x r1 r2. (Monad m, Monoid x, Functor a, a1 ~ SinkFunctor a x, a2 ~ SourceFunctor a x) => (Sink m a1 x -> Coroutine a1 m r1) -> (Source m a2 x -> Coroutine a2 m r2) -> Coroutine a m (r1, r2)
+ Control.Concurrent.SCC.Streams: pipe :: forall (m :: Type -> Type) (a :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) x r1 r2. (Monad m, Monoid x, Functor a, a1 ~ SinkFunctor a x, a2 ~ SourceFunctor a x) => (Sink m a1 x -> Coroutine a1 m r1) -> (Source m a2 x -> Coroutine a2 m r2) -> Coroutine a m (r1, r2)
- Control.Concurrent.SCC.Streams: pipeG :: forall m a a1 a2 x r1 r2. (Monad m, Monoid x, Functor a, a1 ~ SinkFunctor a x, a2 ~ SourceFunctor a x) => PairBinder m -> (Sink m a1 x -> Coroutine a1 m r1) -> (Source m a2 x -> Coroutine a2 m r2) -> Coroutine a m (r1, r2)
+ Control.Concurrent.SCC.Streams: pipeG :: forall (m :: Type -> Type) (a :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) x r1 r2. (Monad m, Monoid x, Functor a, a1 ~ SinkFunctor a x, a2 ~ SourceFunctor a x) => PairBinder m -> (Sink m a1 x -> Coroutine a1 m r1) -> (Source m a2 x -> Coroutine a2 m r2) -> Coroutine a m (r1, r2)
- Control.Concurrent.SCC.Streams: pipeP :: forall m a a1 a2 x r1 r2. (MonadParallel m, Monoid x, Functor a, a1 ~ SinkFunctor a x, a2 ~ SourceFunctor a x) => (Sink m a1 x -> Coroutine a1 m r1) -> (Source m a2 x -> Coroutine a2 m r2) -> Coroutine a m (r1, r2)
+ Control.Concurrent.SCC.Streams: pipeP :: forall (m :: Type -> Type) (a :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) x r1 r2. (MonadParallel m, Monoid x, Functor a, a1 ~ SinkFunctor a x, a2 ~ SourceFunctor a x) => (Sink m a1 x -> Coroutine a1 m r1) -> (Source m a2 x -> Coroutine a2 m r2) -> Coroutine a m (r1, r2)
- Control.Concurrent.SCC.Streams: pour :: forall m a1 a2 d x. (Monad m, Monoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => Source m a1 x -> Sink m a2 x -> Coroutine d m Bool
+ Control.Concurrent.SCC.Streams: pour :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x. (Monad m, Monoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => Source m a1 x -> Sink m a2 x -> Coroutine d m Bool
- Control.Concurrent.SCC.Streams: pourParsed :: forall m p a1 a2 d x y. (Monad m, MonoidNull x, MonoidNull y, AncestorFunctor a1 d, AncestorFunctor a2 d) => Parser p x y -> Source m a1 x -> Sink m a2 y -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: pourParsed :: forall (m :: Type -> Type) p (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x y. (Monad m, MonoidNull x, MonoidNull y, AncestorFunctor a1 d, AncestorFunctor a2 d) => Parser p x y -> Source m a1 x -> Sink m a2 y -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: pourRead :: forall m a1 a2 d x y. (Monad m, MonoidNull x, MonoidNull y, AncestorFunctor a1 d, AncestorFunctor a2 d) => Reader x y y -> Source m a1 x -> Sink m a2 y -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: pourRead :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x y. (Monad m, MonoidNull x, MonoidNull y, AncestorFunctor a1 d, AncestorFunctor a2 d) => Reader x y y -> Source m a1 x -> Sink m a2 y -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: pourUntil :: forall m a1 a2 d x. (Monad m, FactorialMonoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> Bool) -> Source m a1 x -> Sink m a2 x -> Coroutine d m (Maybe x)
+ Control.Concurrent.SCC.Streams: pourUntil :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x. (Monad m, FactorialMonoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> Bool) -> Source m a1 x -> Sink m a2 x -> Coroutine d m (Maybe x)
- Control.Concurrent.SCC.Streams: pourWhile :: forall m a1 a2 d x. (Monad m, FactorialMonoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> Bool) -> Source m a1 x -> Sink m a2 x -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: pourWhile :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x. (Monad m, FactorialMonoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => (x -> Bool) -> Source m a1 x -> Sink m a2 x -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: pour_ :: forall m a1 a2 d x. (Monad m, Monoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => Source m a1 x -> Sink m a2 x -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: pour_ :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type) x. (Monad m, Monoid x, AncestorFunctor a1 d, AncestorFunctor a2 d) => Source m a1 x -> Sink m a2 x -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: put :: forall m a d x. (Monad m, AncestorFunctor a d) => Sink m a [x] -> x -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: put :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, AncestorFunctor a d) => Sink m a [x] -> x -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: putAll :: forall m a d x. (Monad m, MonoidNull x, AncestorFunctor a d) => x -> Sink m a x -> Coroutine d m x
+ Control.Concurrent.SCC.Streams: putAll :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, MonoidNull x, AncestorFunctor a d) => x -> Sink m a x -> Coroutine d m x
- Control.Concurrent.SCC.Streams: putChunk :: Sink m a x -> forall d. AncestorFunctor a d => x -> Coroutine d m x
+ Control.Concurrent.SCC.Streams: putChunk :: Sink m a x -> forall (d :: Type -> Type). AncestorFunctor a d => x -> Coroutine d m x
- Control.Concurrent.SCC.Streams: tee :: forall m a1 a2 a3 d x. (Monad m, Monoid x, AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d) => Source m a1 x -> Sink m a2 x -> Sink m a3 x -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: tee :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (a3 :: Type -> Type) (d :: Type -> Type) x. (Monad m, Monoid x, AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d) => Source m a1 x -> Sink m a2 x -> Sink m a3 x -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: teeSink :: forall m a1 a2 a3 x. (Monad m, AncestorFunctor a1 a3, AncestorFunctor a2 a3) => Sink m a1 x -> Sink m a2 x -> Sink m a3 x
+ Control.Concurrent.SCC.Streams: teeSink :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (a3 :: Type -> Type) x. (Monad m, AncestorFunctor a1 a3, AncestorFunctor a2 a3) => Sink m a1 x -> Sink m a2 x -> Sink m a3 x
- Control.Concurrent.SCC.Streams: tryPut :: forall m a d x. (Monad m, AncestorFunctor a d) => Sink m a [x] -> x -> Coroutine d m Bool
+ Control.Concurrent.SCC.Streams: tryPut :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, AncestorFunctor a d) => Sink m a [x] -> x -> Coroutine d m Bool
- Control.Concurrent.SCC.Streams: type SinkFunctor a x = Sum a (Request x x)
+ Control.Concurrent.SCC.Streams: type SinkFunctor (a :: Type -> Type) x = Sum a Request x x
- Control.Concurrent.SCC.Streams: type SourceFunctor a x = Sum a (ReadRequest x)
+ Control.Concurrent.SCC.Streams: type SourceFunctor (a :: Type -> Type) x = Sum a ReadRequest x
- Control.Concurrent.SCC.Streams: unfoldMStream :: forall m a d x acc. (Monad m, AncestorFunctor a d) => (acc -> Coroutine d m (Maybe (x, acc))) -> acc -> Sink m a [x] -> Coroutine d m acc
+ Control.Concurrent.SCC.Streams: unfoldMStream :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x acc. (Monad m, AncestorFunctor a d) => (acc -> Coroutine d m (Maybe (x, acc))) -> acc -> Sink m a [x] -> Coroutine d m acc
- Control.Concurrent.SCC.Streams: unmapMStreamChunks_ :: forall m a d x. (Monad m, MonoidNull x, AncestorFunctor a d) => Coroutine d m x -> Sink m a x -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: unmapMStreamChunks_ :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, MonoidNull x, AncestorFunctor a d) => Coroutine d m x -> Sink m a x -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: unmapMStream_ :: forall m a d x. (Monad m, AncestorFunctor a d) => Coroutine d m (Maybe x) -> Sink m a [x] -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: unmapMStream_ :: forall (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x. (Monad m, AncestorFunctor a d) => Coroutine d m (Maybe x) -> Sink m a [x] -> Coroutine d m ()
- Control.Concurrent.SCC.Streams: zipWithMStream :: forall m a1 a2 a3 d x y z. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d) => (x -> y -> Coroutine d m z) -> Source m a1 [x] -> Source m a2 [y] -> Sink m a3 [z] -> Coroutine d m ()
+ Control.Concurrent.SCC.Streams: zipWithMStream :: forall (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (a3 :: Type -> Type) (d :: Type -> Type) x y z. (Monad m, AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d) => (x -> y -> Coroutine d m z) -> Source m a1 [x] -> Source m a2 [y] -> Sink m a3 [z] -> Coroutine d m ()
- Control.Concurrent.SCC.Types: Consumer :: (forall a d. OpenConsumer m a d x r) -> Consumer m x r
+ Control.Concurrent.SCC.Types: Consumer :: (forall (a :: Type -> Type) (d :: Type -> Type). () => OpenConsumer m a d x r) -> Consumer (m :: Type -> Type) x r
- Control.Concurrent.SCC.Types: Performer :: m r -> Performer m r
+ Control.Concurrent.SCC.Types: Performer :: m r -> Performer (m :: Type -> Type) r
- Control.Concurrent.SCC.Types: Producer :: (forall a d. OpenProducer m a d x r) -> Producer m x r
+ Control.Concurrent.SCC.Types: Producer :: (forall (a :: Type -> Type) (d :: Type -> Type). () => OpenProducer m a d x r) -> Producer (m :: Type -> Type) x r
- Control.Concurrent.SCC.Types: Splitter :: (forall a1 a2 a3 d. OpenSplitter m a1 a2 a3 d x ()) -> Splitter m x
+ Control.Concurrent.SCC.Types: Splitter :: (forall (a1 :: Type -> Type) (a2 :: Type -> Type) (a3 :: Type -> Type) (d :: Type -> Type). () => OpenSplitter m a1 a2 a3 d x ()) -> Splitter (m :: Type -> Type) x
- Control.Concurrent.SCC.Types: Transducer :: (forall a1 a2 d. OpenTransducer m a1 a2 d x y ()) -> Transducer m x y
+ Control.Concurrent.SCC.Types: Transducer :: (forall (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type). () => OpenTransducer m a1 a2 d x y ()) -> Transducer (m :: Type -> Type) x y
- Control.Concurrent.SCC.Types: [consume] :: Consumer m x r -> forall a d. OpenConsumer m a d x r
+ Control.Concurrent.SCC.Types: [consume] :: Consumer (m :: Type -> Type) x r -> forall (a :: Type -> Type) (d :: Type -> Type). () => OpenConsumer m a d x r
- Control.Concurrent.SCC.Types: [perform] :: Performer m r -> m r
+ Control.Concurrent.SCC.Types: [perform] :: Performer (m :: Type -> Type) r -> m r
- Control.Concurrent.SCC.Types: [produce] :: Producer m x r -> forall a d. OpenProducer m a d x r
+ Control.Concurrent.SCC.Types: [produce] :: Producer (m :: Type -> Type) x r -> forall (a :: Type -> Type) (d :: Type -> Type). () => OpenProducer m a d x r
- Control.Concurrent.SCC.Types: [split] :: Splitter m x -> forall a1 a2 a3 d. OpenSplitter m a1 a2 a3 d x ()
+ Control.Concurrent.SCC.Types: [split] :: Splitter (m :: Type -> Type) x -> forall (a1 :: Type -> Type) (a2 :: Type -> Type) (a3 :: Type -> Type) (d :: Type -> Type). () => OpenSplitter m a1 a2 a3 d x ()
- Control.Concurrent.SCC.Types: [transduce] :: Transducer m x y -> forall a1 a2 d. OpenTransducer m a1 a2 d x y ()
+ Control.Concurrent.SCC.Types: [transduce] :: Transducer (m :: Type -> Type) x y -> forall (a1 :: Type -> Type) (a2 :: Type -> Type) (d :: Type -> Type). () => OpenTransducer m a1 a2 d x y ()
- Control.Concurrent.SCC.Types: class Branching c (m :: * -> *) x r | c -> m x
+ Control.Concurrent.SCC.Types: class Branching c (m :: Type -> Type) x r | c -> m x
- Control.Concurrent.SCC.Types: class PipeableComponentPair (m :: * -> *) w c1 c2 c3 | c1 c2 -> c3, c1 c3 -> c2, c2 c3 -> c2, c1 -> m w, c2 -> m w, c3 -> m
+ Control.Concurrent.SCC.Types: class PipeableComponentPair (m :: Type -> Type) w c1 c2 c3 | c1 c2 -> c3, c1 c3 -> c2, c2 c3 -> c2, c1 -> m w, c2 -> m w, c3 -> m
- Control.Concurrent.SCC.Types: combineBranches :: Branching c m x r => (forall d. PairBinder m -> (forall a d'. AncestorFunctor d d' => OpenConsumer m a d' x r) -> (forall a d'. AncestorFunctor d d' => OpenConsumer m a d' x r) -> forall a. OpenConsumer m a d x r) -> PairBinder m -> c -> c -> c
+ Control.Concurrent.SCC.Types: combineBranches :: Branching c m x r => (forall (d :: Type -> Type). () => PairBinder m -> (forall (a :: Type -> Type) (d' :: Type -> Type). AncestorFunctor d d' => OpenConsumer m a d' x r) -> (forall (a :: Type -> Type) (d' :: Type -> Type). AncestorFunctor d d' => OpenConsumer m a d' x r) -> forall (a :: Type -> Type). () => OpenConsumer m a d x r) -> PairBinder m -> c -> c -> c
- Control.Concurrent.SCC.Types: isolateConsumer :: forall m x r. (Monad m, Monoid x) => (forall d. Functor d => Source m d x -> Coroutine d m r) -> Consumer m x r
+ Control.Concurrent.SCC.Types: isolateConsumer :: forall (m :: Type -> Type) x r. (Monad m, Monoid x) => (forall (d :: Type -> Type). Functor d => Source m d x -> Coroutine d m r) -> Consumer m x r
- Control.Concurrent.SCC.Types: isolateProducer :: forall m x r. (Monad m, Monoid x) => (forall d. Functor d => Sink m d x -> Coroutine d m r) -> Producer m x r
+ Control.Concurrent.SCC.Types: isolateProducer :: forall (m :: Type -> Type) x r. (Monad m, Monoid x) => (forall (d :: Type -> Type). Functor d => Sink m d x -> Coroutine d m r) -> Producer m x r
- Control.Concurrent.SCC.Types: isolateSplitter :: forall m x b. (Monad m, Monoid x) => (forall d. Functor d => Source m d x -> Sink m d x -> Sink m d x -> Coroutine d m ()) -> Splitter m x
+ Control.Concurrent.SCC.Types: isolateSplitter :: forall (m :: Type -> Type) x b. (Monad m, Monoid x) => (forall (d :: Type -> Type). Functor d => Source m d x -> Sink m d x -> Sink m d x -> Coroutine d m ()) -> Splitter m x
- Control.Concurrent.SCC.Types: isolateTransducer :: forall m x y. (Monad m, Monoid x) => (forall d. Functor d => Source m d x -> Sink m d y -> Coroutine d m ()) -> Transducer m x y
+ Control.Concurrent.SCC.Types: isolateTransducer :: forall (m :: Type -> Type) x y. (Monad m, Monoid x) => (forall (d :: Type -> Type). Functor d => Source m d x -> Sink m d y -> Coroutine d m ()) -> Transducer m x y
- Control.Concurrent.SCC.Types: newtype Consumer m x r
+ Control.Concurrent.SCC.Types: newtype Consumer (m :: Type -> Type) x r
- Control.Concurrent.SCC.Types: newtype Performer m r
+ Control.Concurrent.SCC.Types: newtype Performer (m :: Type -> Type) r
- Control.Concurrent.SCC.Types: newtype Producer m x r
+ Control.Concurrent.SCC.Types: newtype Producer (m :: Type -> Type) x r
- Control.Concurrent.SCC.Types: newtype Splitter m x
+ Control.Concurrent.SCC.Types: newtype Splitter (m :: Type -> Type) x
- Control.Concurrent.SCC.Types: newtype Transducer m x y
+ Control.Concurrent.SCC.Types: newtype Transducer (m :: Type -> Type) x y
- Control.Concurrent.SCC.Types: oneToOneTransducer :: (Monad m, FactorialMonoid x, Monoid y) => (x -> y) -> Transducer m x y
+ Control.Concurrent.SCC.Types: oneToOneTransducer :: forall (m :: Type -> Type) x y. (Monad m, FactorialMonoid x, Monoid y) => (x -> y) -> Transducer m x y
- Control.Concurrent.SCC.Types: statefulSplitter :: Monad m => (state -> x -> (state, Bool)) -> state -> Splitter m [x]
+ Control.Concurrent.SCC.Types: statefulSplitter :: forall (m :: Type -> Type) state x. Monad m => (state -> x -> (state, Bool)) -> state -> Splitter m [x]
- Control.Concurrent.SCC.Types: statefulTransducer :: (Monad m, MonoidNull y) => (state -> x -> (state, y)) -> state -> Transducer m [x] y
+ Control.Concurrent.SCC.Types: statefulTransducer :: forall (m :: Type -> Type) y state x. (Monad m, MonoidNull y) => (state -> x -> (state, y)) -> state -> Transducer m [x] y
- Control.Concurrent.SCC.Types: statelessChunkTransducer :: Monad m => (x -> y) -> Transducer m x y
+ Control.Concurrent.SCC.Types: statelessChunkTransducer :: forall (m :: Type -> Type) x y. Monad m => (x -> y) -> Transducer m x y
- Control.Concurrent.SCC.Types: statelessSplitter :: Monad m => (x -> Bool) -> Splitter m [x]
+ Control.Concurrent.SCC.Types: statelessSplitter :: forall (m :: Type -> Type) x. Monad m => (x -> Bool) -> Splitter m [x]
- Control.Concurrent.SCC.Types: statelessTransducer :: Monad m => (x -> y) -> Transducer m [x] y
+ Control.Concurrent.SCC.Types: statelessTransducer :: forall (m :: Type -> Type) x y. Monad m => (x -> y) -> Transducer m [x] y
- Control.Concurrent.SCC.Types: type Parser m x b = Transducer m x [Markup b x]
+ Control.Concurrent.SCC.Types: type Parser (m :: Type -> Type) x b = Transducer m x [Markup b x]
- Control.Concurrent.SCC.Types: type OpenProducer m a d x r = (AncestorFunctor a d, Monoid x) => Sink m a x -> Coroutine d m r
+ Control.Concurrent.SCC.Types: type OpenProducer (m :: Type -> Type) (a :: Type -> Type) (d :: Type -> Type) x r = (AncestorFunctor a d, Monoid x) => Sink m a x -> Coroutine d m r
- Control.Concurrent.SCC.Types: type OpenSplitter m a1 a2 a3 d x r = (AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d, Monoid x) => Source m a1 x -> Sink m a2 x -> Sink m a3 x -> Coroutine d m r
+ Control.Concurrent.SCC.Types: type OpenSplitter (m :: Type -> Type) (a1 :: Type -> Type) (a2 :: Type -> Type) (a3 :: Type -> Type) (d :: Type -> Type) x r = (AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d, Monoid x) => Source m a1 x -> Sink m a2 x -> Sink m a3 x -> Coroutine d m r
Files
- scc.cabal +10/−13
scc.cabal view
@@ -1,6 +1,6 @@ Name: scc-Version: 0.8.4-Cabal-Version: >= 1.10+Version: 0.8.4.1+Cabal-Version: 2.0 Build-Type: Simple Synopsis: Streaming component combinators Category: Control, Combinators, Concurrency@@ -32,13 +32,12 @@ Control.Concurrent.SCC.Combinators, Control.Concurrent.SCC.Primitives, Control.Concurrent.SCC.XML, Control.Concurrent.Configuration, Control.Concurrent.SCC.Configurable Build-Depends: base < 5, containers,- transformers >= 0.2 && < 0.7, transformers-compat >= 0.3 && < 0.8, bytestring < 1.0, text < 3,+ transformers >= 0.2 && < 0.7, transformers-compat >= 0.3 && < 0.9, bytestring < 1.0, text < 3, monoid-subclasses >= 0.2 && < 1.3, incremental-parser >= 0.4 && < 0.6, monad-parallel, monad-coroutine == 0.9.*, process, haskeline, parsec == 3.* GHC-options: -threaded- if impl(ghc >= 7.0.0)- default-language: Haskell2010+ default-language: Haskell2010 test-suite Main Type: exitcode-stdio-1.0@@ -49,13 +48,12 @@ Control.Concurrent.SCC.XML, Control.Concurrent.Configuration, Control.Concurrent.SCC.Configurable Build-Depends: base < 5, containers,- transformers, transformers-compat, bytestring, text,- monoid-subclasses, incremental-parser,- monad-parallel, monad-coroutine,+ transformers >= 0.2 && < 0.7, transformers-compat >= 0.3 && < 0.9, bytestring < 1.0, text < 3,+ monoid-subclasses >= 0.2 && < 1.3, incremental-parser >= 0.4 && < 0.6,+ monad-parallel, monad-coroutine == 0.9.*, QuickCheck >= 2 && < 3, test-framework >= 0.4.1, test-framework-quickcheck2 GHC-options: -threaded -freduction-depth=30- if impl(ghc >= 7.0.0)- default-language: Haskell2010+ default-language: Haskell2010 Library Exposed-Modules: Control.Concurrent.SCC.Streams, Control.Concurrent.SCC.Types,@@ -65,8 +63,7 @@ Control.Concurrent.SCC.Combinators.Parallel, Control.Concurrent.SCC.Combinators.Sequential, Control.Concurrent.SCC.Combinators, Control.Concurrent.SCC.Primitives, Control.Concurrent.SCC.XML Build-Depends: base < 5, containers,- transformers >= 0.2 && < 0.7, transformers-compat >= 0.3 && < 0.8, bytestring < 1.0, text < 3,+ transformers >= 0.2 && < 0.7, transformers-compat >= 0.3 && < 0.9, bytestring < 1.0, text < 3, monoid-subclasses >= 0.2 && < 1.3, incremental-parser >= 0.4 && < 0.6, monad-parallel, monad-coroutine == 0.9.*- if impl(ghc >= 7.0.0)- default-language: Haskell2010+ default-language: Haskell2010