Re: Why is Ada NOT a good choice for a beginner to programming?

[Richard Riehle <richard@adaworks.com>]

Georg Bauhaus wrote:

> One complaint he had was that it be possible to define a Length
> using derived types and still have "*" return values of type Length,
> when it should return an area.  He had a point, hadn't he?
> OTOH, with only structural equivalence of types, and no way to derive
> both an integral length type and an integral area type, that are really
> diferent, how can you build areas into your types, such that the compiler
> will prevent use of values of the wrong type?
>
> In which languages has this been fixed?

We can still achieve compile-time safety using generic formal package
parameters.   The following code does not directly address the derived
type issue,  but it does illustrate a model that can be modified to
provide a solution to this problem.  In some ways, it is like putting
a wrapper around the data type, as suggested in the C++ example
from Hyman Rosen.

=================================================


-- ==========================================================
-- Using generic formal package parameters to ensure
-- type safety from compile-time checking.
-- Author:  Richard Riehle
-- ==========================================================
with Arithmetic_Operations;
with Adding_Operators;
with Multiplying_Operators;
procedure Arithmetic_Experiment is

  type Length is digits 7;  -- could be a derived type
  type Time   is digits 7;  -- could be a derived type
  type Mass   is digits 7; -- could be a derived type

  function "+" (L, R : Length) return Length'Base is
     Result : Length := 0.0;
  begin
     return Result; -- define algorithm for appropiate behavior;
  end "+";

  function "-" (L, R : Length) return Length'Base is
    Result : Length := 0.0;
  begin
     return Result; -- define algorithm for appropiate behavior;
  end "-";

  package Add_Length is new Adding_Operators
                       (Item => Length,
                        "+"  => Arithmetic_Experiment."+",
                        "-"  => Arithmetic_Experiment."-");
  package Add_Mass   is new Adding_Operators (Item => Mass);
  package Add_Time   is new Adding_Operators (Item => Time);

  package Multiply_Length is new Multiplying_Operators (Item => Length);
  package Multiply_Mass   is new Multiplying_Operators (Item => Mass);
  package Multiply_Time   is new Multiplying_Operators (Item => Time);

  package Length_Ops is new Arithmetic_Operations
                                                (Arithmetic => Length,
                                                  F1 => Add_Length,
                                                  F2 => Multiply_Length);

  package Mass_Ops   is new Arithmetic_Operations
                                                (Arithmetic => Mass,
                                                  F1 => Add_Mass,
                                                  F2 => Multiply_Mass);

  package Time_Ops   is new Arithmetic_Operations
                                                 (Arithmetic => Time,
                                                  F1 => Add_Time,
                                                  F2 => Multiply_Time);

begin

     null;

end Arithmetic_Experiment;

====================================================================


with Adding_Operators;
with Multiplying_Operators;
generic
  type Arithmetic is digits <>;
  with package F1 is new Adding_Operators      (Item => Arithmetic);
  with package F2 is new Multiplying_Operators (Item => Arithmetic);
package Arithmetic_Operations is end Arithmetic_Operations;

====================================================================

generic
  type Item is digits <>;
  with function "+" (L, R : Item) return Item is <>;
  with function "-" (L, R : Item) return Item is <>;
package Adding_Operators is end Adding_Operators;

========================================================

generic
  type Item is digits <>;
  with function "*" (L, R : Item) return Item is <>;
  with function "/" (L, R : Item) return Item is <>;
package Multiplying_Operators is end Multiplying_Operators;