Re: was Re: Ada / C++ comparison paper anymore

["Mark Lundquist" <no.spam@getalife.com>]

(gee I wonder what happened to the Subject: line... looks like I slipped
with the "paste" shortcut :-)

"Brian Rogoff" <bpr@bpr.best.vwh.net> wrote in message
news:Pine.BSF.4.40.0112190135400.32168-100000@bpr.best.vwh.net...
> On Wed, 19 Dec 2001, Mark Lundquist wrote:
> > "Brian Rogoff" <bpr@bpr.best.vwh.net> wrote in message
> > news:Pine.BSF.4.40.0112181924260.32168-100000@bpr.best.vwh.net...
> >
> > > I have made the point many
> > > times that I think some amount of inference/automatic instantiation,
like
> > > what C++ has, would be a great thing in an Ada like language.
> >
> > Yes.
>
> It's good to know that at least *one* more Ada fan likes this capability.

For generic subprograms, it would be _really_ nice.  I'd like to be able to
write this:

        -- An ordinary generic subprogram
        --
        generic
            type T (<>) is private;
            with function F (X  : T);
        function Thunk return T;
        .
        .
        .
        -- Another ordinary generic subprogram
        --
        generic
            type T (<>) is private;
            with function F return T;
        procedure Do_Something;
        .
        .
        .
        -- a call
        --
        Do_Something (Thunk (Some_Function (Some_Object)));

Note:
    (a) the instantiations are implicit (no "new" required);
    (b) the instantiations are anonymous; and
    (c) the actuals to formal type T are inferred

This is just scratching the surface of what could be done, but you get the
idea... Just to play around with, I wrote a package of generics for
functional programming, including a bunch of Thunks, Predicates and logical
operations on the predicates, and composition and identity functions.  It's
fun, but the syntactic overhead of building up the instantiations for any
call is way too heavy.  Plus I have to use crappy names because generics
aren't overloadable (the subject of another thread).  It could be much
more elegant.

There's a suite of enhancements to generics that I plan to write up as a
proposal... sometime before 2005 :-)

>
> > I might prefer a more longhand shorthand :-), e.g.
> >
> >     X'Increment;                        -- (X names object of integer
type)
> >     X'Increase (By => 1.23);     -- (X names object of any numeric type,
> > here a FP type)
> >     etc...
>
> Well, you can do something pretty close now with a generic package and the
> function call notation.

Been there, done that :-)... but I'd rather they were intrinsic.  In a
revised Ada, I'd still prefer the attribute notation over new operators, but
that's just my own taste...

Cheers,
-- mark

-------------
Reply by email to: Mark dot Lundquist at ACM dot org
Consulting services: http://home.attbi.com/~mlundquist2/consulting