diff --git a/Text/GrammarCombinators/Base/Domain.hs b/Text/GrammarCombinators/Base/Domain.hs
--- a/Text/GrammarCombinators/Base/Domain.hs
+++ b/Text/GrammarCombinators/Base/Domain.hs
@@ -146,8 +146,8 @@
 instance (MemoFam phiL, MemoFam phiR) => 
          MemoFam (MergeDomain phiL phiR) where
            data Memo (MergeDomain phiL phiR) v = MemoMD (Memo phiL (SubVal LeftIx v)) (Memo phiR (SubVal RightIx v))
-           fromMemo (MemoMD ml mr) (LeftIdx idx) = unSubVal $ fromMemo ml idx
-           fromMemo (MemoMD ml mr) (RightIdx idx) = unSubVal $ fromMemo mr idx
+           fromMemo (MemoMD ml _) (LeftIdx idx) = unSubVal $ fromMemo ml idx
+           fromMemo (MemoMD _ mr) (RightIdx idx) = unSubVal $ fromMemo mr idx
            toMemo f = MemoMD (toMemo (MkSubVal . f . LeftIdx)) (toMemo (MkSubVal . f . RightIdx))
 
 instance (ShowFam phiL, ShowFam phiR) => 
diff --git a/Text/GrammarCombinators/Library/Numeric.hs b/Text/GrammarCombinators/Library/Numeric.hs
new file mode 100644
--- /dev/null
+++ b/Text/GrammarCombinators/Library/Numeric.hs
@@ -0,0 +1,101 @@
+{-  Copyright 2010 Dominique Devriese
+
+    This file is part of the grammar-combinators library.
+
+    The grammar-combinators library is free software: you can
+    redistribute it and/or modify it under the terms of the GNU
+    Lesser General Public License as published by the Free
+    Software Foundation, either version 3 of the License, or (at
+    your option) any later version.
+
+    Foobar 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General
+    Public License along with Foobar. If not, see
+    <http://www.gnu.org/licenses/>.
+-}
+
+{-# LANGUAGE EmptyDataDecls #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE TypeFamilies #-}
+
+module Text.GrammarCombinators.Library.Numeric ( 
+  DecimalInteger,
+  NumericDomain (DecimalInteger),
+  NumericValue (NVI),
+  numericGrammar,
+  procNumericGrammar
+  ) where
+
+import Text.GrammarCombinators.Base
+
+data DecimalDigit
+data DecimalNonZeroDigit
+data DecimalInteger
+
+-- | This domain is intended to be reused in grammars where decimal integers are used.
+--   You can refer to the DecimalInteger non-terminal using the 'lib' primitive from the 'ProductionRuleWithLibrary' type class  
+--   and then obtain the combined grammar by combining your grammar with 'procNumericGrammar' using the 
+--   'Text.GrammarCombinators.Transform.CombineGrammars.combineGrammars' function
+data NumericDomain ix where
+  DecimalDigit :: NumericDomain DecimalDigit
+  DecimalNonZeroDigit :: NumericDomain DecimalNonZeroDigit
+  DecimalInteger :: NumericDomain DecimalInteger
+
+instance ShowFam NumericDomain where
+  showIdx DecimalDigit = "DecimalDigit"
+  showIdx DecimalNonZeroDigit = "DecimalNonZeroDigit"
+  showIdx DecimalInteger = "DecimalInteger"
+
+instance FoldFam NumericDomain where
+  foldFam f n = f DecimalDigit $ f DecimalNonZeroDigit $ f DecimalInteger n
+
+instance MemoFam NumericDomain where
+  data Memo NumericDomain v = MND (v DecimalDigit) (v DecimalNonZeroDigit) (v DecimalInteger)
+  toMemo f = MND (f DecimalDigit) (f DecimalNonZeroDigit) (f DecimalInteger)
+  fromMemo (MND v _ _) DecimalDigit = v
+  fromMemo (MND _ v _) DecimalNonZeroDigit = v
+  fromMemo (MND _ _ v) DecimalInteger = v
+
+instance EqFam NumericDomain where
+  overrideIdx _ DecimalDigit v DecimalDigit = v
+  overrideIdx _ DecimalNonZeroDigit v DecimalNonZeroDigit = v
+  overrideIdx _ DecimalInteger v DecimalInteger = v
+  overrideIdx f _ _ idx = f idx
+
+instance Domain NumericDomain
+
+data PFNum r ix where
+  DecimalDigitF :: Char -> PFNum r DecimalDigit
+  DecimalNonZeroDigitF :: Char -> PFNum r DecimalNonZeroDigit
+  DecimalIntegerF :: r DecimalNonZeroDigit -> [r DecimalDigit] -> PFNum r DecimalInteger
+
+type instance PF NumericDomain = PFNum
+
+numericGrammar :: ExtendedContextFreeGrammar NumericDomain Char
+numericGrammar DecimalInteger       = DecimalIntegerF       $>> ref DecimalNonZeroDigit >>> manyRef DecimalDigit
+numericGrammar DecimalDigit         = DecimalDigitF         $>> tokenRange ['0'..'9']
+numericGrammar DecimalNonZeroDigit  = DecimalNonZeroDigitF  $>> tokenRange ['1'..'9']
+
+data family NumericValue n ix
+data instance NumericValue n DecimalInteger = NVI n
+data instance NumericValue n DecimalDigit = NVD { unNVD :: Char }
+data instance NumericValue n DecimalNonZeroDigit = NVND Char
+
+processNumerics :: (Read n) => Processor NumericDomain (NumericValue n)
+processNumerics DecimalDigit (DecimalDigitF c) = NVD c 
+processNumerics DecimalNonZeroDigit (DecimalNonZeroDigitF c) = NVND c 
+processNumerics DecimalInteger (DecimalIntegerF (NVND c) wcs) = NVI num
+  where num = read $ c : cs
+        cs = map unNVD wcs
+
+-- | The standard processing grammar for domain 'NumericDomain', intended to be combined with other grammars using
+--   the 'Text.GrammarCombinators.Transform.CombineGrammars.combineGrammars' function.
+procNumericGrammar :: (Read n) => ProcessingExtendedContextFreeGrammar NumericDomain Char (NumericValue n)
+procNumericGrammar = applyProcessorE numericGrammar processNumerics
diff --git a/Text/GrammarCombinators/Utils/LiftGrammar.hs b/Text/GrammarCombinators/Utils/LiftGrammar.hs
new file mode 100644
--- /dev/null
+++ b/Text/GrammarCombinators/Utils/LiftGrammar.hs
@@ -0,0 +1,115 @@
+{-  Copyright 2010 Dominique Devriese
+
+    This file is part of the grammar-combinators library.
+
+    The grammar-combinators library is free software: you can
+    redistribute it and/or modify it under the terms of the GNU
+    Lesser General Public License as published by the Free
+    Software Foundation, either version 3 of the License, or (at
+    your option) any later version.
+
+    Foobar 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General
+    Public License along with Foobar. If not, see
+    <http://www.gnu.org/licenses/>.
+-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TemplateHaskell #-}
+
+module Text.GrammarCombinators.Utils.LiftGrammar (
+  liftGrammar,
+  unfoldAndLiftGrammar
+  ) where
+
+import Text.GrammarCombinators.Base
+
+import Language.Haskell.TH.Syntax
+
+import Control.Monad
+
+data LiftedRule (phi :: * -> *) (r :: * -> *) t v = 
+    MkLR { liftRule :: Q Exp -> Q Exp -> Q Exp -> Q Exp }
+
+instance ProductionRule (LiftedRule phi r t) where
+  endOfInput = MkLR $ \_ _ _ -> [| endOfInput |]
+  a >>> b = MkLR $ \r mr m1r -> [| $(liftRule a r mr m1r) >>> $(liftRule b r mr m1r) |]
+  a ||| b = MkLR $ \r mr m1r -> [| $(liftRule a r mr m1r) ||| $(liftRule b r mr m1r) |]
+  die = MkLR $ \_ _ _ -> [| die |]
+
+instance BiasedProductionRule (LiftedRule phi r t) where
+  a >||| b = MkLR $ \r mr m1r -> [| $(liftRule a r mr m1r) >||| $(liftRule b r mr m1r) |]
+  a <||| b = MkLR $ \r mr m1r -> [| $(liftRule a r mr m1r) <||| $(liftRule b r mr m1r) |]
+
+instance PenaltyProductionRule (LiftedRule phi r t) where
+  penalty p br = MkLR $ \r mr m1r -> [| penalty p $(liftRule br r mr m1r) |]
+
+instance LiftableProductionRule (LiftedRule phi r t) where
+  epsilonL _ q = MkLR $ \_ _ _ -> [|epsilon $(q)|]
+
+instance (Token t) => TokenProductionRule (LiftedRule phi r t) t where
+  token tt = MkLR $ \_ _ _ -> [| token $(lift tt) |]
+  anyToken = MkLR $ \_ _ _ -> [| anyToken |]
+
+instance (LiftFam phi) =>
+         RecProductionRule (LiftedRule phi r t) phi r where
+  ref idx = MkLR $ \r _ _ -> [| $(r) $(return $ liftIdxE idx) |]
+
+instance (LiftFam phi) =>
+         LoopProductionRule (LiftedRule phi r t) phi r where
+  manyRef idx = MkLR $ \_ mr _ -> [| $(mr) $(return $ liftIdxE idx) |]
+  many1Ref idx = MkLR $ \_ _ m1r -> [| $(m1r) $(return $ liftIdxE idx) |]
+
+liftGrammar' :: forall phi t r rr. (FoldFam phi, LiftFam phi, Token t) =>
+               GLAnyExtendedContextFreeGrammar phi t r rr -> Name ->
+               Q Exp -> Q Exp -> Q Exp ->
+               Q Dec
+liftGrammar' gram name refQ manyRefQ many1RefQ = 
+  let 
+    clause :: phi ix -> Q Clause
+    clause idx = do lr <- liftRule (gram idx) refQ manyRefQ many1RefQ
+                    return $ Clause [liftIdxP idx] (NormalB lr) []
+    addClause idx b = do c <- clause idx
+                         cs <- b
+                         return (c:cs)
+    clauses = foldFam addClause (return [])
+  in liftM (FunD name) clauses
+
+-- | Lift a given grammar to Template Haskell 
+liftGrammar :: forall phi t r rr. (FoldFam phi, LiftFam phi, Token t) =>
+               GLAnyExtendedContextFreeGrammar phi t r rr -> Name ->
+               Q Type -> 
+               Q [Dec]
+liftGrammar gram name grammarType =
+  let sig = do t <- grammarType
+               return $ SigD name t
+      fundef = liftGrammar' gram name [|ref|] [|manyRef|] [|many1Ref|]
+  in do s <- sig
+        f <- fundef
+        return [s,f]
+
+-- | Lift a given grammar to Template Haskell and replace recursion and loops with 
+-- infinite-tree style recursive calls to the grammar itself. This allows GHC to do
+-- a much better optimization (x20 speed-ups in one realistic test, compared with
+-- result of 'liftGrammar').
+unfoldAndLiftGrammar :: forall phi t r rr. (FoldFam phi, LiftFam phi, Token t) =>
+                        GLAnyExtendedContextFreeGrammar phi t r rr -> Name ->
+                        Q Type -> 
+                        Q [Dec]
+unfoldAndLiftGrammar gram name gramType =
+  let refQ = return $ VarE name
+      manyRefQ = return $ AppE (AppE (VarE '(.)) (VarE 'manyInf)) $ VarE name
+      many1RefQ = return $ AppE (AppE (VarE '(.)) (VarE 'many1Inf)) $ (VarE name)
+      sig = do t <- gramType
+               return $ SigD name t
+      fundef = liftGrammar' gram name refQ manyRefQ many1RefQ
+  in do s <- sig
+        d <- fundef
+        return [s,d]
diff --git a/Text/GrammarCombinators/Utils/MemoizeGrammar.hs b/Text/GrammarCombinators/Utils/MemoizeGrammar.hs
new file mode 100644
--- /dev/null
+++ b/Text/GrammarCombinators/Utils/MemoizeGrammar.hs
@@ -0,0 +1,45 @@
+{-  Copyright 2010 Dominique Devriese
+
+    This file is part of the grammar-combinators library.
+
+    The grammar-combinators library is free software: you can
+    redistribute it and/or modify it under the terms of the GNU
+    Lesser General Public License as published by the Free
+    Software Foundation, either version 3 of the License, or (at
+    your option) any later version.
+
+    Foobar 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General
+    Public License along with Foobar. If not, see
+    <http://www.gnu.org/licenses/>.
+-}
+{-# LANGUAGE RankNTypes #-}
+
+module Text.GrammarCombinators.Utils.MemoizeGrammar (
+  memoizeGrammarR,
+  memoizeGrammar,
+  memoizeGrammarE
+  ) where
+
+import Text.GrammarCombinators.Base
+
+newtype WrapCFGR p rr ix = WCFGR { unWCFGR :: p (rr ix) }
+
+-- | Memoize the production rules of a regular grammar. Currently not sure if this is ever useful.
+memoizeGrammarR :: (MemoFam phi) => 
+                  GRegularGrammar phi t r rr -> GRegularGrammar phi t r rr
+memoizeGrammarR gram idx = unWCFGR (memoFamily (\idx' -> WCFGR (gram idx')) idx)
+
+-- | Memoize the production rules of a grammar. Currently not sure if this is ever useful.
+memoizeGrammar :: (MemoFam phi) => 
+                  GContextFreeGrammar phi t r rr -> GContextFreeGrammar phi t r rr
+memoizeGrammar gram idx = unWCFGR (memoFamily (\idx' -> WCFGR (gram idx')) idx)
+
+-- | Memoize the production rules of an extended grammar. Currently not sure if this is ever useful.
+memoizeGrammarE :: (MemoFam phi) => 
+                  GExtendedContextFreeGrammar phi t r rr -> GExtendedContextFreeGrammar phi t r rr
+memoizeGrammarE gram idx = unWCFGR (memoFamily (\idx' -> WCFGR (gram idx')) idx)
diff --git a/grammar-combinators.cabal b/grammar-combinators.cabal
--- a/grammar-combinators.cabal
+++ b/grammar-combinators.cabal
@@ -1,5 +1,5 @@
 Name:                grammar-combinators
-Version:             0.2
+Version:             0.2.1
 Description:
     The grammar-combinators library is a novel parsing library using
     an explicit representation of recursion to provide various novel
@@ -36,6 +36,7 @@
                      Text.GrammarCombinators.Base.ProductionRule
                      Text.GrammarCombinators.Base.Processor
                      Text.GrammarCombinators.Base.Token
+                     Text.GrammarCombinators.Library.Numeric
                      Text.GrammarCombinators.Parser.LL1
                      Text.GrammarCombinators.Parser.LL1TH
                      Text.GrammarCombinators.Parser.Packrat
@@ -69,6 +70,8 @@
                      Text.GrammarCombinators.Utils.IsDead
                      Text.GrammarCombinators.Utils.IsEpsilon
                      Text.GrammarCombinators.Utils.IsReachable
+                     Text.GrammarCombinators.Utils.LiftGrammar
+                     Text.GrammarCombinators.Utils.MemoizeGrammar
                      Text.GrammarCombinators.Utils.PrintGrammar
                      Text.GrammarCombinators.Utils.ToGraph
                      Text.GrammarCombinators.Utils.UnfoldDepthFirst