Hi,
This possibly might go against the spirit of what Stream programming is
about but I having difficulties converting an imperative algorithm [1]
into Haskell and think it would be easier if I was able to write it in a
monadic style with operations to read and write from and to the streams.
I first tried to approach it by delving into the innards of other Stream
functions to devise what I needed. I only got so far and the sticking
point was defining the Monad. I then approached it from the Monad side
and although what I have is workable, it probably isn't going to perform
(for one it uses fromStream and tailS on each read off the front of the
stream).
So:
1. Is this monadic style within the spirit of what Stream programming is
about?
2. Is there anyway to do this more elegantly and without the user of
fromStream and tailS, for example.
This is the workable solution I have:
module StreamMonad where
import Data.Array.Parallel.Stream
import Data.Monoid
import Control.Monad.Writer
import Control.Monad.State
instance Monoid (Stream a) where
mempty = emptyS
mappend = (+++)
type SM a b c = StateT (Stream a) (Writer (Stream b)) c
readS :: SM a b a
readS = do
s <- get
let a = head $ fromStream s
put $ tailS s
return a
writeS :: b -> SM a b ()
writeS x = tell $ singletonS x
t1' :: SM (Int,Int) Int ()
t1' = mapM_ (\_ -> do
(x,y) <- readS
writeS x
writeS y) [1..2]
t1 = fromStream $ snd $ runWriter $ runStateT t1' $ toStream [(1,2),(3,4)]
-- At least this works ..
t2 = fromStream $ snd $ runWriter $ runStateT t1' $ toStream
[(2*x-1,2*x) | x <- [1..] ]
Cheers
Mark
[1] The arithmentic coding and decoding algorithms given in
http://mattmahoney.net/dc/dce.html#Section_32
_______________________________________________
Haskell-Cafe mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/haskell-cafe
