[Haskell] randomgen for foreign random functions
Simon PeytonJones
simonpj at microsoft.com
Mon Jun 28 03:59:24 EDT 2004
 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 sideeffecting 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#
More information about the Haskell
mailing list