- Haskell-Cafe - Haskell.org

Re: Learning Haskell and FP
by Michael Zawrotny 05 Jan '01

05 Jan '01

"Benjamin L. Russell" <russell(a)brainlink.com> wrote > Michael Zawrotny <zawrotny(a)gecko.sb.fsu.edu> wrote: [snip] > > > > The thing that I would most like to see would entitled "A > > Practical Guide to Haskell" or something of that nature. > > > > [snip] > > > > One is tempted to come to the conclusion that Haskell is > > not > > suited for "normal" programmers writing "normal" > > programs. > > How would you define a "'normal' programmer writing 'normal' programs?" What > exactly is a "'normal' program?" That was sloppy on my part. My message was getting long, so I used "normal" as a short cut. I should know better after seeing all of the flamewars about whether or not FP is suitable for "real" work. What I meant by "normal programmer" was (surprise) someone like myself. I.e. someone who doesn't have much, if any background in formal logic, higher mathematics, proofs of various and sundry things, etc. By "normal program" I meant things like short utility programs that I might otherwise write in shell, python, perl, etc. or data extraction and analysis programs that I might write in in python, perl, C or C++ depending on the type of analysis. > (Perhaps another way of phrasing the issue is as the "declarative" vs. "proce > dural" distinction, since the issue seems to be that of "what is" (types) vs. > "how to" (imperative expression; i.e., procedures).) Although there is some of that, for me at least, the types aren't a big deal. The main thing for me is figuring out how to actually get something done. Most of the things I've read have had tons of really neat things that you can do with functional abstractions, but it's all ... abstract. I would love to see something that is more about getting things done in a how-to sense, including IO. Much of the material I've seen tends to either relegate IO and related topics into a small section near the end (almost as if it were somehow tainted by not being able to be modelled as a mathematical function), or it goes into it talking about monads and combinators and things that make no sense to me. > While I agree that "A Practical Guide to Haskell" would indeed be a suitable > alternative for programmers from the procedural school of expression, I would > caution that such an introduction would probably not be suitable for all. This is very true. I think that there is plenty of material that would be helpful for an SMLer to learn Haskell, but not much for someone who was was only familiar with with C or who was only comfortable with FP to the extent of understanding lambdas, closures and functions as values, but none of the more esoteric areas of FP. I'm advocating something along the lines of the "Practical Guide" I mentioned or the "Nutshell" book below. > Perhaps, ideally, two separate tutorials (or perhaps a single tutorial with t > wo sections based on different viewpoints?) may be needed? The difficulty is > that the conceptual distance between the declarative and procedural schools > of thought seems too great to be bridged by a single viewpoint. It seems tha > t any introduction favoring either one would risk alienating the other. I agree that any single tutorial would be able to target both audiences. > Personally, I would really prefer "A Gentle Elementary Introduction to Haskel > l: Elements of the Haskell School of Expression with Practical Examples," bu > t some would no doubt choose "Haskell in a Nutshell: How to Write Practical > Programs in Haskell." I'm definitely the "Nutshell" type. If it were published, I'd buy it in a heartbeat. That's why it would be good to have both, everyone would have one that suited their needs. I'd like to say a couple things in closing, just so that people don't get the wrong idea. I like Haskell. Even if I never really write any programs in it, trying to learn it has given me a different way of thinking about programming as well as exposing me to some new ideas and generally broadening my horizons. My only problem is that I just can't seem to get things done with it. Please note that I am not saying here, nor did I say previously that it isn't possible to do things in Haskell. Obviously there are a number of people who can. I am simply saying that I am having trouble doing it. I would also like to mention that I really appreciate the helpful and informative tone on the list, especially on a topic that, even though not intended that way, could be considered critical of Haskell. Mike -- Michael Zawrotny 411 Molecular Biophysics Building Florida State University | email: zawrotny(a)sb.fsu.edu Tallahassee, FL 32306-4380 | phone: (850) 644-0069

2 1

Re: Learning Haskell and FP
by Benjamin L. Russell 04 Jan '01

04 Jan '01

On Wed, 03 Jan 2001 11:26:53 -0500 Michael Zawrotny <zawrotny(a)gecko.sb.fsu.edu> wrote: > > [snip] > > The reason that I found GITH difficult wasn't that the > concept > of programming with functions/functional style was new to > me. What got me was that the concepts and notations were > much > more "mathematical" than "programmatic". In my > explorations > of various languages, my experience with introductions to > scheme/CL has mostly been that they tend to show how to > do > things that are familiar to imperative programmers, plus > all > of the things that you can do with functions as first > class > values. With intros to SML, OCaml and Haskell, there is > a > much greater emphasis on types, type systems, and > provable > program correctness. > > [snip] > > The thing that I would most like to see would entitled "A > Practical Guide to Haskell" or something of that nature. > > [snip] > > One is tempted to come to the conclusion that Haskell is > not > suited for "normal" programmers writing "normal" > programs. How would you define a "'normal' programmer writing 'normal' programs?" What exactly is a "'normal' program?" (Perhaps another way of phrasing the issue is as the "declarative" vs. "procedural" distinction, since the issue seems to be that of "what is" (types) vs. "how to" (imperative expression; i.e., procedures).) While I agree that "A Practical Guide to Haskell" would indeed be a suitable alternative for programmers from the procedural school of expression, I would caution that such an introduction would probably not be suitable for all. If I may give my own case as an example, I studied both C and Scheme (in addition to auditing a course in Haskell) in college, and favored Scheme over C precisely because of my Scheme course's emphasis on provable program correctness. This is largely a matter of background and taste: my course background was relatively focused on the design and analysis of algorithms, with provable program correctness being a related topic. Perhaps, ideally, two separate tutorials (or perhaps a single tutorial with two sections based on different viewpoints?) may be needed? The difficulty is that the conceptual distance between the declarative and procedural schools of thought seems too great to be bridged by a single viewpoint. It seems that any introduction favoring either one would risk alienating the other. Personally, I would really prefer "A Gentle Elementary Introduction to Haskell: Elements of the Haskell School of Expression with Practical Examples," but some would no doubt choose "Haskell in a Nutshell: How to Write Practical Programs in Haskell." --Ben -- Benjamin L. Russell russell(a)brainlink.com benjamin.russell.es.94(a)aya.yale.edu "Furuike ya! Kawazu tobikomu mizu no oto." --Matsuo Basho

1 0

Problems compiling HDirect 0.17
by Eric Allen Wohlstadter 04 Jan '01

04 Jan '01

When I try to compile hdirect on cygwin on my NT I get a lot of complaints from ghc about bad tokens. Particularly the use of "\" to continue a line. For some reason it doesn't see it as the line continuation character. Also, it compiled ok on a different machine but it complains about a missing link to CYGWIN1.DLL when I try to do anything. Any help would be appreciated. Eric Wohlstadter

2 1

Re: Learning Haskell and FP
by senganb＠ia.nsc.com 29 Dec '00

29 Dec '00

> * The Design Patterns Haskell Companion > by [someone(s) reading this list?] I agree except I would also like to see more on Haskell space-leaks and how to find them. Lazyness is great for structuring programs and garbage collection helps rapid prototyping immensely. However it makes it difficult to find the cause of that 128Mb heap overflow once you have 2000 lines of code. Yes the profiler gives you an idea of which function is using a lot of heap, but not exactly where. E.g. I rewrote my monads ultra stritly and the heap consumption fell by half, even though I'm not convinced being so strict isn't just masking some other problem: > (MN c1) >>= fc2 = MN $ \s0 -> case c1 s0 of { (r1,io1,s1) -> > case fc2 r1 of { ( MN c2 ) -> > case c2 s1 of { (r2,io2,s2) -> > (r2,io1 >> io2,s2) }}} Such a "community written book" might be good for http://www.lightandmatter.com/cgi-bin/asbrowsesubject.cgi?class=Q Sengan

1 0

Haskell question
by Scott 29 Dec '00

29 Dec '00

Hello! I am reading Discrete Mathematics Using a computer by Hall and O'Donnell and in the introduction to hugs section, they give this example: [[x,y] | x<-[1..50],y<-[1..50],z<-[1..50],x**2+y**2==z**2] now I type it in and expect it to return a number of results, but it doesn't, it shows: [[8.0,15.0,17.0],[14.0,48.0,50.0],[15.0,8.0,17.0],[15.0,20.0,25.0],[20.0,15.0,25.0],[21.0,28.0,35.0],[27.0,36.0,45.0],[28.0,21.0,35.0],[30.0,40.0,50.0],[36.0,27.0,45.0],[40.0,30.0,50.0],[48.0,14.0,50.0]] My question is where is [3.0,4.0,5.0],[5.0,12.0,13.0]? I have looked everywhere I could think of to see what I am doing wrong, but I have no idea. Maybe a rounding error somewhere? Thank you, Scott Anderson

3 2

Re: Haskell question
by Mike Gunter 29 Dec '00

29 Dec '00

This is fairly subtle. The fact that the numbers are printed with a decimal point hints that they are floating point numbers. Floating-point arithmetic's inexactness makes equality tests less valuable than for, e.g., Integer arithmetic. If you change the "**"s to "^"s you'll get [3,4], etc. (or [3,4,5] if you change "[x,y]" to "[x,y,z]"). mike gunter E.g.: Main> [[x,y,z] | x<-[1..50],y<-[1..50],z<-[1..50],x^2+y^2==z^2] [[3,4,5],[4,3,5],[5,12,13],[6,8,10],[7,24,25], ... ] > Hello! > I am reading Discrete Mathematics Using a computer by Hall and O'Donnell > and in the introduction to hugs section, they give this example: > [[x,y] | x<-[1..50],y<-[1..50],z<-[1..50],x**2+y**2==z**2] > now I type it in and expect it to return a number of results, but it > doesn't, it shows: > [[8.0,15.0,17.0],[14.0,48.0,50.0],[15.0,8.0,17.0],[15.0,20.0,25.0],[20.0,15.0,25.0],[21.0,28.0,35.0],[27.0,36.0,45.0],[28.0,21.0,35.0],[30.0,40.0,50.0],[36.0,27.0,45.0],[40.0,30.0,50.0],[48.0,14.0,50.0]] > My question is where is [3.0,4.0,5.0],[5.0,12.0,13.0]? > I have looked everywhere I could think of to see what I am doing wrong, but > I have no idea. Maybe a rounding error somewhere? > Thank you, > Scott Anderson

1 0

RE: Haskell question
by Conal Elliott 28 Dec '00

28 Dec '00

It's probably due to rounding. If you use "^" instead of "**", defaulting to integers, you'll get the triples you expected. - Conal -----Original Message----- From: Scott [mailto:adric@wipcradio.cc] Sent: Thursday, December 28, 2000 3:05 PM To: Haskell-Cafe(a)haskell.org Subject: Haskell question Hello! I am reading Discrete Mathematics Using a computer by Hall and O'Donnell and in the introduction to hugs section, they give this example: [[x,y] | x<-[1..50],y<-[1..50],z<-[1..50],x**2+y**2==z**2] now I type it in and expect it to return a number of results, but it doesn't, it shows: [[8.0,15.0,17.0],[14.0,48.0,50.0],[15.0,8.0,17.0],[15.0,20.0,25.0],[20.0,15. 0,25.0],[21.0,28.0,35.0],[27.0,36.0,45.0],[28.0,21.0,35.0],[30.0,40.0,50.0], [36.0,27.0,45.0],[40.0,30.0,50.0],[48.0,14.0,50.0]] My question is where is [3.0,4.0,5.0],[5.0,12.0,13.0]? I have looked everywhere I could think of to see what I am doing wrong, but I have no idea. Maybe a rounding error somewhere? Thank you, Scott Anderson _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

Boolean Primes Map (continued)
by Shlomi Fish 22 Dec '00

22 Dec '00

Well, after some thought, I decided to try re-writing the boolean primes map program only using a list instead of an array. I came up with this program: primes :: Int -> [Int] primes how_much = (iterate 2 initial_map) where initial_map :: [Bool] initial_map = (map (\x -> True) [ 0 .. how_much]) iterate :: Int -> [Bool] -> [Int] iterate p (a:as) | p > mybound = process_map p (a:as) | a = p:(iterate (p+1) (mymark (p+1) step (2*p) as)) | (not a) = (iterate (p+1) as) where step :: Int step = if p == 2 then p else 2*p mymark :: Int -> Int -> Int -> [Bool] -> [Bool] mymark cur_pos step next_pos [] = [] mymark cur_pos step next_pos (a:as) = if (cur_pos == next_pos) then False:(mymark (cur_pos+1) step (cur_pos+step) as) else a:(mymark (cur_pos+1) step next_pos as) mybound :: Int mybound = ceiling(sqrt(fromIntegral(how_much))) process_map :: Int -> [Bool] -> [Int] process_map cur_pos [] = [] process_map cur_pos (a:as) | a = cur_pos:(process_map (cur_pos+1) as) | (not a) = (process_map (cur_pos+1) as) I don't know too much about Haskell yet, so it is possible this program can be further optimized using some Haskell built-ins. Now, this program can scale to 100,000 and beyond, as opposed to the array version which only got until 30,000 or 40,000. It's a pity Haskell doesn't handle arrays very well, but I guess every language has its faults. Regards, Shlomi Fish ---------------------------------------------------------------------- Shlomi Fish shlomif(a)vipe.technion.ac.il Home Page: http://t2.technion.ac.il/~shlomif/ Home E-mail: shlomif(a)techie.com The prefix "God Said" has the extraordinary logical property of converting any statement that follows it into a true one.

1 0

finding primes
by S.D.Mechveliani 21 Dec '00

21 Dec '00

Hello, On generating prime numbers, people wrote ... | import Array | primes n = [ i | i <- [2 ..n], not (primesMap ! i)] where | primesMap = accumArray (||) False (2,n) multList | [..] I think that it is good for functional programming to avoid arrays, as possible. Shlomi Fish <shlomif(a)vipe.technion.ac.il> writes > [..] > primes :: Int -> [Int] > > primes how_much = sieve [2..how_much] where > sieve (p:x) = > p : (if p <= mybound > then sieve (remove (p*p) x) > else x) where > remove what (a:as) | what > how_much = (a:as) > | a < what = a:(remove what as) > | a == what = (remove (what+step) as) > | a > what = a:(remove (what+step) as) > remove what [] = [] > step = (if (p == 2) then p else (2*p)) > sieve [] = [] > mybound = ceiling(sqrt(fromIntegral how_much)) > > I optimized it quite a bit, but the concept remained the same. > > Anyway, this code can scale very well to 100000 and beyond. But it's not > exactly the same algorithm. > [..] C.Runciman <Colin.Runciman(a)cs.york.ac.uk> gives a paper reference about this. Aslo may I ask what do you mean by "can scale to 100000", the value of a prime or its position No in the list? Anyway, here are my attempts: ----------------------------------- 1. primes1 = s [(2::Int)..] :: [Int] where s (p:ns) = p: (s (filter (notm p) ns)) notm p n = (mod n p) /= 0 main = putStr $ shows (primes1!!9000) "\n" After compiling by GHC-4.08 -O2 it yields 93187 in 115 sec on Intel-586, 160 MHz. ----------------------------------- 2. The DoCon program written in Haskell (again, no arrays) gives about 10 sec (for Integer values). Also it finds, for example, first 5 primes after 10^9 as follows: take 5 $ filter isPrime [(10^9 ::Integer) ..] --> [1000000007,1000000009,1000000021,1000000033,1000000087] This takes 0.05 sec. But DoCon uses a particular isPrime test method: Pomerance C., Selfridge J.L., Wagstaff S.S.: The pseudoprimes to 25*10^9. Math.Comput., 1980, v.36, No.151, pp.1003-1026. After 25*10^9 it becomes again, expensive. ------------------ Sergey Mechveliani mechvel(a)botik.ru

2 1

finding primes
by S.D.Mechveliani 21 Dec '00

21 Dec '00

Hello, I wrote recently on generating prime numbers > [..] > The DoCon program written in Haskell (again, no arrays) gives > [..] > take 5 $ filter isPrime [(10^9 ::Integer) ..] > --> > [1000000007,1000000009,1000000021,1000000033,1000000087] > > This takes 0.05 sec. > [..] But it is better to refer to the BAL library for Haskell (basAlgPropos) http://www.botik.ru/pub/local/Mechveliani/basAlgPropos/ It is easier to use. ------------------ Sergey Mechveliani mechvel(a)botik.ru

1 0