- Haskell-Cafe - Haskell.org

Sequencing Operations in a Monad
by SevenThunders 22 Sep '07

22 Sep '07

I have a matrix library written in C and interfaced into Haskell with a lot of additional Haskell support. The C library of course has a lot of side effects and actually ties into the BLAS libraries, thus at the present time, most of the interesting calls are done in the IO monad. I have no intention of rewriting what I've done so far or using someone elses Matrix library. (Mine is tuned somewhat for my application). I attempted to extend my Haskell matrix interface using type classes (real and complex matrices) and have run into a conceptual problem. I would like to be able to use operator notation for matrix arithmetic. e.g. R = Q * (A + B) Unfortunately if I wrap my matrix references in the IO monad, then at best computations like S = A + B are themselves IO computations and thus whenever they are 'invoked' the computation ends up getting performed repeatedly contrary to my intentions. For example I might have some code like this, let S = A += B in do (r,c) <- size S k <- matindex S ..... code of this nature results in S being applied twice and if the operator += has side effects, those side effects will be applied twice. Even if there are no side effects the computation will unnecessarily be applied twice. What I need is a way to force a single execution of the IO action without losing the syntax sugar. If you arrange the types to try to do all the operations inside the IO monad you can't chain together more than 1 binary operation. eg. do S <- A + B Z <- Q * S vs do S <- Q * (A + B) Are there any suggestions for this dilemma? Am I using the wrong monad for this task? -- View this message in context: http://www.nabble.com/Sequencing-Operations-in-a-Monad-tf4446047.html#a1268… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

6 10

Re: [Haskell-cafe] reverse with foldl
by Miguel Mitrofanov 21 Sep '07

21 Sep '07

> reverse = foldl (\x -> \xs -> xs:x) [] Doesn't typecheck.

2 1

Interesting folds over bytestring lists?
by Justin Bailey 21 Sep '07

21 Sep '07

I have a data structure which is a list of bytestrings, but externally it looks like one big string. One of the operations I want to support takes a section of the string, starting at some arbitrary index and ending somewhere further down the line. In implementing the function I came up with the two functions below, dropTo and takeTo. In my mind, dropTo moves over the list of bytestrings until it reaches the starting point, and then returns the rest. takeTo, in contrast, scans over the list until it has seen enough bytes to return the amount requested. In both cases I am trying to share structure as much as possible in order to avoid unnecessary copying and space leaks. I thought these two functions were interested and am looking for feedback, comments, improvements, etc. Thanks! import qualified Data.ByteString as S import qualified Data.ByteString.Lazy as L import qualified Data.ByteString.Base as B import Test.QuickCheck import Data.List (foldl') import Data.Word dropTo :: Int -> [L.ByteString] -> [L.ByteString] dropTo _ [] = [] dropTo amt strs = let dropTo' :: (Int, [L.ByteString]) -> L.ByteString -> (Int, [L.ByteString]) dropTo' (rem, acc) ss | rem == 0 = (0, acc) | otherwise = let chunks = L.toChunks ss in case foldl' dropStricts (rem, chunks) chunks of (!n, rest) | null rest -> (n, drop 1 acc) | otherwise -> (0, L.fromChunks rest : drop 1 acc) dropStricts :: (Int, [S.ByteString]) -> S.ByteString -> (Int, [S.ByteString]) dropStricts (rem, acc) str | rem == 0 = (0, acc) | rem - S.length str == 0 = (0, drop 1 acc) | rem - S.length str < 0 = (0, S.drop rem str : (drop 1 acc)) | otherwise = (rem - S.length str, drop 1 acc) (_, rest) = foldl' dropTo' (amt, strs) strs in rest takeTo :: Int -> [L.ByteString] -> [L.ByteString] takeTo _ [] = [] takeTo amt strs = let countLazies :: (Int, Int, L.ByteString) -> L.ByteString -> (Int, Int, L.ByteString) countLazies (rem, !total, lazyLeftover) ss | rem == 0 = (0, total, lazyLeftover) | otherwise = let chunks = L.toChunks ss in case foldl' countStricts (rem, 0, S.empty) chunks of (!n, amt, strictLeftover) | S.null strictLeftover -> (n, total + 1, L.empty) | otherwise -> (n, total, L.fromChunks (take amt chunks ++ [strictLeftover])) countStricts :: (Int, Int, S.ByteString) -> S.ByteString -> (Int, Int, S.ByteString) countStricts (rem, !total, leftover) str | rem == 0 = (0, total, leftover) | rem - S.length str == 0 = (0, total + 1, S.empty) | rem - S.length str < 0 = (0, total, S.take rem str) | otherwise = (rem - S.length str, total + 1, S.empty) in case foldl' countLazies (amt, 0, L.empty) strs of (_, total, leftover) | L.null leftover -> take total strs | otherwise -> take total strs ++ [leftover] prop_dropToNonEmpty :: [[Word8]] -> Int -> Property prop_dropToNonEmpty strs amt = amt >= 0 && (all (not . null) strs) ==> all (not . L.null) (dropTo amt (map (L.pack) strs)) prop_dropToCorrect :: [[Word8]] -> Int -> Property prop_dropToCorrect strs amt = let lazyStr = L.drop amt64 (toLazyBS strs) amt64 = fromIntegral amt in amt >= 0 && (all (not . null) strs) ==> (L.concat (dropTo amt (map (L.pack) strs))) == lazyStr prop_takeToNonEmpty :: [[Word8]] -> Int -> Property prop_takeToNonEmpty strs amt = amt >= 0 && (all (not . null) strs) ==> all (not . L.null) (takeTo amt (map (L.pack) strs)) prop_takeToCorrect :: [[Word8]] -> Int -> Property prop_takeToCorrect strs amt = let lazyStr = L.take amt64 (toLazyBS strs) amt64 = fromIntegral amt in amt >= 0 && (all (not . null) strs) ==> (L.concat (takeTo amt (map (L.pack) strs))) == lazyStr -- Functions and instances for testing purposes toLazyBS :: [[Word8]] -> L.ByteString toLazyBS = L.concat . map L.pack instance Arbitrary Word8 where arbitrary = elements [minBound .. maxBound] coarbitrary = undefined main = do putStrLn "prop_takeToNonEmpty" quickCheck prop_takeToNonEmpty putStrLn "prop_takeToCorrect" quickCheck prop_takeToCorrect putStrLn "prop_dropToCorrect" quickCheck prop_dropToCorrect putStrLn "prop_dropToNonEmpty" quickCheck prop_dropToNonEmpty

4 5

Graphics.SOE
by Peter Padawitz 21 Sep '07

21 Sep '07

Can scrollbars be attached to windows created with openWindow?

1 0

Slightly Off-topic
by PR Stanley 21 Sep '07

21 Sep '07

Hi Does anyone know of a good active list for students and experts in discrete mathematics, in particular, logic? Thanks, Paul

1 0

Accumulator value for "and" and "or"
by PR Stanley 21 Sep '07

21 Sep '07

Hi or = foldl (||) False and = foldl (&&) True I can understand the rationale for the accumulator value - True && [] where [] = True and True || [] where [] = False Other than the practical convenience is there a reason for having the empty list in and and or equating to True and False? Thanks, Paul

4 3

How can I stop GHCi from calling "show" for IO actions?
by Ryan Ingram 21 Sep '07

21 Sep '07

Prelude> let inf = repeat 1 Prelude> inf [1,1,(lots of output until I press ctrl-c),Interrupted. (I expect this to happen) Prelude> let x = inf (no output here!) Prelude> :t x x :: [Integer] Prelude> return inf [1,1,(lots of output until I press ctrl-c),Interrupted. (I also expect this to happen) Prelude> y <- return inf [1,1,(lots of output until I press ctrl-c),Interrupted. (I do not expect this to happen here!) Prelude> :t y <interactive>:1:0: Not in scope: 'y' Is this a bug? Why does "y <- return exp" have different behavior than "let y = exp"? Is there a way to make GHCi not print the result of an action but still make my variables get bound? -- ryan

10 14

interaction between OS processes
by Andrea Rossato 21 Sep '07

21 Sep '07

Hi, there's something I don't get about interaction among OS processes and Haskell handles/channels. Suppose I have a very small program that takes a line and prints it till you write "quit": main = do s <- getLine case s of "quit" -> putStrLn "quitting" >> return () _ -> loop s where loop s = do putStrLn s main This is a small interactive process I would like to talk to from another Haskell program, like the following one which, indeed, is just a wrapper around the first. Now, if I write a single line with "quit", I get "quitting" back, otherwise the program doesn't work. I think I need some direction in order to understand how handles work. The same with channels, I'm afraid. Could you please point me in the right direction? Thanks for your kind attention. Andrea The not working code: import Control.Concurrent import System.Process import System.IO main = do c <- runInteractiveCommand "./main2" loop c loop c@(i,o,e,p) = do s <- getLine hPutStrLn i s hFlush i -- now "i" is closed, right? s' <- hGetLine o putStrLn s' loop c

5 11

reverse with foldl
by PR Stanley 21 Sep '07

21 Sep '07

Hi reverse = foldl (xs x . x:xs) [] (xs ++ ) = foldl (\ys y -> ys ++ [y]) xs If I were to define reverse with foldl I would do it this way: reverse = foldl (\x -> \xs -> xs:x) [] Any idea what the first code frag is suposed to achieve? Thanks, Paul

1 0

Re: [Haskell-cafe] What on earth
by PR Stanley 21 Sep '07

21 Sep '07

but ebook usually means a PDF which would be all right if the text didn't contain specialist symbols. The publishers weren't very helpful when I contacted them. According to the "lady" on the phone they didn't even have the latex source code. I'll probably try again. Hopefully this time I'll get someone more reasonable to deal with. Cheers, Paul At 00:51 21/09/2007, you wrote: >According to >http://www.cambridge.org/catalogue/catalogue.asp?isbn=9780511292187, >it is available as an ebook. Perhaps if you contact them and explain >that you have the paper version, they will send you an electronic copy >of it? > >Rodrigo > >On 20/09/2007, PR Stanley <prstanley(a)ntlworld.com> wrote: > > Hi > > tfoldr (-) 1 [4,3] > > = 4-3-(-1) > > = 2 > > A similar thing happens with foldr (/) 2 [8,2] = 8.0 > > I thought foldr \oplus v [] = v > > Any ideas? > > Thanks, Paul > > > > _______________________________________________ > > Haskell-Cafe mailing list > > Haskell-Cafe(a)haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-cafe > >

1 0