October 2002 - Haskell-Cafe

autocompletion mode for ghci?
by Steffen Mazanek 26 Oct '02

26 Oct '02

Hallo, is there any mode for the ghci, which provides autocompletion like e.g. the bash? Thanks, Steffen Mazanek

1 0

New to Haskell
by Andy Schmidt 24 Oct '02

24 Oct '02

Hi, My name is Andy Schmidt and I am new to Haskell. My prof just introduced me to it yesterday actually. I want to learn more. It sounds like a really interesting thing. So let me know what I need to do in order to get started. Thanks Andy _________________________________________________________________ Surf the Web without missing calls! Get MSN Broadband. http://resourcecenter.msn.com/access/plans/freeactivation.asp

3 2

RE: Rational sequence
by Simon Peyton-Jones 24 Oct '02

24 Oct '02

| > The Report says that the Enum instance for Ratio uses the | > same rule as for Float/Double, | | Now I can see that the revised Report contains more about | this than the one on haskell.org. But I still can't see the | statement you cited above. Where should I look? You look in the instance declaration for Ratio, which is given in the Ratio chapter of the Library report. | As I told above, I can't see anything to change, except | implementation. As I understand it, GHC conforms to the Report, but Hugs perhaps does not, yet. Simon

3 2

Re: Odd Performance
by Tim Otten 23 Oct '02

23 Oct '02

Tom Pledger writes: > Probably. Try replacing this > (\z -> z <= (intsqrt x)) > with this > (\z -> z^2 <= x) Yes! This is significantly nicer. Taking 4000 primes, this is about twice as fast as the original (loose) algorithm, and it appears that it gets better as n grows. (Call this version #3). > or moving the O(sqrt(n)) step[1] into a let expression This does help -- the implementation with this adjustment seems to hover around 1.1 times the speed of the loose algorithm. (Call this version #4) > Only if the predicate function (the p in takeWhile p xs) is > significantly more expensive than a constant-cost piece of arithmetic > and pattern-matching. This makes sense and explains the results above: squaring z is easier than square-rooting x. In fact, the way intsqrt is written, #4's takeWhile indirectly tests (z*z > x) once for each [z | 1<=z<=sqrt(x)]. #3's takeWhile expression will only evaluate (z^2 < x) once for each [ z | z <- primes, z<=sqrt(x) ]. Moreover, #4's takeWhile will do additional tests (z <= sqrt) for each [z | z <- primes, z <= sqrt(x)]. In retrospect, the intsqrt-approach seems rather silly. :) Thank you, Tim

1 0

using IOExts...
by Jason Smith 22 Oct '02

22 Oct '02

Hi All I don't know what I'm doing wrong here but for some reason no matter what esoteric command line option I seem to be able to dream up I can get ghc to include IOExts..I want to use the side-affect IO commands but cannot. I am using ghc-5.02.2 for Win32. Can someone just give me a command line example that alows me to compile a file that includes IOExts? Thanks J.

2 1

representation getting verbose...
by None 22 Oct '02

22 Oct '02

Greetings Haskellers, I'm running into a problem representing some fairly complicated types, and I'll try to put together a simpler example to get your suggestions. In Paul Hudak's SOE, I find a definition of expression: data Expr = C Float | V String | Expr :+ Expr | Expr :- Expr | Expr :* Expr | Expr :/ Expr Now this is compelling, but sometimes, I might want to have a function that takes a variable only, not just any kind of expression. I could write something like: typeOfVariable :: Expression -> Type typeOfVariable (V s) = ... _ = error... But thats not very satisfying from a type-checking perspective. So it makes sense to create a constructor: data Variable = VVariable String data Expr = C Float | V Variable | Expr :+ Expr | Expr :- Expr | Expr :* Expr | Expr :/ Expr and make typeOfVariable :: Variable -> Type. But then when I want to match or create a variable expression, things are starting to get verbose: case expr of C f -> ... V (Variable (VVariable s)) -> ... ... And if I want a still more accurate hierarchy, the construction and destruction of Variables can really become cumbersome. For an interpreter I'm writing, I found myself writing a function "constructVarExpr :: String -> Expr" just to make it easier. This all seems very inelegant, and I get the feeling that there's a better way to do this. Any suggestions on how I could better represent Expressions or Variables to keep the type-checking but decrease the verbosity? peace, Isaac Jones

4 4

Odd Performance
by Tim Otten 22 Oct '02

22 Oct '02

As a student in an undergraduate 'Intro to Discrete Structures' course, I recently did a project which required generating the first n primes. We discussed the sieve of Eratosthenes in class. Although the professor is not familiar with Haskell, he allowed me to use it, and I mistakenly wrote the following code[1]: -- A list of all prime numbers primes = [2] ++ [ x | x <- [3..], isPrime x ] -- x is prime if the set of primes [2 <= p <= sqrt(x)] is empty isPrime x = ( [] == [ y | y <- (take (intsqrt x) primes), x `mod` y == 0 ] ) This works, and I used it as I developed my project. However, it tests more primes than necessary. A better version would seem to be: -- x is prime if the set of prime factors [2 <= p <= sqrt(x)] is empty isPrime x = ( [] == [ y | y <- (takeWhile (\z -> z <= (intsqrt x)) primes), x `mod` y == 0 ]) Surprisingly, the second (tight) version grows significantly more costly than the first (loose) version as we take more primes. Taking 20 primes, > take 20 primes both algorithms require under a second. Taking 200 primes, the tight algorithm requires twice as much time as the loose one. Taking 2000 primes, the tight algorithm requires about 4.5 times as much time as the loose one.[2] Can anyone suggest why the tighter algorithm exhibits significantly worse performance? Is takeWhile significicantly more expensive than take? Is the \z lambda expression expensive? The intsqrt isn't recalculated each time takeWhile evalutes a prime, is it? Slightly confused, Tim Otten [1] Note that intsqrt calculates the floor of the square root of x. intsqrt x = intsqrt' 1 x intsqrt' n x | (n*n > x) = n-1 | otherwise = intsqrt' (n+1) x [2] A few comments on the test apparatus: * Debian GNU/Linux 3.0 * Hugs98 circa Sept 2001 * Tested on a G3 400mhz and a PII 233mhz. The G3 was consistently faster, but the relationship (Time(Alg2)/Time(Alg1)) remains comparable across chips * Times were established using the bash shell's 'time' command * Each test was performed in a new instance of 'runhugs' * Tests were repeated and staggered (Test alg1 @ n primes; test alg2 @ n primes; test alg1 @ n primes; test alg2 @ n primes) Codes, scripts, etc. available upon request.

2 2

SOE exercise
by Isaac Jones 22 Oct '02

22 Oct '02

(I'm not sure why my postings seem somewhat anonymous, I'll mess with the headers in this post to see if that fixes it. I post to other mailman lists and haven't noticed this problem.) I'm working through Paul Hudak's SOE, and have a question about problem 9.4, which is to define a function applyEach. I've come up with several versions, but not one which usefully uses currying (the exercise doesn't explicitly say to use currying, but that's the only thing in this section). My real question is whether I should be trying to apply currying here. Solutions are welcome, but I can think of several good reasons not to post solutions to this forum. The behavior of applyEach should be obvious from my attempts below. Output: applyEach [(+1), (+3), (+2)] 1 => [2,4,3] :: [Integer] Recursive version: > applyEach :: [a->b] -> a -> [b] > applyEach [] _ = [] > applyEach (h:t) x = (h x) : (applyEach t x) Now with higher order functions: > applyEach' :: [a->b] -> a -> [b] > applyEach' funs x = map applyx funs where applyx (fun) = fun x With Lambda: > applyEach'' :: [a->b] -> a -> [b] > applyEach'' funs x = map (\fun-> fun x) funs With Currying: ? peace, isaac P.S. I'm enjoying this book a great deal :-)

2 1

RE: Rational sequence
by Simon Peyton-Jones 22 Oct '02

22 Oct '02

The Report says that the Enum instance for Ratio uses the same rule as for Float/Double, namely that [a..b] means takeWhile (<= (b+1/2)) [a, a+1, a+2, ...] You may say that the "<=" should be "<" but that's what the Report says. Certainly if you do [1%3..10%3] you'll get more values than your rule suggests. I'm not sure what your rule should be, though. (What about [2%4, ... 20%4]?) Anyway, it's a bit late to change the Report Simon | -----Original Message----- | From: Ferenc Wagner [mailto:wferi@bolyai1.elte.hu] | Sent: 22 October 2002 11:12 | To: haskell-cafe(a)haskell.org | Subject: Rational sequence | | With GHC-5.02.2, I do | | $ ghci | Prelude> :m Ratio | Ratio> [1%2..10%2] | [1 % 2,3 % 2,5 % 2,7 % 2,9 % 2,11 % 2] | | The question is, why is there 11%2 at the end of the list? | It's inconsistent with the (good) rules for Integer, since | | Ratio> [1,3..10] | [1,3,5,7,9] | | Is this intentional? | Feri. | _______________________________________________ | Haskell-Cafe mailing list | Haskell-Cafe(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell-cafe

2 1

Re: Haskell-Cafe digest, Vol 1 #518 - 4 msgs
by Yoann Padioleau 21 Oct '02

21 Oct '02

"Berron Lara Virginia" <berron(a)nuyoo.utm.mx> writes: > Hi everybody! > Is there any tool for draWING the graph of a function in one or two variables what do you mean ? you mean drawing the trace of execution of a function ? cos there is the Hat tools. > in Haskell? > Thanks in advance > Virgin > > > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > -- Yoann Padioleau, INSA de Rennes, France, Opinions expressed here are only mine. Je n'écris qu'à titre personnel. **____ Get Free. Be Smart. Simply use Linux and Free Software. ____**

1 0