Re: How come Ada isn't more popular?

[Markus E Leypold <development-2006-8ecbb5cc8aREMOVETHIS@ANDTHATm-e-leypold.de>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> On Thu, 01 Feb 2007 17:26:21 +0100, Georg Bauhaus wrote:
>
>> On Thu, 2007-02-01 at 15:22 +0100, Dmitry A. Kazakov wrote:
>
>>> On Wed, 31 Jan 2007 16:16:20 +0100, Markus E Leypold wrote:
>> 
>>>> BTW -- another argument _for_ a builtin list syntax.
>>> 
>>> Hey, Ada already has ()-brackets. Maybe our Unicode fans would propose
>>> special glyphs for )), ))), )))), ))))), )))))) etc. Is it what you mean as
>>> special syntax? (:-)) 
>> 
>> Actually, a syntax that is used in a theory book is
>> {left/right paren}{subscript i}.
>
> Great. The next step would be to introduce expression in subscripts: )2+1 =
> )3 = ))). Right? Then we proceed to )f(...) where f is a free function that
> determines the number of brackets. OK? Now the question is, is it still
> syntax? (:-))
>
>> What does a list syntax buy us if there is no argument pattern matching,
>> or no data structure pattern matching in Ada? Brevity?
>
> There is no need in pattern matching. What is actually required in Ada is
> abstract aggregates, i.e. an ability do have user-defined constructor
> functions with the parameter specified in the form of a list.
>
>> generic
>>    type T is private;
>>    with function "+"(a, b: T) return T;
>>    increment: T;
>> function Inc(arg: T) return T;
>> 
>> function Inc(arg: T) return T is
>> begin
>>    return increment + arg;
>> end Inc;
>> 
>> Looks like more code, and I hear an FP advocate saying, "in FP,
>> you just ...". Any sentence that starts with "You just ..."
>> is suspicious :-)
>> 
>> Can I have this without generics, please, Dmitry? ;-)
>
> Sure you can:
>
> type Additive is abstract;  -- Should be enough for an interface
> function "+" (A, B : Additive) return Additive is abstract;
>
> Here I am not sure about "increment" variable, because it is not
> initialized. Anyway:
>
> function Increment return Additive is abstract;
>    -- Better be getter/setter pair. Unfortunately Ada does not have
>    -- "abstract variable interface" it should have
>
> function Inc (Arg : Additive'Class) return Additive'Class is
> begin
>    return Increment + Arg;
> end Inc;
>
> There is a very simple rule for all this:
>
> 1. Formal generic subroutines -> abstract primitive operations
> 2. Subroutines in the body -> class-wide operations.


So you derive from Additive to get a specific implementation?

Like

  type Vector   is Additive with ...;
  type CountVal is Additive with ...;

Right? But then, you should note that with

  C: Countval;

  Inc(C).

returns an 'Additive', not a 'CountVal'. That is one problem. The
other is of course that Increment is not initialized. This is exactly
what generics are here to solve.

Regards -- Markus