diff --git a/incremental-parser.cabal b/incremental-parser.cabal
--- a/incremental-parser.cabal
+++ b/incremental-parser.cabal
@@ -1,5 +1,5 @@
 Name:                incremental-parser
-Version:             0.4.0.2
+Version:             0.5
 Cabal-Version:       >= 1.10
 Build-Type:          Simple
 Synopsis:            Generic parser library capable of providing partial results from partial input.
@@ -30,7 +30,7 @@
                      Text.ParserCombinators.Incremental.LeftBiasedLocal, Text.ParserCombinators.Incremental.Symmetric,
                      Control.Applicative.Monoid
   Build-Depends:     base >= 4.9 && < 5, transformers >= 0.5 && < 0.6, parsers < 0.13,
-                     monoid-subclasses < 1.1, rank2classes >= 1.0 && < 1.5
+                     monoid-subclasses < 1.1, rank2classes >= 1.0 && < 1.5, input-parsers < 0.2
   ghc-options:       -Wall
   if impl(ghc >= 7.0.0)
      default-language: Haskell2010
diff --git a/src/Control/Applicative/Monoid.hs b/src/Control/Applicative/Monoid.hs
--- a/src/Control/Applicative/Monoid.hs
+++ b/src/Control/Applicative/Monoid.hs
@@ -1,17 +1,5 @@
 {-
-    Copyright 2011-2018 Mario Blazevic
-
-    This file is part of the Streaming Component Combinators (SCC) project.
-
-    The SCC project is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
-    License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later
-    version.
-
-    SCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
-    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along with SCC.  If not, see
-    <http://www.gnu.org/licenses/>.
+    Copyright 2011-2020 Mario Blazevic
 -}
 
 -- | This module defines the 'MonoidApplicative' and 'MonoidAlternative' type classes. Their methods are specialized
@@ -23,8 +11,8 @@
    )
 where
 
-import Control.Applicative (Applicative (pure, (<*>)), Alternative ((<|>), some, many), (<$>))
-import Data.Monoid (Monoid, mempty, mappend)
+import Control.Applicative (Applicative (pure, (<*>)), Alternative ((<|>)), (<$>))
+import Data.Monoid (Monoid, mempty)
 import Data.Semigroup (Semigroup, (<>))
 
 
@@ -34,7 +22,7 @@
    (+<*>) :: f (a -> a) -> f a -> f a
    (+<*>) = (<*>)
 
-   -- | Lifted and potentially optimized monoid `mappend` operation from the parameter type.
+   -- | Lifted and potentially optimized monoid `Data.Monoid.mappend` operation from the parameter type.
    infixl 5 ><
    (><) :: Semigroup a => f a -> f a -> f a
    a >< b = (<>) <$> a +<*> b
@@ -44,13 +32,13 @@
    moptional :: (Semigroup a, Monoid a) => f a -> f a
    moptional x = x <|> pure mempty
 
-   -- | Zero or more argument occurrences like 'many', but concatenated.
+   -- | Zero or more argument occurrences like 'Control.Applicative.many', but concatenated.
    concatMany :: (Semigroup a, Monoid a) => f a -> f a
    concatMany x = many'
       where many' = some' <|> pure mempty
             some' = x >< many'
 
-   -- | One or more argument occurrences like 'some', but concatenated.
+   -- | One or more argument occurrences like 'Control.Applicative.some', but concatenated.
    concatSome :: (Semigroup a, Monoid a) => f a -> f a
    concatSome x = some'
       where many' = some' <|> pure mempty
diff --git a/src/Text/ParserCombinators/Incremental.hs b/src/Text/ParserCombinators/Incremental.hs
--- a/src/Text/ParserCombinators/Incremental.hs
+++ b/src/Text/ParserCombinators/Incremental.hs
@@ -1,17 +1,5 @@
 {-
     Copyright 2010-2020 Mario Blazevic
-
-    This file is part of the Streaming Component Combinators (SCC) project.
-
-    The SCC project is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
-    License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later
-    version.
-
-    SCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
-    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along with SCC.  If not, see
-    <http://www.gnu.org/licenses/>.
 -}
 
 -- | This module defines parsing combinators for incremental parsers.
@@ -26,7 +14,7 @@
 -- 
 -- Implementation is based on Brzozowski derivatives.
 
-{-# LANGUAGE FlexibleContexts, FlexibleInstances, GADTs, RankNTypes, UndecidableInstances #-}
+{-# LANGUAGE FlexibleContexts, FlexibleInstances, GADTs, RankNTypes, TypeFamilies, UndecidableInstances #-}
 
 module Text.ParserCombinators.Incremental (
    -- * The Parser type
@@ -47,7 +35,6 @@
    )
 where
 
-import Prelude hiding (and, null, pred, span, takeWhile)
 import Control.Applicative (Applicative (pure, (<*>), (*>), (<*)), Alternative ((<|>)), (<$>))
 import Control.Applicative.Monoid(MonoidApplicative(..), MonoidAlternative(..))
 import Control.Monad.Fail (MonadFail(fail))
@@ -59,19 +46,25 @@
 import Data.Semigroup (Semigroup(..))
 import Data.String (fromString)
 import Data.Monoid (Monoid, mempty, mappend)
-import Data.Monoid.Cancellative (LeftReductiveMonoid, isPrefixOf, stripPrefix)
-import Data.Monoid.Factorial (FactorialMonoid, splitPrimePrefix, span, tails)
+import Data.Monoid.Factorial (FactorialMonoid, length, span, splitAt, splitPrimePrefix, tails)
 import Data.Monoid.Null (MonoidNull(null))
 import Data.Monoid.Textual (TextualMonoid)
 import qualified Data.Monoid.Textual as Textual
+import Data.Semigroup.Cancellative (LeftReductive, isPrefixOf, stripPrefix)
 import Text.Parser.Combinators (Parsing)
 import Text.Parser.Char (CharParsing)
 import Text.Parser.LookAhead (LookAheadParsing)
+import Text.Parser.Deterministic (DeterministicParsing)
+import Text.Parser.Input (InputParsing(take), InputCharParsing)
+import qualified Text.Parser.Deterministic
+import qualified Text.Parser.Input
 import qualified Text.Parser.Combinators
 import qualified Text.Parser.Char
 import qualified Text.Parser.LookAhead
 import qualified Rank2
 
+import Prelude hiding (and, length, null, pred, span, splitAt, take, takeWhile)
+
 -- | The central parser type. Its first parameter is the subtype of the parser, the second is the input monoid type, the
 -- third the output type.
 data Parser t s r where
@@ -234,11 +227,40 @@
 instance (Alternative (Parser t s), MonoidNull s) => LookAheadParsing (Parser t s) where
    lookAhead = lookAhead
 
+instance (Alternative (Parser t s), MonoidNull s) => DeterministicParsing (Parser t s) where
+   (<<|>) = (<<|>)
+
 instance (Alternative (Parser t s), TextualMonoid s) => CharParsing (Parser t s) where
    satisfy = fmap (fromMaybe (error "isNothing . characterPrefix") . Textual.characterPrefix) . satisfyChar
    string s = string (fromString s) *> pure s
    text t = string (Textual.fromText t) *> pure t
 
+instance (Alternative (Parser t s), FactorialMonoid s, LeftReductive s) => InputParsing (Parser t s) where
+   type ParserInput (Parser t s) = s
+   getInput = lookAhead acceptAll
+   anyToken = anyToken
+   take n = more (f . splitAt n)
+     where f (prefix, suffix)
+             | n' == 0 = Result suffix prefix
+             | otherwise = resultPart (prefix <>) (take n')
+             where n' = n - length prefix
+   satisfy predicate = p
+     where p = more (f . splitPrimePrefix)
+           f (Just (first, rest)) = if predicate first then Result rest first else Failure "satisfy"
+           f Nothing = p
+   notSatisfy predicate = p
+     where p = Delay mempty (f . splitPrimePrefix)
+           f (Just (first, rest)) = if predicate first then Failure "satisfy" else Result rest ()
+           f Nothing = p
+   string = string
+   takeWhile = takeWhile
+   takeWhile1 = takeWhile1
+
+instance (TextualMonoid s, LeftReductive s, LookAheadParsing (Parser t s)) => InputCharParsing (Parser t s) where
+   satisfyCharInput = satisfyChar
+   takeCharsWhile = takeCharsWhile
+   takeCharsWhile1 = takeCharsWhile1
+
 appendIncremental :: (Monoid s, Semigroup r) => Parser t s r -> Parser t s r -> Parser t s r
 appendIncremental (Result s r) p = resultPart (r <>) (feed s p)
 appendIncremental (ResultPart r e f) p2 = ResultPart r (appendIncremental e p2) (flip appendIncremental p2 . f)
@@ -460,7 +482,7 @@
                   Nothing -> p
 
 -- | A parser that consumes and returns the given prefix of the input.
-string :: (LeftReductiveMonoid s, MonoidNull s, Semigroup s) => s -> Parser t s s
+string :: (LeftReductive s, MonoidNull s, Semigroup s) => s -> Parser t s s
 string x | null x = mempty
 string x = more (\y-> case (stripPrefix x y, stripPrefix y x)
                       of (Just y', _) -> Result y' x