[Haskell-cafe] On the verge of ... giving up!

[Andrew Coppin]

Vimal wrote:
> @Andrew:
>   
> But, being a computer science student, I think I need to look into it too!
> I like the quote found on this site: http://patryshev.com/monad/m-intro.html
> <quote>
> Monads in programming seem to be the most mysterious notion of the century.
> I find two reasons for this:
>
>     * lack of familiarity with category theory;
>     * many authors carefully bypass any mention of categories.
>
> It's like talking about electricity without using calculus.
> Good enough to replace a fuse, not good enough to design an amplifier.
> </quote>
>   

Maybe *this* is why I get nowhere with designing electronic things? I 
know very little about calculus. (And I can't begin to imagine what it 
has to do with electricity...)

For what it's worth, a "category" is a "class" bearing some additional 
structure. A "class" is exactly like a "set", except that all sets are 
classes, but only some classes are also sets. There *is* a reason for 
this, but nobody knows what it is. (They say it's because some classes 
are "bigger" than sets - which is absurd since a set can be of any size...)

> Ah, I am not familiar with the "term-rewrite" you are talking about.
> I will Google it up then.
> Thanks :)
>   

A term-rewrite system is just a system that replaces ("rewrites") 
certain terms with other terms. For example, a package like Mathematica 
would have a term rewrite rule that says that all occurrances of "x - x" 
should be rewritten as "0". Haskell can't do anything quite *that* 
sophisticated, but what it *can* do is things like

  linear a b x = a*x + b

which causes all terms involving "linear" to be rewritten into the thing 
on the RHS. You can actually draw the "reduction" sequence as an 
expression is transformed step by step into the final result:

  sum [1,2,3]
  foldr1 (+) [1,2,3]
  foldr (+) 1 [2,3]
  foldr (+) (1+2) [3]
  foldr (+) (1+2+3) []
  1+2+3
  3+3
  6

Each line is derrived from the previous one by some program rule. (The 
last three being hard-coded into the language itself.)

If you're pathologically curiose, look up "lambda calculus" for a 
programming language like Haskell where the last few steps above are 
*definable* from first principles. >:-D