- Haskell-Cafe - Haskell.org

RE: autocompletion mode for ghci?
by Simon Marlow 28 Oct '02

28 Oct '02

> is there any mode for the ghci, which provides autocompletion > like e.g. the bash? GHCi on Unix provides autocomplete through the readline library (the same library used by bash) albeit only for filenames and directories. We don't compile with readline support on Windows (I'm not sure why). If you want completion of function names, type names, etc. then the answer is that we haven't implemented it, but it would be an interesting project. Cheers, Simon

1 0

Interruptibility and thread safeness with readMVar
by Patrick Bosworth 28 Oct '02

28 Oct '02

How does the ghc run-time system determine if an operation is interruptible when within "block" function scope? Explanations I've read in various papers/web pages state that an operation is interruptible, even within a the scope of the "block" function, if that operation can potentially block waiting for input/output. Take the readMVar function. In my implementation of ghc, readMVar is defined as follows. readMVar :: MVar a -> IO a readMVar m = block $ do a <- takeMVar m putMVar m a return a Since, by the above definition of interruptible, both takeMVar and putMVar are both interruptible operations, isn't there a possibility that, on receipt of an exception while blocked on the "putMVar m a" operation, "MVar m" would be left in an inconsistent state (i.e. empty)? Am I right in thinking that readMVar should only ever be used when no other thread can potentially access "MVar m"? Or have I completely missed the point? My second question concerns readMVar directly. Is this function intended to be an atomic operation in the context of multiple threads accessing the "MVar m" parameter (i.e. thread safe)? Presumably, if a context switch takes place after takeMVar but before putMVar, there is a possibility that another thread will successfully evaluate putMVar on "MVar m", inserting a different value. Is this intended? I suppose it's necessary to resort to some kind of cunning ploy of using more MVars/threads to control access to MVar m if we wan't to guarantee readMVar's thread safeness? If so, does anyone have such an implementation? Both of these questions are a result of trying to implement a function that will atomically (in the presence of both other threads and asynchronous exceptions) transfer the contents of one MVar to another (or leave both MVars in their original states of the operation fails). ********************************************************************** This message is intended only for the stated addressee(s) and may be confidential. Access to this email by anyone else is unauthorised. Any opinions expressed in this email do not necessarily reflect the opinions of royalblue. Any unauthorised disclosure, use of dissemination, either whole or part is prohibited. If you are not the intended recipient of this message, please notify the sender immediately. **********************************************************************

1 0

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 25 Oct '02

25 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 23 Oct '02

23 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 23 Oct '02

23 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 23 Oct '02

23 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 23 Oct '02

23 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