diff --git a/Control/Concurrent/SCC/Combinators.hs b/Control/Concurrent/SCC/Combinators.hs
--- a/Control/Concurrent/SCC/Combinators.hs
+++ b/Control/Concurrent/SCC/Combinators.hs
@@ -73,7 +73,7 @@
    )
 where
    
-import Prelude hiding (drop, even, last, length, map, null, sequence)
+import Prelude hiding (drop, even, join, last, length, map, null, sequence)
 import Control.Monad (liftM, void, when)
 import Control.Monad.Trans.Class (lift)
 import Data.Maybe (isJust, mapMaybe)
diff --git a/Control/Concurrent/SCC/Configurable.hs b/Control/Concurrent/SCC/Configurable.hs
--- a/Control/Concurrent/SCC/Configurable.hs
+++ b/Control/Concurrent/SCC/Configurable.hs
@@ -30,7 +30,7 @@
        )
 where
 
-import Prelude hiding (appendFile, even, id, last, sequence, (||), (&&))
+import Prelude hiding (appendFile, even, id, join, last, sequence, (||), (&&))
 import qualified Control.Category
 import Data.Text (Text)
 import Data.Monoid (Monoid, Sum)
diff --git a/Control/Concurrent/SCC/Streams.hs b/Control/Concurrent/SCC/Streams.hs
--- a/Control/Concurrent/SCC/Streams.hs
+++ b/Control/Concurrent/SCC/Streams.hs
@@ -80,6 +80,7 @@
 import qualified Control.Monad
 import Control.Monad (liftM, when, unless, foldM)
 import Data.Functor.Identity (Identity(..))
+import Data.Functor.Sum (Sum(InR))
 import Data.Monoid (Monoid(mappend, mconcat, mempty), First(First, getFirst))
 import Data.Monoid.Factorial (FactorialMonoid, foldl, foldMap, mapM, mapM_, span, primePrefix, splitPrimePrefix)
 import Data.Monoid.Null (MonoidNull(null))
@@ -94,10 +95,10 @@
                                                    ReadRequest, requestRead,
                                                    Reader, Reading(..), ReadingResult(..),
                                                    weaveNestedReadWriteRequests)
-import Control.Monad.Coroutine.Nested (EitherFunctor(..), AncestorFunctor(..), liftAncestor)
+import Control.Monad.Coroutine.Nested (AncestorFunctor(..), liftAncestor)
 
-type SourceFunctor a x = EitherFunctor a (ReadRequest x)
-type SinkFunctor a x = EitherFunctor a (Request x x)
+type SourceFunctor a x = Sum a (ReadRequest x)
+type SinkFunctor a x = Sum a (Request x x)
 
 -- | A 'Sink' can be used to yield output from any nested `Coroutine` computation whose functor provably descends from
 -- the functor /a/. It's the write-only end of a communication channel created by 'pipe'.
@@ -184,10 +185,10 @@
 pipeG run2 producer consumer =
    liftM (uncurry (flip (,))) $
    weave run2 weaveNestedReadWriteRequests (consumer source) (producer sink)
-   where sink = Sink {putChunk= \xs-> liftAncestor (mapSuspension RightF (request xs) :: Coroutine a1 m x)}
+   where sink = Sink {putChunk= \xs-> liftAncestor (mapSuspension InR (request xs) :: Coroutine a1 m x)}
          source = Source {readChunk= fc}
          fc :: forall d py y. AncestorFunctor a2 d => Reader x py y -> Coroutine d m (ReadingResult x py y)
-         fc t = liftAncestor (mapSuspension RightF (requestRead t) :: Coroutine a2 m (ReadingResult x py y))
+         fc t = liftAncestor (mapSuspension InR (requestRead t) :: Coroutine a2 m (ReadingResult x py y))
 
 fromParser :: forall p x y. Monoid x => y -> Parser p x y -> Reader x (y -> y) y
 fromParser failure p s = case inspect (feed s p)
diff --git a/Makefile b/Makefile
--- a/Makefile
+++ b/Makefile
@@ -2,8 +2,10 @@
 TestExecutables=$(addprefix test/, scc parallel benchmark-coroutine incremental-parser monoid-subclasses \
                                    enumerator iteratee)
 IncrementalParserFiles=Text/ParserCombinators/Incremental.hs Control/Applicative/Monoid.hs $(MonoidSubclassFiles)
-MonoidSubclassFiles=$(addprefix Data/Monoid/, Cancellative.hs Factorial.hs Null.hs Textual.hs \
-                                              Instances/ByteString/UTF8.hs)
+MonoidSubclassFiles=$(addsuffix .hs, \
+	              $(addprefix Data/Monoid/, Cancellative Factorial Null Textual))
+MonoidInstanceFiles=$(addsuffix .hs, \
+	              $(addprefix Data/Monoid/Instances/, ByteString/UTF8 Concat Measured Positioned Stateful))
 CoroutineLibraryFiles=$(IncrementalParserFiles)      \
 	                   $(addprefix Control/Monad/,  \
                                   Parallel.hs Coroutine.hs Coroutine/SuspensionFunctors.hs Coroutine/Nested.hs)
@@ -34,8 +36,9 @@
 test/incremental-parser: Test/TestIncrementalParser.hs $(IncrementalParserFiles) | obj test
 	ghc --make $< -o $@ $(OptimizingOptions) -eventlog
 
-test/monoid-subclasses: Test/TestMonoidSubclasses.hs $(MonoidSubclassFiles) | obj test
-	ghc --make $< -o $@ $(OptimizingOptions) -eventlog -hide-package checkers -package quickcheck-instances
+test/monoid-subclasses: Test/TestMonoidSubclasses.hs $(MonoidSubclassFiles) $(MonoidInstanceFiles) | obj test
+	ghc --make $< -o $@ $(OptimizingOptions) -eventlog -hide-package checkers -package quickcheck-instances \
+        -cpp -D'MIN_VERSION_containers(x,y,z)=1'
 
 test/enumerator: Test/TestEnumerator.hs $(CoroutineLibraryFiles) Control/Monad/Coroutine/Enumerator.hs | obj test
 	ghc --make $< -o $@ $(OptimizingOptions) -eventlog
diff --git a/Shell.hs b/Shell.hs
--- a/Shell.hs
+++ b/Shell.hs
@@ -474,10 +474,12 @@
 
 showHelp = putStrLn (usageInfo usageSyntax flagList)
 
+interact :: Flags -> InputT IO ()
 interact options = do Just command <- getInputLine "> "
                       finish <- lift $ interpret options command
                       when (not finish) (interact options)
 
+interpret :: Flags -> String -> IO Bool
 interpret options command = case parseExpression command
                             of Left position -> hPutStrLn stderr ("Error at " ++ show position) >> return False
                                Right (Exit, "", _) -> return True
diff --git a/Test/TestSCC.hs b/Test/TestSCC.hs
--- a/Test/TestSCC.hs
+++ b/Test/TestSCC.hs
@@ -584,26 +584,27 @@
 splitterFromTrace :: SplitterTrace -> SplitterComponent Identity [x]
 splitterFromTrace trace = atomic "splitterFromTrace" 1 (splitterFromTrace' trace)
 
-splitterFromTrace' :: SplitterTrace -> Splitter Identity [x]
-splitterFromTrace' trace1
-   = Splitter $
-     \source true false->
-     let follow previous trace2@(head:tail) q = get source >>= maybe fail succeed
-            where succeed x = let q' = q |> x
-                              in case head
-                                 of Nothing -> follow previous tail q'
-                                    Just Nothing -> when (not previous) (putChunk true [] >> return ())
-                                                    >> follow False tail q'
-                                    Just (Just True) -> when (not previous) (putChunk true [] >> return ())
-                                                        >> putAll (Foldable.toList (Seq.viewl q')) true
-                                                        >> follow True tail Seq.empty
-                                    Just (Just False) -> putAll (Foldable.toList (Seq.viewl q')) false
-                                                         >> follow False tail Seq.empty
-                  fail = if find (maybe False isJust) trace2 == Just (Just (Just True))
-                         then putAll (Foldable.toList (Seq.viewl q)) true
-                         else putAll (Foldable.toList (Seq.viewl q)) false
-     in follow False (cycle (fst trace1 ++ [Just (Just $ snd trace1)])) Seq.empty 
-        >> return ()
+splitterFromTrace' :: forall x. SplitterTrace -> Splitter Identity [x]
+splitterFromTrace' trace1 = isolateSplitter s
+   where s :: forall d. Functor d => Source Identity d [x] -> Sink Identity d [x] -> Sink Identity d [x] -> Coroutine d Identity ()
+         s source true false =
+            let follow :: Bool -> [Maybe (Maybe Bool)] -> Seq x -> Coroutine d Identity [x]
+                follow previous trace2@(head:tail) q = get source >>= maybe fail succeed
+                   where succeed x = let q' = q |> x
+                                     in case head
+                                        of Nothing -> follow previous tail q'
+                                           Just Nothing -> when (not previous) (putChunk true [] >> return ())
+                                                           >> follow False tail q'
+                                           Just (Just True) -> when (not previous) (putChunk true [] >> return ())
+                                                               >> putAll (Foldable.toList (Seq.viewl q')) true
+                                                               >> follow True tail Seq.empty
+                                           Just (Just False) -> putAll (Foldable.toList (Seq.viewl q')) false
+                                                                >> follow False tail Seq.empty
+                         fail = if find (maybe False isJust) trace2 == Just (Just (Just True))
+                                then putAll (Foldable.toList (Seq.viewl q)) true
+                                else putAll (Foldable.toList (Seq.viewl q)) false
+            in follow False (cycle (fst trace1 ++ [Just (Just $ snd trace1)])) Seq.empty 
+               >> return ()
 
 swap :: (x, y) -> (y, x)
 swap (x, y) = (y, x)
diff --git a/scc.cabal b/scc.cabal
--- a/scc.cabal
+++ b/scc.cabal
@@ -1,10 +1,10 @@
 Name:                scc
-Version:             0.8.2
+Version:             0.8.2.1
 Cabal-Version:       >= 1.10
 Build-Type:          Simple
 Synopsis:            Streaming component combinators
 Category:            Control, Combinators, Concurrency
-Tested-with:         GHC == 7.4, GHC == 7.6
+Tested-with:         GHC == 7.4, GHC == 7.6, GHC == 7.8
 Description:
   SCC is a layered library of Streaming Component Combinators. The lowest layer in "Control.Concurent.SCC.Streams"
   defines stream abstractions and nested producer-consumer coroutine pairs based on the Coroutine monad transformer.
@@ -25,18 +25,16 @@
 Source-repository head
   type:              darcs
   location:          http://code.haskell.org/SCC/
-Flag Test
-  Description: Install QuickCheck test suite
-  Default:     False
 
 Executable shsh
   Main-is:           Shell.hs
   Other-Modules:     Control.Concurrent.SCC.Streams, Control.Concurrent.SCC.Types, Control.Concurrent.SCC.Coercions,
                      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.4, bytestring < 1.0, text < 1.0,
-                     monoid-subclasses >= 0.2 && < 0.4, incremental-parser >= 0.2.2 && < 0.3,
-                     monad-parallel, monad-coroutine == 0.8.*,
+  Build-Depends:     base < 5, containers,
+                     transformers >= 0.2 && < 0.5, transformers-compat >= 0.3 && < 0.4, bytestring < 1.0, text < 1.3,
+                     monoid-subclasses >= 0.2 && < 0.5, incremental-parser >= 0.2.2 && < 0.3,
+                     monad-parallel, monad-coroutine == 0.9.*,
                      process, haskeline, parsec == 3.*
   GHC-options:       -threaded
   if impl(ghc >= 7.0.0)
@@ -50,13 +48,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.4, bytestring < 1.0, text < 1.0,
-                     monoid-subclasses >= 0.2 && < 0.4, incremental-parser >= 0.2.2 && < 0.3,
-                     monad-parallel, monad-coroutine == 0.8.*,
+  Build-Depends:     base < 5, containers,
+                     transformers >= 0.2 && < 0.5, transformers-compat >= 0.3 && < 0.4, bytestring < 1.0, text < 1.3,
+                     monoid-subclasses >= 0.2 && < 0.5, incremental-parser >= 0.2.2 && < 0.3,
+                     monad-parallel, monad-coroutine == 0.9.*,
                      QuickCheck >= 2 && < 3, test-framework >= 0.4.1, test-framework-quickcheck2
   GHC-options:       -threaded -fcontext-stack=30
-  if !flag(test)
-    buildable:       False
   if impl(ghc >= 7.0.0)
      default-language: Haskell2010
 
@@ -67,9 +64,10 @@
   Other-Modules:     Control.Concurrent.Configuration, Control.Concurrent.SCC.Coercions,
                      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.4, bytestring < 1.0, text < 1.0,
-                     monoid-subclasses >= 0.2 && < 0.4, incremental-parser >= 0.2.2 && < 0.3,
-                     monad-parallel, monad-coroutine == 0.8.*
+  Build-Depends:     base < 5, containers,
+                     transformers >= 0.2 && < 0.5, transformers-compat >= 0.3 && < 0.4, bytestring < 1.0, text < 1.3,
+                     monoid-subclasses >= 0.2 && < 0.5, incremental-parser >= 0.2.2 && < 0.3,
+                     monad-parallel, monad-coroutine == 0.9.*
   GHC-prof-options:  -auto-all
   if impl(ghc >= 7.0.0)
      default-language: Haskell2010