diff --git a/derp.cabal b/derp.cabal
--- a/derp.cabal
+++ b/derp.cabal
@@ -1,5 +1,5 @@
 Name:                derp
-Version:             0.1.4
+Version:             0.1.5
 Description:         A parser based on derivatives of parser combinators (Might
                      and Darais).  Our paper on Arxiv details the theory of
                      parsing with derivatives: <http://arxiv.org/abs/1010.5023>.
diff --git a/src/Text/Derp.hs b/src/Text/Derp.hs
--- a/src/Text/Derp.hs
+++ b/src/Text/Derp.hs
@@ -41,25 +41,22 @@
   }
 
 data ParserRec p a where
-  Alt :: (ResultType a)               => p a -> p a -> ParserRec p a
-  Con :: (ResultType a, ResultType b) => p a -> p b -> ParserRec p (a, b)
-  Red :: (ResultType a, ResultType b) => (Set a -> Set b) -> p a -> ParserRec p b
-  Nul :: (ResultType a)               => p a -> ParserRec p a
-  Zip :: (ResultType a, ResultType b) => p a -> ContextR p a b -> ParserRec p b
-  Ter ::                                 String -> ParserRec p String
-  Eps :: (ResultType a)               => Set a -> ParserRec p a
-  Emp :: (ResultType a)               => ParserRec p a
+  Alt :: (Ord a)        => p a -> p a -> ParserRec p a
+  Con :: (Ord a, Ord b) => p a -> p b -> ParserRec p (a, b)
+  Red :: (Ord a, Ord b) => (Set a -> Set b) -> p a -> ParserRec p b
+  Nul :: (Ord a)        => p a -> ParserRec p a
+  Zip :: (Ord a, Ord b) => p a -> ContextR p a b -> ParserRec p b
+  Ter ::                   String -> ParserRec p String
+  Eps :: (Ord a)        => Set a -> ParserRec p a
+  Emp :: (Ord a)        => ParserRec p a
 
 data ContextR p a b where
-  ConContext :: (ResultType a, ResultType b) => p b -> ContextR p (a, b) c -> ContextR p a c
-  RedContext :: (ResultType a, ResultType b) => (Set a -> Set b) -> ContextR p b c -> ContextR p a c
-  TopContext :: (ResultType a) => ContextR p a a
+  ConContext :: (Ord a, Ord b) => p b -> ContextR p (a, b) c -> ContextR p a c
+  RedContext :: (Ord a, Ord b) => (Set a -> Set b) -> ContextR p b c -> ContextR p a c
+  TopContext :: (Ord a)        => ContextR p a a
 
 type Context a b = ContextR Parser a b
 
-class (Ord a) => ResultType a
-instance (Ord a) => ResultType a
-
 -- | The input type for parsing.  For example the parser:
 --
 -- > (ter "x") 
@@ -75,38 +72,38 @@
 data Token = Token { tokenClass :: String, tokenValue :: String }
   deriving (Eq, Ord, Show)
 
-parser :: (ResultType a) => ParserRec Parser a -> FPValue Bool -> Parser a
+parser :: (Ord a) => ParserRec Parser a -> FPValue Bool -> Parser a
 parser p n = fix $ \ self -> Parser p n (memoFun (deriveImp self)) (compactImp self)
 
 -- | Alternation.
-(<|>) :: (ResultType a) => Parser a -> Parser a -> Parser a
+(<|>) :: (Ord a) => Parser a -> Parser a -> Parser a
 (<|>) a b = parser (Alt a b) FPUndecided 
 -- | Concatenation.
-(<~>) :: (ResultType a, ResultType b) => Parser a -> Parser b -> Parser (a, b)
+(<~>) :: (Ord a, Ord b) => Parser a -> Parser b -> Parser (a, b)
 (<~>) a b = parser (Con a b) FPUndecided 
 -- | Reduction.
-(==>) :: (ResultType a, ResultType b) => Parser a -> (a -> b) -> Parser b
+(==>) :: (Ord a, Ord b) => Parser a -> (a -> b) -> Parser b
 (==>) p f = p ==>| Set.map f
 -- | Set generalized version of `==>'.
-(==>|) :: (ResultType a, ResultType b) => Parser a -> (Set a -> Set b) -> Parser b
+(==>|) :: (Ord a, Ord b) => Parser a -> (Set a -> Set b) -> Parser b
 (==>|) p f = parser (Red f p) FPUndecided 
 -- | Null-parse extraction.
-nul :: (ResultType a) => Parser a -> Parser a
+nul :: (Ord a) => Parser a -> Parser a
 nul p = parser (Nul p) FPUndecided 
 -- | One-hole-context focus.
-pzip :: (ResultType a, ResultType b) => Parser a -> Context a b -> Parser b
+pzip :: (Ord a, Ord b) => Parser a -> Context a b -> Parser b
 pzip p c = parser (Zip p c) (FPDecided False) 
 -- | Terminal.
 ter :: String -> Parser String
 ter t = parser (Ter t) (FPDecided False) 
 -- | Epsilon/empty-string.
-eps :: (ResultType a) => a -> Parser a
+eps :: (Ord a) => a -> Parser a
 eps = epsM . Set.singleton
 -- | Set generalized version of `eps'.
-epsM :: (ResultType a) => Set a -> Parser a
+epsM :: (Ord a) => Set a -> Parser a
 epsM e = parser (Eps e) (FPDecided True) 
 -- | The empty language.
-emp :: (ResultType a) => Parser a
+emp :: (Ord a) => Parser a
 emp = parser Emp (FPDecided False) 
 
 infixr 3 <~>
@@ -178,19 +175,19 @@
     nulContext (RedContext f c) = RedContext f (nulContext c)
     nulContext TopContext = TopContext
 
-    thread :: (ResultType a, ResultType b, ResultType c) => Context a b -> Context b c -> Context a c
+    thread :: (Ord a, Ord b, Ord c) => Context a b -> Context b c -> Context a c
     thread TopContext d = d
     thread (RedContext f c) d = RedContext f (thread c d)
     thread (ConContext a c) d = ConContext a (thread c d)
 
-    unfoldOne :: (ResultType a, ResultType b) => Parser a -> Context a b -> Parser b
+    unfoldOne :: (Ord a, Ord b) => Parser a -> Context a b -> Parser b
     unfoldOne a (ConContext b c) = pzip (a <~> b) c
     unfoldOne a (RedContext f c) = unfoldOne (a ==>| f) c
     unfoldOne _ TopContext = error "cannot unfold top"
 
 -- | Extract the parse-null set of a parser.
 
-parseNull :: (ResultType a) => Parser a -> Set a
+parseNull :: (Ord a) => Parser a -> Set a
 parseNull p = work $ nul p
   where
     work (Parser (Eps sM) _ _ _) = sM
@@ -199,11 +196,6 @@
 
 -- running parsers
 
--- | The number of compact steps that usually keeps a parser constant in size
---   while parsing.
-defaultCompactSteps :: Int
-defaultCompactSteps = 10
-
 -- | A specified number of compactions.
 compactNum :: Int -> Parser a -> Parser a
 compactNum 0 p = p
@@ -214,10 +206,15 @@
 deriveStepNum n p i = compactNum n $ derive p i
 
 -- | Parse using a specified number of intermediate compactions.
-runParseNum :: (ResultType a) => Int -> Parser a -> [Token] -> Set a
+runParseNum :: (Ord a) => Int -> Parser a -> [Token] -> Set a
 runParseNum _ p [] = parseNull p
 runParseNum n p (i:is) = runParseNum n (deriveStepNum n p i) is
 
+-- | The number of compact steps that usually keeps a parser constant in size
+--   while parsing.
+defaultCompactSteps :: Int
+defaultCompactSteps = 10
+
 -- | Derivation followed by the default number of compactions.
 deriveStep :: Parser a -> Token -> Parser a
 deriveStep = deriveStepNum defaultCompactSteps
@@ -241,7 +238,7 @@
 --
 -- > Set.fromList [9]
 --
-runParse :: (ResultType a) => Parser a -> [Token] -> Set a
+runParse :: (Ord a) => Parser a -> [Token] -> Set a
 runParse = runParseNum defaultCompactSteps
 
 -- inspecting parsers