[Haskell] randomgen for foreign random functions

[Simon Peyton-Jones]

| Say I have a foreign function:
| 
| foreign import ccall "statistical_c.h gengam"     c_gengam :: CDouble
-> CDouble -> IO CDouble
| 
| that returns a random value parameterized by the two CDoubles.
clearly
| this must happen in IO since the return value will be different each
time,
| and some global state stuff is getting modified on the C side to
| facilitate future random # generation.
| 
| However, I would like to wrap this into an essentially pure function,
ala
| the Random class.  basically, i want to wrap this up as something
like:
| 
| gengam :: RandomGen g => g -> Double -> Double -> (g, Double)
| 
| analogously to the normal random # generation stuff.

There's a standard approach, originally due to Lennart Augustsson.

Have a single function that generates an infinite supply
	mkSupply :: IO Supply

The Supply is a tree
	data Supply = Supply Int Supply Supply

So splitting and generation are easy.  But how do you generate an
infinite tree?  By using your side-effecting function plus
unsafeInterleaveIO.  (This function is better behaved then
unsafePerformIO; no need for NOINLINE nonsense.)

Here's the code from GHC's unique supply (you can ignore all the unboxed
stuff.  The genSymZh thing is the equivalent to your gengam.

You still need the tree so that if you split the same random supply
twice, you get the same thing:
	let (g1,g2) = split g in ..
is the same as
	let g1 = fst (split g); g2 = snd (split g) in ...

Simon


mkSplitUniqSupply (C# c#)
  = let
	mask# = (i2w (ord# c#)) `uncheckedShiftL#` (i2w_s 24#)

	-- This is one of the most hammered bits in the whole compiler
	mk_supply#
	  = unsafeInterleaveIO (
		mk_unique   >>= \ uniq ->
		mk_supply#  >>= \ s1 ->
		mk_supply#  >>= \ s2 ->
		return (MkSplitUniqSupply uniq s1 s2)
	    )

	mk_unique = genSymZh		>>= \ (W# u#) ->
		    return (I# (w2i (mask# `or#` u#)))
    in
    mk_supply#