diff --git a/Control/Monad/Random/Extras.hs b/Control/Monad/Random/Extras.hs
--- a/Control/Monad/Random/Extras.hs
+++ b/Control/Monad/Random/Extras.hs
@@ -1,3 +1,5 @@
+{-# LANGUAGE FlexibleContexts #-}
+
 {- |
 Module       : Control.Monad.Random.Extras
 Copyright    : 2010 Aristid Breitkreuz
@@ -5,11 +7,9 @@
 Stability    : experimental
 Portability  : portable
 
-Additional monadic random functions, based on 'MonadRandom'.
-
+Additional monadic random functions, based on random-fu.
 -}
 
-
 module Control.Monad.Random.Extras
 (
   -- * Random functions
@@ -35,11 +35,12 @@
 )
 where
 
-import Control.Monad (liftM)
-import Control.Monad.Random (MonadRandom, getRandomR, getRandomRs)
-import System.Random (Random)
-import Data.List (mapAccumL, foldl')
-import Data.Maybe (fromJust)
+import Control.Monad
+import Data.Random.RVar
+import Data.Random.Distribution
+import Data.Random.Distribution.Uniform
+import Data.List
+import Data.Maybe
 import qualified Data.Sequence as Seq
 import Data.Sequence ((><), ViewL((:<)))
 import qualified Data.Array.IArray as Arr
@@ -61,12 +62,6 @@
     where (a, r) = Seq.splitAt i s 
           (b :< c) = Seq.viewl r
 
-getRandomR' :: (MonadRandom m, Random a) => a -> a -> m a
-getRandomR' = curry getRandomR
-
-getRandomRNums :: (MonadRandom m, Random a, Num a) => [a] -> m [a]
-getRandomRNums = mapM (getRandomR' 0)
-
 backsaw :: Int -> [Int]
 backsaw n = [n - 1, n - 2 .. 0]
           
@@ -78,16 +73,16 @@
 -- of both methods should be comparable.
 --
 -- /Complexity:/ O(n * log n), where /n/ is the length of the input list.
-shuffle :: (MonadRandom m) => [a] -> m [a]
+shuffle :: [a] -> RVar [a]
 shuffle = shuffleSeq . Seq.fromList
 
 -- | Shuffle a sequence randomly. This is being used by 'shuffle',
 -- so it logically uses the same method.
 --
 -- /Complexity:/ O(n * log n), where /n/ is the length of the input sequence.
-shuffleSeq :: (MonadRandom m) => Seq.Seq a -> m [a]
+shuffleSeq :: Seq.Seq a -> RVar [a]
 shuffleSeq s = do
-  samples <- getRandomRNums . backsaw $ Seq.length s
+  samples <- mapM (uniform 0) . backsaw $ Seq.length s
   return (shuffleSeq' s samples)
 
 shuffleSeq' :: Seq.Seq a -> [Int] -> [a]
@@ -99,16 +94,16 @@
 -- 
 -- /Complexity:/ O(n + m * log n), where /n/ is the length of the input list 
 -- and /m/ is the sample size.
-sample :: (MonadRandom m) => Int -> [a] -> m [a]
+sample :: Int -> [a] -> RVar [a]
 sample m = sampleSeq m . Seq.fromList
 
 -- | Take a random sample from a sequence.
 -- 
 -- /Complexity:/ O(m * log n), where /n/ is the length of the input sequence 
 -- and /m/ is the sample size.
-sampleSeq :: (MonadRandom m) => Int -> Seq.Seq a -> m [a]
+sampleSeq :: Int -> Seq.Seq a -> RVar [a]
 sampleSeq m s = do
-  samples <- getRandomRNums . take m . backsaw $ Seq.length s
+  samples <- mapM (uniform 0) . take m . backsaw $ Seq.length s
   return (shuffleSeq' s samples)
 
 -- Choice
@@ -116,30 +111,30 @@
 -- | Randomly choose and extract an element from a list.
 -- 
 -- /Complexity:/ O(n), where /n/ is the length of the input list.
-choiceExtract :: (MonadRandom m) => [a] -> m (Maybe ([a], a))
-choiceExtract [] = return Nothing
-choiceExtract xs = extract xs `liftM` getRandomR (0, length xs - 1)
+choiceExtract :: [a] -> Maybe (RVar ([a], a))
+choiceExtract [] = Nothing
+choiceExtract xs = Just $ (fromJust . extract xs) `liftM` uniform 0 (length xs - 1)
                     
 -- | Randomly choose and extract an element from a sequence.
 -- 
 -- /Complexity:/ O(log n), where /n/ is the length of the input sequence.
-choiceExtractSeq :: (MonadRandom m) => Seq.Seq a -> m (Maybe (Seq.Seq a, a))
-choiceExtractSeq s | Seq.null s = return Nothing
-                   | otherwise  = extractSeq s `liftM` getRandomR (0, Seq.length s - 1)
+choiceExtractSeq :: Seq.Seq a -> Maybe (RVar (Seq.Seq a, a))
+choiceExtractSeq s | Seq.null s = Nothing
+                   | otherwise  = Just $ (fromJust . extractSeq s) `liftM` uniform 0 (Seq.length s - 1)
 
 -- | Select a random element from a list.
 -- 
 -- /Partial function:/ This function is only defined on non-empty lists.
 -- 
 -- /Complexity:/ O(n), where /n/ is the length of the input list.
-choice :: (MonadRandom m) => [a] -> m a
+choice :: [a] -> RVar a
 choice [] = error "Control.Monad.Random.Extras.choice: empty list"
-choice xs = (xs !!) `liftM` getRandomR (0, length xs - 1)
+choice xs = (xs !!) `liftM` uniform 0 (length xs - 1)
 
 -- | Safely select a random element from a list.
 -- 
 -- /Complexity:/ O(n), where /n/ is the length of the input list.
-safeChoice :: (MonadRandom m) => [a] -> Maybe (m a)
+safeChoice :: [a] -> Maybe (RVar a)
 safeChoice [] = Nothing
 safeChoice xs = Just $ choice xs
 
@@ -149,11 +144,11 @@
 --                     with a length below ('maxBound' + 1 :: Int).
 -- 
 -- /Complexity:/ O(n), where /n/ is the length of the input list.
-iterativeChoice :: MonadRandom m => [a] -> m a
+iterativeChoice :: [a] -> RVar a
 iterativeChoice xs = fst `liftM` foldl' stepM (return start) xs
     where stepM x y = x >>= step y
           step offered (old, n) = do
-            i <- getRandomR (0, n)
+            i <- uniform 0 n
             let new | i == 0    = offered
                     | otherwise = old
             return $! new `seq` (new, n + 1)
@@ -165,22 +160,22 @@
 -- /Partial function:/ This function is only defined on non-empty sequences.
 -- 
 -- /Complexity:/ O(log n), where /n/ is the length of the input sequence.
-choiceSeq :: (MonadRandom m) => Seq.Seq a -> m a
+choiceSeq :: Seq.Seq a -> RVar a
 choiceSeq s | Seq.null s = error "Control.Monad.Random.Extras.choiceSeq: empty sequence"
-            | otherwise  = Seq.index s `liftM` getRandomR (0, Seq.length s - 1)
+            | otherwise  = Seq.index s `liftM` uniform 0 (Seq.length s - 1)
                            
 -- | Safely select a random element from a sequence.
 -- 
 -- /Complexity:/ O(log n), where /n/ is the length of the input sequence.
-safeChoiceSeq :: (MonadRandom m) => Seq.Seq a -> Maybe (m a)
+safeChoiceSeq :: Seq.Seq a -> Maybe (RVar a)
 safeChoiceSeq s | Seq.null s = Nothing
                 | otherwise  = Just $ choiceSeq s
 
 -- | Select a random element from an array.
 -- 
 -- /Complexity:/ O(1).
-choiceArray :: (MonadRandom m, Arr.IArray arr a, Arr.Ix i, Random i) => arr i a -> m a
-choiceArray v = (v !) `liftM` getRandomR (Arr.bounds v)
+choiceArray :: (Arr.IArray arr a, Arr.Ix i, Distribution Uniform i) => arr i a -> RVar a
+choiceArray v = (v !) `liftM` uncurry uniform (Arr.bounds v)
 
 -- Choices
 
@@ -189,20 +184,20 @@
 -- /Partial function:/ This function is only defined on non-empty lists.
 -- 
 -- /Complexity:/ O(n) base and O(1) per element.
-choices :: (MonadRandom m) => [a] -> m [a]
-choices [] = error "Control.Monad.Random.Extras.choices: empty list"
-choices xs = choicesArray $ Data.Array.listArray (1, length xs) xs
+choices :: Int -> [a] -> RVar [a]
+choices _ [] = error "Control.Monad.Random.Extras.choices: empty list"
+choices n xs = choicesArray n $ Data.Array.listArray (1, length xs) xs
 
 -- | Safely get a stream of random elements from a list.
 -- 
 -- /Complexity:/ O(n) base and O(1) per element, where /n/ is the length of 
 -- the input list.
-safeChoices :: (MonadRandom m) => [a] -> Maybe (m [a])
-safeChoices [] = Nothing
-safeChoices xs = Just $ choices xs
+safeChoices :: Int -> [a] -> Maybe (RVar [a])
+safeChoices _ [] = Nothing
+safeChoices n xs = Just $ choices n xs
 
 -- | A stream of random elements from an array.
 --
 -- /Complexity:/ O(1) per element.
-choicesArray :: (MonadRandom m, Arr.IArray arr a, Arr.Ix i, Random i) => arr i a -> m [a]
-choicesArray v = map (v !) `liftM` getRandomRs (Arr.bounds v)
+choicesArray :: (Arr.IArray arr a, Arr.Ix i, Distribution Uniform i) => Int -> arr i a -> RVar [a]
+choicesArray n v = map (v !) `liftM` replicateM n (uncurry uniform (Arr.bounds v))
diff --git a/random-extras.cabal b/random-extras.cabal
--- a/random-extras.cabal
+++ b/random-extras.cabal
@@ -7,13 +7,13 @@
 -- The package version. See the Haskell package versioning policy
 -- (http://www.haskell.org/haskellwiki/Package_versioning_policy) for
 -- standards guiding when and how versions should be incremented.
-Version:             0.4
+Version:             0.10
 
 -- A short (one-line) description of the package.
 Synopsis:            Additional functions for random values.
 
 -- A longer description of the package.
-Description:         Additional functions for random values, based on MonadRandom. Inspired by random-shuffle.
+Description:         Additional functions for random values, based on random-fu. Inspired by random-shuffle.
 
 -- URL for the project homepage or repository.
 Homepage:            http://github.com/aristidb/random-extras
@@ -56,8 +56,7 @@
         base >=4 && <5,
         containers ==0.3.*,
         array ==0.3.*,
-        random ==1.0.0.*,
-        MonadRandom ==0.1.*
+        random-fu ==0.1.*
   
   -- Modules not exported by this package.
   -- Other-modules: