Michael D. Adams mdmko...@gmail.com writes:
A bit hurray for strong typing!
Don't forget Algebraic Data Types. Those seem to also avoid many of
the sorts of errors that you would see in OO or struct-based (i.e. C)
programming.
I think the combination of algebraic data types and strong
Hi Peter,
I'm delighted to hear about your successes with Haskell programming!
I suspect that parametric polymorphism has a lot to do with phenomenon of
works-when-it-compiles. The more polymorphic a signature is, the fewer the
possible type-correct definitions. Luckily, the definition that
On Sun, Feb 15, 2009 at 12:51:38AM +0100, Peter Verswyvelen wrote:
However, it is just amazing that whenever my Haskell program compiles (which
to be fair can take a while for an average Haskeller like me ;-), it just...
works! I have heard rumors that this was the case, but I can really
I have been learning Haskell for the last two weeks and was relaying that
exact benefit to my friend in attempts to convert him. I spend 3 hours
getting a few functions to compile, but when they do, they just work. Every
time.
2009/2/14 Peter Verswyvelen bugf...@gmail.com
One of the things I
As this topic popped out, my secrets for programming in Haskell are
three words: assert, HUnit, QuickCheck.
- Create internal functions that verify the results of the exported
ones, or maybe an easier to verify implementation that is slower, and
put them on assert's. This has saved me a few
2009/2/14 Peter Verswyvelen bugf...@gmail.com
One of the things I liked a lot when working with C# was that as soon as my
code compiled, it usually worked after an iteration of two.At least if we
forget about the nasty imperative debugging that is needed after a while
because of unanticipated
At Sun, 15 Feb 2009 05:37:12 +,
Sebastian Sylvan wrote:
So my conclusion is that it's not just static typing, it's functional
programming in conjunction with static strong type checking.
Indeed. For example, it's pretty hard to accidentally use an
'uninitialized variable' in Haskell,
2009/2/15 Sebastian Sylvan syl...@student.chalmers.se:
2009/2/14 Peter Verswyvelen bugf...@gmail.com
One of the things I liked a lot when working with C# was that as soon as
my code compiled, it usually worked after an iteration of two.At least if we
forget about the nasty imperative debugging
Hello,
2009/2/15 Michael D. Adams mdmko...@gmail.com:
Has anyone seen any real studies of this phenomenon? There is plenty
of anecdotal evidence that Haskell is doing something right to reduce
the bugs
Let's just call it a miracle of FP, write many books and articles on
the matter
(i.e.,
