Programmazione generic in Ada ── Contratti nei tipi e riuso a costo zero

1. Introduzione ── Non «accettare qualsiasi cosa», ma «che cosa si promette»

Quando si prova a scrivere codice riusabile in un linguaggio a tipizzazione statica, si urta subito lo stesso problema. Lo stack scritto per gli interi lo si vorrebbe usare anche con le stringhe. Sull’array in virgola mobile si vorrebbe applicare la stessa statistica. La logica di un ordinamento crescente la si vorrebbe riusare per quello decrescente. Se però si copia lo stesso codice per ogni tipo, le correzioni si dimenticano. Se al contrario si accetta qualsiasi cosa con void* o con i cast, la type safety si spezza.

La risposta di Ada sono i generic (generic units).

I generic Ada non sono una semplice sostituzione di testo. Accettano come parametri formali tipi, valori, sottoprogrammi e persino package interi, e al momento dell’istanziazione vengono type-checkati in modo statico. Non si verifica a runtime «questo tipo va davvero bene»: in compilazione si stabilisce «questo componente soddisfa il contratto».

flowchart LR
    accTitle: Tre modi di riusare la stessa logica
    accDescr: Confronto tra copia e incolla, void-star o cast, e i generic Ada rispetto a type safety e costi a runtime
    A[Logica da riusare] --> B{Come riusarla?}
    B --> C[Copia e incolla]
    B --> D[void* / Object / cast]
    B --> E[Generic Ada]

    C --> C1[Facile dimenticare una correzione]
    D --> D1[Errori a runtime e perdita di type safety]
    E --> E1[Type-safe]
    E --> E2[Controllo in compilazione]
    E --> E3[Nessun dispatch extra a runtime]

In questo articolo organizziamo la programmazione generic in Ada nel seguente ordine.

• Sottoprogrammi generici
• Package generici
• Parametri di tipo, di valore e di sottoprogramma
• Categorie di tipo come private, range <>, digits <>
• Esempi di implementazione: ordinamento, stack, statistica, Count_If, key-value store
• Generic di ordine superiore tramite parametri formali di package
• Il contract model di Ada e i criteri di progettazione pratica

1.1 A chi è rivolto e che cosa potete portarvi via

L’articolo è pensato per chi si riconosce in uno di questi profili.

• Chi ha già usato template C++, generics C# o Java, oppure i generic di Rust
• Chi non è esperto della sintassi Ada ma è interessato a una progettazione in cui «i contratti si scrivono nei tipi»
• Chi, in manutenzione di lungo periodo, embedded o alta affidabilità, sta valutando come progettare componenti riusabili

Come sintassi Ada basta conoscere i package (separazione tra specifica .ads e corpo .adb) e i modi dei parametri in / out / in out. Se questi due punti sono incerti, leggere prima «Il fascino del linguaggio Ada» accelera la comprensione.

Ciò che potete portarvi via non è tanto la sintassi Ada in sé, quanto l’abitudine di progettare: scrivere come tipi, prima dell’implementazione, che cosa un componente riusabile richiede. Lo stesso ragionamento si applica quando decidete fino a dove spingere i vincoli di interfaccia in C# o i concepts di C++20.

1.2 Guida alla lettura ── Non serve leggere tutto

L’articolo ha 20 capitoli. Non è necessario leggerli in sequenza: potete selezionare in base allo scopo.

Il percorso più breve sono i tre capitoli 4, 6 e 13. In questi tre avete il nucleo: parametri formali, istanziazione, contract model. I capitoli 5 e 9 sono elenchi di parametri formali: va bene consultarli come dizionario quando servono.

Il tema si colloca nella serie del blog dopo «Il fascino del linguaggio Ada», «Introduzione alla verifica formale con SPARK», «Concorrenza sicura in Ada» e «Sistemi real-time in Ada». Qui approfondiamo, dal lato dei generic, l’idea Ada di «far parlare i tipi del progetto».

Mappa della conoscenza di questo articolo

I generic Ada sono un meccanismo di riuso che accetta tipi, valori, sottoprogrammi e package come parametri formali e che, al momento dell’istanziazione con new, viene type-checkato in modo statico. I sottoprogrammi generici e i package generici sono i due pilastri di questo meccanismo: i parametri di tipo formali rendono esplicito, tramite categorie come private, range <> e digits <>, il contratto delle operazioni che il corpo può usare; i parametri formali di sottoprogramma iniettano comportamenti come confronti e predicati; i parametri formali di package accettano come componente un package generico già istanziato. Grazie al contract model, che type-checka il corpo da solo nel solo raggio dei parametri formali, il problema che i template C++ hanno avuto storicamente, per cui l’errore si vede solo all’istanziazione, in Ada non si verifica per costruzione. Con GNAT e Alire si può provare questo meccanismo in un ambiente gratuito.

flowchart LR
    accTitle: Mappa della conoscenza della programmazione generic in Ada
    accDescr: Diagramma che mostra come i sottoprogrammi generici e i package generici poggino sul contratto (contract model) dei parametri formali di tipo, valore, sottoprogramma e package, come l'istanziazione con new ne verifichi il contratto, e la differenza rispetto al problema storico dei template C++ per cui gli errori emergevano solo all'istanziazione
    ada_generics["Generic di Ada (unità generiche)"]
    ada_generic_contract_model["Contract model dei generic Ada"]
    ada["Ada (linguaggio di programmazione)"]
    ada_generic_subprogram["Sottoprogramma generico (Generic Subprogram)"]
    ada_generic_package["Package generico (Generic Package)"]
    ada_generic_formal_type["Parametro formale di tipo (Formal Type)"]
    ada_generic_formal_subprogram["Parametro formale di sottoprogramma (Formal Subprogram)"]
    ada_generic_formal_package["Parametro formale di package (Formal Package)"]
    ada_generic_instantiation["Istanziazione (instantiation)"]
    ada_generic_formal_object["Parametro formale di oggetto (valore) (Formal Object)"]
    late_instantiation_error["Errore di template rilevabile solo all'istanziazione"]
    cpp_templates["Template C++"]
    gnat["GNAT"]
    alire["Alire"]
    ada -->|"implementa"| ada_generics
    ada_generics -->|"usa"| ada_generic_subprogram
    ada_generics -->|"usa"| ada_generic_package
    ada_generic_subprogram -.->|"richiede"| ada_generic_formal_type
    ada_generics -->|"usa"| ada_generic_formal_subprogram
    ada_generics -->|"usa"| ada_generic_formal_package
    ada_generics -->|"richiede"| ada_generic_instantiation
    ada_generic_formal_type -->|"configurato da"| ada_generic_instantiation
    ada_generic_package -.->|"richiede"| ada_generic_formal_type
    ada_generic_package -.->|"richiede"| ada_generic_formal_object
    ada_generic_formal_subprogram -->|"implementa"| ada_generic_contract_model
    ada_generic_formal_type -->|"implementa"| ada_generic_contract_model
    ada_generic_contract_model -->|"previene"| late_instantiation_error
    cpp_templates -.->|"può causare"| late_instantiation_error
    ada_generic_formal_package -->|"richiede"| ada_generic_instantiation
    gnat -->|"implementa"| ada
    gnat -.->|"configurato da"| alire
    ada_generic_subprogram -.->|"usa"| ada_generic_formal_subprogram
    ada_generic_package -.->|"usa"| ada_generic_formal_subprogram
    ada_generic_instantiation -.->|"richiede"| ada_generic_formal_object
    ada_generic_formal_object -->|"implementa"| ada_generic_contract_model

Nel diagramma, una linea continua indica una relazione che vale sempre e una linea tratteggiata indica una relazione condizionale (le condizioni sono nella spiegazione di ciascuna relazione nella pagina di dettaglio). L’elenco completo delle relazioni (in totale 21, con evidenza e livello di certezza) e le definizioni dei concetti principali sono raccolti nella pagina di dettaglio della mappa della conoscenza (in giapponese). Dati: JSON-LD / Turtle

2. La mappa di questo articolo

Prima fissiamo il quadro d’insieme. Se i generic Ada li si capisce solo come «una funzione che prende un tipo come argomento», la visione è stretta. In realtà, a seconda dell’unità che si vuole riusare, si combinano sottoprogrammi, package, parametri di sottoprogramma, parametri valore e parametri formali di package.

mindmap
  root((Ada Generics))
    Sottoprogramma generico
      Swap
      Count_If
      Sort
    Package generico
      Stack
      Statistics
      KV Store
    Parametri formali
      Tipo
        private
        limited private
        range box
        mod box
        digits box
        delta box
        discrete box
      Oggetto
        Max_Size
        Threshold
      Sottoprogramma
        Funzione Less
        Funzione Equals
        Predicate
      Package
        with package P is new Generic
    Idee di progettazione
      Contract Model
      Controllo statico
      Astrazione a costo zero
      Specifica e corpo separati

Nei diagrammi box indica il <> di Ada (box compound delimiter). Mermaid non riesce a disegnare <> così com’è, quindi solo nei diagrammi si scrive box.

Il modo di leggere l’articolo è semplice. Nella prima metà seguiamo la sintassi, nella seconda le decisioni di progettazione. Se è la prima volta che leggete Ada, all’inizio non cercate di memorizzare i dettagli sintattici: concentratevi su che cosa è stato reso parametro formale e quali operazioni quel parametro consente.

2.1 Mini-glossario

Prima di proseguire, mettiamo in corrispondenza i termini che torneranno più volte. Nella letteratura Ada, generic si rende spesso con «generico»; in questo articolo useremo «sottoprogramma generico» e «package generico», con lo stesso significato di «generic».

Nel testo scriviamo range <>, digits <> come nella notazione Ada, ma solo nei diagrammi scriviamo range box, digits box. Mermaid non disegna etichette che contengono <>; il significato è lo stesso del testo. Come nella tabella, Ada stesso chiama <> box, quindi la notazione dei diagrammi non esce dal vocabolario Ada.

3. Ambiente di esecuzione e compilazione

Il codice di questo articolo presuppone GNAT 15.x o successivo. GNAT è il compilatore Ada di riferimento e si può installare da Alire. Alire è il package manager di Ada / SPARK e serve anche a gestire toolchain e build.

gnat --version
# GNAT 15.2.1

Installate GNAT da Alire (il package manager Ada) con alr install gnat_native gprbuild e mettete i binari nel PATH.

I campioni trattati qui si intendono disposti così nel repository.

flowchart TB
    accTitle: Disposizione dei campioni nel repository
    accDescr: I frammenti 01_swap.ada fino a 06_kv_store.ada stanno in src/snippets sotto ada-generic-programming
    R[ada-generic-programming/] --> S[src/]
    S --> N[snippets/]
    N --> A[01_swap.ada]
    N --> B[02_stack.ada]
    N --> C[03_sort.ada]
    N --> D[04_statistics.ada]
    N --> E[05_filter.ada]
    N --> F[06_kv_store.ada]
    R --> README[README.md]

I campioni che riuniscono più unità di compilazione in un solo file si spezzano con gnatchop e poi si compilano con gnatmake.

mkdir work
cd work
gnatchop ../src/snippets/01_swap.ada
gnatmake -gnata swap_demo
./swap_demo

-gnata abilita le asserzioni. Non è obbligatorio per usare i generic in sé, ma nei campioni didattici rende più facile verificare contratti e condizioni di bordo.

sequenceDiagram
    accTitle: Flusso da un file .ada all'eseguibile
    accDescr: gnatchop spezza il file, gnatmake fa bind e link, poi si esegue il programma
    participant Dev as Sviluppatore
    participant Chop as gnatchop
    participant Build as gnatmake
    participant Exe as Eseguibile

    Dev->>Chop: Passa un solo file .ada
    Chop-->>Dev: Spezza in .ads / .adb / main
    Dev->>Build: gnatmake -gnata main
    Build-->>Dev: Esegue bind e link
    Dev->>Exe: ./main
    Exe-->>Dev: Output

4. Il modello di base dei generic Ada

I generic Ada si capiscono bene, in larga sintesi, in tre passi.

1. Si scrive un’unità generica
2. Nella parte generic si scrivono i parametri formali
3. Dal lato utente si istanzia con new

flowchart LR
    accTitle: Tre passi del modello generic Ada
    accDescr: Dalla dichiarazione generic ai parametri formali, al corpo, all'istanziazione con new e all'uso come sottoprogramma o package ordinario
    G[dichiarazione generic] --> F[Parametri formali]
    F --> B[Corpo del generic]
    B --> I[Istanziazione con new]
    I --> U[Uso come sottoprogramma o package ordinario]

    F --> F1[Tipi]
    F --> F2[Valori]
    F --> F3[Sottoprogrammi]
    F --> F4[Package]

Per esempio, se si rende generic lo scambio di due valori, basta il tipo come parametro formale.

generic
   type Element is private;
procedure Generic_Swap (A, B : in out Element);

A questo punto Generic_Swap non è ancora chiamabile. È «il template di uno scambio utilizzabile per un tipo Element qualsiasi». Diventa una procedura ordinaria solo quando si fornisce un tipo concreto.

procedure Swap_Integer is new Generic_Swap (Integer);

In figura, la relazione è questa.

flowchart TB
    accTitle: Istanziazione di Generic_Swap per tipo
    accDescr: Lo stesso template produce Swap_Integer, Swap_Character e Swap_My_Record a seconda del tipo passato
    Template[Generic_Swap<br/>type Element is private] -->|Passa Integer| SwapInt[Swap_Integer]
    Template -->|Passa Character| SwapChar[Swap_Character]
    Template -->|Passa My_Record| SwapRecord[Swap_My_Record]

    SwapInt --> ICall[Scambia variabili Integer]
    SwapChar --> CCall[Scambia variabili Character]
    SwapRecord --> RCall[Scambia variabili My_Record]

Il punto cruciale è che il corpo del template è scritto solo con le operazioni disponibili su Element. Se si dichiara type Element is private;, si possono usare operazioni di base come assegnamento e uguaglianza, ma non confronti di ordine né aritmetica. In altre parole, la dichiarazione generic stessa dice «che cosa questo componente può presupporre».

5. Tipi di parametro formale ── Il vocabolario dei generic Ada

Ciò che un generic Ada può ricevere non è solo un tipo. È qui che si discosta in modo netto dai generics tipici di C# o Java.

flowchart TB
    accTitle: Quattro tipi di parametro formale
    accDescr: I parametri formali Ada sono tipi, oggetti o valori, sottoprogrammi e package
    P[generic formal parameters] --> T[Parametri di tipo]
    P --> O[Parametri oggetto / valore]
    P --> S[Parametri di sottoprogramma]
    P --> PKG[Parametri di package]

    T --> T1[type Element is private]
    T --> T2[type Index is box]
    T --> T3[type Real is digits box]
    O --> O1[Max_Size : Positive]
    O --> O2[Default_Value : Element]
    S --> S1[with function Less...]
    S --> S2[with procedure Put ...]
    PKG --> P1[with package P is new ...]

Nei diagrammi box indica il <> di Ada (box compound delimiter). Mermaid non riesce a disegnare <> così com’è, quindi solo nei diagrammi si scrive box.

I parametri formali rappresentativi, in tabella, sono i seguenti.

Grazie a questo vocabolario, in Ada è naturale scrivere non «accetto qualsiasi cosa e dentro faccio operazioni pericolose», ma «accetto solo i tipi su cui queste operazioni sono possibili».

6. Sottoprogrammi generici ── Capire la forma minima con Generic_Swap

Come primo esempio, vediamo Generic_Swap, che scambia due variabili di un tipo qualsiasi.

6.1 Specifica

generic
   type Element is private;
procedure Generic_Swap (A, B : in out Element);

La parte che segue generic è l’elenco dei parametri formali. Qui si riceve un tipo chiamato Element. is private significa che, dal punto di vista del corpo del generic, la rappresentazione interna di quel tipo non è nota.

Da questa dichiarazione risultano chiare due cose.

• Generic_Swap è utilizzabile per un tipo Element qualsiasi
• Il corpo non dipende dalla struttura interna di Element né da confronti di ordine

6.2 Corpo

procedure Generic_Swap (A, B : in out Element) is
   Temp : constant Element := A;
begin
   A := B;
   B := Temp;
end Generic_Swap;

In questo corpo, su Element si usa solo l’assegnamento. Non c’è A < B né A + B. Quindi funziona in modo naturale per Integer, Character, tipi record, enumerazioni: qualunque tipo assegnabile.

flowchart LR
    accTitle: Scambio di due valori tramite Temp
    accDescr: Prima della chiamata A vale 10 e B vale 20; dopo, tramite Temp, A vale 20 e B vale 10
    subgraph Before[Prima della chiamata]
        A1[A = 10]
        B1[B = 20]
    end

    A1 --> T[Temp = A]
    B1 --> A2[A = B]
    T --> B2[B = Temp]

    subgraph After[Dopo la chiamata]
        A2[A = 20]
        B2[B = 10]
    end

6.3 Istanziazione

Dal lato utente si usa new.

procedure Swap_Int  is new Generic_Swap (Integer);
procedure Swap_Char is new Generic_Swap (Character);

Così Swap_Int e Swap_Char sono chiamabili come procedure ordinarie.

with Ada.Text_IO; use Ada.Text_IO;

procedure Swap_Demo is
   generic
      type Element is private;
   procedure Generic_Swap (A, B : in out Element);

   procedure Generic_Swap (A, B : in out Element) is
      Temp : constant Element := A;
   begin
      A := B;
      B := Temp;
   end Generic_Swap;

   procedure Swap_Int is new Generic_Swap (Integer);

   X : Integer := 10;
   Y : Integer := 20;
begin
   Put_Line ("Before: X=" & Integer'Image (X) & ", Y=" & Integer'Image (Y));
   Swap_Int (X, Y);
   Put_Line ("After : X=" & Integer'Image (X) & ", Y=" & Integer'Image (Y));
end Swap_Demo;

L’output è il seguente.

Before: X= 10, Y= 20
After : X= 20, Y= 10

A Swap_Int (X, Y); non si può passare una variabile Float. Swap_Int è una procedura ordinaria istanziata per Integer. I generic non sono «un buco in cui entra qualsiasi cosa»: sono «un meccanismo che produce un oggetto concreto type-safe per ciascun tipo».

7. Package generici ── Parametrizzare insieme tipo e valore

Quando non basta un solo sottoprogramma e si vogliono riusare più operazioni insieme a uno stato interno, si usa un package generico. L’esempio classico è lo stack.

Nello stack, se si cambiano solo il tipo degli elementi e la capacità massima, la logica di base resta la stessa.

flowchart TB
    accTitle: Generic_Stack parametrizzato per tipo e capacità
    accDescr: Generic_Stack riceve Element_Type e Max_Size e produce istanze Int_Stack, Float_Stack e String_Stack
    G[Generic_Stack] --> P1[Element_Type]
    G --> P2[Max_Size]
    G --> Ops[Push / Pop / Size / Is_Empty / Is_Full]

    G --> I1[Int_Stack<br/>Element=Integer<br/>Max_Size=5]
    G --> I2[Float_Stack<br/>Element=Float<br/>Max_Size=3]
    G --> I3[String_Stack<br/>Element=Unbounded_String<br/>Max_Size=20]

7.1 Specifica

generic
   type Element_Type is private;
   Max_Size : Positive;
package Generic_Stack is
   procedure Push (Item : Element_Type);
   function Pop return Element_Type;
   function Is_Empty return Boolean;
   function Is_Full  return Boolean;
   function Size return Natural;

   Stack_Overflow  : exception;
   Stack_Underflow : exception;
end Generic_Stack;

Qui si usano due tipi di parametro formale.

• Element_Type è un parametro di tipo
• Max_Size è un parametro valore

Max_Size è Positive, quindi non si può istanziare con una capacità minore o uguale a zero. Anche i parametri valore portano vincoli di tipo.

7.2 Corpo

package body Generic_Stack is
   subtype Index_Type is Positive range 1 .. Max_Size;
   type Storage_Type is array (Index_Type) of Element_Type;

   Data : Storage_Type;
   Top  : Natural := 0;

   procedure Push (Item : Element_Type) is
   begin
      if Top = Max_Size then
         raise Stack_Overflow;
      end if;

      Top := Top + 1;
      Data (Top) := Item;
   end Push;

   function Pop return Element_Type is
      Result : Element_Type;
   begin
      if Top = 0 then
         raise Stack_Underflow;
      end if;

      Result := Data (Top);
      Top := Top - 1;
      return Result;
   end Pop;

   function Is_Empty return Boolean is
   begin
      return Top = 0;
   end Is_Empty;

   function Is_Full return Boolean is
   begin
      return Top = Max_Size;
   end Is_Full;

   function Size return Natural is
   begin
      return Top;
   end Size;
end Generic_Stack;

Nel corpo del package, il punto importante è che Data e Top vengono creati separatamente per ciascuna istanza.

package Int_Stack   is new Generic_Stack (Integer, 5);
package Float_Stack is new Generic_Stack (Float,   3);

Le due istanze nascono dallo stesso template, ma non condividono lo stato interno.

flowchart LR
    accTitle: Stato indipendente per ciascuna istanza di stack
    accDescr: Int_Stack e Float_Stack hanno ciascuno il proprio Top e il proprio array Data
    Template[Generic_Stack] --> IntStack[Int_Stack]
    Template --> FloatStack[Float_Stack]

    subgraph I[Stato di Int_Stack]
        ITop[Top]
        IData[Data : array di Integer]
    end

    subgraph F[Stato di Float_Stack]
        FTop[Top]
        FData[Data : array di Float]
    end

    IntStack --> I
    FloatStack --> F

7.3 Transizioni di stato dello stack

Lo stack si capisce bene se lo si guarda come macchina a stati.

stateDiagram-v2
    accTitle: Macchina a stati di uno stack a capacità fissa
    accDescr: Push e Pop spostano lo stack tra vuoto, non vuoto e pieno, e Push/Pop illegali portano a overflow o underflow
    [*] --> Empty
    Empty --> NonEmpty: Push
    NonEmpty --> NonEmpty: Push / Pop
    NonEmpty --> Empty: Pop estrae ultimo elemento
    NonEmpty --> Full: Push raggiunge Max_Size
    Full --> NonEmpty: Pop
    Full --> Overflow: Push
    Empty --> Underflow: Pop

7.4 Esempio d’uso

with Ada.Text_IO; use Ada.Text_IO;

procedure Stack_Demo is
   generic
      type Element_Type is private;
      Max_Size : Positive;
   package Generic_Stack is
      procedure Push (Item : Element_Type);
      function Pop return Element_Type;
      function Is_Empty return Boolean;
      function Is_Full  return Boolean;
      function Size return Natural;
      Stack_Overflow  : exception;
      Stack_Underflow : exception;
   end Generic_Stack;

   package body Generic_Stack is
      subtype Index_Type is Positive range 1 .. Max_Size;
      type Storage_Type is array (Index_Type) of Element_Type;

      Data : Storage_Type;
      Top  : Natural := 0;

      procedure Push (Item : Element_Type) is
      begin
         if Top = Max_Size then
            raise Stack_Overflow;
         end if;

         Top := Top + 1;
         Data (Top) := Item;
      end Push;

      function Pop return Element_Type is
         Result : Element_Type;
      begin
         if Top = 0 then
            raise Stack_Underflow;
         end if;

         Result := Data (Top);
         Top := Top - 1;
         return Result;
      end Pop;

      function Is_Empty return Boolean is (Top = 0);
      function Is_Full  return Boolean is (Top = Max_Size);
      function Size     return Natural is (Top);
   end Generic_Stack;

   package Int_Stack is new Generic_Stack (Integer, 5);
begin
   Int_Stack.Push (10);
   Int_Stack.Push (20);
   Int_Stack.Push (30);

   Put_Line ("Size=" & Natural'Image (Int_Stack.Size));
   Put_Line ("Pop =" & Integer'Image (Int_Stack.Pop));
   Put_Line ("Pop =" & Integer'Image (Int_Stack.Pop));
   Put_Line ("Size=" & Natural'Image (Int_Stack.Size));
end Stack_Demo;

Si compilano ed eseguono con la stessa procedura del capitolo 3.

gnatchop ../src/snippets/02_stack.ada
gnatmake -gnata stack_demo
./stack_demo

Size= 3
Pop = 30
Pop = 20
Size= 1

Lo spazio dopo = è dovuto alla specifica di 'Image sui tipi interi, che mette un carattere di spazio davanti a un valore non negativo. Dopo tre Push e due Pop, l’ultimo Size è 1. Se si chiama Push a stack pieno (in questo esempio 5 elementi, Max_Size) viene sollevata Int_Stack.Stack_Overflow; se si chiama Pop a stack vuoto, Int_Stack.Stack_Underflow.

I package generici, in pratica, funzionano bene per «piccoli contenitori», «buffer a lunghezza fissa», «ring buffer», «code di log», «strati di astrazione hardware». In Ada, in particolare, fissare le dimensioni in modo statico come parametri di tipo o di valore, invece di muoverle a runtime, sta bene insieme alla progettazione di sistemi ad alta affidabilità.

8. Parametri formali di sottoprogramma ── Iniettare un comportamento

Anche ricevendo solo un tipo, resta qualcosa che non si riesce a esprimere. In un ordinamento, per esempio, serve non solo il tipo degli elementi ma anche la logica di confronto: quale elemento viene prima.

In Ada, questa funzione di confronto può essere un parametro formale del generic.

flowchart LR
    accTitle: Generic_Insertion_Sort e la funzione di confronto
    accDescr: Oltre a Item_Type, Index e Item_Array, il confronto si può sostituire con l'ordine standard, Greater o un ordine personalizzato
    A[Generic_Insertion_Sort] --> T[Item_Type]
    A --> I[Index]
    A --> ARR[Item_Array]
    A --> CMP[Funzione di confronto]

    CMP --> ASC[Usa il confronto standard]
    CMP --> DESC["Passa Greater per l'ordine decrescente"]
    CMP --> CUSTOM[Passa un ordine personalizzato]

8.1 Specifica

generic
   type Item_Type is private;
   type Index is (<>);
   type Item_Array is array (Index range <>) of Item_Type;
   with function "<" (Left, Right : Item_Type) return Boolean is <>;
procedure Generic_Insertion_Sort (Items : in out Item_Array);

Ci sono quattro parametri formali.

1. Item_Type: tipo degli elementi dell’array
2. Index: tipo degli indici dell’array
3. Item_Array: il tipo array effettivo
4. "<": la funzione di confronto

type Index is (<>); accetta un tipo discreto. Non solo interi: anche enumerazioni. Potere usare come indice non solo Positive ma un’enumerazione come Day è un tratto tipicamente Ada.

In with function "<" ... is <>;, is <> significa che, se si omette il parametro attuale, si usa l’operatore standard visibile o una funzione compatibile. Quindi, per un tipo che ha già < come Integer, si può usare il generic senza indicare esplicitamente la funzione di confronto.

8.2 Corpo

procedure Generic_Insertion_Sort (Items : in out Item_Array) is
   J   : Index;
   Key : Item_Type;
begin
   if Items'Length <= 1 then
      return;
   end if;

   for I in Index'Succ (Items'First) .. Items'Last loop
      Key := Items (I);
      J := I;

      while J > Items'First and then Key < Items (Index'Pred (J)) loop
         Items (J) := Items (Index'Pred (J));
         J := Index'Pred (J);
      end loop;

      Items (J) := Key;
   end loop;
end Generic_Insertion_Sort;

L’insertion sort non è adatto ad array grandi, ma è adatto a spiegare i generic. Sostituendo solo la funzione di confronto, la stessa struttura di ciclo serve sia per l’ordine crescente sia per quello decrescente.

flowchart TB
    accTitle: Flusso dell'insertion sort
    accDescr: Si prende Key da sinistra, si confronta con l'elemento precedente, lo si sposta a destra se necessario e si inserisce Key finché l'array è ordinato
    Start[Array non ordinato] --> Pick[Prendi Key da sinistra]
    Pick --> Compare{"Key precede l'elemento precedente?"}
    Compare -->|Yes| Shift["Sposta a destra l'elemento precedente"]
    Shift --> Compare
    Compare -->|No| Insert[Inserisci Key]
    Insert --> Done{Elaborazione finita?}
    Done -->|No| Pick
    Done -->|Yes| End[Array ordinato]

8.3 Ottenere crescente e decrescente dallo stesso corpo

type Int_Array is array (Positive range <>) of Integer;

procedure Sort_Asc is new Generic_Insertion_Sort
  (Item_Type  => Integer,
   Index      => Positive,
   Item_Array => Int_Array);

function Greater (Left, Right : Integer) return Boolean is
  (Left > Right);

procedure Sort_Desc is new Generic_Insertion_Sort
  (Item_Type  => Integer,
   Index      => Positive,
   Item_Array => Int_Array,
   "<"        => Greater);

Sort_Asc usa il < standard. Sort_Desc, invece, sostituisce la funzione di confronto con "<" => Greater.

flowchart LR
    accTitle: Crescente e decrescente dallo stesso corpo
    accDescr: Sort_Asc con il confronto standard e Sort_Desc con Greater producono ordini opposti sugli stessi dati
    Data[99, 3, 47, 12] --> A[Sort_Asc<br/>confronto standard]
    Data --> D[Sort_Desc<br/>Greater passato come confronto]
    A --> AO[3, 12, 47, 99]
    D --> DO[99, 47, 12, 3]

Il meccanismo è vicino al passare un function object come argomento di template in C++, o al richiedere un ordinamento con un trait bound in Rust. In Ada, però, si rende esplicito come parametro formale di sottoprogramma: «passa una funzione di questa forma».

8.4 Esempio di esecuzione

Seguendo la struttura del capitolo 18, se Generic_Insertion_Sort sta in file separati (generic_insertion_sort.ads / .adb), il lato chiamante è il seguente.

with Ada.Text_IO;            use Ada.Text_IO;
with Generic_Insertion_Sort;

procedure Sort_Demo is
   type Int_Array is array (Positive range <>) of Integer;

   function Greater (Left, Right : Integer) return Boolean is
     (Left > Right);

   procedure Sort_Asc is new Generic_Insertion_Sort
     (Item_Type  => Integer,
      Index      => Positive,
      Item_Array => Int_Array);

   procedure Sort_Desc is new Generic_Insertion_Sort
     (Item_Type  => Integer,
      Index      => Positive,
      Item_Array => Int_Array,
      "<"        => Greater);

   procedure Show (Label : String; Items : Int_Array) is
   begin
      Put (Label);
      for V of Items loop
         Put (Integer'Image (V));
      end loop;
      New_Line;
   end Show;

   Asc  : Int_Array := (99, 3, 47, 12);
   Desc : Int_Array := (99, 3, 47, 12);
begin
   Sort_Asc (Asc);
   Sort_Desc (Desc);
   Show ("Asc :", Asc);
   Show ("Desc:", Desc);
end Sort_Demo;

gnatchop ../src/snippets/03_sort.ada
gnatmake -gnata sort_demo
./sort_demo

Asc : 3 12 47 99
Desc: 99 47 12 3

Si verifica che due procedure nate dallo stesso corpo di Generic_Insertion_Sort risultino in ordine inverso solo sostituendo la funzione di confronto. Lo spazio davanti a ciascun elemento è quello che 'Image degli interi mette prima di un valore non negativo.

9. Categorie di tipo ── Scrivere un contratto più concreto di private

type T is private; è comodo, ma non permette tutto. Su un tipo private non si possono dare per scontate le quattro operazioni aritmetiche né i confronti di ordine. Per questo Ada consente di specificare una categoria sul parametro di tipo formale.

flowchart TB
    accTitle: Categorie di tipo dei parametri formali
    accDescr: private, limited private, discreto, intero con segno, modulare, virgola mobile, virgola fissa e access
    FormalType[Formal Type] --> Private[private]
    FormalType --> Limited[limited private]
    FormalType --> Discrete[discrete box: tipo discreto]
    FormalType --> Signed[range box: intero con segno]
    FormalType --> Modular[mod box: intero modulare]
    FormalType --> Float[digits box: virgola mobile]
    FormalType --> Fixed[delta box: virgola fissa]
    FormalType --> Access[tipo access]

    Discrete --> Enum[Enumerazione]
    Discrete --> Int[Tipo intero]
    Float --> F1[Float]
    Float --> F2[Long_Float]
    Float --> F3["Floating-point definito dall'utente"]

Nei diagrammi box indica il <> di Ada (box compound delimiter). Mermaid non riesce a disegnare <> così com’è, quindi solo nei diagrammi si scrive box.

9.1 Che cosa si guadagna specificando una categoria

Per calcolare media e varianza servono addizione, sottrazione, moltiplicazione e divisione. Un tipo private non può presupporre queste operazioni. Quindi si restringe ai tipi in virgola mobile.

generic
   type Real is digits <>;
   type Real_Array is array (Positive range <>) of Real;
package Generic_Statistics is
   function Mean (Values : Real_Array) return Real;
   function Variance (Values : Real_Array) return Real;
end Generic_Statistics;

Con type Real is digits <>; si capisce che Real è un tipo in virgola mobile. Di conseguenza, nel corpo del generic si possono usare +, -, *, /.

9.2 Corpo

package body Generic_Statistics is
   function Mean (Values : Real_Array) return Real is
      Sum : Real := 0.0;
   begin
      if Values'Length = 0 then
         return 0.0;
      end if;

      for V of Values loop
         Sum := Sum + V;
      end loop;

      return Sum / Real (Values'Length);
   end Mean;

   function Variance (Values : Real_Array) return Real is
      M   : constant Real := Mean (Values);
      Sum : Real := 0.0;
   begin
      if Values'Length = 0 then
         return 0.0;
      end if;

      for V of Values loop
         declare
            D : constant Real := V - M;
         begin
            Sum := Sum + D * D;
         end;
      end loop;

      return Sum / Real (Values'Length);
   end Variance;
end Generic_Statistics;

9.3 Uso con Float e Long_Float

type Float_Array is array (Positive range <>) of Float;
type Long_Array  is array (Positive range <>) of Long_Float;

package Float_Stats is new Generic_Statistics (Float, Float_Array);
package Long_Stats  is new Generic_Statistics (Long_Float, Long_Array);

La stessa statistica si può riusare su tipi in virgola mobile di precisione diversa.

flowchart LR
    accTitle: Stessa statistica, tre precisioni
    accDescr: Generic_Statistics si istanzia per Float, Long_Float e un Real definito dall'utente
    Stats[Generic_Statistics<br/>Real is digits box] --> FS[Float_Stats]
    Stats --> LS[Long_Stats]
    Stats --> MS[My_Real_Stats]

    FS --> FCalc[Mean / Variance su Float]
    LS --> LCalc[Mean / Variance su Long_Float]
    MS --> MCalc[Mean / Variance su Real utente]

9.4 Esempio di esecuzione

with Ada.Text_IO;        use Ada.Text_IO;
with Ada.Float_Text_IO;  use Ada.Float_Text_IO;
with Generic_Statistics;

procedure Statistics_Demo is
   type Float_Array is array (Positive range <>) of Float;

   package Float_Stats is new Generic_Statistics (Float, Float_Array);

   Samples : constant Float_Array := (1.0, 2.0, 3.0, 4.0);
begin
   Put ("Mean     = ");
   Put (Float_Stats.Mean (Samples), Fore => 1, Aft => 3, Exp => 0);
   New_Line;

   Put ("Variance = ");
   Put (Float_Stats.Variance (Samples), Fore => 1, Aft => 3, Exp => 0);
   New_Line;
end Statistics_Demo;

gnatchop ../src/snippets/04_statistics.ada
gnatmake -gnata statistics_demo
./statistics_demo

Mean     = 2.500
Variance = 1.250

Ada.Float_Text_IO è la libreria standard che istanzia Ada.Text_IO.Float_IO per Float; con Exp => 0 si ottiene la notazione decimale ordinaria, non quella esponenziale. Aft => 3 è il numero di cifre dopo la virgola. Attenzione: questa Variance è la varianza della popolazione (si divide per Values'Length), non la varianza campionaria.

9.5 La categoria è una «specifica a livello di tipo»

Specificare una categoria non è solo sintassi per far stare zitto il compilatore. Per il lettore è anche una specifica che comunica «che cosa questo componente richiede».

10. Iniezione di predicati ── Scrivere Count_If in modo Ada

I parametri formali di sottoprogramma non servono solo alle funzioni di confronto: si usano anche sui predicati. Un predicato è una funzione che riceve un valore e restituisce Boolean.

Il ruolo vicino a Func<T, bool> in C#, Predicate<T> in Java, lambda o function object in C++, in Ada si esprime come sottoprogramma formale di un generic.

10.1 Specifica

generic
   type Element is private;
   type Index is (<>);
   type Array_Type is array (Index range <>) of Element;
   with function Predicate (Item : Element) return Boolean;
function Generic_Count_If (Arr : Array_Type) return Natural;

Qui a Predicate non abbiamo messo is <>. Non esiste una funzione predicato standard visibile, quindi il progetto chiede al chiamante di passarla sempre.

10.2 Corpo

function Generic_Count_If (Arr : Array_Type) return Natural is
   Count : Natural := 0;
begin
   for Item of Arr loop
      if Predicate (Item) then
         Count := Count + 1;
      end if;
   end loop;

   return Count;
end Generic_Count_If;

Il flusso è semplice.

flowchart LR
    accTitle: Flusso di Generic_Count_If
    accDescr: Si scorre l'array, si incrementa Count se Predicate è vero e alla fine si restituisce Count
    Arr[Array] --> Loop[Scorri gli elementi]
    Loop --> P{"Predicate(Item)?"}
    P -->|True| Inc[Incrementa Count]
    P -->|False| Skip[Non fare nulla]
    Inc --> Next[Elemento successivo]
    Skip --> Next
    Next --> Result[Restituisci Count]

10.3 Conteggio dei pari e conteggio sopra soglia

type Int_Array is array (Positive range <>) of Integer;

function Is_Even (N : Integer) return Boolean is
  (N mod 2 = 0);

function Is_Large (N : Integer) return Boolean is
  (N > 50);

function Count_Even is new Generic_Count_If
  (Element    => Integer,
   Index      => Positive,
   Array_Type => Int_Array,
   Predicate  => Is_Even);

function Count_Large is new Generic_Count_If
  (Element    => Integer,
   Index      => Positive,
   Array_Type => Int_Array,
   Predicate  => Is_Large);

Dalla stessa logica di scansione si ottengono due funzioni che differiscono solo per la condizione.

flowchart TB
    accTitle: Due conteggi dallo stesso Generic_Count_If
    accDescr: Count_Even con Is_Even e Count_Large con Is_Large applicati allo stesso array
    G[Generic_Count_If] --> E[Count_Even<br/>Predicate = Is_Even]
    G --> L[Count_Large<br/>Predicate = Is_Large]

    Data[12, 7, 88, 3, 56, 91, 44, 19, 62] --> E
    Data --> L
    E --> ER[Numero di pari]
    L --> LR[Numero maggiori di 50]

In questo esempio, scansione dell’array, gestione del contatore e restituzione del risultato sono tutti in comune. Si inietta come funzione solo che cosa contare. Questa è la forma di base della progettazione di ordine superiore in Ada.

10.4 Esempio di esecuzione

with Ada.Text_IO;       use Ada.Text_IO;
with Generic_Count_If;

procedure Count_If_Demo is
   type Int_Array is array (Positive range <>) of Integer;

   function Is_Even (N : Integer) return Boolean is
     (N mod 2 = 0);

   function Is_Large (N : Integer) return Boolean is
     (N > 50);

   function Count_Even is new Generic_Count_If
     (Element    => Integer,
      Index      => Positive,
      Array_Type => Int_Array,
      Predicate  => Is_Even);

   function Count_Large is new Generic_Count_If
     (Element    => Integer,
      Index      => Positive,
      Array_Type => Int_Array,
      Predicate  => Is_Large);

   Data : constant Int_Array := (12, 7, 88, 3, 56, 91, 44, 19, 62);
begin
   Put_Line ("Even  =" & Natural'Image (Count_Even (Data)));
   Put_Line ("Large =" & Natural'Image (Count_Large (Data)));
end Count_If_Demo;

gnatchop ../src/snippets/05_filter.ada
gnatmake -gnata count_if_demo
./count_if_demo

Even  = 5
Large = 4

Tra i 9 elementi di Data, i pari sono 12, 88, 56, 44, 62 (5) e quelli maggiori di 50 sono 88, 56, 91, 62 (4).

11. Composizione di più parametri ── Un key-value store generico

Nei componenti reali, un solo parametro di tipo non basta quasi mai. Tipo della chiave, tipo del valore, modo di confrontare le chiavi, numero massimo di voci: si combinano più condizioni.

Qui prendiamo come esempio un key-value store semplice a lunghezza fissa.

flowchart TB
    accTitle: Parametri e usi di Generic_KV_Store
    accDescr: Generic_KV_Store combina Key_Type, Value_Type, uguaglianza delle chiavi e Max_Entries, con Put, Get e Contains
    KV[Generic_KV_Store] --> K[Key_Type]
    KV --> V[Value_Type]
    KV --> EQ[Funzione di uguaglianza delle chiavi]
    KV --> M[Max_Entries]

    KV --> Ops[Put / Get / Contains]
    Ops --> Use1[Store di valori di configurazione]
    Ops --> Use2[Cache di piccole dimensioni]
    Ops --> Use3[Dizionario a lunghezza fissa per embedded]

11.1 Specifica

generic
   type Key_Type is private;
   type Value_Type is private;
   with function "=" (Left, Right : Key_Type) return Boolean is <>;
   Max_Entries : Positive := 50;
package Generic_KV_Store is
   procedure Put (Key : Key_Type; Val : Value_Type);
   function Get (Key : Key_Type) return Value_Type;
   function Contains (Key : Key_Type) return Boolean;

   Key_Not_Found : exception;
   Store_Full    : exception;
end Generic_KV_Store;

Questo package ha quattro parametri formali.

A Max_Entries diamo il default := 50. Se non si specifica, lo store ha 50 posti.

11.2 Corpo

package body Generic_KV_Store is
   subtype Index_Type is Positive range 1 .. Max_Entries;

   type Key_Array   is array (Index_Type) of Key_Type;
   type Value_Array is array (Index_Type) of Value_Type;
   type Used_Array  is array (Index_Type) of Boolean;

   Keys   : Key_Array;
   Values : Value_Array;
   Used   : Used_Array := (others => False);

   function Find_Index (Key : Key_Type) return Natural is
   begin
      for I in Index_Type loop
         if Used (I) and then Keys (I) = Key then
            return I;
         end if;
      end loop;

      return 0;
   end Find_Index;

   function Find_Free return Natural is
   begin
      for I in Index_Type loop
         if not Used (I) then
            return I;
         end if;
      end loop;

      return 0;
   end Find_Free;

   procedure Put (Key : Key_Type; Val : Value_Type) is
      Pos : Natural := Find_Index (Key);
   begin
      if Pos = 0 then
         Pos := Find_Free;

         if Pos = 0 then
            raise Store_Full;
         end if;

         Used (Pos) := True;
         Keys (Pos) := Key;
      end if;

      Values (Pos) := Val;
   end Put;

   function Get (Key : Key_Type) return Value_Type is
      Pos : constant Natural := Find_Index (Key);
   begin
      if Pos = 0 then
         raise Key_Not_Found;
      end if;

      return Values (Pos);
   end Get;

   function Contains (Key : Key_Type) return Boolean is
   begin
      return Find_Index (Key) /= 0;
   end Contains;
end Generic_KV_Store;

L’implementazione è una ricerca lineare, quindi non è per grandi volumi di dati. È però una forma comoda quando contano lunghezza fissa, piccola scala e assenza di allocazione dinamica.

sequenceDiagram
    accTitle: Put e Get in Generic_KV_Store
    accDescr: Put aggiorna o inserisce una chiave; Get cerca l'indice e restituisce Values(Pos)
    participant App as Chiamante
    participant Store as Istanza di Generic_KV_Store
    participant Data as Keys/Values/Used

    App->>Store: Put(Key, Value)
    Store->>Data: Find_Index(Key)
    alt Chiave già presente
        Store->>Data: Values(Pos) := Value
    else Nuova chiave
        Store->>Data: Find_Free
        Store->>Data: Keys(Pos) := Key
        Store->>Data: Values(Pos) := Value
        Store->>Data: Used(Pos) := True
    end
    App->>Store: Get(Key)
    Store->>Data: Find_Index(Key)
    Data-->>Store: Pos
    Store-->>App: Values(Pos)

11.3 Esempio di istanziazione

with Ada.Text_IO;           use Ada.Text_IO;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Generic_KV_Store;

procedure KV_Demo is
   package Int_String_Store is new Generic_KV_Store
     (Key_Type    => Integer,
      Value_Type  => Unbounded_String,
      Max_Entries => 10);
begin
   Int_String_Store.Put (1, To_Unbounded_String ("Ada"));
   Int_String_Store.Put (2, To_Unbounded_String ("SPARK"));

   if Int_String_Store.Contains (1) then
      Put_Line ("1 => " & To_String (Int_String_Store.Get (1)));
   else
      Put_Line ("1 => (not found)");
   end if;

   --  Un Put su una chiave esistente sovrascrive il valore
   Int_String_Store.Put (1, To_Unbounded_String ("Ada 2022"));
   Put_Line ("1 => " & To_String (Int_String_Store.Get (1)));

   if Int_String_Store.Contains (9) then
      Put_Line ("9 => " & To_String (Int_String_Store.Get (9)));
   else
      Put_Line ("9 => (not found)");
   end if;
end KV_Demo;

gnatchop ../src/snippets/06_kv_store.ada
gnatmake -gnata kv_demo
./kv_demo

1 => Ada
1 => Ada 2022
9 => (not found)

Se si chiama Get senza aver verificato l’esistenza con Contains, in assenza della chiave viene sollevata Key_Not_Found. Scegliete se ramificare con Contains, come nell’esempio sopra, o scrivere un gestore di eccezioni.

"=" è omesso. Integer ha l’operatore di uguaglianza standard e is <> lo usa.

Se la chiave fosse una stringa che ignora maiuscole e minuscole, si può passare una funzione di uguaglianza propria.

function Same_Key (Left, Right : Unbounded_String) return Boolean is
  (To_Lower (To_String (Left)) = To_Lower (To_String (Right)));

package String_Key_Store is new Generic_KV_Store
  (Key_Type    => Unbounded_String,
   Value_Type  => Integer,
   "="         => Same_Key,
   Max_Entries => 100);

12. Parametri formali di package ── Rendere i generic ulteriormente componibili

Nei generic Ada, un package intero può essere un parametro formale. Così si può trattare «un’istanza nata da un certo package generico» come input di un altro generic.

flowchart LR
    accTitle: Concatenare Generic_Stack e un logger
    accDescr: Int_Stack nasce da Generic_Stack e viene passato a Generic_Stack_Logger
    GS[Generic_Stack] --> IS[Int_Stack]
    IS --> Logger[Generic_Stack_Logger]
    Logger --> Logged[Int_Stack_Logger_Instance]

12.1 Un logger che riceve uno stack

Supponiamo di voler costruire un logger che riceve un’istanza del Generic_Stack di prima e ne mostra la dimensione.

generic
   with package Stack is new Generic_Stack (<>);
package Generic_Stack_Logger is
   procedure Print_Size;
end Generic_Stack_Logger;

Il corpo è il seguente.

with Ada.Text_IO; use Ada.Text_IO;

package body Generic_Stack_Logger is
   procedure Print_Size is
   begin
      Put_Line ("Stack size =" & Natural'Image (Stack.Size));
   end Print_Size;
end Generic_Stack_Logger;

Dal lato utente si crea prima lo stack e poi lo si passa al logger.

package Int_Stack is new Generic_Stack
  (Element_Type => Integer,
   Max_Size     => 10);

package Int_Stack_Logger is new Generic_Stack_Logger
  (Stack => Int_Stack);

Con questo progetto si possono combinare componenti generic tra loro.

flowchart TB
    accTitle: Due stadi di istanziazione
    accDescr: Prima si istanzia Generic_Stack in Int_Stack, poi si passa Int_Stack a Generic_Stack_Logger
    subgraph Layer1[Primo stadio]
        T1[Generic_Stack] --> I1[Int_Stack]
    end

    subgraph Layer2[Secondo stadio]
        T2[Generic_Stack_Logger] --> I2[Int_Stack_Logger]
    end

    I1 --> T2
    I2 --> API[Print_Size]

L’uso è vicino ai template template parameter del C++, ma in Ada si può dire esplicitamente «ricevi un’istanza di questo package generico». Nel codice Ada di grandi dimensioni è comodo quando si vogliono tenere separati e poi combinare contenitori, algoritmi, log, controlli, ausili di test.

13. Contract Model ── L’idea più importante dei generic Ada

Per capire i generic Ada, il punto centrale è il contract model.

Il corpo del generic deve essere scritto usando solo le operazioni promesse dai parametri formali. Per esempio, se si è dichiarato solo type Element is private;, non si può usare < su Element. Se si vuole <, o lo si rende esplicito come sottoprogramma formale, o si rende più concreta la categoria di tipo.

flowchart TB
    accTitle: Contract model dei generic Ada
    accDescr: Il corpo si type-checka da solo nel raggio del formal part; all'istanziazione si verifica che i parametri attuali soddisfino il contratto
    Spec[generic formal part<br/>contratto] --> Body[generic body<br/>implementazione nel raggio del contratto]
    Body --> Check1[Type-check del corpo da solo]
    Spec --> Inst[Istanziazione]
    Actual[actual parameters<br/>tipo, funzione e valore reali] --> Inst
    Inst --> Check2[I parametri attuali soddisfano il contratto?]
    Check2 --> Instance[Package / sottoprogramma ordinario]

Grazie a questo progetto, è protetto non solo chi usa il generic ma anche chi lo scrive.

13.1 Come appare diverso rispetto ai template C++

I template C++ sono potenti, ma storicamente avevano la proprietà che «l’errore esce solo quando si istanzia il corpo del template». C++20 con i concepts ha migliorato la situazione; i generic Ada, però, sono un modello in cui il contratto è esplicito fin dall’inizio.

flowchart LR
    accTitle: Ada e i template C++ a confronto
    accDescr: Ada scrive il contratto nel formal part e controlla il corpo; i template C++ concretizzano le richieste all'istanziazione, con i concepts come vincolo esplicito
    subgraph Ada[Ada]
        A1[Si scrive il contratto nel formal part] --> A2[Il body si controlla nel contratto]
        A2 --> A3["All'instantiation si controllano gli actual"]
    end

    subgraph CPP[C++ templates]
        C1[Si scrive il template body] --> C2["All'instantiation si concretizzano le richieste"]
        C2 --> C3[Con i concepts i vincoli si possono rendere espliciti]
    end

I generics di Java e C# ruotano intorno a tipi riferimento, vincoli, type erasure e rappresentazione a runtime. I generic Ada, invece, stanno più vicini all’idea di produrre un’istanza concreta in compilazione.

Le funzionalità di dettaglio differiscono, ma il tratto Ada è «scrivere prima il contratto come sintassi».

14. Decisioni di progettazione in pratica ── Che cosa rendere generic

I generic sono comodi, ma non va bene rendere generic qualsiasi cosa. In pratica si sbaglia meno ragionando così.

flowchart TB
    accTitle: Albero di decisione su che cosa rendere generic
    accDescr: Si valutano in ordine tipo, dimensione o soglia, comportamento di confronto, stato interno; altrimenti basta un sottoprogramma ordinario
    Start["C'è un'elaborazione da riusare"] --> Q1{Cambia solo il tipo?}
    Q1 -->|Yes| GType[Valuta un parametro di tipo]
    Q1 -->|No| Q2{Cambiano anche dimensione o soglia?}
    Q2 -->|Yes| GObject[Aggiungi un parametro valore]
    Q2 -->|No| Q3{Cambia il comportamento di confronto o giudizio?}
    Q3 -->|Yes| GSubp[Aggiungi un sottoprogramma formale]
    Q3 -->|No| Q4{Vuoi raggruppare stato interno e API?}
    Q4 -->|Yes| GPackage[Package generico]
    Q4 -->|No| Normal[Basta un sottoprogramma ordinario]

14.1 Quando è adatto un sottoprogramma generico

I sottoprogrammi generici stanno bene agli algoritmi senza stato.

• Swap
• Sort
• Count_If
• Find
• Trasformazioni in stile Map
• Min / Max

Quando il corpo dell’algoritmo è corto e input e output sono chiari, un sottoprogramma è più leggibile di un package.

14.2 Quando è adatto un package generico

I package generici stanno bene quando, insieme al tipo, si vogliono più operazioni e uno stato interno.

• Stack a lunghezza fissa
• Ring buffer
• Dizionario di piccole dimensioni
• Suite di statistica
• Astrazione I/O per dispositivo
• Suite di operazioni su tipi numerici con unità di misura

In Ada, in particolare, la specifica del package è l’API pubblica e il corpo è l’implementazione: un package generico si usa quindi come «template di modulo type-safe».

flowchart LR
    accTitle: Specifica, corpo e formal part di un package generico
    accDescr: Il formal part vincola specifica e corpo; l'utente vede l'API pubblica, l'implementazione resta nascosta
    Spec[package spec<br/>API pubblica] --> User[Lato utente]
    Body[package body<br/>implementazione interna] -.nasconde.-> User
    Formal[generic formal part<br/>contratto di tipo, valore, funzione] --> Spec
    Formal --> Body

14.3 Partire da pochi parametri formali

Se si aumentano troppo i parametri formali, l’istanziazione diventa illeggibile. È più sicuro partire dal minimo e aggiungerne quando c’è un motivo per sostituirli.

-- Esempio che diventa presto illeggibile
package X is new Generic_Foo
  (A, B, C, D, E, F, G);

-- L'associazione nominata lascia visibile l'intento
package X is new Generic_Foo
  (Element_Type => Integer,
   Index_Type   => Positive,
   Buffer_Size  => 128,
   "<"          => Less);

In Ada, all’istanziazione si può usare l’associazione nominata. I punti importanti del progetto generic appaiono proprio nell’istanziazione, quindi nel codice di produzione scrivere i nomi rende di solito la manutenzione più facile.

15. Punti in cui si inciampa spesso

I generic Ada sono potenti, ma all’inizio ci sono punti in cui è facile inciampare.

15.1 Su un tipo private non si possono fare confronti di ordine

Un corpo come il seguente non si può scrivere.

generic
   type Element is private;
function Bad_Min (A, B : Element) return Element;

function Bad_Min (A, B : Element) return Element is
begin
   if A < B then      -- errore qui
      return A;
   else
      return B;
   end if;
end Bad_Min;

Element è dichiarato solo private, quindi non è detto che < sia disponibile. Se si vuole confrontare, si aggiunge il confronto al contratto.

generic
   type Element is private;
   with function "<" (Left, Right : Element) return Boolean is <>;
function Generic_Min (A, B : Element) return Element;

flowchart LR
    accTitle: Confrontare richiede di scrivere il confronto nel contratto
    accDescr: Se il confronto sta nel formal part, all'istanziazione si verifica la confrontabilità; con solo private il corpo non compila
    Need[Nel corpo si vuole usare un confronto] --> Contract[Si scrive la funzione di confronto nel formal part]
    Contract --> OK["All'istanziazione si verifica la confrontabilità"]
    Need --> NoContract[Solo private]
    NoContract --> Error[Errore di compilazione nel corpo del generic]

15.2 is <> non è «inferenza automatica di qualsiasi cosa»

is <> è comodo, ma non è magia. Nel punto di istanziazione deve essere visibile un operatore o un sottoprogramma compatibile. Se la funzione di confronto propria sta in un altro package, è più sicuro fare with o use in modo appropriato, oppure passarla esplicitamente per nome.

procedure Sort_By_Age is new Generic_Insertion_Sort
  (Item_Type  => Person,
   Index      => Positive,
   Item_Array => Person_Array,
   "<"        => Younger_Than);

15.3 Anche le eccezioni sono oggetti distinti per ciascuna istanza

Se si dichiarano eccezioni nella specifica di un package generico, ciascuna istanza ha eccezioni distinte.

package Int_Stack   is new Generic_Stack (Integer, 5);
package Float_Stack is new Generic_Stack (Float, 3);

In questo caso Int_Stack.Stack_Overflow e Float_Stack.Stack_Overflow sono eccezioni diverse. Se si vogliono trattare come eccezione comune, si può valutare di definirle fuori dal generic.

flowchart TB
    accTitle: Eccezioni distinte per ciascuna istanza
    accDescr: Stack_Overflow di Int_Stack e di Float_Stack, dichiarati in Generic_Stack, sono eccezioni diverse
    Generic[Generic_Stack<br/>dichiarazione di Stack_Overflow] --> I[Int_Stack.Stack_Overflow]
    Generic --> F[Float_Stack.Stack_Overflow]
    I -.eccezione diversa.-> F

15.4 La dimensione del codice può crescere

I generic evitano facilmente indirezioni extra a runtime; d’altra parte, poiché si crea un’istanza per tipo, molti istanziamenti possono far crescere la dimensione del codice.

È lo stesso trade-off dei template C++ e della monomorfizzazione in Rust. Nello sviluppo orientato ad alta affidabilità, embedded o real-time, l’idea è ridurre l’incertezza a runtime e, in cambio, gestire la dimensione di ciò che si genera in build.

flowchart LR
    accTitle: Un corpo generic, più codice generato
    accDescr: Ciascuna istanza produce codice macchina; si evitano test di tipo e boxing a runtime, ma troppe istanze fanno crescere la dimensione
    Generic[Un solo corpo generic] --> I1[Versione Integer]
    Generic --> I2[Versione Float]
    Generic --> I3[Versione Long_Float]
    Generic --> I4[Versione My_Type]

    I1 --> Code[Codice generato]
    I2 --> Code
    I3 --> Code
    I4 --> Code

    Code --> Pros[Si evitano test di tipo e boxing a runtime]
    Code --> Cons[Con molte istanze, attenzione alla crescita della dimensione]

15.5 Quando conviene limited private

type Element is private; presuppone l’assegnamento. Per oggetti che non si vogliono copiare — handle di file, lock, handle di dispositivo — si valuta limited private.

generic
   type Resource is limited private;
   with procedure Close (R : in out Resource);
procedure Generic_Use_And_Close (R : in out Resource);

Nei progetti che trattano tipi non copiabili, è più sicuro un algoritmo che applica una procedura, o un progetto che rende esplicito il riferimento, piuttosto che un contenitore che memorizza valori.

16. Una piccola raccolta di pattern di progettazione

Da qui in poi organizziamo in breve le forme che si usano spesso in pratica.

16.1 Offrire Min solo ai valori confrontabili

generic
   type Element is private;
   with function "<" (Left, Right : Element) return Boolean is <>;
function Generic_Min (A, B : Element) return Element;

function Generic_Min (A, B : Element) return Element is
begin
   if A < B then
      return A;
   else
      return B;
   end if;
end Generic_Min;

flowchart LR
    accTitle: Generic_Min richiede una funzione di confronto
    accDescr: Element più la funzione di confronto producono Generic_Min, che restituisce il minore
    T[Element] --> C[Serve una funzione di confronto]
    C --> M[Generic_Min]
    M --> R[Restituisce il minore]

16.2 Mettere la soglia in un parametro valore

generic
   type Count_Type is range <>;
   Threshold : Count_Type;
function Generic_Is_Over (Value : Count_Type) return Boolean;

function Generic_Is_Over (Value : Count_Type) return Boolean is
begin
   return Value > Threshold;
end Generic_Is_Over;

I parametri valore stanno bene a valori che si vogliono fissare come proprietà dell’istanza, non come impostazione a runtime.

16.3 Iniettare il mezzo di output

generic
   type Element is private;
   with procedure Put (Item : Element);
procedure Generic_Print_Twice (Item : Element);

procedure Generic_Print_Twice (Item : Element) is
begin
   Put (Item);
   Put (Item);
end Generic_Print_Twice;

In questa forma si può sostituire la destinazione: output standard, log, buffer di test.

flowchart TB
    accTitle: Iniettare Put in Generic_Print_Twice
    accDescr: Put come sottoprogramma formale consente output su console, log o buffer di test
    Print[Generic_Print_Twice] --> Put[Riceve Put come sottoprogramma formale]
    Put --> Console[Output su console]
    Put --> Log[Output di log]
    Put --> Test[Buffer di test]

16.4 Non fissare il tipo di indice dell’array

In Ada anche il tipo di indice di un array è informazione di tipo importante. Invece di inchiodare Positive, rendere all’occorrenza anche il tipo di indice un parametro formale alza il riuso.

generic
   type Element is private;
   type Index is (<>);
   type Array_Type is array (Index range <>) of Element;
procedure Generic_Clear (Arr : in out Array_Type; Value : Element);

Con questo progetto si coprono non solo array con indice Positive, ma anche array con indice enumerato.

flowchart LR
    accTitle: Index discreto per più tipi di indice
    accDescr: Index può essere un range Positive, un'enumerazione Day o State, o un tipo intero proprio
    Index[Index is discrete] --> Positive[Positive range]
    Index --> Day[Enumerazione Day]
    Index --> State[Enumerazione State]
    Index --> Slot[Tipo intero proprio]

17. Checklist per un’API in stile Ada

Quando scrivete un generic, alla fine rileggetelo con questi criteri: diventa più leggibile.

flowchart TB
    accTitle: Checklist di progettazione di un generic
    accDescr: Parametri minimi, operazioni nel formal part, categoria adeguata, associazione nominata, stato ed eccezioni per istanza, dimensione del codice, istanze di test
    C[Checklist di progettazione generic] --> C1[I parametri formali sono il minimo?]
    C --> C2[Le operazioni necessarie sono esplicite nel formal part?]
    C --> C3[La categoria private / range / digits è adeguata?]
    C --> C4["Si può istanziare in modo leggibile con l'associazione nominata?"]
    C --> C5[Si è consapevoli di stato ed eccezioni per ciascuna istanza?]
    C --> C6[Si può accettare la crescita della dimensione del codice?]
    C --> C7["Si è preparata un'istanza per i test?"]

In forma testuale, è questo.

• Le operazioni usate nel corpo devono essere visibili come contratto dei parametri formali.
• Se basta private, usate private. Se serve aritmetica, usate range <> o digits <>.
• Confronti, hash, output, conversioni: i comportamenti che cambiano per tipo vanno in un sottoprogramma formale.
• Se dimensione o soglia sono proprietà dell’istanza, usate un parametro valore.
• Con stato, pensate prima a un package generico; senza stato, a un sottoprogramma generico.
• All’istanziazione, più argomenti ci sono, più si usa l’associazione nominata.
• Progettate presupponendo che eccezioni e stato interno siano indipendenti per ciascuna istanza.

18. Esempio di struttura complessiva dei campioni

Se si vogliono spezzare i campioni dell’articolo in file, una struttura come la seguente è più leggibile.

flowchart TB
    accTitle: Struttura di file dei campioni
    accDescr: Specifiche e corpi dei generic in src/generics, demo in src/demos
    Root[ada-generic-programming] --> Src[src]
    Src --> G[generics]
    Src --> D[demos]

    G --> SwapSpec[generic_swap.ads]
    G --> SwapBody[generic_swap.adb]
    G --> StackSpec[generic_stack.ads]
    G --> StackBody[generic_stack.adb]
    G --> SortSpec[generic_insertion_sort.ads]
    G --> SortBody[generic_insertion_sort.adb]
    G --> StatsSpec[generic_statistics.ads]
    G --> StatsBody[generic_statistics.adb]
    G --> CountSpec[generic_count_if.ads]
    G --> CountBody[generic_count_if.adb]
    G --> KVSpec[generic_kv_store.ads]
    G --> KVBody[generic_kv_store.adb]

    D --> SwapDemo[swap_demo.adb]
    D --> StackDemo[stack_demo.adb]
    D --> SortDemo[sort_demo.adb]
    D --> StatsDemo[statistics_demo.adb]
    D --> CountDemo[count_if_demo.adb]
    D --> KVDemo[kv_demo.adb]

Per un campione piccolo da articolo, riunire tutto in un file e usare gnatchop è comodo; se però si pensa alla pratica e alla manutenzione di lungo periodo, separare specifica .ads e corpo .adb è la struttura più Ada.

19. Conclusione ── Decidere il confine del riuso con i tipi

La programmazione generic in Ada non è solo «una funzione per scrivere codice indipendente dal tipo». L’essenza è rendere esplicito, come contratto di tipi, sottoprogrammi e valori, che cosa un componente riusabile richiede.

flowchart LR
    accTitle: Dal contratto al riuso type-safe
    accDescr: Si scrive il contratto, si scrive il corpo, si istanzia passando tipo, valore e funzione, e si riusa senza copiare
    Contract[Si scrive il contratto] --> Generic[Si scrive il corpo del generic]
    Generic --> Instance[Si istanzia passando tipo, valore, funzione]
    Instance --> Safe[Si usa in modo type-safe]
    Safe --> Reuse[Si riusa senza copiare]