Just for the record:
Jan Skibinski writes (comment on my divagations on
mathematical "goodies" in Haskell):
> ... then you worry about "jury"
> and "their benevolent consideration". Forget about
> the later - there is no jury and never be.
BUT I KNOW THAT!! I KNOW, I KNOW...
I am not worrying at all.
It was a bit sarcastic echo of Sergey's posting, whose
philosophy is to *change* this layer of the language, so
he wants a kind of "official imprimatur" or "nihil obstat"
or whatever you find in your personal Latin vocabulary.
For me it is obvious that Simon PJ, the Oregon Strong Team,
Lennart, and others who actively work/ed *on the language
itself* have different priorities! Changing a mature
programming language is dangerous, everybody knows that
(in particular if one teaches it...).
==
I believe that the situation will get unblocked with the
birth of the *successor* to Haskell. But the question is
whether squeezing the general math hierarchy into a universal
language is worth the effort. Shall we reconstruct Axiom or
Magma in Haskell? Most probably NOT.
Although - on the other hand - I deplore veery strongly the
fact that all computer algebra packages on the market use
strict algorithms. Laziness is so nice and crazy that I *had*
to rework some known algorithms in this way: in Haskell
(and Clean).
[A shameless self-advertizing follows]
I found even the usage for a -seemingly- mad Wadler's monadic
Time-Vehicle (the counterclock-world State Transformer) for
the implementation of the Adjoint Computational Differentiation
Technique... (If somebody here read my drunk posting on the
non-existent language "Søren" on comp.funct. newsgroup, sent
just for fun - well, it was not +completely+ meaningless.)
Yes, I need a good math in Haskell!!
======
About the Category theory and Sergey's remarks - this merits
a longer discussion.
I will say only one thing about the "uselessness" of it:
You draw a commutative diagram, you prove that it is
commutative, blahBlah, and somebody will say that it doesn't
solve any real problem. But now you start to implement
something, and you realize that you essentially get some
"theorems for free". Something is easy to be formally
specified along one path, and the actual code goes along the
other. And you deforestate the chain of "maps" without even
moving your finger.
Jerzy Karczmarczuk
Caen, France
