- Haskell-Cafe - Haskell.org

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 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

FFI and GHC
by João Ferreira 21 Oct '02

21 Oct '02

Hello all, I am trying to learn how to use FFI with GHC. I've tried the example in GHC's user's guide but it didn't worked. Here it is: 1) The haskell code =================== [bracaman@tucano hib]$ cat foo.hs foreign export ccall foo :: Int -> IO Int foo :: Int -> IO Int foo n = return (length (f n)) f :: Int -> [Int] f 0 = [] f n = n:(f (n-1)) 2) The error ============ [bracaman@tucano hib]$ ghc -c foo.hs foo.hs:3: Type signature given for an expression [bracaman@tucano hib]$ I just can't understand why this is happening... can someone, please, help? Thank you in advance, João Ferreira

3 2

Re: Haskell-Cafe digest, Vol 1 #518 - 4 msgs
by Berron Lara Virginia 20 Oct '02

20 Oct '02

Hi everybody! Is there any tool for draWING the graph of a function in one or two variables in Haskell? Thanks in advance Virgin

1 0

Any way to read in a time?
by David Roundy 18 Oct '02

18 Oct '02

I've been looking at the standard Time module, and it seems pretty easy to convert a date into a string (using either calendarTimeToString or formatCalendarTime), but there doesn't seem to be any way to reverse the process. I understand that there are so many date and time formats that it may be hard to parse, and that for many formats there may be no unambiguous translation back into a CalendarTime (e.g. if the time zone isn't included in the string), but it seems like a pretty fundamental (and commonly needed) ability to be able to output a human-readable date and then read it back in. Does anyone have a suggestion how best to go about this? I guess the easiest way might be to just convert to UTC and then use formatCalendarTime to choose what formatting I want and then write my own parser to reverse the process. But this seems like a process with a relatively high probability of introducing rarely seen bugs, which ought to be dealt with by a standard library. Of course, there are also a couple of other workarounds I could use. CalendarTime derives from Show, so I could just output the result of show, but that's an awfully verbose format. I could also give up on comparing dates (which I don't necesarily need, although it is nice) and just treat dates as strings. Any ideas or commentary would be welcome. -- David Roundy http://civet.berkeley.edu/droundy/

3 2

(no subject)
by Chris.Angus＠Lawson.com 17 Oct '02

17 Oct '02

Does anyone know what happened to the wiki on haskell.org? There was lots of stuff there last year (mostly to do with design patterns) which seems to have been lost. Some of the links are still there but they don't go anywhere. Cheers Chris

3 2

question about lazy io
by David Roundy 12 Oct '02

12 Oct '02

Hello. I have a problem I ran into when I tried writing a function to use lazy IO . Specifically, I would like to be able to compare two directory trees, and I thought the best way to do this would be to compartmentalize things by writing an IO function to read in a whole directory tree (including the contents of its files) in a lazy manner, and then the code to manipulate this tree could be purely functional and non-monadic. The problem is that while reading a file in with readFile (or openFile followed by hGetContents) is lazy regarding the reading of the actual file data, it leaves the file handle open, and (at least on ghc under linux) quickly exhausts the available file handles. I guess this makes sense, since if the file wasn't opened until it was actually used, a file open error couldn't flag an exception at the appropriate time... I think this is a related question to the thread on config files and pure file reading. Certainly if there was a pure functional file read (i.e. readFileOnce), that would solve my problem. I hate to have to write monadic IO code right into the core of my code. The Haskell 98 Library Report describes the state of a file handle after hGetContents as 'semi-closed', meaning it will close as soon as it is finished with the current read. Is there any way to get the file handle into a 'semi-opened' state, in which it will be opened as soon as it starts getting read? That's what I'd really like. fwiw, here's the code I'd like to use to slurp up a directory and its contents: >slurp dirname = do > isdir <- doesDirectoryExist dirname > if isdir > then do > former_dir <- getCurrentDirectory > fnames <- getDirectoryContents dirname > setCurrentDirectory dirname > sl <- slurp_list $ skip_hidden fnames > setCurrentDirectory former_dir > return $ SlurpDir dirname sl > else do > isfile <- doesFileExist dirname > if isfile > then do > contents <- readFile dirname > return $ SlurpFile dirname (lines contents) > else return $ SlurpFile "Oops" [] > >slurp_list :: [FilePath] -> IO [Slurpy] >slurp_list [] = return [] >slurp_list (f:fs) = do > s <- slurp f > ss <- slurp_list fs > return (s:ss) > >skip_hidden :: [FilePath] -> [FilePath] >skip_hidden [] = [] >skip_hidden (('.':_):fps) = skip_hidden fps >skip_hidden (fp:fps) = fp : skip_hidden fps To restate my question (which I may have forgotten to ask...), is there a good way to do this? The only thing that comes to mind is to use unsafeIO, which sounds scary. (Mostly because I don't think I would really understand the consequences.) -- David Roundy http://civet.berkeley.edu/droundy/

2 1