Dynamism and Database Referential Integrity

[Alex Martelli]

"Jason Orendorff" <jason at jorendorff.com> wrote in message
news:mailman.1010542812.14800.python-list at python.org...
    ...
> > If you want type checking at compile time, you have to look for
> > Haskell or ML-style languages.
>
> ML's type system is **sweet**.  My dream language has something
> like OCaml's semantics and something like Python's syntax.

Haskell?  The semantics are far cleaner than OCaml's (lazy by
default), the syntax does have "something like" Python's, such
as significant whitespace, and list comprehensions albeit with
some punctuation rather than keywords as in Python:
    [ x | x <- someotherlist, x > 0 ]
versus
    [ x for x in someotherlist if x > 0 ]

Personally, I don't think such syntax-sugar issues matter ALL
that much.  But many people set great store in them.

If you do need some "OO on the side", as with OCaml, O'Haskell may
be worth a look -- http://www.cs.chalmers.se/~nordland/ohaskell/ .
I haven't used O'Haskell, just read its docs.

Personally, I find I'm *much* more productive with dynamically
typed languages (such as Python) than even with the best statically
typed ones (such as Haskell).  Maybe I haven't given the latter
enough effort to judge myself fairly on them -- C++, Java, Eiffel
and other "traditional" statically typed languages are clearly no
match for well-founded typesystems such as Haskell or ML, yet those
are where I got most of my experience with static types.  But I
find no particular call to invest a lot more time in good static
type languages, at least at this time -- the kind of errors they
help catch (and yet survive halfway-decent testing) just don't
seem all that frequent in the code I write.


Alex