Ada

History

Distinguishing Features

• Strong static typing.
• A rich system for user-defined types.
• Separate declaration from definition.
• Packages to support programming in the large.
• Concurrency with rendezvous mechanism

Examples: Hello World

Example: Stack abstract data type

Features to note:

• element is a derived type from integer. Therefore, the integer_io package has to be reinstantiated as a new package "elt_io", and get(x) and put(x) in the stack package call elt_io.get(x) and elt_io.put(x).
• get and put are in adt_main.adb are overloaded and disambiguated using the types of e and z. Of course, ultimately they just call the built-in integer get and put -- and assuming a good compiler and inline compilation, they do so directly.

  The high ratio of notation and type juggling to stuff actually happening is quite characteristic. It reflects two things:

  • A. The desire to catch as many errors as possible at compile time. If you want to be able to force yourself to use data in a consistent way, so that the the compiler can catch departures from this, then you have to allow e.g. different kinds of types that at run-time are actually all integers, but at compile time are consider all incompatible. And then you have to provide mechanisms for (a) running the same code on incompatible types, since you don't want to rewrite identical code for each derived type; (b) converting from one of these to another, since in fact you will end up doing this all the time; and probably also (c) running different code with the same name for operations that are conceptually analogous but involve some difference -- i.e. overloading or overriding.

    The other extreme is Scheme, in which there are no declarations, no user-defined types (I think), and almost no compile time errors. It's faster to write, but run-time errors are much harder to catch and to deal with, for obvious reasons.

  • B. The tenet of information hiding. The theory is that you want to provide external access only to high-level functionality and hide low-level implementation, even when the high-level and the low-level are in fact identical.
  • C. In programming languages, there is always a choice to be made between being compact and cryptic and being verbose and clear. Besides readability, verbosity has the advantage that a typo of a single character will usually create a compile time error, rather than compilable but erroneous code. Anyone who has spent hours debugging code and finding at the end that the problem is because he/she wrote = rather than = = will appreciate the force of this. Ada generally chooses verbose clarity.

Control structures and expressions

• begin ... end (used a lot less than { ... } in C etc.)
• if .. then .. end if.
  if ... then ... else ... end if;
  if ... then ... elseif ... elseif ... else ... end if;

• case N is 
     when Val => Statement; 
     when Val | Val | Val => Statement; 
     when others => Statement
  end case;
  

• loop ... exit ... end loop;
  George: loop ... exit George ... end loop George;
  loop for I in 1 .. N loop ... end loop;
  while Condition loop ... end loop
  
• goto label ... < < label >> Statement.
• Expressions as usual. User may override arithmetic and other basic operators.

Types

Scalar types

User defined types

• Enumeration type:
  type Color = (Red, Orange, Yellow, Green, Blue, Violet).
  Color'First = Red. Color'Last=Violet. Color'Range = Red .. Violet.
  Color'Succ(Orange) = Yellow. Color'Pred(Orange)=Red.
• Subtypes:
  type Population is Integer;
• Range subtypes:
  subtype Score is Integer range 0 .. 100;
  subtype Bluish is Color range Green .. Violet;
  Runtime range checking.
• Derived type:
  type Distance is new Float;
  Incompatible with base type; need to carry out cast.
  F: Float; D : Distance;
  D := F; Compile time type error
  D := (Distance) F; OK because of cast.

Arrays

Records

Discriminated record types (variant records)

type ItemCat is (Book, Article, MS);
type BibRecord(Category: ItemCat)
   record Author, Title: string;
       case Category is
         when Book => year: Integer,
                      publisher: String;
         when Article => year, vol, pStart, pEnd: Integer;
                         journal: String;
        end case;
     end record;

Pointers and dynamic objects

As of Ada-95, it is possible to create pointers to a stack object, but the lifetime of the object must be greater than the lifetime of the pointer. Usually a static check; sometimes a dynamic check.

Lots of other pointer mechanisms and notations.

Garbage collection is optional -- up to implementation. User deallocation is supported.

Procedures

• Declaration can be separated from definition.
• Lexical imbedding and lexical scoping. Hidden variables can be accessed by explicit reference to the procedure. E.g.

  procedure P is
  I : integer;
  
    procedure Q  is
    I : integer;
  
    ... P.I ...
    end Q
  
  end P;
  

• Functions return a value and accept parameters call by value. A function failing to return a value is a run-time error. Procedures do not return a value, and allow parameters to be declared "in" (call by value) "out" (only returned); or "in out". "In Out" can be either call by reference or call by value-restore -- incredibly, this is left to the implementation. Code whose behavior depends on this choice is considered erroneous, but this error is not checked.

Packages

Package specifications can be top-level or imbedded in the declaration of another package or a subprogram.

Types can be:

• public (the default). Fields are externally visible.
• private. Only methods in public declaration, assignment, =, and /= are externally visible.
• limited private. Only methods in public declaration are visible (not assignment, =, or /=).

Import package with "use packageName"

Exceptions

function ...
begin 
   body of function
exception when ExceptionName => Action
               ExceptionName => Action
               ...
               others => Action
end

A standard library provides functionalities for passing more information from the raiser to the catcher.

Passing functions as parameters

-- Define type pRealFloat as a pointer to a function from Float to Float
type pRealFun is access function(X: Float) return Float;

function integrate(F: pRealFun; L,U: Float, N: Integer) return Float is
   begin ...
           Sum := Sum + F(X)*Delta;    -- Call of function referenced by F;
         ...
    end;

function square(X: Float) return Float is begin return X*X end;

... 
integrate(square'Access, -- creates pointer to function square
          0.0, 10.0 100)
...

Generics

Generic type and function

generic
  type Item is private;
  type ItemArray is array(Integer range < >) of Item;
  with function f(X: Item) return Item;
  procedure ArrayApplier (A,B: in out ItemArray) is
     begin for I in A'Range loop
             B[I] := f(A[I]);
           end loop
     end 

function square(X: Float) return Float is begin return X*X end;

type FArray is array(Integer range < >) of Float;

function ApplySquare is new ArrayApplier(Float,FArray,square);

Concurrency

Tasks can be individual or instances of a task type.

Individual task:

task Name;
task body Name is begin ... end 

Task types:

type task TaskName; -- Declaration
task body Name is begin ... end -- Body
type TArray is array(< >) of TaskName;
type PTask is access TaskName;

procedure foo is
N1, N2 : TaskName;
TA : TArray(1..10);
PT : PTask;

begin  -- N1, N2, TA start running on entering begin.
   PT = new Ptask;  -- PT starts running now
...
end

Synchronization: Rendezvous and Protection

Rendezvous

From the point of view of A: When A reaches an accept entry point, it halts until some caller C calls that entry point. The in parameters are received; the body of the accept is executed; the out parameters are returned to C; and then A continues executing.

From the point of view of C: When C calls an entry point of task A, it posts the in parameters, and then goes to sleep. When A is ready to accept the call, the run-time system delivers the parameters, and A executes its body, and returns the out parameters. Then C wakes up and continues execution.

Calling syntax in C: A.E(actual parameters);
Accepting syntax in A: Entry points are declared at the start of A.

accept E(formal parameters) do ... body of E ... end E.

Protection

Object orientation