diff --git a/Text/Trifecta/CharSet.hs b/Text/Trifecta/CharSet.hs
--- a/Text/Trifecta/CharSet.hs
+++ b/Text/Trifecta/CharSet.hs
@@ -81,7 +81,7 @@
 import Data.Bits hiding (complement)
 import Data.Word
 import Data.ByteString.Internal (c2w)
-import Data.Monoid (Monoid(..))
+import Data.Semigroup
 import qualified Data.IntSet as I
 import qualified Data.List as L
 import Prelude hiding (filter, map, null)
@@ -345,6 +345,9 @@
       normal = prec 10 $ do
         Ident "fromDistinctAscList" <- lexP
         fromDistinctAscList `fmap` step readPrec
+
+instance Semigroup CharSet where
+  (<>) = union
 
 instance Monoid CharSet where
   mempty = empty
diff --git a/Text/Trifecta/Diagnostic/Err.hs b/Text/Trifecta/Diagnostic/Err.hs
--- a/Text/Trifecta/Diagnostic/Err.hs
+++ b/Text/Trifecta/Diagnostic/Err.hs
@@ -5,7 +5,6 @@
   ) where
 
 import Data.Semigroup
-import Data.Monoid
 import Data.Functor.Plus
 import Text.Trifecta.Diagnostic.Prim
 import Text.Trifecta.Diagnostic.Level
@@ -49,7 +48,7 @@
 
 instance Semigroup (Err t) where
   (<>) = (<!>)
-  replicate1p _ = id
+  times1p _ = id
 
 instance Monoid (Err t) where
   mempty = EmptyErr
diff --git a/Text/Trifecta/Diagnostic/Err/Log.hs b/Text/Trifecta/Diagnostic/Err/Log.hs
--- a/Text/Trifecta/Diagnostic/Err/Log.hs
+++ b/Text/Trifecta/Diagnostic/Err/Log.hs
@@ -4,7 +4,6 @@
 
 import Data.Functor.Plus
 import Data.Semigroup
-import Data.Monoid
 import Text.PrettyPrint.Free
 import Text.Trifecta.Diagnostic.Prim
 import Text.Trifecta.Parser.Token.Highlight
diff --git a/Text/Trifecta/Diagnostic/Err/State.hs b/Text/Trifecta/Diagnostic/Err/State.hs
--- a/Text/Trifecta/Diagnostic/Err/State.hs
+++ b/Text/Trifecta/Diagnostic/Err/State.hs
@@ -5,7 +5,6 @@
 import Data.Functor.Plus
 import Data.Set as Set
 import Data.Semigroup
-import Data.Monoid
 import Text.PrettyPrint.Free
 import Text.Trifecta.Diagnostic.Err
 
diff --git a/Text/Trifecta/Diagnostic/Prim.hs b/Text/Trifecta/Diagnostic/Prim.hs
--- a/Text/Trifecta/Diagnostic/Prim.hs
+++ b/Text/Trifecta/Diagnostic/Prim.hs
@@ -12,7 +12,6 @@
 import Data.Functor.Apply
 import Data.Foldable
 import Data.Traversable
-import Data.Monoid
 import Data.List.NonEmpty hiding (map)
 import Data.Semigroup
 import Data.Semigroup.Reducer
diff --git a/Text/Trifecta/Diagnostic/Rendering/Prim.hs b/Text/Trifecta/Diagnostic/Rendering/Prim.hs
--- a/Text/Trifecta/Diagnostic/Rendering/Prim.hs
+++ b/Text/Trifecta/Diagnostic/Rendering/Prim.hs
@@ -26,7 +26,6 @@
 import Data.Array
 import Data.ByteString hiding (groupBy, empty, any)
 import Data.Foldable
-import Data.Monoid
 import Data.Function (on)
 import Data.Functor.Bind
 import Data.List (groupBy)
diff --git a/Text/Trifecta/Parser/ByteString.hs b/Text/Trifecta/Parser/ByteString.hs
--- a/Text/Trifecta/Parser/ByteString.hs
+++ b/Text/Trifecta/Parser/ByteString.hs
@@ -22,11 +22,10 @@
 
 import Control.Applicative
 import Control.Monad (unless)
-import Data.Monoid
+import Data.Semigroup
 import Data.Foldable
 import qualified Data.ByteString as B
 import System.Console.Terminfo.PrettyPrint
-import Text.Trifecta.Diagnostic.Prim
 import Text.Trifecta.Parser.Class
 import Text.Trifecta.Parser.Prim
 import Text.Trifecta.Parser.Step
@@ -42,35 +41,40 @@
 -- input read from @filePath@ using 'ByteString.readFile'. All diagnostic messages
 -- emitted over the course of the parse attempt are shown to the user on the console.
 --
--- >  main    = do{ result <- parseFromFile numbers "digits.txt"
--- >              ; case result of
--- >                  Nothing -> return ()
--- >                  Just a  -> print $ sum a
--- >              }
+-- > main = do
+-- >   result <- parseFromFile numbers "digits.txt"
+-- >   case result of
+-- >     Nothing -> return ()
+-- >     Just a  -> print $ sum a
 
 parseFromFile :: Show a => Parser String a -> String -> IO (Maybe a)
 parseFromFile p fn = do 
-  (xs, result) <- parseFromFileEx p fn
-  unless (Seq.null xs) $ displayLn $ toList xs
-  return result
+  result <- parseFromFileEx p fn
+  case result of 
+     Success xs a -> Just a  <$ unless (Seq.null xs) (displayLn (toList xs))
+     Failure xs   -> Nothing <$ unless (Seq.null xs) (displayLn (toList xs))
 
 -- | @parseFromFileEx p filePath@ runs a parser @p@ on the
 -- input read from @filePath@ using 'ByteString.readFile'. Returns all diagnostic messages
 -- emitted over the course of the parse and the answer if the parse was successful.
 --
--- >  main    = do{ (xs, result) <- parseFromFileEx numbers "digits.txt"
--- >              ; unless (Seq.null xs) $ displayLn (toList xs)
--- >              ; case result of
--- >                  Nothing -> return ()
--- >                  Just a  -> print $ sum a
--- >              }
+-- > main = do
+-- >   result <- parseFromFileEx (many number) "digits.txt"
+-- >   case result of
+-- >     Failure xs -> unless (Seq.null xs) $ displayLn xs
+-- >     Success xs a  -> 
+-- >       unless (Seq.null xs) $ displayLn xs
+-- >       print $ sum a
+-- >
 
-parseFromFileEx :: Show a => Parser String a -> String -> IO (Seq (Diagnostic TermDoc), Maybe a)
-parseFromFileEx p fn = do
-  i <- B.readFile fn
-  case starve
-     $ feed (rope (F.fromList [LineDirective (UTF8.fromString fn) 0, strand i]))
-     $ stepParser (fmap prettyTerm) (why prettyTerm) (release (Directed n 0 0 0 0) *> p) mempty True mempty mempty of
-     Success xs a -> return (xs,      Just a )
-     Failure xs e -> return (xs |> e, Nothing)
-  where n = UTF8.fromString fn
+parseFromFileEx :: Show a => Parser String a -> String -> IO (Result TermDoc a)
+parseFromFileEx p fn = k <$> B.readFile fn where 
+  k i = starve 
+      $ feed (rope (F.fromList [LineDirective (UTF8.fromString fn) 0, strand i]))
+      $ stepParser (fmap prettyTerm) 
+                   (why prettyTerm) 
+                   (release (Directed (UTF8.fromString fn) 0 0 0 0) *> p) 
+                   mempty 
+                   True 
+                   mempty 
+                   mempty 
diff --git a/Text/Trifecta/Parser/Class.hs b/Text/Trifecta/Parser/Class.hs
--- a/Text/Trifecta/Parser/Class.hs
+++ b/Text/Trifecta/Parser/Class.hs
@@ -34,7 +34,6 @@
 import Control.Monad.Trans.Reader
 import Control.Monad.Trans.Identity
 import Data.Functor.Yoneda
-import Data.Monoid
 import Data.Word
 import Data.ByteString as Strict
 import Data.ByteString.Internal (w2c)
diff --git a/Text/Trifecta/Parser/It.hs b/Text/Trifecta/Parser/It.hs
--- a/Text/Trifecta/Parser/It.hs
+++ b/Text/Trifecta/Parser/It.hs
@@ -15,7 +15,7 @@
 import Control.Applicative
 import Control.Comonad
 import Control.Monad
-import Data.Monoid
+import Data.Semigroup
 import Data.ByteString as Strict
 import Data.ByteString.Lazy as Lazy
 import Data.Functor.Bind
diff --git a/Text/Trifecta/Parser/Prim.hs b/Text/Trifecta/Parser/Prim.hs
--- a/Text/Trifecta/Parser/Prim.hs
+++ b/Text/Trifecta/Parser/Prim.hs
@@ -27,7 +27,6 @@
 import Data.Functor.Plus hiding (some, many)
 import Data.Semigroup
 import Data.Foldable
-import Data.Monoid
 import Data.Functor.Bind (Apply(..), Bind((>>-)))
 import Data.IntervalMap.FingerTree (Interval(..))
 import qualified Data.IntervalMap.FingerTree as IntervalMap
@@ -260,12 +259,12 @@
   go mempty $ p ju no ju no l0 b80 d0 bs0
   where
     ju a e l b8 d bs = Pure (JuSt a e l b8 d bs)
-    no e l b8 d bs = Pure (NoSt e l b8 d bs)
+    no e l b8 d bs   = Pure (NoSt e l b8 d bs)
     go r (Pure (JuSt a _ l _ _ _)) = StepDone r (yl <$> errLog l) a
-    go r (Pure (NoSt e l b8 d bs)) = StepFail r (yl <$> errLog l) $ y e b8 d bs
+    go r (Pure (NoSt e l b8 d bs)) = StepFail r ((yl <$> errLog l) |> y e b8 d bs)
     go r (It ma k) = StepCont r (case ma of
                                    JuSt a _ l _ _ _  -> Success (yl <$> errLog l) a
-                                   NoSt e l b8 d bs  -> Failure (yl <$> errLog l) $ y e b8 d bs) 
+                                   NoSt e l b8 d bs  -> Failure ((yl <$> errLog l) |> y e b8 d bs)) 
                                 (go <*> k)
 
 why :: Pretty e => (e -> Doc t) -> ErrState e -> Bool -> Delta -> ByteString -> Diagnostic (Doc t)
@@ -286,7 +285,7 @@
 parseTest p s = case starve 
                    $ feed (UTF8.fromString s) 
                    $ stepParser (fmap prettyTerm) (why prettyTerm) (release mempty *> p) mempty True mempty mempty of
-  Failure xs e -> displayLn $ prettyTerm $ toList (xs |> e)
+  Failure xs -> displayLn $ toList xs
   Success xs a -> do
-    unless (Seq.null xs) $ displayLn $ prettyTerm $ toList xs
+    unless (Seq.null xs) $ displayLn $ toList xs
     print a
diff --git a/Text/Trifecta/Parser/Result.hs b/Text/Trifecta/Parser/Result.hs
--- a/Text/Trifecta/Parser/Result.hs
+++ b/Text/Trifecta/Parser/Result.hs
@@ -3,7 +3,6 @@
   ) where
 
 import Control.Applicative
-import Data.Monoid
 import Data.Semigroup
 import Data.Foldable
 import Data.Functor.Apply
@@ -17,59 +16,56 @@
 
 data Result e a
   = Success !(Seq (Diagnostic e)) a
-  | Failure !(Seq (Diagnostic e)) !(Diagnostic e)
+  | Failure !(Seq (Diagnostic e))
   deriving Show
 
 instance (Pretty e, Show a) => Pretty (Result e a) where
   pretty (Success xs a) 
     | Seq.null xs = string (show a)
     | otherwise   = prettyList (toList xs) `above` string (show a)
-  pretty (Failure xs e) = prettyList $ toList $ xs |> e
+  pretty (Failure xs) = prettyList $ toList xs
 
 instance (PrettyTerm e, Show a) => PrettyTerm (Result e a) where
   prettyTerm (Success xs a)
     | Seq.null xs = string (show a)
     | otherwise   = prettyTermList (toList xs) `above` string (show a)
-  prettyTerm (Failure xs e) = prettyTermList $ toList $ xs |> e
+  prettyTerm (Failure xs) = prettyTermList $ toList xs
 
 instance Functor (Result e) where
   fmap f (Success xs a) = Success xs (f a)
-  fmap _ (Failure xs e) = Failure xs e
+  fmap _ (Failure xs) = Failure xs
 
 instance Bifunctor Result where
   bimap f g (Success xs a) = Success (fmap (fmap f) xs) (g a)
-  bimap f _ (Failure xs e) = Failure (fmap (fmap f) xs) (fmap f e)
+  bimap f _ (Failure xs) = Failure (fmap (fmap f) xs)
 
 instance Foldable (Result e) where
   foldMap f (Success _ a) = f a
-  foldMap _ (Failure _ _) = mempty
+  foldMap _ (Failure _) = mempty
 
 instance Traversable (Result e) where
   traverse f (Success xs a) = Success xs <$> f a
-  traverse _ (Failure xs e) = pure $ Failure xs e
+  traverse _ (Failure xs) = pure $ Failure xs
 
 instance Applicative (Result e) where
   pure = Success mempty
-  Success xs f <*> Success ys a  = Success (xs <> ys) (f a)
-  Success xs _ <*> Failure ys e  = Failure (xs <> ys) e
-  Failure xs e <*> Success ys _  = Failure (xs <> ys) e
-  Failure xs e <*> Failure ys e' = Failure (xs <> ys |> e) e'
+  Success xs f <*> Success ys a = Success (xs <> ys) (f a)
+  Success xs _ <*> Failure ys   = Failure (xs <> ys)
+  Failure xs   <*> Success ys _ = Failure (xs <> ys)
+  Failure xs   <*> Failure ys   = Failure (xs <> ys)
 
 instance Apply (Result e) where
   (<.>) = (<*>)
 
-{-
 instance Alt (Result e) where
-  Failure xs e <!> Failure ys e' = Failure (xs <> ys |> e) e'
+  Failure xs   <!> Failure ys    = Failure (xs <> ys)
   Success xs a <!> Success ys _  = Success (xs <> ys) a
-  Success xs a <!> Failure ys e  = Success (xs <> ys) a
-  Failure xs _ <!> Success ys a  = Success (xs <> ys |> e) a
+  Success xs a <!> Failure ys    = Success (xs <> ys) a
+  Failure xs   <!> Success ys a  = Success (xs <> ys) a
 
 instance Plus (Result e) where
-  zero = Failure mempty zero
+  zero = Failure mempty
 
 instance Alternative (Result e) where 
   (<|>) = (<!>)
   empty = zero
--}
-
diff --git a/Text/Trifecta/Parser/Step.hs b/Text/Trifecta/Parser/Step.hs
--- a/Text/Trifecta/Parser/Step.hs
+++ b/Text/Trifecta/Parser/Step.hs
@@ -15,38 +15,38 @@
 
 data Step e a
   = StepDone !Rope !(Seq (Diagnostic e)) a
-  | StepFail !Rope !(Seq (Diagnostic e)) !(Diagnostic e)
+  | StepFail !Rope !(Seq (Diagnostic e))
   | StepCont !Rope (Result e a) (Rope -> Step e a)
 
 instance (Show e, Show a) => Show (Step e a) where
   showsPrec d (StepDone r xs a) = showParen (d > 10) $ 
     showString "StepDone " . showsPrec 11 r . showChar ' ' . showsPrec 11 xs . showChar ' ' . showsPrec 11 a
-  showsPrec d (StepFail r xs e) = showParen (d > 10) $ 
-    showString "StepFail " . showsPrec 11 r . showChar ' ' . showsPrec 11 xs . showChar ' ' . showsPrec 11 e
+  showsPrec d (StepFail r xs) = showParen (d > 10) $ 
+    showString "StepFail " . showsPrec 11 r . showChar ' ' . showsPrec 11 xs
   showsPrec d (StepCont r fin _) = showParen (d > 10) $ 
     showString "StepCont " . showsPrec 11 r . showChar ' ' . showsPrec 11 fin . showString " ..."
     
 instance Functor (Step e) where
   fmap f (StepDone r xs a) = StepDone r xs (f a)
-  fmap _ (StepFail r xs e) = StepFail r xs e
+  fmap _ (StepFail r xs)   = StepFail r xs
   fmap f (StepCont r z k)  = StepCont r (fmap f z) (fmap f . k)
 
 instance Bifunctor Step where
   bimap f g (StepDone r xs a) = StepDone r (fmap (fmap f) xs) (g a)
-  bimap f _ (StepFail r xs e) = StepFail r (fmap (fmap f) xs) (fmap f e)
+  bimap f _ (StepFail r xs)   = StepFail r (fmap (fmap f) xs)
   bimap f g (StepCont r z k)  = StepCont r (bimap f g z) (bimap f g . k)
 
 feed :: Reducer t Rope => t -> Step e r -> Step e r
 feed t (StepDone r xs a) = StepDone (snoc r t) xs a
-feed t (StepFail r xs e) = StepFail (snoc r t) xs e
-feed t (StepCont r _ k) = k (snoc r t)
+feed t (StepFail r xs)   = StepFail (snoc r t) xs
+feed t (StepCont r _ k)  = k (snoc r t)
 
 starve :: Step e a -> Result e a
 starve (StepDone _ xs a) = Success xs a
-starve (StepFail _ xs e) = Failure xs e
+starve (StepFail _ xs)   = Failure xs
 starve (StepCont _ z _)  = z
 
 stepResult :: Rope -> Result e a -> Step e a
 stepResult r (Success xs a) = StepDone r xs a
-stepResult r (Failure xs e) = StepFail r xs e
+stepResult r (Failure xs) = StepFail r xs
 
diff --git a/Text/Trifecta/Rope/Delta.hs b/Text/Trifecta/Rope/Delta.hs
--- a/Text/Trifecta/Rope/Delta.hs
+++ b/Text/Trifecta/Rope/Delta.hs
@@ -9,7 +9,6 @@
   ) where
 
 import Control.Applicative
-import Data.Monoid
 import Data.Semigroup
 import Data.Hashable
 import Data.Word
diff --git a/Text/Trifecta/Rope/Prim.hs b/Text/Trifecta/Rope/Prim.hs
--- a/Text/Trifecta/Rope/Prim.hs
+++ b/Text/Trifecta/Rope/Prim.hs
@@ -9,7 +9,6 @@
   , grabLine
   ) where
 
-import Data.Monoid
 import Data.Semigroup
 import Data.Semigroup.Reducer
 import Data.ByteString (ByteString)
diff --git a/trifecta.cabal b/trifecta.cabal
--- a/trifecta.cabal
+++ b/trifecta.cabal
@@ -1,6 +1,6 @@
 name:          trifecta
 category:      Text, Parsing, Diagnostics, Pretty Printer, Logging
-version:       0.31
+version:       0.32
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -82,7 +82,7 @@
     hashable             >= 1.1.2.1 && < 1.2,
     bytestring           >= 0.9.1   && < 0.10,
     mtl                  >= 2.0.1   && < 2.1,
-    semigroups           >= 0.7.1   && < 0.8, 
+    semigroups           >= 0.8     && < 0.9, 
     fingertree           >= 0.0.1   && < 0.1,
     reducers             >= 0.1.4   && < 0.2,
     profunctors          >= 0.1.1   && < 0.2,
@@ -94,5 +94,5 @@
     comonad              >= 1.1.1   && < 1.2,
     terminfo             >= 0.3.2   && < 0.4,
     keys                 >= 2.1     && < 2.2,
-    wl-pprint-extras     >= 1.4     && < 1.5,
-    wl-pprint-terminfo   >= 0.5.1   && < 0.6
+    wl-pprint-extras     >= 1.5     && < 1.6,
+    wl-pprint-terminfo   >= 0.6     && < 0.7