00:02:35 --- log: started haskell/01.12.31 00:02:35 --- quit: clog (Leaving) 00:02:35 --- log: stopped haskell/01.12.31 00:03:04 --- log: started haskell/01.12.31 00:03:04 --- join: clog (nef@bespin.org) joined #haskell 00:03:04 --- topic: 'spooky. quiet. | we be loggin' http://tunes.org/~nef/logs/haskell/ | welcome to the Haskell Dojo' 00:03:04 --- topic: set by shapr on [Sun Dec 30 06:56:21 2001] 00:03:04 --- names: list (clog teek dennisb smklsmkl jlb pHa xbill sjanes71) 00:23:08 --- join: julien (~julien@uu212-190-122-70.unknown.uunet.be) joined #haskell 00:23:23 hi all 00:37:47 --- join: shapr (~user@p-c2fbaba8.easy.inet.fi) joined #haskell 00:40:34 Hi shapr 00:40:42 hi julien! 00:40:43 what's up? 00:41:10 I compiled my first Haskell program with ghc :-) 00:41:15 yay! 00:41:27 (I was missing the -package option for 2 weeks ...) 00:41:56 No I'm ready to try serious things 00:42:06 yah, I'm still finding lots of stuff myself 00:42:33 --- topic: set to 'spooky. quiet. | we be loggin' http://tunes.org/~nef/logs/haskell/ | welcome to the Haskell Dojo | shapr is a white belt!' by shapr 00:42:51 sounds like you're up to white belt also! 00:43:08 yes :-) 00:43:11 --- topic: set to 'spooky. quiet. | we be loggin' http://tunes.org/~nef/logs/haskell/ | welcome to the Haskell Dojo | julien and shapr are up to white belt!' by shapr 00:43:23 :-) 00:44:11 I've been working on cleaning up a very old example program 00:44:13 a haskell shell 00:44:32 hmm, is it usable ? 00:44:50 http://kungens.kemi.fi/~shae/Hsh4.hs 00:45:53 I converted the direct word to word changes, and dennisb and xbill helped me with the stuff I had no clue about. 00:46:02 it works, but it doesn't *do* anything yet 00:46:10 :) 00:46:50 There is a lot to learn from that (for me at least ...) 00:47:20 http://kungens.kemi.fi/~shae/Hsh.hs 00:47:26 ok, that's the latest version 00:48:15 yah, lots to learn for me also 00:51:11 hey, I was having fun experimenting in ghci 00:51:20 have you found the [1..5] notation? 00:52:10 Yes, but I don't remember where ... 00:52:26 it just turns into [1,2,3,4,5] 00:52:30 an example like fac n = product [1..n] or sth like that 00:52:30 you can also do [1..] 00:52:37 and that gives you all integers 00:52:38 right 00:52:41 that where it becomes funny :) 00:53:02 I love lazy evaluation 00:53:09 yah, me too 00:54:45 so I did: 00:54:59 map (+1) [1..5] 00:55:14 filter (>3) [1..5] 00:55:29 let x = map (+1) . filter (>3) 00:55:34 x [1..5] 00:55:43 :) 00:55:49 map (+1) . filter (>3) [1..5] 00:55:58 you can play a long time like that 00:56:03 and that last line exploded 00:56:10 I found out that I have to do: 00:56:17 map (+1) . filter (>3) $ [1..5] 00:57:11 I remembered that function application is the tightest binding operation 00:57:19 yah, ghci is fun 01:07:56 --- quit: teek ("2.8.2-EPIC3.004+Kasi -- just do it.") 01:13:05 * shapr reads Simon Thompson's book 01:15:45 hm, I bet I could change my Mandelbrot.hs to use iterate 01:26:23 I wonder how I could build iterateWhile 01:39:43 hrrrm 01:39:46 what am I doing wrong? 01:39:51 until (>5) iterate (+1) $ [1] 01:40:33 oh! 01:40:39 aha 01:40:49 iterate returns an infinite list of repeated applications 01:40:50 duh 01:42:41 hm 01:42:48 what do you want to do? 01:43:38 I'm trying to build an iterateWhile 01:43:47 and I know I should be able to do this :) 01:44:01 well, the iterate gives a list of results 01:44:04 I think I shouldn't be using iterate 01:44:22 I just want to keep re-applying a function to its own result until a condition is true 01:44:28 maybe it's just until you want? 01:44:28 which I am doing in Mandelbrot.hs 01:44:33 maybe so 01:44:45 until (>4000) (*2) 2 01:45:00 I thought there might be some kind of apply until 01:45:25 how would I do something like "until length (>6) take [1..10]" 01:45:29 --- join: teek (ttkurppa@kruuna.helsinki.fi) joined #haskell 01:45:30 until performs the function on the argument util the first predicate returns true 01:46:06 shapr: I don't understand myself what the result would be 01:46:27 I was hoping to do something until the returned list is longer than 6 01:46:33 hi teek 01:47:45 i'm not sure how.. 01:48:25 nor am I 01:48:27 take is not something you can just apply many times on the list 01:48:41 oh 01:49:35 hm 01:49:42 until ((>6 ) . length ) iterate (+1) 1 01:49:45 hmm 01:49:57 the function to iterate must have type a->a, so you can call it over and over again 01:50:05 oh 01:50:19 so it should be (+) 01:50:30 plus takes two arguments 01:50:36 (+1) is okay 01:50:47 takes a number, gives a number 01:51:21 iterate (+1) 1 01:51:23 that works 01:51:25 iterate (+1) 1 woule run the plus one function over and over again starting on the 1 01:51:27 very quickly ;) 01:51:38 yah, 30523 before I could interrupt it 01:51:44 that's the list of all numbers starting from one 01:51:49 right 01:51:56 so I want to do that until a condition is met 01:52:08 then use dropWhile 01:52:31 (might even be better functions, I don't rember them all) 01:52:38 dropWhile (length < 6) iterate (+1) 1 01:53:07 no 01:53:17 look at the type (use :t drowWhile) 01:53:22 (use :t dropWhile) 01:53:30 hm 01:54:00 it looks on each element in the list and drops as long as the predicate says yes 01:54:01 ohhh 01:54:21 *each element* not *the entire list* 01:54:25 that's what I was missing 01:54:29 lenght < 6 is something strange 01:54:42 well, I thought it was operating on the returned list 01:55:08 the entire list is just simple, take 5 [1..] will take the first five elements 01:56:04 for fractals I guess you want se how many iterations until it's below a special number or something? 01:56:08 right 01:56:22 I have a function oneIter 01:56:33 so, iterate the function on the start value, that will give you the list of all intermediate values 01:56:48 I want to do that function on the result of the last time I ran that function, until something happens 01:57:05 yes, sounds like iterate 01:57:21 iterate oneIter start 01:57:48 but after I've done one point, I only want to know how many times it iterated 01:58:44 iterate oneIter start, that should give the infinite list of all the values in the serie 01:58:56 then you just do takeWhile followed by length 01:59:06 oh 01:59:17 that sounds much more elegant than what I've been using, thanks! 01:59:32 lazy lists are great... 01:59:51 hi teek! 01:59:53 but maybe there is even better ways 02:00:17 hi, I just popped in, and saw you talking 02:00:30 yah, we're here and learning :) 02:00:35 I'm up to while belt! 02:01:07 --- quit: smklsmkl (Remote closed the connection) 02:01:37 --- quit: julien (carter.openprojects.net irc.openprojects.net) 02:01:59 --- join: smklsmkl (~sami@glubimox.yok.utu.fi) joined #haskell 02:01:59 --- join: julien (~julien@uu212-190-122-70.unknown.uunet.be) joined #haskell 02:02:29 dennisb, you meant something like: length . takeWhile pred $ iterate oneIter start 02:02:53 did you ? 02:02:54 something like that 02:03:28 if it works, that's what I meant :-) 02:03:34 * shapr grins 02:03:52 findIndex might work fine to 02:04:00 never heard of that one 02:04:06 shapr, what are you trying to do ? 02:04:24 I'm still not completely comfortable with using the . and $ operators 02:04:29 I think I realize what they do 02:04:35 findIndex pred (iterate oneIter start) 02:04:51 gives the index where the predicate is true 02:04:54 teek: I'm trying to clean up this code I wrote: http://kungens.kemi.fi/~shae/Mandelbrot.hs 02:05:15 or rather, maybe gives an index 02:06:46 what you want to make sure is that the list is not built up by the compiler, it should run in constant space 02:07:47 * shapr blinks 02:07:53 --- join: Verbed (verbed@24.70.83.145) joined #haskell 02:07:54 but it probably will do that in this case. But this is where the biggest problem with lazy evaluation is, it's hard to know when things are done 02:08:02 hi Verbed! 02:08:07 Hi! 02:08:20 welcome to the #haskell channel, have you been here before? 02:08:26 Nope, first time. 02:08:35 cool! 02:09:05 are you learning Haskell? Or maybe a long-time user? 02:09:14 dennisb, what do you mean by "list is not build up by the compiler" 02:09:31 dennisb: yah, is there some way to figure out when the list gets built? 02:09:45 shapr: Actually, I've really only glanced at it's specifications, but I've had a recent fascination with functional languages in general 02:09:55 I'm just hear, hopin' to eavesdrop on an interesting conversation.. 02:10:11 s/hear/here 02:10:22 Verbed: have you done much procedural or other programming before? 02:10:25 Although, that WAS a pre-emptive pun. 02:10:32 heh :) 02:11:16 My tool of choice has always been C, and recently, a Python mix. 02:11:26 I have to admit, I really didn't know anything else existed 02:11:34 I've been using Python for several years 02:11:35 Until I stumbled upon O'Caml 02:11:37 How about you? 02:12:27 teek: it really should trow away the first part of the list as soon as it have computed the next number, you don't want to build the list and keep all the old ones in memory until you find what you want and then free the whole list so far 02:12:34 s/trow/throw 02:12:36 I do Java professionally, though I mostly design and prototype in Jython 02:12:51 I find Python much saner than any other procedural language 02:13:02 dennisb: ah, that's what you meant 02:13:15 right, because memoization is not needed in this case 02:13:17 dennisb: ok, but is that possible, i.e. if i take composition of length and takeWhile ? 02:13:21 but it's hard to know such things since compiler optimization can make a difference 02:14:00 dennisb, do you mean that compiler _should_ figure out that, or that ghc or whatever actually does that ? 02:14:11 but usually, if you make sure that you don't keep a reference to the whole list, for example to do some more calculations afterward it usually works fine 02:14:13 Verbed: I realized that functional programming existed, but only recently did I choose to learn it. 02:14:44 Verbed: so far, I've written a Mandelbrot.hs, and I've persuaded other people on #haskell to help me clean up a very old bit of example code, Hsh.hs 02:15:15 http://kungens.kemi.fi/~shae/Mandelbrot.hs and http://kungens.kemi.fi/~shae/Hsh.hs 02:15:18 oh yes, so no memoization, and it works that way. Finally something from Persistent Data Structures seminar pops in my mind 02:15:30 I should probably make a haskell folder... 02:15:41 whoa, I want to have that seminar 02:15:53 shapr: Hrmm, I'm googling on Mandelbrot 02:15:54 if you for example also do the iterate bla bla and get a list in xs, then if you do y = sum (take 6 xs) as well as the normal takeWhile the system will keep the xs list in memory 02:16:04 Verbed: it's just the most basic fractal 02:16:29 if you look at the code, it has a text graph at the top 02:16:30 if you need the y later it will start calculating the sum, that means the list must be kept 02:16:36 I'm sure it will look familiar 02:16:59 but it will not start calculating until you need y since it's lazy, so it will keep xs for a long time 02:17:49 this is what is called a memory leak in haskell, you will keep maybe a long list xs just so you can calculate that sum in the future, if you calculate it now it can then throw away the list 02:18:08 Verbed: you'll probably find much of the Mandelbrot.hs readable, even if you've not read much at all about Haskell 02:18:11 dennisb, yep, now i start to remember. 02:18:16 * dennisb is not explaining well now 02:18:50 right now my code is passing around IterationCount 02:18:55 in our case I think it will work, but very small changes can make a big difference on the space usage 02:19:00 so the last calculation isn't saved at all 02:19:49 in cases like this you usually force the evaluation of the sum using a seq and then the y will be a single number and the xs is not needed more 02:20:09 lazy evaluation is tricky 02:20:14 can you give an example? 02:20:23 even something trivial showing the difference would help me 02:20:28 yes 02:20:32 let me think 02:20:34 for example, I demonstrated $ to myself with: 02:20:44 map (+1) [1..5] 02:20:51 filter (>3) [1..5] 02:21:04 dennisb: yep, you can prototype quickly with lazy evaluation, but have to spend time with optimization 02:21:19 let myfunc = map (+1) . filter (>3) 02:21:25 myfunc [1..5] 02:21:34 but I noticed I have to use: 02:21:36 teek: exactly, but I don't think it's that much harder then to debug other programs 02:21:45 map (+1) . filter (>3) $ [1..5] 02:21:51 Verbed: do you have a ghci running? 02:21:58 dennisb, yep, i think it's much better this way. 02:22:05 let xs = iterate (+1) 1 02:22:06 y = sum (take 5 xs) 02:22:06 in do print (drop 10000 xs) 02:22:06 print y 02:22:14 (i think this will show it) 02:22:27 xs is an infinite list, y is a number depending on xs 02:22:50 it's lazy so y will not be calculated until the end where it is printed 02:23:18 shapr: I shall compile it when I am finished with Hugs. I joined expecting an idle channel :) 02:23:19 (hmm, the first print is wrong, should be head also) 02:23:49 but the first print drops elements in the list, but we must still keep the beginning of the list since it's needed by y 02:24:18 it it was not needed by y when we do the drop, the system can throw away the beginning of the list 02:24:31 yeah, I understand, and if we calculated it immediately, we could throw away elements while dropping 02:24:40 so, since eval of y is lazy we must keep xs 02:24:40 Verbed: well, whichever one works for you.. hugs or ghc 02:24:52 yes, forcing y would do that 02:25:02 Verbed: hugs is probably better for learning 02:25:16 how forcing is done ? 02:25:22 (now the compiler might optimize and do that anyway, but) 02:25:30 teek: using the seq function 02:26:06 but this is the most tricky part about haskell as I see it 02:26:38 part of the power of haskell is that normally you don't enforce order of operations 02:26:50 so the compiler/runtime has more opportunities to optimize it 02:27:09 so when you have to order things, it's harder... 02:27:15 at least, this is how I see it so far 02:29:55 yes, for most thing it works okay anyway, and if it dont you analyse and fixes leaks like this 02:30:19 usually you can use the heap profiler to see how the memory is used 02:31:08 I looked at http://www.haskell.org/onlinereport/basic.html#sect6.2 about seq 02:31:42 teek: okay 02:31:45 but don't get it properly. How should I use it in our case 02:32:02 a = sum (take 5 xs) 02:32:07 y = seq a a 02:32:09 or what ? 02:32:20 why there's two parameters 02:32:49 you can change the first print to seq y (print (head (drop 10000 xs))) 02:33:03 it will force the y to an integer and perform the print 02:33:38 if yu hide the seq inside of y it will not be done until you use y anyway 02:34:36 okay, so it's kind of "dummy" function that enforces the first parameter to be evaluated and returns second 02:34:40 yes 02:34:46 exactly 02:37:39 I always seems to get into talking about seq, it probably because I don't like people trying to hide hard parts and instead I sort of always talks about the hard part... :-) 02:37:54 and if I wanted, i could write y = sum $! take 5 xs and take 5 xs would be evaluated. 02:38:12 oops. no. because y isn't used yet 02:38:31 yes, y is not used and needs not to be evaluated 02:38:37 Well, I'm going to idle for a bit, but it's nice to know this channel is somewhat active 02:38:47 How often is it like this? 02:38:53 Verbed: once a day or something :-) 02:39:11 you got here in the exact right moment 02:39:25 Well, it was certainly surprising :P 02:39:50 now it's probably another 24h of silence... 02:39:54 Verbed, i'm first time chatting here although i been lurking for some days 02:40:07 but I just keep this channel open, just in case 02:40:57 #ocaml seems to be silent also, even more than #haskell 02:41:39 well, we are not that many that chat here either, it's mostly shapr that keeps it up 02:41:48 heh, thanks :) 02:41:55 I try 02:42:04 I figure if I talk enough I can jumpstart this channel. 02:42:31 with the help of everyone else of course 02:42:58 shapr, that's seems to be the only way. All interesting channels that I have looked lately are about as dead as stone 02:43:08 #python is pretty awesome 02:43:16 lively ? 02:43:27 but that's happened from the effort of me and several other people who really worked at it 02:43:43 I try hard to keep #emacs, #haskell, and #python worth joining 02:44:11 I'm afriad I'm a dirty Vim user :P 02:44:17 s/afriad/afraid 02:44:22 i'll check it out... althought I'm moving my scripting from python to ocaml 02:44:54 --- topic: set to 'Functional Programming, that's the opposite of Dysfunctional Programming (like VB) | we be loggin' http://tunes.org/~nef/logs/haskell/ | welcome to the Haskell Dojo | julien and shapr are up to white belt!' by shapr 02:45:24 teek: if you use Debian Linux, you may also want to check out #debian-fi 02:45:40 though my suomi is bad enough that I don't talk much there 02:49:39 I have a strong suspicion I'll be able to edit several chunks of #haskell logs into examples for the Haskell Tutorial 02:50:12 I wish emacs had a better ghci interaction mode 02:50:59 how does the heap profiler work? 02:51:50 I'd like to see the heap profiler showing what dennisb was saying about a 'memory leak' 02:55:24 * shapr plays with dropWhile 02:56:46 ack 02:57:29 is ocaml simpler than haskell? 02:58:37 hm, three from .fi on #haskell :) 03:00:15 * shapr figures out how to use dropWhile in Mandelbrot.hs 03:06:12 shapr, Haskell is a way more elegant, and in some simple toy-programs I've written, I've found it easier 03:06:58 shapr, However, if you like to do imperative programming, in Ocaml it's easy. 03:07:38 I started with Haskell after Functional Programming seminar (not course, not here in Uni of Helsinki, damn it) 03:07:46 where was the seminar? 03:08:20 I meant that seminar was in Uni of Helsinki, but we don't have any courses on functional languages 03:09:07 oh 03:09:09 that sucks 03:09:31 However, I'm going to start implementing one of my pet projects, and I decided to use ocaml instead of Haskell 03:09:31 not that I can take courses there unless they were online 03:09:37 what's the project? 03:09:48 ai client for freeciv 03:09:54 oh, nifty! 03:10:03 I compiled: 03:10:04 main = let xs = iterate (*2) 2 03:10:04 y = sum (take 5 xs) 03:10:04 in do print (head (drop 10000 xs)) 03:10:04 print y 03:10:12 with and without the seq 03:10:28 the leaky one used 6M of memory, the other 100K 03:10:33 wow 03:10:34 cool! 03:10:44 and there was a speed difference as well of course.. 03:11:22 http://www.zigo.dhs.org/~dennis/leak1.ps 03:11:24 http://www.zigo.dhs.org/~dennis/leak2.ps 03:11:27 is the profiles 03:11:54 dennisb, have you done some real programming on haskell ? Do you encounter many situations where you have to force evaluations to get acceptable performance ? 03:12:16 teek: Yes I have, and no there are not that many situations 03:12:46 which situations did require it? 03:12:51 usually the performence is just fine, when you have problems you look in to it 03:13:01 also, how did you get those cool graphs so quickly? :) 03:13:05 ghc 03:13:19 it has tools for it 03:13:30 are you using debian? 03:13:36 just compile with -prof 03:13:37 no 03:13:41 oh 03:13:42 but it's probably there 03:14:02 then you run the program with +RTS -h 03:14:11 then you get a .prof file 03:14:24 that is converted to postscript using hp2ps 03:14:39 * shapr tries that 03:15:11 but you need a program that runs longer then 0.0001 seconds, so I had to change the program to iterate (*2) 2 03:15:27 man, irc is really fastest way to learn nifty tricks... 03:16:40 yah, totally 03:16:52 I need to start HaskellNiftyTricks on HaskellWiki 03:17:38 I've been collecting stuff for months on EmacsNiftyTricks 03:17:58 http://emacswiki.org/cgi-bin/wiki.pl?EmacsNiftyTricks 03:18:28 you can easily see that the first program does not run in constant space so you have a space leak. Usually the programmer knows he want something that is for example going to run in constant space, and if it doesn't you start to look for leaks 03:18:55 if the programmer has no clue, then it's hard (in any language) 03:19:53 that's true 03:21:26 Someone could try to write that program in C and get a fast result out :-) 03:21:47 s/fast/faster 03:22:22 (but that is just because you don't have big numbers in C) 03:25:45 so the haskell program would be more flexible, right? 03:25:52 but no matter what, it will be a big program in C, probably with different loops for the two parts, one for y and one for the printing 03:26:07 you don't want to make a list of numbers in C 03:27:12 dennisb, yeah, i've been hacking some c for freeciv lately and boy I miss good standard data structures from Ocaml 03:27:37 rewrite freeciv in Haskell ;) 03:27:40 * shapr is joking 03:27:43 that is what I also miss, but I like and have write much C in my life as well 03:27:51 s/write/written 03:28:46 I've done mainly c++/stl lately in my work 03:29:15 I've never done any C past reading the White Book 03:30:12 hm, I can't get any profiling info from Hsh.hs 03:30:18 and Mandelbrot.hs won't compile with ghc >:( 03:34:24 shae@raven:~/src/haskell$> ghc -prof -o mandel Mandelbrot.hs 03:34:24 /usr/lib/ghc-5.02/libHSstd_p.a(PrelMain__1.p_o): In function `__stginit_PrelMain': 03:34:24 PrelMain__1.p_o(.text+0x83): undefined reference to `__stginit_Main' 03:34:24 /usr/lib/ghc-5.02/libHSstd_p.a(PrelMain__2.p_o)(.text+0x24): undefined reference to `Main_main_closure' 03:34:24 /usr/lib/ghc-5.02/libHSstd_p.a(PrelMain__2.p_o): In function `PrelMain_mainIO_fast1': 03:34:24 PrelMain__2.p_o(.text+0x65): undefined reference to `Main_main_closure' 03:34:26 collect2: ld returned 1 exit status 03:34:28 hmmm 03:34:39 linker problems? 03:38:12 any ideas? 03:38:49 --- quit: julien ("Client Exiting") 03:39:00 it works when I use :load Mandelbrot.hs 03:39:04 but not when I compile... hmm 03:41:55 Where is the Mandelbrot.hs 03:42:14 http://kungens.kemi.fi/~shae/Mandelbrot.hs 03:42:18 * dennisb has just got out from the shower 03:43:06 if i remember correctly, i compiled my toy-programs with ghc --make Mandelbrot.hs . same results ? 03:43:13 oh, let me try that 03:43:24 you need to call the module Main i think 03:43:52 ? 03:44:07 it does not find the main function when it is hidden in a module Mandelbrot 03:44:16 oh, I need to export it? 03:44:32 module Mandelbrot (main) 03:44:33 ? 03:44:38 module Main where 03:44:54 or have another module Main where the main function is 03:45:01 oh!! 03:45:18 (or no module at all) 03:45:28 aha!! 03:45:33 module Main (main) works 03:45:35 thanks! 03:45:44 It does not try Mandelbrot.main as the main function 03:46:09 thats why the linker says: undefined reference to `Main_main_closure' 03:46:20 I read that as somthing: Main.main 03:46:36 I see! 03:47:48 shae@raven:~/src/haskell$> ghc -prof -o mandel Mandelbrot.hs && ./mandel +RTS -hC 03:47:48 Segmentation fault 03:48:04 it worked here 03:48:10 you program uses constant memory 03:48:15 wow 03:48:19 I'm surprised :) 03:48:21 I didn't use -hC though 03:48:32 I just ran +RTS -h 03:48:34 just -h ? 03:48:42 don't know if it makes a difference 03:48:55 ooh, you have to delete the .o file first 03:49:03 oh! 03:49:05 that's probably it 03:49:23 it doesn't understand it have to rebuild it... 03:49:24 urf 03:49:57 i think that ghc --make will take care of such things 03:50:16 teek: maybe, probably 03:50:41 still segfaulting... 03:50:52 what version of ghc 03:50:58 I use 5.02.1 03:51:17 oh 03:51:18 5.00 have been a bit buggy, as almost all .0 programs 03:51:20 I think I found it 03:51:28 I think it's my ghc itself 03:51:45