June 2003 - Haskell-Cafe

Re: Haskell-Cafe digest, Vol 1 #730 - 5 msgs
by Mark Espinoza 23 Jun '03

23 Jun '03

2 1

RE: Assembling lists start-to-end
by Hal Daume 21 Jun '03

21 Jun '03

sorry, forgot to send this to the list: Another way to do it is to use accumulating lists. As a simple example, let's consider: > myf p l = reverse (filter p l) (myf Char.isUpper "Hello Cruel World" ==> "WCH") that is, it returns elements of a list which match the predicate in reverse order. we could write this very slowly using explicit recursion as: > myf2 p [] = [] > myf2 p (x:xs) > | p x = myf2 p xs ++ [x] > | otherwise = myf2 p xs but traversing the recusive list is very slow. we might induce tail recursion in something like: > myf3 p l = myf3' l [] > where > myf3' [] acc = acc > myf3' (x:xs) acc = myf3' xs (x:acc) Now, the accumulator 'acc' holds the value we're going to return at the end. So this is pretty much what you want. Now, suppose we're just doing filter without the reversing, but we still want it to be tail recursive. We might think we have to write: > myf4 p l = reverse (myf3' l []) (where myf3' is as before) this is not so. We can have fun with function composition. What we do is change the accumulator from a list to a function from a list to a list. > myf4 p l = myf4' l id > where > myf4' [] acc = acc [] > myf4' (x:xs) acc > | p x = myf4' xs (\l -> acc (x:l)) > | otherwise = myf4' xs acc here, we start out the accumulator as the identity function. to add an element to it, we make a function which takes the old list, adds 'x' to the front and then applies the accumulator. in the base case, we simply apply the empty list to the accumulator function. the second-to-last line can be rewritten a bit more conveniently as: > | p x = myf4' xs (acc . (x:)) the neat thing about this is that you can easily change the way the list goes. as it is, we have filter, but if we flip the order for (.), as in: > | p x = myf4' xs ((x:) . acc) then we get (reverse . filter). HTH - Hal -- Hal Daume III | hdaume(a)isi.edu "Arrest this man, he talks in maths." | www.isi.edu/~hdaume > -----Original Message----- > From: haskell-cafe-admin(a)haskell.org > [mailto:haskell-cafe-admin@haskell.org] On Behalf Of Mark Carroll > Sent: Saturday, June 21, 2003 5:39 AM > To: haskell-cafe(a)haskell.org > Subject: Assembling lists start-to-end > > > I am assembling a list from start to end. I can add elements > to the end > with "previous ++ [current]" or I can add them with "current > : previous" > and reverse it when I'm done. Or, maybe I should use some other data > structure. (I don't know the length in advance.) Any thoughts? > > -- Mark > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

1 0

IO system
by naudts guido 21 Jun '03

21 Jun '03

Hallo, Take following function: f::Array Int Char -> (Array Int Char, Char) f array = (array1, c) where c = array!1 array1 = array//[(2,'b')] and also following function: f::Direct_access_file -> (Direct_access_file, Char) f daf = (daf1, c) where c = getnext daf daf1 = set 2 'b' with a hypothetical format for the direct access file. Now I can certainly implement the first function in Haskell but not the second. Now the only difference between the two functions is the location of the data: in the first the data of the array are in RAM, in the second the data of the direct access file are on disk. There is no other difference. As far as referential integrity is concerened I don't see any difference too. So why can I implement the first function and not the second (well I can use direct access files but I have to change the type of my function.The problem is: I do not see why the location of data should have an influence here. Greetings, __________________________________ Do you Yahoo!? SBC Yahoo! DSL - Now only $29.95 per month! http://sbc.yahoo.com

3 2

Using an accumulator, "iterating"...
by Brett Kelly 21 Jun '03

21 Jun '03

Hello all, I'm trying to write a function that takes a list and a element (same type) and returns the index of the first instance of the element in the list. like: getindex "brett" 'e' would return 2, etc. i'm trying to accomplish this using an accumulator, here's what i've got: pyindex :: Eq a => a -> [a] -> Maybe Int pyindex c l = pyindex' 0 chr (x:xs) where pyindex' count chr (x:xs) = do if x == chr then return count else pyindex' (count + 1) chr xs now, i know i've got a syntax problem, because i'm pretty sure my logic is correct (or at least MOSTLY correct). can anybody see what's wrong with my stuff? thanks! -- Brett Kelly bkelly(a)sourcereview.net This message has been digitally autographed using GnuPG. Vim - this ain't your daddy's text editor http://www.vim.org

5 6

Assembling lists start-to-end
by Mark Carroll 21 Jun '03

21 Jun '03

I am assembling a list from start to end. I can add elements to the end with "previous ++ [current]" or I can add them with "current : previous" and reverse it when I'm done. Or, maybe I should use some other data structure. (I don't know the length in advance.) Any thoughts? -- Mark

3 2

RE: Help: Stack-overflow and tail-recursive functions
by Hal Daume 20 Jun '03

20 Jun '03

> GHCi didn't have any problem even with the original code. mine didn't either, until I increased the "200" to around "1500"...it's probably OS/memory specific.

2 1

Help: Stack-overflow and tail-recursive functions
by Koji Nakahara 20 Jun '03

20 Jun '03

Hi I've written a function that is tail-recursive and takes a list(queue) as one of its arguments. However the function fails because of "Stack space overflow"(GHC) or "ERROR - Garbage collection fails to reclaim sufficient space"(hugs). For example (simplified), both of these results in stack-overflow: f1 100000 [0,1,2], and even f2 100000 [0,1,2], where, f1 0 l = l f1 n l = f (n-1) $ take 3 $ l ++ [0,1] f2 0 l = l f2 n l = f2 (n - 1) $! (take 3 $ l ++ [0,1]) Why f2 overflows? How to avoid this stack-overflow?

1 1

Re: Help: Stack-overflow and tail-recursive functions
by oleg＠pobox.com 19 Jun '03

19 Jun '03

It seems the problem is indeed in rmat: > rmat n = listArray ((1,1),(n,n)) $ map ct (randoms (mkStdGen 1) ::[Bool]) > where ct True = Unknown > ct False = Dead To be more precise, the problem is in randoms. If you replace rmat with the following rmat n = array ((1,1),(n,n)) $ zipWith (\ind v -> v `seq` (ind,v)) [(i,j) | i<-range, j<-range] $ map ct (randoms (mkStdGen 1) ::[Bool]) where ct True = Unknown ct False = Dead range = [1..n] then > main = putStrLn $ show $ forpaintbdry $ rmat 400 computes without problems (compiled with GHC 5.04.1, no flags). BTW, GHCi didn't have any problem even with the original code.

1 0

RE: Help: Stack-overflow and tail-recursive functions
by Hal Daume 19 Jun '03

19 Jun '03

The problem here is actually in the rmat function, not the forpaintbdry or whatever. The problem is that, afaik, the listArray function doesn't deforest the list argument (someone can correct me here, though). That is, you write: rmat n = listArray ... [a big list] and then this list is first built, then the array is filled in. You can see that this is a problem by replacing your main with: main = print (m ! snd (bounds m)) where m = rmat 800 This will stack overflow too. Solution: use mutable arrays and fill them in by hand :). -- Hal Daume III | hdaume(a)isi.edu "Arrest this man, he talks in maths." | www.isi.edu/~hdaume > -----Original Message----- > From: Koji Nakahara [mailto:yu-@div.club.ne.jp] > Sent: Wednesday, June 18, 2003 7:41 PM > To: Hal Daume; haskell-cafe(a)haskell.org > Subject: Re: Help: Stack-overflow and tail-recursive functions > > > On Wed, 18 Jun 2003 17:36:28 -0700 > "Hal Daume" <t-hald(a)microsoft.com> wrote: > > > Note that there is essentially no difference between f1 and > f2. When > > you $! in f2, all it does is ensure that the argument isn't > undefined. > > It doesn't evaluate any of the list. Try $!! from the > DeepSeq module or > > write your own list-forcing function. > > Thank you very much. I understand. > > However my original program still (or maybe from the > beginning) stack-overflows > at another point, in the middle of the evaluation of "forpaintbdry". > > Please give me some advice. > ----------- > -- snippet of the program for painting a random matrix from > its boundary. > module Main where > import System > import Random > import Array > import Ix > import List > > main = putStrLn $ show $ forpaintbdry $ rmat 200 > > forpaintbdry m = [(pos, Live) | pos <- (uncurry bdryidxlist) > $ bounds m , isUnknown $ m ! pos ] > > bdryidxlist :: (Int, Int) -> (Int, Int) -> [(Int, Int)] > bdryidxlist (a1, a2) (b1, b2) = nub $ [(ab, j) | ab <- [a1, > b1], j <- [a2..b2]] ++ > [(i, ab) | ab <- [a2, b2], i <- > [a1..b1]] > > rmat n = listArray ((1,1),(n,n)) $ map ct (randoms > (mkStdGen 1) ::[Bool]) > where ct True = Unknown > ct False = Dead > > data CellColor = Live | Unknown | Dead > > isUnknown Unknown = True > isUnknown _ = False > > instance Show CellColor where > show Live = "Live" > show Unknown = "Unknown" > show Dead = "Dead" > >

1 0

RE: Help: Stack-overflow and tail-recursive functions
by Hal Daume 18 Jun '03

18 Jun '03

Note that there is essentially no difference between f1 and f2. When you $! in f2, all it does is ensure that the argument isn't undefined. It doesn't evaluate any of the list. Try $!! from the DeepSeq module or write your own list-forcing function. For me, the following works: f1 0 l = l f1 n l = f1 (n-1) $!! (take 3 $ l ++ [0,1]) f $!! x = force x `seq` f x where force [] = () force (x:xs) = x `seq` force xs whereas it doesn't without the $!!. -- Hal Daume III | hdaume(a)isi.edu "Arrest this man, he talks in maths." | www.isi.edu/~hdaume > -----Original Message----- > From: haskell-cafe-admin(a)haskell.org > [mailto:haskell-cafe-admin@haskell.org] On Behalf Of Koji Nakahara > Sent: Wednesday, June 18, 2003 5:18 PM > To: haskell-cafe(a)haskell.org > Subject: Help: Stack-overflow and tail-recursive functions > > > Hi > > I've written a function that is tail-recursive and takes > a list(queue) as one of its arguments. > However the function fails because of > "Stack space overflow"(GHC) or "ERROR - Garbage collection > fails to reclaim sufficient space"(hugs). > > For example (simplified), both of these results in > stack-overflow: f1 100000 [0,1,2], and even f2 100000 [0,1,2], > > where, > f1 0 l = l > f1 n l = f (n-1) $ take 3 $ l ++ [0,1] > > f2 0 l = l > f2 n l = f2 (n - 1) $! (take 3 $ l ++ [0,1]) > > Why f2 overflows? > > How to avoid this stack-overflow? > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskel> l-cafe >

2 1