[Haskell-cafe] Linking to third party libraries in windows

[Brian Hulley]

Dear friends -
I must have clicked "reply" instead of "reply all" so here is the reply 
haskell cafe would have received:

 Matthew Bromberg wrote:
> Not only does your suggestion make more sense than what I was doing,
> but also
> it causes the 'matrices' to behave as expected, namely to have the
> side effects
> incorporated into their array values.
>
> I can't say I fully understand why this is true.  In both cases I was
> wrapping Rmatrix in
> a monad after every computation.  The difference is that the array
> component  had an
> additional monad wrapper around and now it doesn't.  That is,
>
> old case
> newtype Rmatrix = Rmatrix (Int, Int,  IO(StorableArray Int CDouble))
>
> new case
> newtype Rmatrix = Rmatrix (Int, Int,  StorableArray Int CDouble)
>
> In the old way, the additional IO wrapper forces an additional
> nesting of do loops for most processing.

 This is the essential difference, but I think you haven't quite
understood what it means.
When you say

> The difference is that the array component  had an
> additional monad wrapper around and now it doesn't.

 this is not correct. IO (StorableArray Int CDouble) is a monadic
*value* itself, which represents an *action* which returns a storable
array, and since you are filling in the slot in Rmatrix with the
action (newListArray a l), this monadic value represents the action
of creating a new array whenever the action is executed.

 Whereas (StorableArray Int CDouble) is the actual array itself.

 You could also use your old definition of Rmatrix but change the way
 it is created eg:

 listtoRmatrix r c es = do
      arr <- newListArray (0, r * c) es
      return (Rmatrix r c (return arr))

 do
      r2 <-  listtoRmatrix 3 2 [1, 1, 1, 1, 1, 1]
      -- the rest is old code

 and everything would work as expected, because in this case, the
monadic action contained in Rmatrix just returns the array arr that
was created in the execution of  listtoRmatrix 3 2 [1, 1, 1, 1, 1,
1], because listtoRmatrix is the only place where the action of
creating a new array, ie (newListArray (0, r * c) es) is actually
executed.

 I think the subtlety is one of these things that's very difficult to
understand at first, but once you've grasped the fact that in Haskell
expressions can evaluate to actions which are themselves values, and
which in turn can create new values when executed, it will hopefully
become a lot clearer.

 Regards, Brian.

-- 
Logic empowers the living and justifies the dead.
But societal laws, and religious dogma,
empower the dead,
to destroy what's living.

http://www.metamilk.com