The real essence and subtlety of FP is the typing system

Uses syntax in the examples that you can't simply type into the "runloop interfaces" without modifying it.

What I mean by "2D syntax" the Python-style required whitespace--2d alignment rules.

And what is 'a? Where did that come from? "a" seems to be a "generic type placeholder" generated by the type inferencing, but what is the ' doing? Is it a function that tests the value of the type represented by the "a"?

map :: (a -> b) -> [a] -> [b]
[download]

strlen :: String -> Integer
strlen x = length x

example = ["dog", "cat", "orange"]
[download]

The Haskell tuts never explain what '$' does that I have found, but if you look at any non-trivial Haskell code, it pops up all over the place. (I know what it does now through trial and error!).

And '.'. This is explained, usually as f . g x = f( g( x )) or f . g x = (f (g x ) ) depending upon flavour, but what that doesn't tell you is when you need to use it! In most dialecs, simple abutment of functions f g x achieves the same thing--except when it doesn't and the '.' is required!

Enough ranting, (sorry you caught me after another fruitless search for information and examples, and several long and ultimately useless downloads of PDFs that I had to search manually because the stupid UI won't let me search for stuff that wasn't bloody indexed. Grrr!).

Here's where I'll heartily recommend the book The Haskell School of Expression: Learning Functional Programming through Multimedia

Well. As an interim measure I read the lecture slides. From that cursory glance--that actually went at about the right pace (4 or 5 slides representing a few 10s of pages)--it does at least appear to attempt to deal with (what I term) real-world problems.

However, and here's the reason I will want to browse the book before purchasing rather buying on line, it (appears) to skips the nasty little details.

For example, the treatment of the trivial, but strongly indicative example of the unix wc program. (Which I had to type in because it doesn't come as part of the source file distribution with the book)

import System

wcf :: ( Int, Int, Int ) -> String -> ( Int, Int, Int )
wcf ( cc, w, lc ) []                          =    ( cc,   w,   lc   )
wcf ( cc, w, lc ) ( ' '  : xs )               = wcf( cc+1, w+1, lc   )
+ xs
wcf ( cc, w, lc ) ( '\t' : xs )               = wcf( cc+1, w+1, lc   )
+ xs
wcf ( cc, w, lc ) ( '\n' : xs )               = wcf( cc+1, w+1, lc+1 )
+ xs
wcf ( cc, w, lc ) (   x  : xs )               = wcf( cc+1, w,   lc   )
+ xs

wc :: IO()
wc = do name <- getLine
        contents <- readFile name
        let ( cc, w, lc ) = wcf( 0, 0, 0 ) contents
        putStrLn ( "The file:" ++ name ++ " has " )
        putStrLn ( show cc ++ " chars " )
        putStrLn ( show w  ++ " words " )
        putStrLn ( show lc ++ " lines." )
[download]

Compiling and running that fails because it has no main. Okay, it's off a slide, so add  main = wc. Compile and I get a (500kb!) executable. Try running it--on a file with 2 lines of 30 spaces:

 
C:\ghc\test>wc 60sp2l.txt
wc: interrupted

C:\ghc\test>wc
60sp2l.txt
The file:60sp2l.txt has
62 chars
62 words
2 lines.

C:\ghc\test>wc
p:\test\1GB.dat
The file:p:\test\1GB.dat has
Heap exhausted;
Current maximum heap size is 268435456 bytes (256 Mb);
use `+RTS -M<size>' to increase it.
[download]

Impressed? Not! Doesn't handle command line parameters. No prompt. Counts spaces and newlines as words. Can't handle a big file.

Yes. I know it's only a demo. I should be able to add a prompt easily enough:

wcf :: ( Int, Int, Int ) -> String -> ( Int, Int, Int )
wcf ( cc, w, lc ) []                        =    ( cc,   w,   lc   )
wcf ( cc, w, lc ) ( ' '  : xs )             = wcf( cc+1, w+1, lc   ) x
+s
wcf ( cc, w, lc ) ( '\t' : xs )             = wcf( cc+1, w+1, lc   ) x
+s
wcf ( cc, w, lc ) ( '\n' : xs )             = wcf( cc+1, w+1, lc+1 ) x
+s
wcf ( cc, w, lc ) (   x  : xs )                = wcf( cc+1, w,   lc   
+) xs

wc :: IO()
wc = do putStr ( "Filename; " )
     name <- getLine
        contents <- readFile name
        let ( cc, w, lc ) = wcf( 0, 0, 0 ) contents
        putStrLn ( "The file:" ++ name ++ " has " )
        putStrLn ( show cc ++ " chars " )
        putStrLn ( show w  ++ " words " )
        putStrLn ( show lc ++ " lines." )

main = wc
[download]

Compile:

C:\ghc\test>ghc -o wc.exe wc.hs

wc.hs:9:8: Parse error in pattern
[download]

Hmmm. Informative!

So, skip the prompt, and try and get the argument from the command line. Scan the library docs. System looks promising. But there is nothing that looks like it gives me access to the commmand line? Okay, skip that. Try dealing with the "words are spaces" problem. In an imperative language I'd simple 'remember' the previous character and treat consecutive spaces (and newlines) as a single delimiter for the purpose of counting words...but of course, that's state!

So, how about dealing with the memory issue? I thought the beauty of Haskell was that it was non-strict or lazy. That it dealt with infinite lists. Then why does getContents insist on loading the whole darn file?

Another example drawn from the same source.

From Chapter 8, containsS for Rectangles is defined as:

Rectangle s1 s2 `containsS` (x,y) =
    let t1 = s1 / 2
        t2 = s2 / 2
    in -t1<=x && x<=t1 && -t2<=y && t2<=t2
[download]

But there is a classical GUI problem here. If you divide the screen into a grid, of say 10 x 10 pixels, then by the above definition any point on the right edge of one rectangle also appears on the left edge of the adjacent rectangle to its right. Likewise for points on the other three edges and their corresponding neighbours. This leaves a point at the crossroads between 4 adjacent squares testing as being contained within all four squares simultaneously! Might work for a Corner bet in roulette, but it surely doesn't work well for the majority of hit-testing purposes in graphical applications.

And that's the problem. All the demos are the same. They concentrate on (laborious formal) examination of Haskell's strengths and completely skip over all the messy edge cases.

All languages have their strengths and weaknesses. What defines a languages usability is the way in which it deals with it's weaknesses. What puts the P in Perl, is the practical way in which it has built-in mechanisms for dealing with the messiness of the real world--the edge cases--even where that means it has to eshew orthoganality and purity in order to achieve that practicality. Where the same problem in usability crops up frequently, the language has been extended and "special cased" to deal with that situation in a reasonable and usually quite intuative way. And the special cases are the subject of extensive documentation in the FAQ.

My problem with trying to get to grips with FP is that the FP language documentation reflects their theoretical origins by expounding on the formalism of their definitions extensively, but (from what I've seen so far) leaving the messy detail of dealing with the edge cases to .... I don't know yet. I haven't found the answer.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

Lingua non convalesco, consenesco et abolesco. -- Rule 1 has a caveat! -- Who broke the cabal?

"Science is about questioning the status quo. Questioning authority".

The "good enough" maybe good enough for the now, and perfection maybe unobtainable, but that should not preclude us from striving for perfection, when time, circumstance or desire allow.

However, and here's the reason I will want to browse the book before purchasing rather buying on line

Go to your nearest public library. If they don't have it, ask them to do an interlibrary loan. You'll get to browse it for a month before you decide if you want to buy a copy.

For example, the treatment of the trivial, but strongly indicative example of the unix wc program. (Which I had to type in because it doesn't come as part of the source file distribution with the book)

I don't remember any word counting problem in the book. So I grabbed my copy off the shelf and looked in the index. No luck. I skimmed it quickly. No luck. I can't even think what chapter it would be in. Maybe it doesn't come as part of the source for the book because it not in there? I don't know.

Compile and I get a (500kb!) executable.

Yeah, its a high level language. The current compilers statically link everything in the runtime into one executable. Just for comparison, my version of perl clocks in at over 1MB.

wc.hs:9:8: Parse error in pattern Hmmm. Informative!

It's that 2D syntax thing biting you again. You need to indent the "name <- getLine" line in to match up with everything else...

wc = do putStr ( "Filename; " )
        name <- getLine
        contents <- readFile name
        let ( cc, w, lc ) = wcf( 0, 0, 0 ) contents
        putStrLn ( "The file:" ++ name ++ " has " )
        putStrLn ( show cc ++ " chars " )
        putStrLn ( show w  ++ " words " )
        putStrLn ( show lc ++ " lines." )
[download]

So, skip the prompt, and try and get the argument from the command line. Scan the library docs. System looks promising. But there is nothing that looks like it gives me access to the commmand line?

getArgs

And that's the problem. All the demos are the same. They concentrate on (laborious formal) examination of Haskell's strengths and completely skip over all the messy edge cases.

I think the assumption is that the books provides a high-level overview of the concepts necessary and its up to the user to provide the nitty-gritty details which are important to them.

All languages have their strengths and weaknesses.

Yeah, Haskell isn't Perl. They live in different niches of the programming language eco-system. If you're looking for a better lanugage to bang out one-off scripts in 15 minutes, Haskell isn't what you're looking for. Before I discovered functional programming, I always thought there must be a better way of creating programs then I was currently doing. When I saw the light of FP, I realized that it went a long way towards making programming work the way I thought it should. I could now make good looking programs that weren't brittle. And they looked beautiful. Learning FP made me a better Perl programmer too. But I'm not going to tell you that FP is the one true way for everybody. If imperative curly brace Algol descended languages suit you fine, stick with them. Different strokes for different folks.

So, how about dealing with the memory issue? I thought the beauty of Haskell was that it was non-strict or lazy. That it dealt with infinite lists. Then why does getContents insist on loading the whole darn file?

I was curious about why this happened, so I tried my own variations to see if I could overcome it. Nothing I tried worked; Hugs ran out of memory with a large file every time. So I did some more searching online and through the Haskell mailing list. There's a thread that talks about the 'wc' program, and gives the reasons why it uses so much memory.

In essence, it's not that Haskell is not being lazy enough and reading in the entire file. The problem is that it's being too lazy, and not evaluating the '+1's in the recursive function call. So it keeps all these '+1's around in memory, waiting to be evaluated until it hits the base case, but you run out of memory before it gets there.

The solution they came up with on the mailing list was to create a data type to hold the stats, and put strictness markers on the data type so that the '+1's would get evaluated immediately. Below is your example converted to that style. The strictness markers are the exclamation points before the parametric types in the data constructor Stats. They tell Haskell to evaluate whatever value is about to be put into that slot in the Stats value being created, instead of keeping the "thunks" around to evaluate later. This version does run in constant memory space with a huge file.

data Stats = Stats !Int !Int !Int

wcf :: Stats -> String -> Stats
wcf stats []                    = stats
wcf (Stats cc w lc) (' '  : xs) = wcf (Stats (cc+1) (w+1) (lc  ) ) xs
wcf (Stats cc w lc) ('\t' : xs) = wcf (Stats (cc+1) (w+1) (lc  ) ) xs
wcf (Stats cc w lc) ('\n' : xs) = wcf (Stats (cc+1) (w+1) (lc+1) ) xs
wcf (Stats cc w lc) ( x   : xs) = wcf (Stats (cc+1) (w  ) (lc  ) ) xs

wc :: IO()
wc = do
    putStr ( "Filename: " )
    name <- getLine
    contents <- readFile name
    let (Stats cc w lc) = wcf (Stats 0 0 0) contents
    putStrLn ( "The file " ++ name ++ " has " )
    putStrLn ( show cc ++ " chars " )
    putStrLn ( show w  ++ " words " )
    putStrLn ( show lc ++ " lines." )

main = wc
[download]