diff --git a/QuickCheck-GenT.cabal b/QuickCheck-GenT.cabal
--- a/QuickCheck-GenT.cabal
+++ b/QuickCheck-GenT.cabal
@@ -1,7 +1,7 @@
 name:
   QuickCheck-GenT
 version:
-  0.2.1
+  0.2.2
 synopsis:
   A GenT monad transformer for QuickCheck library.
 description:
diff --git a/src/QuickCheck/GenT.hs b/src/QuickCheck/GenT.hs
--- a/src/QuickCheck/GenT.hs
+++ b/src/QuickCheck/GenT.hs
@@ -4,9 +4,45 @@
 -- Most of the code is borrowed from 
 -- <http://haskell.1045720.n5.nabble.com/darcs-patch-GenT-monad-transformer-variant-of-Gen-QuickCheck-2-td3172136.html a mailing list discussion>.
 -- Therefor, credits go to Paul Johnson and Felix Martini.
-module QuickCheck.GenT where
+module QuickCheck.GenT
+  ( GenT
+  , runGenT
+  , MonadGen(..)
+  -- * Lifted functions
+  , arbitrary'
+  , oneof
+  , frequency
+  , elements
+  , growingElements
+  , getSize
+  , scale
+  , suchThat
+  , suchThatMap
+  , suchThatMaybe
+  , applyArbitrary2
+  , applyArbitrary3
+  , applyArbitrary4
+  , listOf
+  , listOf1
+  , vectorOf
+  , vector
+  , infiniteListOf
+  , infiniteList
+  , shuffle
+  , sublistOf
+  , orderedList
+  -- * Re-exports
+  , Arbitrary(..)
+  , QC.Gen
+  -- * Safe functions
+  , oneofMay
+  , elementsMay
+  , growingElementsMay
+  ) where
 
 import QuickCheck.GenT.Prelude
+import Test.QuickCheck (Arbitrary(..))
+import qualified Test.QuickCheck.Arbitrary as QC
 import qualified Test.QuickCheck.Gen as QC
 import qualified Test.QuickCheck.Random as QC
 import qualified System.Random as Random
@@ -72,9 +108,44 @@
 var k = 
   (if k == k' then id else var k') . (if even k then fst else snd) . Random.split 
   where k' = k `div` 2 
- 
 
 --------------------------------------------------------------------------
+-- ** Lifted functions
+
+arbitrary' :: (Arbitrary a, MonadGen m) => m a
+arbitrary' = liftGen arbitrary
+
+getSize :: MonadGen m => m Int
+getSize = liftGen getSize
+
+scale :: MonadGen m => (Int -> Int) -> m a -> m a
+scale f g = sized (\n -> resize (f n) g)
+
+applyArbitrary2 :: MonadGen m => (Arbitrary a, Arbitrary b) => (a -> b -> r) -> m r
+applyArbitrary2 = liftGen . QC.applyArbitrary2
+
+applyArbitrary3 :: MonadGen m => (Arbitrary a, Arbitrary b, Arbitrary c) => (a -> b -> c -> r) -> m r
+applyArbitrary3 = liftGen . QC.applyArbitrary3
+
+applyArbitrary4 :: MonadGen m => (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => (a -> b -> c -> d -> r) -> m r
+applyArbitrary4 = liftGen . QC.applyArbitrary4
+
+infiniteListOf :: MonadGen m => m a -> m [a]
+infiniteListOf = sequence . repeat
+
+infiniteList :: (Arbitrary a, MonadGen m) => m [a]
+infiniteList = infiniteListOf arbitrary'
+
+shuffle :: MonadGen m => [a] -> m [a]
+shuffle = liftGen . QC.shuffle
+
+sublistOf :: MonadGen m => [a] -> m [a]
+sublistOf = liftGen . QC.sublistOf
+
+orderedList :: (Ord a, Arbitrary a, MonadGen m) => m [a]
+orderedList = liftGen QC.orderedList
+
+--------------------------------------------------------------------------
 -- ** Common generator combinators
 
 -- | Generates a value that satisfies a predicate.
@@ -85,6 +156,12 @@
        Just x  -> return x
        Nothing -> sized (\n -> resize (n+1) (gen `suchThat` p))
 
+-- | Generates a value for which the given function returns a 'Just', and then
+-- applies the function.
+suchThatMap :: MonadGen m => m a -> (a -> Maybe b) -> m b
+gen `suchThatMap` f =
+  fmap fromJust $ fmap f gen `suchThat` isJust
+
 -- | Tries to generate a value that satisfies a predicate.
 suchThatMaybe :: MonadGen m => m a -> (a -> Bool) -> m (Maybe a)
 gen `suchThatMaybe` p = sized (try 0 . max 1)
@@ -110,6 +187,10 @@
 -- | Generates a list of the given length.
 vectorOf :: MonadGen m => Int -> m a -> m [a]
 vectorOf k gen = sequence [ gen | _ <- [1..k] ]
+
+-- | Generates a list of a given length.
+vector :: (Arbitrary a, MonadGen m) => Int -> m [a]
+vector n = vectorOf n arbitrary'
 
 
 -- * Partial functions