On 10/27/05, Joel Reymont wrote:

Would it cover the range between minBound :: Word32 and maxBound :: Word32? I cannot figure out how to do this since maxBound :: Int32 is less that that of Word32.

Also, I get the following error with ghci -fglasgow-exts

foo.hs:7:52: parse error on input `.'

Okay, try this then: import Data.Word import Test.QuickCheck instance Arbitrary Word32 where arbitrary = do let mx,mn :: Integer mx = fromIntegral (maxBound :: Word32) mn = fromIntegral (minBound :: Word32) c <- choose (mx, mn) return (fromIntegral c) That really should work. However the following will work too instance Arbitrary Word32 where arbitrary = do c <- arbitrary :: Gen Integer return (fromIntegral c) Though I'm not sure of the range and distribution of the generated Word32's (since it would depend on how fromIntegral behaves transforming an Integer to a Word32 when the Integer is larger than maxBound::Word32). /S

-- module Foo where

import Data.Word import Test.QuickCheck

instance Arbitrary Word32 where arbitrary = arbitrary :: Gen Integer >>= return . fromIntegral

prop_Word32 :: Word32 -> Bool prop_Word32 a = a == a

Thanks, Joel

On Oct 27, 2005, at 3:44 PM, Sebastian Sylvan wrote:

...

Something like (untested!):

instance Arbitrary Word32 where arbitrary = arbitrary :: Gen Integer >>= return . fromIntegral

-- http://wagerlabs.com/

-- Sebastian Sylvan +46(0)736-818655 UIN: 44640862

Is there a way to squeeze this boilerplate code? class Arbitrary instance Arbitrary Word16 where arbitrary = do let mx,mn :: Integer mx = fromIntegral (maxBound :: Word16) mn = fromIntegral (minBound :: Word16) c <- choose (mx, mn) return (fromIntegral c) coarbitrary a = error "Not implemented" instance Arbitrary Word32 where arbitrary = do let mx,mn :: Integer mx = fromIntegral (maxBound :: Word32) mn = fromIntegral (minBound :: Word32) c <- choose (mx, mn) return (fromIntegral c) coarbitrary a = error "Not implemented" instance Arbitrary Word64 where arbitrary = do let mx,mn :: Integer mx = fromIntegral (maxBound :: Word64) mn = fromIntegral (minBound :: Word64) c <- choose (mx, mn) return (fromIntegral c) coarbitrary a = error "Not implemented" On Oct 27, 2005, at 5:35 PM, Sebastian Sylvan wrote:

instance Arbitrary Word32 where arbitrary = do let mx,mn :: Integer mx = fromIntegral (maxBound :: Word32) mn = fromIntegral (minBound :: Word32) c <- choose (mx, mn) return (fromIntegral c)

-- http://wagerlabs.com/

How about this? class ArbitraryDefault a where {} instance (Integral a, Bounded a, ArbitraryDefault a) => Arbitrary a where arbitrary = arbitraryBound coarbitrary a = error "Not implemented" instance ArbitraryDefault Word16 instance ArbitraryDefault Word32 instance ArbitraryDefault Word64 arbitraryBound :: forall a.(Integral a, Bounded a) => Gen a arbitraryBound = do let mx,mn :: Integer mx = fromIntegral (maxBound :: a) mn = fromIntegral (minBound :: a) c <- choose (mx, mn) return (fromIntegral c) Joel Reymont wrote:

I came up with this but can it be done better? I'm wishing for "default class methods" :-).

instance Arbitrary Word16 where arbitrary = arbitraryBound coarbitrary a = error "Not implemented"

instance Arbitrary Word32 where arbitrary = arbitraryBound coarbitrary a = error "Not implemented"

instance Arbitrary Word64 where arbitrary = arbitraryBound coarbitrary a = error "Not implemented"

arbitraryBound :: forall a.(Integral a, Bounded a) => Gen a arbitraryBound = do let mx,mn :: Integer mx = fromIntegral (maxBound :: a) mn = fromIntegral (minBound :: a) c <- choose (mx, mn) return (fromIntegral c)

On Oct 27, 2005, at 6:13 PM, Joel Reymont wrote:

...

Is there a way to squeeze this boilerplate code?

class Arbitrary instance Arbitrary Word16 where arbitrary = do let mx,mn :: Integer mx = fromIntegral (maxBound :: Word16) mn = fromIntegral (minBound :: Word16) c <- choose (mx, mn) return (fromIntegral c) coarbitrary a = error "Not implemented"

instance Arbitrary Word32 where arbitrary = do let mx,mn :: Integer mx = fromIntegral (maxBound :: Word32) mn = fromIntegral (minBound :: Word32) c <- choose (mx, mn) return (fromIntegral c) coarbitrary a = error "Not implemented"

instance Arbitrary Word64 where arbitrary = do let mx,mn :: Integer mx = fromIntegral (maxBound :: Word64) mn = fromIntegral (minBound :: Word64) c <- choose (mx, mn) return (fromIntegral c) coarbitrary a = error "Not implemented"

-- http://wagerlabs.com/

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

I've not had any problems with them, though of course your mileage may vary. Have a look at section 7.4.4.3 in http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.html... for an explanation. Basically, if you have a cyclic class dependency graph, the type checker won't terminate. Well, it will, but only because there's a limit on the recursion depth. The trivial example is instance C a => C a where ... In practice, I'm not sure that this is really a big issue, and it does come in handy. Perhaps someone who's actually been bitten by a problem with undecidable instances can comment? Bryn Joel Reymont wrote:

This requires

{-# OPTIONS_GHC -fallow-undecidable-instances #-}

but since I'm using -fglasgow-exts in a lot of places I'm wondering if adding undecidable instances would be a bad habit. I guess not... not until I shoot myself in the foot :-).

Any explanation of undecidable instances, the good and the bad?

Joel

On Oct 27, 2005, at 6:49 PM, Bryn Keller wrote:

...

How about this?

class ArbitraryDefault a where {}

instance (Integral a, Bounded a, ArbitraryDefault a) => Arbitrary a where arbitrary = arbitraryBound coarbitrary a = error "Not implemented"

instance ArbitraryDefault Word16 instance ArbitraryDefault Word32 instance ArbitraryDefault Word64

-- http://wagerlabs.com/

On Oct 27, 2005, at 5:34 PM, Sebastian Sylvan wrote:

import Data.Word import Test.QuickCheck

instance Arbitrary Word32 where arbitrary = do let mx,mn :: Integer mx = fromIntegral (maxBound :: Word32) mn = fromIntegral (minBound :: Word32) c <- choose (mx, mn) return (fromIntegral c)

Awesome! This actually works!

instance Arbitrary Word32 where arbitrary = do c <- arbitrary :: Gen Integer return (fromIntegral c)

Though I'm not sure of the range and distribution of the generated Word32's (since it would depend on how fromIntegral behaves transforming an Integer to a Word32 when the Integer is larger than maxBound::Word32).

It wraps around, apparently *Foo> maxBound :: Word32 4294967295 *Foo> let x :: Integer = 4294967295 + 1 *Foo> x 4294967296 *Foo> fromIntegral x :: Word32 0 *Foo> let x :: Integer = 4294967295 + 10 *Foo> x 4294967305 *Foo> fromIntegral x :: Word32 9 *Foo> let x :: Integer = 4294967295 * 2 *Foo> x 8589934590 *Foo> fromIntegral x :: Word32 4294967294 Thanks, Joel -- http://wagerlabs.com/

Just one more question... data Prop = forall a b. (Eq a, Eq b, Show a, Packet b, Convertible a b) => Attr a b := a deriving (Typeable) data Attr a b = Attr String (a -> Dynamic, Dynamic -> Maybe a) (a -> b, b -> a) makeAttr :: (Typeable a, Convertible a b) => String -> Attr a b makeAttr name = Attr name (toDyn, fromDynamic) (convert_AB, convert_BA) I can do this for Attr instance (Typeable a, Arbitrary a, Typeable b, Arbitrary b, Convertible a b) => Arbitrary (Attr a b) where arbitrary = makeAttr `fmap` arbitrary coarbitrary a = error "Not implemented" How do I define an arbitrary prop, though? Following does not work: arbitraryProp :: forall a b.(Arbitrary a, Arbitrary b) => Attr a b -> Gen Prop arbitraryProp = arbitrary := arbitrary Thanks, Joel -- http://wagerlabs.com/

Joel Reymont writes:

...

I would very much like to see QuickCheckM extended to handle IO directly. I've wanted to use QuickCheck to test TCP/IP stacks for unhandled cases. Think of the entertainment value :-)

Is this gonna be in the next version of QuickCheck? Or can it be implemented now?

You'd have to monadify the internals of QuickCheck. QC depends on each monad having a 'run' function :: (m a -> a), which works for ST, but not IO. Thomas Jäger described the necessary changes to me on irc some months ago, Search for QuickCheckM in http://tunes.org/~nef/logs/haskell/05.03.21 I haven't gotten around to trying to implement them yet. If you do implement these changes, I'd definitely jump in and help. -- Shae Matijs Erisson - http://www.ScannedInAvian.com/ - Sockmonster once said: You could switch out the unicycles for badgers, and the game would be the same.

Joel Reymont writes:

How is this supposed to work? Does anyone have a simple explanation?

Here's a demonstration of an arbitrary instance for a datatype. <code> module ProtoArbitrary where import Test.QuickCheck import Control.Monad data Tree a = Nil | Node (Tree a) a (Tree a) deriving (Eq,Ord,Show) instance (Arbitrary a) => Arbitrary (Tree a) where arbitrary = oneof [return Nil, liftM3 Node arbitrary arbitrary arbitrary] coarbitrary = error "not implemented" prop_TreeI :: Tree Int -> Bool prop_TreeI x = True prop_TreeF :: Tree Float -> Bool prop_TreeF x = True </code>

I could not understand how to define this for arbitraries of my choosing and Shae seems to have defined coarbitrary = error "Not implemented" :-).

Coarbitrary is for generator transformers, see section 3.3 on page 5 of the original paper http://www.md.chalmers.se/~koen/Papers/quick.ps -- Shae Matijs Erisson - http://www.ScannedInAvian.com/ - Sockmonster once said: You could switch out the unicycles for badgers, and the game would be the same.