Q:

Evaluating function at random arguments using QuickCheck

I am trying to use quickcheck to generate random arguments of a given function (assuming all its types have Arbitrary instance and Show instance) along with the evaluation of the function at those arguments. I just need to print the values of arguments and evaluated answer afterwards. So I expect a function with following type 
randomEvaluate :: Testable a => a -> IO ( [String] -- arguments
                                        , String ) -- Answer after evaluating
                                                   -- IO is just needed to get a new random number generator. If I pass a generator then I think probably I will not need IO here. 

I am still not sure about the type here but I think Testable a would do.
I am still unable to actually get what I need. I am all confused in the mess of quickcheck datatypes Rose, Result etc. 
UPDATE
Suppose I have a function 
add :: Int -> Int -> Int
add a b = a+b

Then I assume a behavior like 
> randomEvaluate add
(["1","3"],"4")

where 1 and 3 are random values generated for Int and 4 is f 1 3.  

A:

I don’t think that you can use much of the QuickCheck code besides the modules Test.QuickCheck.Arbitrary and Test.QuickCheck.Gen.
One parameter only
Here is some simple code that provides what you need for functions with one argument only:
import Test.QuickCheck.Arbitrary
import Test.QuickCheck.Gen
import System.Random

randomEvaluate :: (Arbitrary a, Show a, Show b) => (a -> b) -> IO (String, String)
randomEvaluate f = do
    stdGen <- newStdGen
    let x = unGen arbitrary stdGen 1000
    let y = f x
    return (show x, show y)

And here you can see it in action:
*Main> randomEvaluate (\(a,b) -> a + b)
("(-292,-655)","-947")
*Main> randomEvaluate (\(a,b) -> a + b)
("(586,-905)","-319")
*Main> randomEvaluate (\(a,b) -> a + b)
("(547,-72)","475")

As you can see it is possible to use it with functions with more than one argument if you uncurry it. If that is not sufficient things become a little bit more difficult, but should be posssible with some type class trickery.
Multiple parameters, return type marked explicitly
Here is an approach that requires “only” to wrap the return value of the function in a newtype. (This might be avoidable with non-Haskell98-features):
class RandEval a where
    randomEvaluate :: StdGen -> a -> ([String], String)

newtype Ret a = Ret a

instance Show a => RandEval (Ret a)  where
    randomEvaluate _ (Ret x) = ([], show x)

instance (Show a, Arbitrary a, RandEval b) => RandEval (a -> b) where
    randomEvaluate stdGen f = (show x : args, ret)
        where (stdGen1, stdGen2) = split stdGen
              x = unGen arbitrary stdGen1 1000
              (args, ret) = randomEvaluate stdGen2 (f x) 

doRandomEvaluate :: RandEval a => a -> IO ([String], String)
doRandomEvaluate f = do
    stdGen <- newStdGen
    return $ randomEvaluate stdGen f

See it in action here:
*Main> doRandomEvaluate (\a b -> Ret (a && b))
(["False","True"],"False")
*Main> doRandomEvaluate (\a b -> Ret (a + b))
(["944","758"],"1702")
*Main> doRandomEvaluate (\a b c -> Ret (a + b + c))
(["-274","413","865"],"1004")
*Main> doRandomEvaluate (\a b c d -> Ret (a + b + c + d))
(["-61","-503","-704","-877"],"-2145")

Multiple parameters with language extensions
If it is also undesirable to have to explicitly mark the return value, this works, but uses language extensions:
{-# LANGUAGE FlexibleInstances, UndecidableInstances, OverlappingInstances #-}

import Test.QuickCheck.Arbitrary
import Test.QuickCheck.Gen
import System.Random
import Control.Arrow

class RandEval a where
    randomEvaluate :: StdGen -> a -> ([String], String)

instance (Show a, Arbitrary a, RandEval b) => RandEval (a -> b) where
    randomEvaluate stdGen f = first (show x:) $ randomEvaluate stdGen2 (f x) 
        where (stdGen1, stdGen2) = split stdGen
              x = unGen arbitrary stdGen1 1000

instance Show a => RandEval a where
    randomEvaluate _ x = ([], show x)

doRandomEvaluate :: RandEval a => a -> IO ([String], String)
doRandomEvaluate f = do
    stdGen <- newStdGen
    return $ randomEvaluate stdGen f

And here is the original use case from the posting:
*Main> doRandomEvaluate ( (+) :: Int -> Int -> Int )
(["-5998437593420471249","339001240294599646"],"-5659436353125871603")

But now you are at the whims of how GHC resolves overlapping instances. E.g. even with this nice (but also non-Haskell98) instance to show boolean functions:
type BoolFun a = Bool -> a

instance Show a => Show (BoolFun a) where
    show f = "True -> " ++ show (f True) ++ ", False -> " ++ show (f False)

aBoolFun :: Bool -> BoolFun Bool
aBoolFun x y = x && y

you do not see this instance in use in doRandomEvaluate:
*Main> doRandomEvaluate aBoolFun 
    (["False","False"],"False")

With the original solution, you do:
*Main> doRandomEvaluate (Ret . aBoolFun)
(["False"],"True -> False, False -> False")
*Main> doRandomEvaluate (Ret . aBoolFun)
(["True"],"True -> True, False -> False")

A warning
But note that this is a slippery slope. A small change to the code above, and it stops working in GHC 7.6.1 (but still works in GHC 7.4.1):
instance (Show a, Arbitrary a, RandEval b) => RandEval (a -> b) where
    randomEvaluate stdGen f = (show x:args, ret)
        where (stdGen1, stdGen2) = split stdGen
              x = unGen arbitrary stdGen1 1000
              (args, ret) = randomEvaluate stdGen2 (f x) 

SPJ explains why this is not really a bug – to me a clear sign that this approach is pushing the type class hackery a bit too far.

A:

QuickCheck is stunningly simple:
Prelude> import Test.QuickCheck

A simple driver function is provided:
Prelude Test.QuickCheck> :t quickCheck
quickCheck :: Testable prop => prop -> IO ()

So define something that has a type found in 'Testable':
Prelude Test.QuickCheck> let prop_commut a b = a + b == b + a
Prelude Test.QuickCheck> :t prop_commut
prop_commut :: (Eq a, Num a) => a -> a -> Bool

And run it:
Prelude Test.QuickCheck> quickCheck prop_commut 
+++ OK, passed 100 tests.

For a fuller treatment see RWH

