November 2002 - Haskell-Cafe

producing and consuming lists
by Jorge Adriano 06 Nov '02

06 Nov '02

I might have been not very clear in my last mail. I decided to post again, and go straight to the point, with some small examples. Consider the following function streams. streams :: (Int->Bool, Int->Bool)->(Int, Int)->([Int],[Int]) streams (p,q) (x,y) = (xs',ys') where (xs,ys) = streams (p,q) ((x+y),(y-x)) xs' = if p x then x:xs else xs ys' = if q y then y:xs else ys - produces a pair of ('infinite') lists - produced lists are not indepentent (you need to calculate elements of one list to calculate elements of the other) - in each recursive call an element is added to the 1st/2nd list iff it satisfies a given (Int->Bool) function p/q How should one consume (part of) both lists, avoiding space leaks? A particular example of consuming both lists might be writing them to files: main :: IO() main = do let (s1,s2)=stream ... -- stream applied to some arguments (p,q) (x,y) p' = ... q' = ... writeFile "f1.txt" (show$ takeWhile p' s1) writeFile "f2.txt" (show$ takeWhile q' s2) In this example all elements of s2 required to evaluate (takeWhile p' s1) are kept in memory, until the first file is writen. Notice that writing one element from s1 and one from s2 successively might still cause space leaks to arise. Fusing the consuming functions with the producer is a possible, but IMO dirty, way out. If my question doesn't seem to make sense for any reason, please tell me, maybe I am missing something obvious here. Thanks, J.A.

3 6

GUI Library for Visualizing Data
by Peter Simons 06 Nov '02

06 Nov '02

Hi, the Haskell language is fairly new to me, so please pardon me if this is a frequently asked question, but I wasn't able to find an answer myself. I'm looking for a library that allows me to visualize data under X11 screen, for instance as a pie chart or as a bar chart. I seem to recall that something like that was available for the GTK toolkit, but has this library been ported to Haskell? Or any other library? I'd appreciate any pointers! -peter

5 6

Job
by Mark Carroll 05 Nov '02

05 Nov '02

The company I'm involved with - Aetion, a tiny defense contractor in Columbus, Ohio - will likely be wanting to hire an affordable Haskell programmer before the end of the year. So, on the offchance that any of you guys are be interested, or know of someone who might be, feel free to e-mail me for more information or to supply your resume. Unfortunately, the nature of the work is such that US citizenship or a security clearance would help, and telecommuting isn't really an option. On the upside, the work should be varied and interesting - more challenging than mundane. (I wonder if I should mention this in comp.lang.functional, too.) For the next Haskell communities report thing in a few months, I'll try to say a bit about what we're up to. (-: At this stage, we're just starting, so there's little to say. -- Mark

2 1

streaming, state, etc...
by Jorge Adriano 03 Nov '02

03 Nov '02

Hi, OK so I had completed my (search) algorithm implementation. And the 'last' function was something like: "until p f x0". But now I wanted all iterations, I wanted to analyze the behavior of the algorithm. What could I do? I thought about using Trace... but it didn't seem adequate, I wanted to manipulate and use that info... maybe monads... that would cluter my algorithm so bad... This feeling lasted for a few seconds, then I thought, Lazy Evaluation! "iterate p f x0" There, done :) I had an infinite list, and I'd just take as much as I wanted. *Analysis* and the *algorithm* itself were *completely separated*, yet it was using the information as soon as it was calculated - or maybe "it was being calculated only when it was needed". I could not do this kind of stuff in imperative languages. Very nice :) ------------ Problem 1: ------------ I've used that many times since then, but lately it doesn't really seem to serve my needs. What if I need to get two different kinds of data, say (list1, list2), and now I want to write them: writeFile file1 (analyze list1) writeFile file2 (analyze list2) What if you need to evaluate list2 to evaluate list1? Not good! I'm evaluating list2 and not consuming it, therefore space leak. I could alternate between one list and another, but what if at a certain point, evaluating the next elem in "list1" caused the evaluation of a few thousand elements of "list2"? So how do you usually deal with this kind of stuff? Concurrency?? ------------ Problem 2: ------------ Yes "iterate p f x0" looks good. What if function "f" is not a pure one? If my monad is a Lazy one, streaming can be used(*), if it is not, that won't work. So streaming could work with monads like State, (lazy) ST. Not with IO, or (lazy) ST. (*) do list<-myalgorithm writeFile file1 (analyze list) So, how do you usually do this kind of thing - extracting lists of info from an algorithm? J.A.

1 0