Re: newbie can't get exceptions to work!

[Laurent Guerby <guerby@acm.org>]

Brian Rogoff <bpr@shell5.ba.best.com> writes:
> Well, I'm doing what I can on the OCaml mailing list to get nice little
> features of Ada adopted. In the case of labeled and optional arguments,
> it's a lot tougher in OCaml than Ada, which has type inference and higher
> order functions. If you look at the recent discussions on the mailing
> list, Jacques Garrigue (the label inventor and main proponent) is laying
> out the alternatives and it looks like the only way to get commuting
> labels is to have labels be non-optional. I don't like that. 

I see label and optional arguments being two separate issue. If you do
only labels, it shouldn't cause any problem at all, you can even
disallow overloading with only label changes while keeping most of the
interesting thing about labels (call site clarity). But even keeping
overloading should be near trivial.

Optional argument are a whole different beast, and I think much less
useful, and I think likely to cause trouble.

Is it that the conjunction of both feature is being considered and
hence the problems (my advice would be to just drop optional
arguments), or am I missing something obvious?

I agree with you that mandating labels is not a good idea.

> > X : constant T := if C1  then V1 elsif C2 then V2 else V3;
> > 
> > This is something I think people miss in Ada, may be someone should
> > wrote an extension proposal ;-).
> 
> That would work. OTOH, since Ada is statement oriented rather than
> expression oriented, perhaps a different syntax for conditional
> expressions is warranted?

I don't buy the statement oriented thing, you can do lots of thing
without statements in Ada (the missing thing is this conditional
feature ;-), and I see no need to invent new syntax here (but well
that's a taste & color issue here ;-).

> Allowing declarations to float is nice. However, if, as I suggested, we
> allow downward funargs (only downward, we don't want to require GC :) 
> and anonymous functions, the {} has the advantage that function
> definitions are lightweight enough to be expressed inline more easily. 

If you type arguments, that's not going to be one liners hence the { }
won't buy you much. (I find SmallTalk syntax for blocks quite nice,
but let's say it's really typed ;-).

> > And I of course forgot the mandatory () for function calls without 
> > args silliness ;-).
> 
> A great feature. Some people hate it though. 

I don't know the history, but I'd say it's mostly because of the
statement = expression + fonction = pointer syntax horrors of C that
forces a hack to disambiguate, not because of methodology that argless
func/proc calls must specify ().

Why are people liking this?

Only C/C++/Java have inherited this syntax, other languages including
most FP do not have it and that's much better this way (am I missing
something obvious here?).

> > No, I just program in Ada at home and work ;-) ;-).
> Lucky you! I've switched to OCaml. 

I looked at the FP situation two years ago when we switched languages
at work (from C to Ada 95), but there was no real industrial stuff
available (with formal support and available even for idiotic
proprietary platforms). 

Right now, I think there's Erlang (we write numerical code and even
the Erlang manual says it's not for us ;-) and may be OCaml if out of
the recently announced consortium a real support company pops up.

As you might have guessed our support comes from ACT Europe and we're
using GNAT.

> Something about French designed languages, eh? :-)

May be ;-).

-- 
Laurent Guerby <guerby@acm.org>