What's New in Ada 2022 — What Works in GNAT and the Parallel Syntax You Can't Write Yet

Ada 2022 is the fourth edition of ISO/IEC 8652, the international standard for Ada, published as ISO/IEC 8652:2023 in May 2023¹. This article explains the added features that are easy to use in everyday code, together with the results of actually compiling and running them with GNAT. It covers declare expressions, delta aggregates, 'Image for every type, square-bracket aggregates, @ and iterator filters, 'Reduce, the arbitrary-precision integers in Big_Integers, the Jorvik profile, and parallel blocks and parallel loops.

The environments tested were GNAT 13.3.0 on Ubuntu (the apt package) and GNAT 15.3.0 (gnat_native 15.3.1 obtained through Alire). Windows was not tested. To give the results up front: everything except the parallel syntax behaved the same in both versions, and neither version accepted the parallel syntax.

Ada basics are covered in The Appeal of the Ada Language, and contracts and proof in Introduction to Formal Verification with SPARK. How to create a project with Alire is in Starting an Ada Project with Alire.

Compiler settings that enable Ada 2022

To use Ada 2022 features with GNAT, pass -gnat2022 to the compiler or write pragma Ada_2022; at the top of the source²³. Both versions tested reported Ada 2022 syntax as an error unless this was specified. Below are the messages from compiling the declare expression and @ that appear later, without the setting.

decl_delta.adb:19:07: error: declare expression is an Ada 2022 feature
decl_delta.adb:19:07: error: unit must be compiled with -gnat2022 switch
misc22.adb:22:13: error: target name is an Ada 2022 feature
misc22.adb:22:13: error: unit must be compiled with -gnat2022 switch

Square-bracket aggregates produce a different error without the setting: illegal character, replaced by "(". It is hard to tell from that message that this is an Ada 2022 feature, so if you see it, check that -gnat2022 is specified.

When building with gprbuild, put it in the Compiler package of the project file.

project Demo is
   for Source_Dirs use ("src");
   for Object_Dir use "obj";
   for Main use ("misc22.adb");

   package Compiler is
      for Default_Switches ("Ada") use ("-gnat2022");
   end Compiler;
end Demo;

All examples in this article are compiled with -gnat2022.

flowchart TB
        accTitle: Ada 2022 features and their results in GNAT
        accDescr: Shows the Ada 2022 features tried in this article, divided into those that worked in GNAT 13.3 and 15.3 and those that were not accepted.
        A["Ada 2022 features tried"] --> B{"Worked in GNAT 13.3 and 15.3?"}
        B -->|"Worked"| C["New expressions and aggregates"]
        B -->|"Worked"| D["Big_Integers, Jorvik"]
        B -->|"Not accepted"| G["Parallel syntax"]
        C --> C1["Declare expressions, delta aggregates"]
        C --> C2["'Image, 'Reduce, @, filters"]
        G --> G1["parallel do, parallel for"]
        G --> G2["'Parallel_Reduce"]

Figure 1: Of the features tried in this article, only the parallel syntax was not accepted by GNAT 13.3 and 15.3.

In the diagram a solid line marks a relation that always holds and a dashed line marks a conditional one (the conditions are given per relation on the detail page). The full list of relations (12 in total, with evidence and certainty) and the definitions of the main concepts are collected on the knowledge map detail page (in Japanese). Data: JSON-LD / Turtle

Declare expressions: naming values inside an expression

A declare expression is syntax for declaring constants or renaming things inside an expression⁴. It takes the form (declare declarations begin expression), and, enclosed in parentheses, it can go anywhere an expression can. It can also be used in expression functions and in preconditions and postconditions.

--  Declare expression: introduces a temporary name inside an expression
function Percent (Done, Total : Natural) return Natural is
  (declare
     Ratio : constant Natural :=
       (if Total = 0 then 0 else Done * 100 / Total);
   begin
     Natural'Min (Ratio, 100));

Percent (3, 4) returned ` 75 and Percent (5, 0) returned 0`. Because the body of an expression function is a single expression, a declare expression lets you name an intermediate result.

Only constants of types that are not limited, and renamings, can be declared. Variables cannot. The RM explains that limited types are excluded to avoid making a task wait in the middle of evaluating an expression⁴.

flowchart TB
        accTitle: How a declare expression is evaluated
        accDescr: Shows that a declare expression uses the constants placed after declare in the expression after begin, and the value of that expression becomes the value of the whole declare expression.
        A["declare"] --> B["Declare constants or renamings"]
        B --> C["begin"]
        C --> D["Evaluate the expression using the declared names"]
        D --> E["Its value becomes the declare expression's value"]
        B -.-> F["Variables and limited-type constants cannot be declared"]

Figure 2: A declare expression uses the constants placed with declare in the expression after begin, and returns that expression’s value.

Delta aggregates: building a value with only some parts changed

A delta aggregate is an expression that builds a new value from an existing one with only some components changed⁵. You write (original_value with delta component => new_value, ...), and components not listed are copied from the original value. It also works with arrays.

type Config is record
   Port    : Natural;
   Timeout : Duration;
   Verbose : Boolean;
end record;

Default : constant Config :=
  (Port => 8080, Timeout => 5.0, Verbose => False);

--  Delta aggregate: builds a value with only some components changed from the original
Debug : constant Config :=
  (Default with delta Verbose => True, Timeout => 30.0);

The output of Debug'Image is as follows; Port keeps the value from Default.

(PORT =>  8080,
 TIMEOUT =>  30.000000000,
 VERBOSE => TRUE)

Because a delta aggregate is an expression, it can also be written in contracts. AdaCore’s explanation gives, as a motivation for delta aggregates, the fact that the approach of preparing a temporary variable and then overwriting components cannot be used inside a contract⁶. The following postcondition means “only Verbose changes to True, and the other components stay as they were before the call”. C'Old is the value of C before the call.

--  Only Verbose changes to True; the other components stay as they were before the call
procedure Enable_Verbose (C : in out Config)
  with Post => C = (C'Old with delta Verbose => True);

procedure Enable_Verbose (C : in out Config) is
begin
   C.Verbose := True;
   C.Timeout := 30.0;  --  A change not in the postcondition (a bug)
end Enable_Verbose;

The body also overwrites Timeout, which the postcondition does not allow. Running it with -gnata⁷, which enables assertion checks, stopped with a postcondition violation.

raised ADA.ASSERTIONS.ASSERTION_ERROR : failed postcondition from contracts.adb:12

Without -gnata, the postcondition was not checked, and the program finished normally with Timeout changed to 30.0. If you want to check at run time, do not forget this switch. How to prove contracts without running the code is covered in Introduction to Formal Verification with SPARK and Proving AI-Written Code with SPARK.

flowchart TB
        accTitle: Checking a postcondition with a delta aggregate
        accDescr: Shows that the expected value is built from the value before the call with a delta aggregate and compared with the value after the call, and that a mismatch is a postcondition violation.
        A["Value before the call: C'Old"] --> B["Change only Verbose with a delta aggregate"]
        B --> C["Expected value"]
        D["Value after the call: C"] --> E{"Equal to the expected value?"}
        C --> E
        E -->|"Equal"| F["Postcondition holds"]
        E -->|"Not equal"| G["Assertion_Error (with -gnata)"]

Figure 3: Comparing the expected value built with a delta aggregate against the value after the call lets a postcondition catch changes to other components.

‘Image for every type, and Put_Image

Up to Ada 2012, the 'Image attribute could only be used with scalar types. In Ada 2022 it can be used with any type, including records and arrays⁸. 'Image is defined through a procedure of the type called Put_Image, and the result is the string that Put_Image writes to a buffer. Put_Image can be replaced per type with an aspect; 'Image itself cannot be replaced.

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Text_Buffers;

procedure Put_Image_Demo is
   package Temps is
      type Celsius is record
         Value : Integer;
      end record
        with Put_Image => Put_Celsius;

      procedure Put_Celsius
        (Buffer : in out Ada.Strings.Text_Buffers.Root_Buffer_Type'Class;
         Item   : Celsius);
   end Temps;

   package body Temps is
      procedure Put_Celsius
        (Buffer : in out Ada.Strings.Text_Buffers.Root_Buffer_Type'Class;
         Item   : Celsius) is
      begin
         Buffer.Put (Item.Value'Image & " C");
      end Put_Celsius;
   end Temps;

   type Reading is record
      Sensor : Positive;
      Temp   : Temps.Celsius;
   end record;

   R : constant Reading := (Sensor => 3, Temp => (Value => 21));
begin
   Put_Line (R.Temp'Image);
   Put_Line (R'Image);
end Put_Image_Demo;

The output is as follows. Reading does not specify Put_Image, but its Temp component is written with the Put_Image of Celsius.

 21 C

(SENSOR =>  3,
 TEMP =>  21 C)

I noticed two things about GNAT’s default output.

• The 'Image of records and arrays started with a newline in both GNAT 13.3 and 15.3. That is why there is a blank line in the output above.
• The RM specifies that the default Put_Image for arrays writes a named aggregate ([1 => ..., 2 => ...])⁸. The output of GNAT 13.3 and 15.3 was the positional form [ 1, 4, 9, 16, 25], as shown in the next section.

That the 'Image of an integer puts one leading space or a minus sign is the same as before⁸. It is safer to use the default 'Image for looking at values in logs and debugging, and not as a format that other programs read. When you want to fix the format, specify Put_Image yourself.

flowchart TB
        accTitle: How 'Image and Put_Image relate
        accDescr: Shows that 'Image calls the type's Put_Image, using the specified one if there is one and the default form otherwise, and that the default form for a record calls the Put_Image of each component's type.
        A["X'Image"] --> B["Call the type's Put_Image"]
        B --> C{"Is Put_Image specified?"}
        C -->|"Yes"| D["Write with the specified procedure"]
        C -->|"No"| E["Write in the default form"]
        E --> F["For records, call each component type's Put_Image"]
        D --> G["The buffer's string is the result of 'Image"]
        F --> G

Figure 4: Because ‘Image builds its string through Put_Image, a Put_Image specified for a component’s type is also used by the enclosing record’s ‘Image.

Shorter code: square-bracket aggregates, @, filters and ‘Reduce

The following example gathers small additions that come up often in everyday code.

with Ada.Text_IO; use Ada.Text_IO;

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

   --  Square-bracket array aggregate. An empty array can be written as []
   Values : constant Int_Array := [3, 8, 1, 6, 5];
   Empty  : constant Int_Array := [];

   --  Array aggregate with an iterator
   Squares : constant Int_Array (1 .. 5) := [for I in 1 .. 5 => I * I];

   Count : Natural := 0;
   Total : Integer := 0;

   --  Reduction expressions: fold with 'Reduce
   Sum     : constant Integer := Values'Reduce ("+", 0);
   Max     : constant Integer := Values'Reduce (Integer'Max, Integer'First);
   Sum_Sq  : constant Integer := [for V of Values => V * V]'Reduce ("+", 0);
begin
   --  Target name @: avoids repeating the left-hand name on the right-hand side
   Count := @ + 1;

   --  Iterator filter: iterate only over elements that satisfy the when condition
   for V of Values when V mod 2 = 0 loop
      Total := @ + V;
   end loop;

   Put_Line ("Count =" & Count'Image);
   Put_Line ("Even total =" & Total'Image);
   Put_Line ("Empty length =" & Empty'Length'Image);
   Put_Line ("Squares =" & Squares'Image);
   Put_Line ("Sum =" & Sum'Image);
   Put_Line ("Max =" & Max'Image);
   Put_Line ("Sum of squares =" & Sum_Sq'Image);
end Misc22;

Count = 1
Even total = 14
Empty length = 0
Squares =
[ 1,  4,  9,  16,  25]
Sum = 23
Max = 8
Sum of squares = 135

• Square-bracket aggregates: array aggregates can be written with [ ]. An empty array can be written [], and elements can be generated with an iterator, as in [for I in 1 .. 5 => I * I]⁵.
• @ (target name): on the right-hand side of an assignment statement, the variable on the left-hand side can be written as @⁹. You no longer have to repeat a long name, as in Statistics.Total_Count := Statistics.Total_Count + 1;.
• Iterator filters: writing for ... when condition loop runs the loop body only for elements that satisfy the condition¹⁰.
• 'Reduce (reduction expressions): folds a sequence of values, such as an array, into a single value using a binary operation and an initial value⁴. Values'Reduce ("+", 0) is the sum; passing Integer'Max gives the maximum.

A filter can also be written in the value sequence of 'Reduce. The following expression squares only the even numbers and adds them. It is the sum of the squares of 8 and 6, and the result was ` 100`.

Even_Sq : constant Integer :=
  [for V of Values when V mod 2 = 0 => V * V]'Reduce ("+", 0);

Note that appending 'Image directly to the result of 'Reduce, as in [for V of Values => V * V]'Reduce ("+", 0)'Image, produced the error prefix of attribute must be a name in both GNAT 13.3 and 15.3. The example above first stores the result in a constant and then applies 'Image.

flowchart TB
        accTitle: How a reduction expression is evaluated
        accDescr: Shows the flow of selecting elements from a sequence of values with an iterator filter, transforming each element, and folding them into one value with an initial value and a binary operation.
        A["Value sequence Values"] --> B["Filter when V mod 2 = 0"]
        B --> C["Transform each element to V * V"]
        C --> D["Fold with + starting from 0"]
        D --> E["Result 100"]

Figure 5: A reduction expression selects from a sequence of values, transforms them, and folds them into one value with an initial value and an operation.

Big_Integers: integers that do not overflow

Ada.Numerics.Big_Numbers.Big_Integers is a package that defines Big_Integer, an integer type with no upper limit on the number of digits¹¹. The following example computes the factorial of 30. This value does not fit even in a 64-bit integer.

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Numerics.Big_Numbers.Big_Integers;
use  Ada.Numerics.Big_Numbers.Big_Integers;

procedure Big_Demo is
   F : Big_Integer := 1;
begin
   for I in 1 .. 30 loop
      F := @ * To_Big_Integer (I);
   end loop;
   Put_Line ("30! =" & F'Image);
end Big_Demo;

30! = 265252859812191058636308480000000

In F : Big_Integer := 1;, an integer literal is assigned directly to a Big_Integer. This works through user-defined literals, added in Ada 2022¹². The RM’s declaration of Big_Integer specifies Integer_Literal => From_Universal_Image, and literals are converted to Big_Integer by this function¹¹. The same declaration also specifies Put_Image, so F'Image returns decimal digits.

flowchart TB
        accTitle: Big_Integer literals and 'Image
        accDescr: Shows that an integer literal becomes a Big_Integer through the function given by the Integer_Literal aspect, and that 'Image becomes a decimal string through Big_Integer's Put_Image.
        A["Integer literal 1"] --> B["Integer_Literal's From_Universal_Image"]
        B --> C["Big_Integer value"]
        C --> D["F'Image"]
        D --> E["Big_Integer's Put_Image"]
        E --> F["Decimal string"]

Figure 6: Big_Integer accepts literals through user-defined literals and builds the ‘Image string with Put_Image.

The Jorvik profile: fewer restrictions than Ravenscar

Jorvik is a tasking profile added to the standard in Ada 2022 that removes some of Ravenscar’s restrictions¹³. What Ravenscar contains and where it is used are explained in Real-Time Systems Programming in Ada, so this section covers only the differences.

According to the RM, Jorvik removes these six restrictions from Ravenscar¹³.

• No_Implicit_Heap_Allocations
• No_Relative_Delay (forbids relative delay statements)
• Max_Entry_Queue_Length => 1
• Max_Protected_Entries => 1 (limits a protected object to one entry)
• No_Dependence => Ada.Calendar
• No_Dependence => Ada.Synchronous_Barriers

It also replaces Simple_Barriers, which applies to entry barriers, with the weaker Pure_Barriers. Every unit that conforms to Ravenscar also conforms to Jorvik¹³.

I tried the following program, which has a protected object with two entries and uses a relative delay. It is split into three files: mailboxes.ads, mailboxes.adb and main.adb.

package Mailboxes is
   protected Mailbox is
      entry Put (Item : Integer);
      entry Get (Item : out Integer);
   private
      Value : Integer := 0;
      Count : Natural := 0;
   end Mailbox;
end Mailboxes;

package body Mailboxes is
   protected body Mailbox is
      --  Count = 0 cannot be written under Ravenscar's Simple_Barriers
      entry Put (Item : Integer) when Count = 0 is
      begin
         Value := Item;
         Count := 1;
      end Put;

      entry Get (Item : out Integer) when Count > 0 is
      begin
         Item  := Value;
         Count := 0;
      end Get;
   end Mailbox;
end Mailboxes;

with Ada.Text_IO; use Ada.Text_IO;
with Mailboxes;   use Mailboxes;

procedure Main is
   X : Integer;
begin
   delay 0.01;  --  Relative delay. Forbidden under Ravenscar by No_Relative_Delay
   Mailbox.Put (42);
   Mailbox.Get (X);
   Put_Line (X'Image);
end Main;

Building with pragma Profile (Jorvik); in gnat.adc compiled without errors and printed ` 42. Building the same code with pragma Profile (Ravenscar);` produced the following errors.

main.adb:7:04: error: violation of restriction "No_Relative_Delay"
main.adb:7:04: error: from profile "Ravenscar" at gnat.adc:1
mailboxes.ads:3:07: error: violation of restriction "Max_Protected_Entries = 1"
mailboxes.ads:3:07: error: from profile "Ravenscar" at gnat.adc:1

gnatmake stops at the errors in the spec, so I checked the barrier violations by checking the body with gcc -c -gnatc mailboxes.adb. Both barriers are violations.

mailboxes.adb:4:45: error: violation of restriction "Simple_Barriers"
mailboxes.adb:4:45: error: from profile "Ravenscar" at gnat.adc:1
mailboxes.adb:10:49: error: violation of restriction "Simple_Barriers"
mailboxes.adb:10:49: error: from profile "Ravenscar" at gnat.adc:1

At first I had put the protected object inside a procedure, which violated No_Local_Protected_Objects under both profiles. This restriction remains in Jorvik, so put protected objects in a package. I tested with the ordinary desktop runtime, not with an embedded runtime.

flowchart TB
        accTitle: How Ravenscar and Jorvik relate
        accDescr: Shows that Jorvik is a profile that removes six restrictions from Ravenscar and replaces Simple_Barriers with Pure_Barriers, and that a unit conforming to Ravenscar also conforms to Jorvik.
        A["Ravenscar profile"] --> B["Remove six restrictions"]
        A --> C["Replace Simple_Barriers with Pure_Barriers"]
        B --> D["Jorvik profile"]
        C --> D
        B -.-> E["Multiple entries, relative delay, Ada.Calendar, etc."]
        A -.-> F["A unit conforming to Ravenscar also conforms to Jorvik"]

Figure 7: Jorvik is a profile that removes some of Ravenscar’s restrictions, and a unit that meets Ravenscar’s requirements also meets Jorvik’s.

Parallel blocks and parallel loops: not yet usable in GNAT

Ada 2022 added parallel blocks (parallel do) and parallel loops (parallel for) as syntax for running work in parallel¹⁴¹⁰. A parallel block advances several sequences of statements separated by and concurrently, each as an independent logical thread of control. A parallel loop is syntax for writing a loop whose iterations may run in parallel. You can also specify an upper limit on the number of units executed together (chunks), as in parallel (4) for ....

The parallel syntax comes with rules for avoiding data races. RM 9.10.1 defines how far potentially conflicting reads and writes are forbidden, as a conflict check policy (pragma Conflict_Check_Policy). Under the default policy (All_Parallel_Conflict_Checks), reading or writing outer variables from inside the parallel constructs is forbidden at compile time¹⁵. The exceptions are synchronized objects and, inside a parallel loop, array elements indexed by the loop variable. So the following parallel loop is allowed by the rules, but code that assigns to the outer variables A and B from each arm of a parallel block is forbidden.

parallel for I in V'Range loop
   V (I) := I * I;
end loop;

However, neither GNAT 13.3 nor 15.3 accepted this syntax. Compiling the parallel loop above produces the following errors.

par_loop.adb:7:12: error: missing ":"
par_loop.adb:9:04: error: "end loop parallel;" expected

parallel do also produced syntax errors such as missing ":=", and 'Parallel_Reduce, the parallel form of the reduction expression, produced unrecognized attribute "Parallel_Reduce". The “Implementation of Ada 2022 Features” chapter of the GNAT Reference Manual lists the Ada 2022 features that have been implemented, but AI12-0119, which defines parallel blocks and parallel loops, is not in it³.

Checking reads and writes of outer variables at compile time is what characterizes this syntax in the RM. With today’s GNAT, write the work you want to run in parallel with tasks and protected objects. How to write them is explained in Safe Concurrency with Ada.

flowchart TB
        accTitle: The parallel syntax and how GNAT handles it
        accDescr: Shows that Ada 2022 parallel blocks and parallel loops have reads and writes of outer variables restricted by the RM's conflict checks, but are syntax errors in GNAT 13.3 and 15.3, so the work is written with tasks and protected objects.
        A["parallel do / parallel for"] --> B["Default conflict checks forbid reading and writing outer variables"]
        B -.-> C["Exceptions: synchronized objects, elements indexed by the loop variable"]
        A --> D{"Usable in GNAT 13.3 and 15.3?"}
        D -->|"Syntax error"| E["Write with tasks and protected objects"]

Figure 8: In the RM the parallel syntax has rules that prevent data races, but the GNAT versions tried do not accept it, so write the work with tasks and protected objects.

Summary of results by feature

Additions not covered here include container aggregates, 'Enum_Rep and 'Enum_Val for working with enumeration representation values, and importing C variadic functions².

Related articles

• The Appeal of the Ada Language — Expressing Design Through Types and Powering Software That Runs for Decades
• Introduction to Formal Verification with SPARK — From Ada Contracts to Mathematical Proof
• Safe Concurrency with Ada — A Practical Guide to Tasks and Protected Objects
• Real-Time Systems Programming in Ada — Priorities, Periodic Execution, and CPU Time Control in Practice
• Generic Programming in Ada — Contracts, Types, and Zero-Cost Reuse
• Starting an Ada Project with Alire
• Proving AI-Written Code with SPARK

References

Related Articles

Recent articles sharing the same tags. Deepen your understanding with closely related topics.

Related Topics

These are topic pages close to this theme. Starting from the article, you can go on to related services and other articles.

Services Connected to This Topic

This article leads to the following service pages. Start from the entry point closest to your situation.

Frequently Asked Questions

Questions commonly asked at the time of consultation about the topic of this article.

What do I need to specify to use Ada 2022 features with GNAT?

Pass -gnat2022 to the compiler, or write pragma Ada_2022; in the source. With both GNAT 13.3 and 15.3, declare expressions and other features were reported as errors ("Ada 2022 feature") unless this was specified. If you use gprbuild, put -gnat2022 in the Compiler package of the project file.

Can I use Ada 2022's parallel block (parallel do) with GNAT?

Not with GNAT 13.3 and 15.3, the versions tried in this article. parallel do and parallel for were both syntax errors, and 'Parallel_Reduce was treated as an unknown attribute. The GNAT Reference Manual's list of implemented Ada 2022 features also does not include the AI for parallel blocks. For work you want to run in parallel today, write it with tasks and protected objects.

How do the Jorvik and Ravenscar profiles differ?

Jorvik is a profile that removes six of Ravenscar's restrictions and relaxes the restriction on entry barriers. It allows multiple entries in a protected object, relative delay statements, use of Ada.Calendar, and more. Any unit that conforms to Ravenscar also conforms to Jorvik.

Author Profile

Profile page for the article author.

Go Komura

Representative of KomuraSoft LLC

Focused on Windows software development, technical consulting, and bug investigation, with particular strength in projects where existing assets remain and in investigating failures whose cause is hard to see.