Package frege.lib.QuickCheck

Compiled: Wed Dec 05 00:07:20 PST 2012 from source file: ./frege/lib/QuickCheck.fr

Package Documentation

Please see the QuickCheck manual at http://www.cse.chalmers.se/~rjmh/QuickCheck/manual.html

Table of Content

Imports

Classes

class Arbitrary a

Known Instances

StringJ, [], Integer, Long, Maybe, Float, Double, Either, Int, Bool, (,,,), ->, (,), (,,), (), Char

Member Functions

arbitrary :: Arbitrary a => Gen a
coarbitrary :: Arbitrary a => a -> Gen b -> Gen b
class Testable a

Known Instances

Result, ->, Bool, Property, ()

Member Functions

property :: Testable a => a -> Property

Instances

instance Arbitrary ()

Member Functions

arbitrary :: Gen ()
coarbitrary :: () -> Gen α -> Gen α
instance Arbitrary (Arbitrary a, Arbitrary b) => (a, b)

Member Functions

arbitrary :: (Arbitrary α, Arbitrary β) => Gen (α, β)
coarbitrary :: (Arbitrary β, Arbitrary α) => (β, α) -> Gen γ -> Gen γ
instance Arbitrary (Arbitrary a, Arbitrary b, Arbitrary c) => (a, b, c)

Member Functions

arbitrary :: (Arbitrary α, Arbitrary β, Arbitrary γ) => Gen (α, β, γ)
coarbitrary :: (Arbitrary α, Arbitrary β, Arbitrary γ) => (α, β, γ) -> Gen δ -> Gen δ
instance Arbitrary (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => (a, b, c, d)

Member Functions

arbitrary :: (Arbitrary α, Arbitrary β, Arbitrary γ, Arbitrary δ) => Gen (α, β, γ, δ)
coarbitrary :: (Arbitrary α, Arbitrary β, Arbitrary δ, Arbitrary γ) => (α, β, δ, γ) -> Gen ε -> Gen ε
instance Arbitrary (Arbitrary a, Arbitrary b) => a->b

Member Functions

arbitrary :: (Arbitrary α, Arbitrary β) => Gen (α->β)
coarbitrary :: (Arbitrary β, Arbitrary α) => (β->α) -> Gen γ -> Gen γ
instance Arbitrary Bool

Member Functions

arbitrary :: Gen Bool
coarbitrary :: Bool -> Gen α -> Gen α
instance Arbitrary Char

Member Functions

arbitrary :: Gen Char
coarbitrary :: Char -> Gen α -> Gen α
instance Arbitrary Double

Member Functions

arbitrary :: Gen Double
coarbitrary :: Double -> Gen α -> Gen α
instance Arbitrary (Arbitrary a, Arbitrary b) => Either a b

Member Functions

arbitrary :: (Arbitrary α, Arbitrary β) => Gen (Either α β)
coarbitrary :: (Arbitrary β, Arbitrary α) => Either β α -> Gen γ -> Gen γ
instance Arbitrary Float

Member Functions

arbitrary :: Gen Float
coarbitrary :: Float -> Gen α -> Gen α
instance Arbitrary Int

Member Functions

arbitrary :: Gen Int
coarbitrary :: Int -> Gen α -> Gen α
instance Arbitrary Integer

Member Functions

arbitrary :: Gen Integer
coarbitrary :: Integer -> Gen α -> Gen α
instance Arbitrary Long

Member Functions

arbitrary :: Gen Long
coarbitrary :: Long -> Gen α -> Gen α
instance Arbitrary Arbitrary a => Maybe a

Member Functions

arbitrary :: Arbitrary α => Gen (Maybe α)
coarbitrary :: Arbitrary α => Maybe α -> Gen β -> Gen β
instance Arbitrary String

Member Functions

arbitrary :: Gen String
coarbitrary :: String -> Gen α -> Gen α
instance Arbitrary Arbitrary a => [a]

Member Functions

arbitrary :: Arbitrary α => Gen [α]
coarbitrary :: Arbitrary α => [α] -> Gen β -> Gen β
instance Functor Gen

Member Functions

fmap :: (α->β) -> Gen α -> Gen β
instance Monad Gen

Member Functions

*> :: Gen α -> Gen β -> Gen β

inherited from Applicative.*>

<* :: Gen α -> Gen β -> Gen α

inherited from Applicative.<*

<*> :: Gen (α->β) -> Gen α -> Gen β

inherited from Monad.<*>

>> :: Gen α -> Gen β -> Gen β

inherited from Monad.>>

>>= :: Gen α -> (α->Gen β) -> Gen β
join :: Gen (Gen α) -> Gen α

inherited from Monad.join

return :: α -> Gen α
instance Testable ()

Member Functions

property :: () -> Property
instance Testable (Arbitrary a, Show a, Testable b) => a->b

Member Functions

property :: (Arbitrary α, Show α, Testable β) => (α->β) -> Property
instance Testable Bool

Member Functions

property :: Bool -> Property
instance Testable Property

Member Functions

property :: Property -> Property
instance Testable Result

Member Functions

property :: Result -> Property

Data Types

data Config

Constructors

Config {configMaxTest :: Int, configMaxFail :: Int, configSize :: Int -> Int, configEvery :: Int -> [String] -> String}

Member Functions

configEvery :: Config -> Int -> [String] -> String

access field configEvery

configMaxFail :: Config -> Int

access field configMaxFail

configMaxTest :: Config -> Int

access field configMaxTest

configSize :: Config -> Int -> Int

access field configSize

data Gen a

Constructors

Gen (Int->StdGen->a)
data Property

Constructors

Prop (Gen Result)
data Result

Constructors

Result {ok :: Maybe Bool, stamp :: [String], arguments :: [String]}

Member Functions

arguments :: Result -> [String]

access field arguments

ok :: Result -> Maybe Bool

access field ok

stamp :: Result -> [String]

access field stamp

Functions and Values

==> :: Testable a => Bool -> a -> Property
backN :: Int -> String
backspaces :: [Char]
check :: Testable a => Config -> a -> IO Bool
choose :: Random a => (a, a) -> Gen a
classify :: Testable a => Bool -> String -> a -> Property
collect :: (Show a, Testable b) => a -> b -> Property
defaultConfig :: Config
done :: String -> Int -> [[String]] -> IO ()
elements :: [a] -> Gen a
evaluate :: Testable a => a -> Gen Result
forAll :: (Show a, Testable b) => Gen a -> (a->b) -> Property
four :: Monad m => m a -> m (a, a, a, a)
fraction :: Real f => Int -> Int -> Int -> f
frequency :: [(Int, Gen a)] -> Gen a
generate :: Int -> StdGen -> Gen a -> a
label :: Testable a => String -> a -> Property
lnsep :: String

line separator

nothing :: Result
oneof :: [Gen a] -> Gen a
promote :: (a->Gen b) -> Gen (a->b)
quick :: Config
quickCheck :: Testable a => a -> IO Bool
rand :: Gen StdGen
resize :: Int -> Gen a -> Gen a
result :: Result -> Property
sized :: (Int->Gen a) -> Gen a
test :: Testable a => a -> IO Bool
tests :: Config -> Gen Result -> StdGen -> Int -> Int -> [[String]] -> IO Bool
three :: Monad m => m a -> m (a, a, a)
trivial :: Testable a => Bool -> a -> Property
two :: Monad m => m a -> m (a, a)
variant :: Int -> Gen a -> Gen a
vector :: Arbitrary a => Int -> Gen [a]
verbose :: Config
verboseCheck :: Testable a => a -> IO Bool

Functions and Values by Type

Gen Result -> Property

Property.Prop

Maybe Bool -> [String] -> [String] -> Result

Result.Result

String -> Int -> [[String]] -> IO ()

done

Config -> (-> Int ([String]->String)->Int->[String]->String) -> Config

Config.chg$configEvery

Config -> (-> Int Int->Int->Int) -> Config

Config.chg$configSize

Config -> (Int->[String]->String) -> Config

Config.upd$configEvery

Config -> (Int->Int) -> Config

Config.chg$configMaxTest, Config.chg$configMaxFail, Config.upd$configSize

Config -> Gen Result -> StdGen -> Int -> Int -> [[String]] -> IO Bool

tests

Config -> Int -> [String] -> String

Config.configEvery

Config -> Int -> Config

Config.upd$configMaxTest, Config.upd$configMaxFail

Config -> Int -> Int

Config.configSize

Config -> Int

Config.configMaxTest, Config.configMaxFail

Property -> Property

Testable_Property.property

Result -> (Maybe Bool->Maybe Bool) -> Result

Result.chg$ok

Result -> ([String]->[String]) -> Result

Result.chg$arguments, Result.chg$stamp

Result -> Maybe Bool -> Result

Result.upd$ok

Result -> [String] -> Result

Result.upd$arguments, Result.upd$stamp

Result -> Maybe Bool

Result.ok

Result -> [String]

Result.arguments, Result.stamp

Result -> Property

result, Testable_Result.property

() -> Property

Testable_().property

Bool -> Property

Testable_Bool.property

Int -> Int -> (Int -> Int) -> (Int -> [String] -> String) -> Config

Config.Config

Int -> String

backN

Gen String

Arbitrary_String.arbitrary

Gen StdGen

rand

Gen ()

Arbitrary_().arbitrary

Gen Bool

Arbitrary_Bool.arbitrary

Gen Char

Arbitrary_Char.arbitrary

Gen Double

Arbitrary_Double.arbitrary

Gen Float

Arbitrary_Float.arbitrary

Gen Int

Arbitrary_Int.arbitrary

Gen Integer

Arbitrary_Integer.arbitrary

Gen Long

Arbitrary_Long.arbitrary

String

lnsep

[Char]

backspaces

Config

defaultConfig, quick, verbose

Result

nothing

(Int->StdGen->a) -> Gen a

Gen.Gen

(Int->Gen a) -> Gen a

sized

Gen (Gen α) -> Gen α

Monad_Gen.join

String -> Gen α -> Gen α

Arbitrary_String.coarbitrary

[(Int, Gen a)] -> Gen a

frequency

[Gen a] -> Gen a

oneof

[a] -> Gen a

elements

() -> Gen α -> Gen α

Arbitrary_().coarbitrary

Bool -> Gen α -> Gen α

Arbitrary_Bool.coarbitrary

Char -> Gen α -> Gen α

Arbitrary_Char.coarbitrary

Double -> Gen α -> Gen α

Arbitrary_Double.coarbitrary

Float -> Gen α -> Gen α

Arbitrary_Float.coarbitrary

Int -> Gen a -> Gen a

resize, variant

Int -> Gen α -> Gen α

Arbitrary_Int.coarbitrary

Int -> StdGen -> Gen a -> a

generate

Integer -> Gen α -> Gen α

Arbitrary_Integer.coarbitrary

Long -> Gen α -> Gen α

Arbitrary_Long.coarbitrary

α -> Gen α

Monad_Gen.return

α -> Bool

Config.has$configMaxTest, Config.has$configEvery, Config.has$configMaxFail, Config.has$configSize, Result.has$ok, Result.has$arguments, Result.has$stamp

Arbitrary a => Int -> Gen [a]

vector

Testable a => String -> a -> Property

label

Testable a => Config -> a -> IO Bool

check

Testable a => Bool -> String -> a -> Property

classify

Testable a => Bool -> a -> Property

==>, trivial

Testable a => a -> IO Bool

quickCheck, test, verboseCheck

Testable a => a -> Gen Result

evaluate

Testable a => a -> Property

Testable.property

Random a => (a, a) -> Gen a

choose

Real f => Int -> Int -> Int -> f

fraction

Arbitrary a => Gen a

Arbitrary.arbitrary

Arbitrary α => Gen (Maybe α)

Arbitrary_Maybe.arbitrary

Arbitrary α => Gen [α]

Arbitrary_[].arbitrary

(a->Gen b) -> Gen (a->b)

promote

(α->β) -> Gen α -> Gen β

Functor_Gen.fmap

Gen (α->β) -> Gen α -> Gen β

Monad_Gen.<*>

Gen α -> (α->Gen β) -> Gen β

Monad_Gen.>>=

Gen α -> Gen β -> Gen α

Monad_Gen.<*

Gen α -> Gen β -> Gen β

Monad_Gen.*>, Monad_Gen.>>

Arbitrary a => a -> Gen b -> Gen b

Arbitrary.coarbitrary

Arbitrary α => Maybe α -> Gen β -> Gen β

Arbitrary_Maybe.coarbitrary

Arbitrary α => [α] -> Gen β -> Gen β

Arbitrary_[].coarbitrary

(Arbitrary α, Show α, Testable β) => (α->β) -> Property

Testable_->.property

Monad m => m a -> m (a, a, a, a)

four

Monad m => m a -> m (a, a, a)

three

Monad m => m a -> m (a, a)

two

(Show a, Testable b) => Gen a -> (a->b) -> Property

forAll

(Show a, Testable b) => a -> b -> Property

collect

(Arbitrary α, Arbitrary β) => Gen (α, β)

Arbitrary_(,).arbitrary

(Arbitrary α, Arbitrary β) => Gen (α->β)

Arbitrary_->.arbitrary

(Arbitrary α, Arbitrary β) => Gen (Either α β)

Arbitrary_Either.arbitrary

(Arbitrary β, Arbitrary α) => (β, α) -> Gen γ -> Gen γ

Arbitrary_(,).coarbitrary

(Arbitrary β, Arbitrary α) => (β->α) -> Gen γ -> Gen γ

Arbitrary_->.coarbitrary

(Arbitrary β, Arbitrary α) => Either β α -> Gen γ -> Gen γ

Arbitrary_Either.coarbitrary

(Arbitrary α, Arbitrary β, Arbitrary γ) => Gen (α, β, γ)

Arbitrary_(,,).arbitrary

(Arbitrary α, Arbitrary β, Arbitrary γ) => (α, β, γ) -> Gen δ -> Gen δ

Arbitrary_(,,).coarbitrary

(Arbitrary α, Arbitrary β, Arbitrary γ, Arbitrary δ) => Gen (α, β, γ, δ)

Arbitrary_(,,,).arbitrary

(Arbitrary α, Arbitrary β, Arbitrary δ, Arbitrary γ) => (α, β, δ, γ) -> Gen ε -> Gen ε

Arbitrary_(,,,).coarbitrary

Valid HTML 4.01 Strict