[Haskell-cafe] Sequencing Operations in a Monad
mattcbro at earthlink.net
Sat Sep 15 13:50:33 EDT 2007
> SevenThunders wrote:
>> Ryan Ingram wrote:
>>> As long as the FFI calls don't make destructive updates to existing
>>> matrices, you can do what you want.
>>> For example, assuming you have:
>>> -- adds the second matrix to the first & overwrites the first
>>> matrixAddIO :: MatrixIO -> MatrixIO -> IO ()
>>> -- creates a new copy of a matrix
>>> matrixCopyIO :: MatrixIO -> IO MatrixIO
>> Well as you point out there is an efficiency issue if we need to copy
>> matrices all of the time in order to insure 'referential transparency'.
>> Moreover I manage my matrices on a stack in C, since it makes it easy to
>> handle memory allocation and deallocation. The stack configuration tends
>> be highly fluid so there are always side effects going on. Right now my
>> Matrix type wraps the index from the bottom of the Matrix stack into the
> If you need destructive updates, you indeed need a monad. Otherwise, I'd
> use ForeignPtrs and import the matrix operations as pure functions (~
>> I was just wondering if there was any obvious way to force an IO action
>> execute only once, since now each reference to the action IO causes it to
>> execute again.
> Isn't that simply
> x <- onlyOnce
> mult x x
> onlyOnce :: IO Int
> mult :: Int -> Int -> IO Int
> If you want
> mult = liftM2 something :: IO Int -> IO Int -> IO Int
> you can
> x' <- onlyOnce
> let x = return x'
> mult x x
> which is
> x <- return `liftM` onlyOnce
> mult x x
> for short.
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
I think you are right. This is about my only choice. All 'computations'
must first occur inside the monad.
For a binary operation that kind of implies a type signature of the form,
-- matrix multiplication, integer indices into Matrix stack
(*.) :: Int -> Int -> IO (Int)
(+.) :: Int -> Int -> IO (Int)
But what if I want to do something like a *. ( c +. d) ? Well I'll have
to live with
s <- c +. d
p <- a *. s
Unless I additionally define an multio multiplication operator
(multio) :: Int -> IO(Int) -> IO(int)
so that I can do
s <- a `multio` (c +. d)
View this message in context: http://www.nabble.com/Sequencing-Operations-in-a-Monad-tf4446047.html#a12692293
Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.
More information about the Haskell-Cafe