[Haskell-cafe] CoArbitrary

[Tony Morris]

Hello,
In the QuickCheck library, there is a type-class called CoArbitrary. It
is defined like so:

class CoArbitrary a where
  coarbitrary :: a -> Gen b -> Gen b -- Gen is a monad

Its purpose is to allow generation of functions. In other words, for
taking Gen x -> Gen (a -> x), which could be done rather degenerately
(fmap const) but QuickCheck constrains with (CoArbitrary a) to perturb
the resulting value instead of ignoring (const) it.

It has always puzzled me in the general sense of thinking about the
scenario: f x -> f (a -> x) and whether the CoArbitrary is a
good/general solution, perhaps for the specific case of f=Gen or maybe
even more generally.

-- approximate
(a -> f x -> f x) -- e.g. CoArbitrary to perturb the result
-> f x -- e.g. Gen x
-> f (a -> x) -- e.g. Gen (a -> x)

So I often wonder about what might be a better (and perhaps more
general) constraint to produce functions f x -> f (a -> x) for a given
Monad f. I was wondering if there is an existing abstraction (or paper)
that might point me in that direction. It is a problem that I encounter
on occasion in general programming and I am using Arbitrary/CoArbitrary
as an example to help make my point, but I am dissatisfied (for reasons
that I am unsure about) with the solution provided by CoArbitrary.

What about other monads? For example, what is a general constraint to be
placed to permit a function Maybe x -> Maybe (a -> x) that does not
simply "const" away the argument.

I hope I have phrased this in a way to make the point. I found it a bit
difficult to articulate and I do wonder (hope!) that others encounter
similar scenarios. Thanks for any tips!

-- 
Tony Morris
http://tmorris.net/