ML vs. Lisp - Programming Languages

Paul Rubin schrieb:[color=blue]
> Besides the infix syntax and the static type system, can someone
> describe the difference between ML and Lisp from a programmer's point
> of view? Should a Lisp programmer be able to get accustomed to .*ML
> (insert your favorite dialect prefix for ".*") without a lot of
> adjustment? I can tell you that does NOT happen with Haskell .[/color]

Lisp has a lot of introspection, and coming with that are various forms
of quoting.
*ML doesn't have or need that.

Lisp allows the construction of executable code at runtime.
ML doesn't have that (whether it would need that is something that MLers
and Lispers probably disagree).

Lisp has macros that work at the syntax tree level.
Macro processors are not available for all *MLs (and they aren't
considered obligatory).

The default data structure for Lisp is the linked list.
The default data structure for *ML is the tagged union (aka algebraic
data type); linked lists are one (important) variant of that class of types.
Also, Lisp lists are by default mutable, while ML lists are not. (This
particular difference isn't as important in practice, because most Lisp
programs don't mutate lists, and because it's possible to have mutable
lists in ML, so the two language groups meet on a middle ground of
"lists are mostly immutable".)

These are just those that come to my mind. I'm pretty sure people with
more direct experience with both systems can enumerate more differences.

Regards,
Jo

Paul Rubin <http://phr.cx@nospam.invalid> wrote:[color=blue]
> Besides the infix syntax and the static type system, can someone
> describe the difference between ML and Lisp from a programmer's point
> of view?[/color]

From a programmer's point of view, I'd say that the big diffence
between the two kinds of language is that the kind of things that one
would do using macros (e.g. [url]http://mlton.org/ForLoops[/url]) or dynamic
typing (e.g. [url]http://mlton.org/Printf[/url]) in Lisp or Scheme one does with
combinators in ML. It takes some time to learn and master. For
learning, I'd recommend reading articles on combinator libraries.
[color=blue]
> Should a Lisp programmer be able to get accustomed to .*ML[/color]
[intentionally cut the rest]

Yes.

-Vesa Karvonen

On 09 Feb 2007 14:02:39 -0800, Paul Rubin <http://phr.cx@NOSPAM.invalid>
wrote:
[color=blue]
>Should a Lisp programmer be able to get accustomed to .*ML (insert your
>favorite dialect prefix for ".*") without a lot of adjustment? I can
>tell you that does NOT happen with Haskell .[/color]

If you find that Haskell wreaks havoc on your brain, then ML probably
will, too, though perhaps to a lesser extent.

Steve Schafer
Fenestra Technologies Corp.
[url]http://www.fenestra.com/[/url]

In article <98cqs2hf3m0rkkhgldks2fss038me8n59l@4ax.com>, Steve Schafer
<steve@fenestra.com> wrote:
[color=blue]
> On 09 Feb 2007 14:02:39 -0800, Paul Rubin <http://phr.cx@NOSPAM.invalid>
> wrote:
>[color=green]
> >Should a Lisp programmer be able to get accustomed to .*ML (insert your
> >favorite dialect prefix for ".*") without a lot of adjustment? I can
> >tell you that does NOT happen with Haskell .[/color]
>
> If you find that Haskell wreaks havoc on your brain, then ML probably
> will, too, though perhaps to a lesser extent.[/color]

ML is not too different from Scheme. Almost not worth the effort.

Haskell is really crazy, elegant, mind-blowing, pure, strange....but
enough so that it's _worth it_ to "break on through to the other side."

--Tim May

Tim May <timcmay@removethis.got.net> writes:[color=blue]
> ML is not too different from Scheme. Almost not worth the effort.[/color]

From a practical standpoint (of trying to escape from godforsaken
languages like C while still writing tight code) I'm hoping that
compile-time type checking can eliminate some debugging, and
similarly, getting rid of dynamic typing makes much better runtime
code.
[color=blue]
> Haskell is really crazy, elegant, mind-blowing, pure, strange....but
> enough so that it's _worth it_ to "break on through to the other side."[/color]

Yeah, that's why I've been spending time on it and should try to get
back to it. Ultimately though writing real applications in it seems
dodgy, e.g. Arch is very slow, that poker guy gave up on it and
converted his server to Erlang, etc.

On Fri, 09 Feb 2007 20:05:24 -0800, Tim May <timcmay@removethis.got.net>
wrote:
[color=blue]
>ML is not too different from Scheme.[/color]

I would think that stuff like type inference would be enough to qualify
as "different enough."

Steve Schafer
Fenestra Technologies Corp.
[url]http://www.fenestra.com/[/url]

Vesa Karvonen <vesa.karvonen@cs.helsinki.fi> writes:[color=blue]
> From a programmer's point of view, I'd say that the big diffence
> between the two kinds of language is that the kind of things that one
> would do using macros (e.g. [url]http://mlton.org/ForLoops[/url]) or dynamic
> typing (e.g. [url]http://mlton.org/Printf[/url]) in Lisp or Scheme one does with
> combinators in ML. It takes some time to learn and master. For
> learning, I'd recommend reading articles on combinator libraries.[/color]

Thanks, do you recommend any particular articles? I think I
understand the gist of what you're saying, though I don't know ML
syntax enough to really grok those two examples.

In article <7xsldebq8v.fsf@ruckus.brouhaha.com>, Paul Rubin
<http://phr.cx@NOSPAM.invalid> wrote:
[color=blue]
> Tim May <timcmay@removethis.got.net> writes:[color=green]
> > ML is not too different from Scheme. Almost not worth the effort.[/color]
>
> From a practical standpoint (of trying to escape from godforsaken
> languages like C while still writing tight code) I'm hoping that
> compile-time type checking can eliminate some debugging, and
> similarly, getting rid of dynamic typing makes much better runtime
> code.
>[color=green]
> > Haskell is really crazy, elegant, mind-blowing, pure, strange....but
> > enough so that it's _worth it_ to "break on through to the other side."[/color]
>
> Yeah, that's why I've been spending time on it and should try to get
> back to it. Ultimately though writing real applications in it seems
> dodgy, e.g. Arch is very slow, that poker guy gave up on it and
> converted his server to Erlang, etc.[/color]

That was _his_ application. Note that nether darcs (the CVS sort of
program) nor Pugs (the language in which Perl 6 is being written) was
written in Erlang.

Popularity is rarely a good measure, in any case.


--Tim May

Tim May <timcmay@removethis.got.net> writes:[color=blue][color=green]
> > dodgy, e.g. Arch is very slow, that poker guy gave up on it and
> > converted his server to Erlang, etc.[/color]
>
> That was _his_ application. Note that nether darcs (the CVS sort of
> program) nor Pugs (the language in which Perl 6 is being written) was
> written in Erlang.[/color]

Sorry, yeah, I meant darcs not Arch. Darcs is well known to be quite
slow and have scaling problems--I dunno whether a comparable
implementation in another language would have had similar problems.
Pugs's slowness can't be held against it since it was supposed be a
prototype, so ok. The poker guy gave up on Haskell because 1) he
spent too much time fighting the type system and decided he was more
productive with dynamic types; and 2) his application (a very highly
concurrent, high traffic internet server) kept uncovering bugs in the
GHC runtime that hadn't been subjected to that kind of stress before.

I do get the impression that doing anything serious in Haskell
requires fairly deep wizardry not needed for Lisp, Erlang, Python,
etc. However, I continue to fool around with Haskell and I still want
to write something nontrivial in it just for educational purposes,
since I don't think the very tiny things I've tried with it so far
really give the flavor.
[color=blue]
> Popularity is rarely a good measure, in any case.[/color]

True. But the experiences of actual users count for something.