# Expressions

## Expressions: Definition

According to the Ada Reference Manual, an expression "is a formula that defines the computation or retrieval of a value." Also, when an expression is evaluated, the computed or retrieved value always has an associated type known at compile-time.

Even though the definition above is very simple, Ada expressions are actually very flexible — and they can also be very complex. In fact, if you read the corresponding section of the Ada Reference Manual, you'll quickly discover that they include elements such as relations, membership choices, terms and primaries. Some of these are classic elements of expressions in programming languages, although some of their forms are unique to Ada. In this section, we present examples of just some of these elements. For a complete overview, please refer to the Reference Manual.

In the Ada Reference Manual

### Relations and simple expressions

Expressions usually consist of relations, which in turn consist of simple expressions. (There are more details to this, but we'll keep it simple for the moment.) Let's see a code example with a few expressions, which we dissect into the corresponding grammatical elements (we're going to discuss them later):

procedure Show_Expression_Elements is type Mode is (Off, A, B, C, D); pragma Unreferenced (B, C, D); subtype Active_Mode is Mode range Mode'Succ (Off) .. Mode'Last; M1, M2 : Mode; Dummy : Boolean; begin M1 := A; Dummy := M1 in Active_Mode and then M2 in Off | A; -- -- ^^^^^^^^^^^^^^^^^ relation -- -- ^^^^^^^^^^^^^^ relation -- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -- expression Dummy := M1 in Active_Mode; -- ^^ name -- ^^ primary -- ^^ factor -- ^^ term -- ^^ simple expression -- -- ^^^^^^^^^^^ membership choice -- ^^^^^^^^^^^ membership choice list -- -- ^^^^^^^^^^^^^^^^^ relation -- ^^^^^^^^^^^^^^^^^ expression Dummy := M2 in Off | A; -- ^^ name -- ^^ primary -- ^^ factor -- ^^ term -- ^^ simple expression -- -- ^^^ membership choice -- ^ membership choice -- ^^^^^^^ membership choice list -- -- ^^^^^^^^^^^^^ relation -- ^^^^^^^^^^^^^ expression end Show_Expression_Elements;

In this code example, we see three expressions. As we mentioned earlier, every
expression has a type; here, the type of each expression is `Boolean`

.

The first expression (`M1 in Active_Mode and then M2 in Off | A`

) consists
of two relations: `M1 in Active_Mode`

and `M2 in Off | A`

. Let's
discuss some of the details.

The `M1 in Active_Mode`

relation consists of the simple expression
`M1`

and the membership choice list `Active_Mode`

. (Here, the
`in`

keyword is part of the relation definition.) Also, as we see in the
comments of the source code, the simple expression `M1`

is, at the same
time, a term, a factor, a primary and a name.

Let's briefly talk about this chain of syntactic elements for simple expressions. Very roughly said, this is how we can break up simple expressions:

a simple expression consists of terms;

a term consists of factors;

a factor consists of primaries;

a primary can be one of those:

a numeric literal;

`null`

;a string literal;

a name;

an allocator (like

`new Integer`

);

For further reading...

The definition of simple expressions we've just seen is very simplified. In actuality, these are the grammatical elements specified in the Ada Reference Manual:

```
simple_expression ::=
[unary_adding_operator] term {binary_adding_operator term}
term ::= factor {multiplying_operator factor}
factor ::= primary [** primary] | abs primary | not primary
primary ::=
numeric_literal | null | string_literal | aggregate
| name | allocator | (expression)
| (conditional_expression) | (quantified_expression)
| (declare_expression)
```

Later on in this chapter, we discuss conditional expressions, quantified expressions and declare expressions in more details.

In the relation `M2 in Off | A`

from the code example, `Off | A`

is
a membership choice list, and `Off`

and `A`

are membership choices.

For further reading...

Relations can actually be much more complicated than the one we just saw. In fact, this is the definition from the Ada Reference Manual:

```
expression ::=
relation {and relation}
| relation {and then relation}
| relation {or relation}
| relation {or else relation}
| relation {xor relation}
relation ::=
simple_expression
[relational_operator simple_expression]
| simple_expression [not] in
membership_choice_list
| raise_expression
```

Again, for more details, please refer to the section on expressions of the Ada Reference Manual.

In the Ada Reference Manual

### Numeric expressions

The expressions we've seen so far had the `Boolean`

type. Although much
of the grammar described in the Manual exists exclusively for Boolean
operations, we can also write numeric expressions such as the following one:

procedure Show_Numeric_Expressions is C1 : constant Integer := 5; Dummy : Integer; begin Dummy := -2 ** 4 + 3 * C1 ** 8; -- ^ numeric literal -- ^ primary -- ^^ name -- ^^ primary -- ^^^^^^^ factor -- ^ multiplying operator -- ^ numeric literal -- ^ primary -- ^ factor -- ^^^^^^^^^^^ term -- -- ^ numeric literal -- ^ primary -- ^ numeric literal -- ^ primary -- ^^^^^^ factor -- ^^^^^^ term -- ^ binary adding operator -- ^ unary adding operator -- -- ^^^^^^^^^^^^^^^^^^^^^^ simple expression -- -- ^^^^^^^^^^^^^^^^^^^^^^ expression end Show_Numeric_Expressions;

In this code example, the expression `- 2 ** 4 + 3 * C1 ** 8`

consists of
just a single simple expression. (Note that simple expressions do not have to
be "simple".) This simple expression consists of two terms: `2 ** 4`

and
`3 * C1 ** 8`

. While the `2 ** 4`

term is also a single factor, the
`3 * C1 ** 8`

term consists of two factors: `3`

and `C1 ** 8`

.
Both the `2 ** 4`

and the `C1 ** 8`

factors consists of two primaries
each:

the

`2 ** 4`

factor has the primaries`2`

and`4`

,the

`C1 ** 8`

factor has the primaries`C1`

and`8`

.

In the Ada Reference Manual

### Other expressions

Expressions aren't limited to the `Boolean`

type or to numeric types.
Indeed, expressions can be of any type, and the definition of primaries we've
seen earlier on already hints in this direction — as it includes elements
such as allocators. Because expressions are very flexible, covering all possible
variations and combinations in this section is out of scope. Again, please refer
to the section on expressions of the Ada Reference Manual for
further details.

### Parenthesized expression

An interesting aspect of primaries is that, by using parentheses, we can embed an expression inside another expression. As an example, let's discuss the following expression and its elements:

procedure Show_Parenthesized_Expressions is C1 : constant Integer := 4; C2 : constant Integer := 5; Dummy : Integer; begin Dummy := (2 + C1) * C2; -- ^^ name -- ^^ primary -- ^^ factor -- ^^ term -- -- ^ numeric literal -- ^ primary -- ^ factor -- ^ term -- -- ^ binary adding operator -- ^^^^^^^^ simple expression -- -- ^^^^^^^^ expression -- ^^^^^^^^ primary -- ^^^^^^^^ factor -- -- ^^ factor -- ^^^^^^^^^^^^^ term -- -- ^^^^^^^^^^^^^ simple expression -- -- ^^^^^^^^^^^^^ expression end Show_Parenthesized_Expressions;

In this example, we first start with the single expression `(2 + C1) * C2`

,
which is also a simple expression consisting of just one term, which consists of
two factors: `(2 + C1)`

and `C2`

. The `(2 + C1)`

factor is also a
primary. Now, because of the parentheses, we identify that the primary
`(2 + C1)`

is an expression that is embedded in another expression.

Important

To be fair, the existence of parentheses in a primary could also indicate other kinds of expressions, such as conditional or quantified expressions. However, differentiating between them is straightforward, as we'll see later on in this chapter.

We then proceed to parse the `(2 + C1)`

expression, which consists of the
terms `2`

and `C1`

. As we've seen in the comments of the code example,
each of these terms consists of one factor, which consists of one primary. In
the end, after parsing the primaries, we identify that `2`

is a numeric
literal and `C1`

is a name.

Note that the usage of parentheses might lead to situations where we have expressions in potentially unsuspected places. For example, consider the following code example:

procedure Show_Name_In_Expression is type Mode is (Off, A, B, C, D); M1 : Mode; begin M1 := A; case M1 is when Off | D => null; when A | B | C => M1 := D; end case; end Show_Name_In_Expression;

Here, the case statement expects a selecting expression. In this case, `M1`

is identified as a name — after being identified as a relation, a simple
expression, a term, a factor and a primary.

However, if we replace `case M1 is`

by `case (M1) is`

, `(M1)`

is identified as a parenthesized expression, not as a name! This parenthesized
expression is first parsed and evaluated, which might have implications in case
statements, as we'll see
in another chapter.

Let's look at another example, this time with a subprogram call:

procedure Increment_By_One (I : in out Integer);procedure Increment_By_One (I : in out Integer) is begin I := I + 1; end Increment_By_One;with Increment_By_One; procedure Show_Name_In_Expression is V : Integer := 0; begin Increment_By_One ((V)); end Show_Name_In_Expression;

The `Increment_By_One`

procedure from this example expects a variable as an
actual parameter because the parameter mode is `in out`

. However, the
`(V)`

in the call to the procedure is interpreted as an expression, so we
end up providing a value — the result of the expression — as the
actual parameter instead of the `V`

variable. Naturally, this is a
compilation error. (Of course, writing `Increment_By_One (V)`

fixes the
error.)

## Conditional Expressions

As we've seen before, we can write simple expressions such as `I = 0`

or
`D.Valid`

. A conditional expression, as the name implies, is an
expression that contains a condition. This might be an "if-expression" (in the
`if ... then ... else`

form) or a "case-expression" (in the
`case ... is when =>`

form).

The `Max`

function in the following code example is an expression function
implemented with a conditional expression — an if-expression, to be more
precise:

package Expr_Func is function Max (A, B : Integer) return Integer is (if A >= B then A else B); end Expr_Func;

Let's say we have a system with four states `Off`

, `On`

,
`Waiting`

, and `Invalid`

. For this system, we want to implement a
function named `Toggled`

that returns the *toggled* value of a state
`S`

. If the current value of `S`

is either `Off`

or `On`

,
the function toggles from `Off`

to `On`

(or from `On`

to `Off`

). For other values, the state remains unchanged — i.e. the
returned value is the same as the input value. This is the implementation using
a conditional expression:

package Expr_Func is type State is (Off, On, Waiting, Invalid); function Toggled (S : State) return State is (if S = Off then On elsif S = On then Off else S); end Expr_Func;

As you can see, if-expressions may contain an `elsif`

branch (and
therefore be more complicated).

The code above corresponds to this more verbose version:

package Expr_Func is type State is (Off, On, Waiting, Invalid); function Toggled (S : State) return State; end Expr_Func;package body Expr_Func is function Toggled (S : State) return State is begin if S = Off then return On; elsif S = On then return Off; else return S; end if; end Toggled; end Expr_Func;

If we compare the if-block of this code example to the if-expression of the
previous example, we notice that the if-expression is just a simplified version
without the `return`

keyword and the `end if;`

. In fact, converting
an if-block to an if-expression is quite straightforward.

We could also replace the if-expression used in the `Toggled`

function
above with a case-expression. For example:

package Expr_Func is type State is (Off, On, Waiting, Invalid); function Toggled (S : State) return State is (case S is when Off => On, when On => Off, when others => S); end Expr_Func;

Note that we use commas in case-expressions to separate the alternatives (the
`when`

expressions). The code above corresponds to this more verbose
version:

package Expr_Func is type State is (Off, On, Waiting, Invalid); function Toggled (S : State) return State; end Expr_Func;package body Expr_Func is function Toggled (S : State) return State is begin case S is when Off => return On; when On => return Off; when others => return S; end case; end Toggled; end Expr_Func;

If we compare the case block of this code example to the case-expression of the
previous example, we notice that the case-expression is just a simplified
version of the case block without the `return`

keyword and the
`end case;`

, and with alternatives separated by commas instead of
semicolons.

In the Ada Reference Manual

## Quantified Expressions

Quantified expressions are `for`

expressions using a quantifier —
which can be either `all`

or `some`

— and a predicate. This
kind of expressions let us formalize statements such as:

"all values of array

`A`

must be zero" into`for all I in A'Range => A (I) = 0`

, and"at least one value of array

`A`

must be zero" into`for some I in A'Range => A (I) = 0`

.

In the quantified expression `for all I in A'Range => A (I) = 0`

, the
quantifier is `all`

and the predicate is `A (I) = 0`

. In the second
expression, the quantifier is `some`

. The result of a quantified
expression is always a Boolean value.

For example, we could use the quantified expressions above and implement these two functions:

`Is_Zero`

, which checks whether all components of an array`A`

are zero, and`Has_Zero`

, which checks whether array`A`

has at least one component of the array`A`

is zero.

This is the complete code:

package Int_Arrays is type Integer_Arr is array (Positive range <>) of Integer; function Is_Zero (A : Integer_Arr) return Boolean is (for all I in A'Range => A (I) = 0); function Has_Zero (A : Integer_Arr) return Boolean is (for some I in A'Range => A (I) = 0); procedure Display_Array (A : Integer_Arr; Name : String); end Int_Arrays;with Ada.Text_IO; use Ada.Text_IO; package body Int_Arrays is procedure Display_Array (A : Integer_Arr; Name : String) is begin Put (Name & ": "); for E of A loop Put (E'Image & " "); end loop; New_Line; end Display_Array; end Int_Arrays;with Ada.Text_IO; use Ada.Text_IO; with Int_Arrays; use Int_Arrays; procedure Test_Int_Arrays is A : Integer_Arr := (0, 0, 1); begin Display_Array (A, "A"); Put_Line ("Is_Zero: " & Boolean'Image (Is_Zero (A))); Put_Line ("Has_Zero: " & Boolean'Image (Has_Zero (A))); A := (0, 0, 0); Display_Array (A, "A"); Put_Line ("Is_Zero: " & Boolean'Image (Is_Zero (A))); Put_Line ("Has_Zero: " & Boolean'Image (Has_Zero (A))); end Test_Int_Arrays;

As you might have expected, we can rewrite a quantified expression as a loop
in the `for I in A'Range loop if ... return ...`

form. In the code below,
we're implementing `Is_Zero`

and `Has_Zero`

using loops and
conditions instead of quantified expressions:

package Int_Arrays is type Integer_Arr is array (Positive range <>) of Integer; function Is_Zero (A : Integer_Arr) return Boolean; function Has_Zero (A : Integer_Arr) return Boolean; procedure Display_Array (A : Integer_Arr; Name : String); end Int_Arrays;with Ada.Text_IO; use Ada.Text_IO; package body Int_Arrays is function Is_Zero (A : Integer_Arr) return Boolean is begin for I in A'Range loop if A (I) /= 0 then return False; end if; end loop; return True; end Is_Zero; function Has_Zero (A : Integer_Arr) return Boolean is begin for I in A'Range loop if A (I) = 0 then return True; end if; end loop; return False; end Has_Zero; procedure Display_Array (A : Integer_Arr; Name : String) is begin Put (Name & ": "); for E of A loop Put (E'Image & " "); end loop; New_Line; end Display_Array; end Int_Arrays;with Ada.Text_IO; use Ada.Text_IO; with Int_Arrays; use Int_Arrays; procedure Test_Int_Arrays is A : Integer_Arr := (0, 0, 1); begin Display_Array (A, "A"); Put_Line ("Is_Zero: " & Boolean'Image (Is_Zero (A))); Put_Line ("Has_Zero: " & Boolean'Image (Has_Zero (A))); A := (0, 0, 0); Display_Array (A, "A"); Put_Line ("Is_Zero: " & Boolean'Image (Is_Zero (A))); Put_Line ("Has_Zero: " & Boolean'Image (Has_Zero (A))); end Test_Int_Arrays;

So far, we've seen quantified expressions using indices — e.g.
`for all I in A'Range => ...`

. We could avoid indices in quantified
expressions by simply using the `E of A`

form. In this case, we can just
write `for all E of A => ...`

. Let's adapt the implementation of
`Is_Zero`

and `Has_Zero`

using this form:

package Int_Arrays is type Integer_Arr is array (Positive range <>) of Integer; function Is_Zero (A : Integer_Arr) return Boolean is (for all E of A => E = 0); function Has_Zero (A : Integer_Arr) return Boolean is (for some E of A => E = 0); end Int_Arrays;

Here, we're checking the components `E`

of the array `A`

and
comparing them against zero.

In the Ada Reference Manual

## Declare Expressions

So far, we've seen expressions that make use of existing objects declared outside of the expression. Sometimes, we might want to declare constant objects inside the expression, so we can use them locally in the expression. Similarly, we might want to rename an object and use the renamed object in an expression. In those cases, we can use a declare expression.

A declare expression allows for declaring or renaming objects within an expression:

pragma Ada_2022; package P is function Max (A, B : Integer) return Integer is (declare Bigger_A : constant Boolean := (A >= B); begin (if Bigger_A then A else B)); end P;

The declare expression starts with the `declare`

keyword and the usual
object declarations, and it's followed by the `begin`

keyword and the
body. In this example, the body of the declare expression is a conditional
expression.

Of course, the code above isn't really useful, so let's look at a more complete example:

pragma Ada_2022; package Integer_Arrays is type Integer_Array is array (Positive range <>) of Integer; function Sum (Arr : Integer_Array) return Integer; -- -- Expression function using -- declare expression: -- function Avg (Arr : Integer_Array) return Float is (declare A : Integer_Array renames Arr; S : constant Float := Float (Sum (A)); L : constant Float := Float (A'Length); begin S / L); end Integer_Arrays;package body Integer_Arrays is function Sum (Arr : Integer_Array) return Integer is begin return Acc : Integer := 0 do for V of Arr loop Acc := Acc + V; end loop; end return; end Sum; end Integer_Arrays;pragma Ada_2022; with Ada.Text_IO; use Ada.Text_IO; with Integer_Arrays; use Integer_Arrays; procedure Show_Integer_Arrays is Arr : constant Integer_Array := [1, 2, 3]; begin Put_Line ("Sum: " & Sum (Arr)'Image); Put_Line ("Avg: " & Avg (Arr)'Image); end Show_Integer_Arrays;

In this example, the `Avg`

function is implemented using a declare
expression. In this expression, `A`

renames the `Arr`

array, and
`S`

is a constant initialized with the value returned by the `Sum`

function.

In the Ada Reference Manual

### Restrictions in the declarative part

The declarative part of a declare expression is more restricted than the declarative part of a subprogram or declare block. In fact, we cannot:

declare variables;

declare constants of limited types;

rename an object of limited type that is constructed within the declarative part;

declare aliased constants;

declare constants that make use of the

`Access`

or`Unchecked_Access`

attributes in the initialization;declare constants of anonymous access type.

Let's see some examples of erroneous declarations:

pragma Ada_2022; package Integer_Arrays is type Integer_Array is array (Positive range <>) of Integer; type Integer_Sum is limited private; type Const_Integer_Access is access constant Integer; function Sum (Arr : Integer_Array) return Integer; function Sum (Arr : Integer_Array) return Integer_Sum; -- -- Expression function using -- declare expression: -- function Avg (Arr : Integer_Array) return Float is (declare A : Integer_Array renames Arr; S1 : aliased constant Integer := Sum (A); -- ERROR: aliased constant S : Float := Float (S1); L : Float := Float (A'Length); -- ERROR: declaring variables S2 : constant Integer_Sum := Sum (A); -- ERROR: declaring constant of -- limited type A1 : Const_Integer_Access := S1'Unchecked_Access; -- ERROR: using 'Unchecked_Access -- attribute A2 : access Integer := null; -- ERROR: declaring object of -- anonymous access type begin S / L); private type Integer_Sum is new Integer; end Integer_Arrays;package body Integer_Arrays is function Sum (Arr : Integer_Array) return Integer is begin return Acc : Integer := 0 do for V of Arr loop Acc := Acc + V; end loop; end return; end Sum; function Sum (Arr : Integer_Array) return Integer_Sum is (Integer_Sum (Integer'(Sum (Arr)))); end Integer_Arrays;

In this version of the `Avg`

function, we see many errors in the
declarative part of the declare expression. If we convert the declare
expression into an actual function implementation, however, those declarations
won't trigger compilation errors. (Feel free to try this out!)

## Reduction Expressions

Note

This feature was introduced in Ada 2022.

A reduction expression reduces a list of values into a single value. For
example, we can reduce the list `[2, 3, 4]`

to a single value:

by adding the values of the list:

`2 + 3 + 4 = 9`

, orby multiplying the values of the list:

`2 * 3 * 4 = 24`

.

We write a reduction expression by using the `Reduce`

attribute and
providing the reducer and its initial value:

the reducer is the operator (e.g.:

`+`

or`*`

) that we use to*combine*the values of the list;the initial value is the value that we use before all other values of the list.

For example, if we use `+`

as the operator and `0`

an the initial
value, we get the reduction expression: `0 + 2 + 3 + 4 = 9`

. This can be
implemented using an array:

with Ada.Text_IO; use Ada.Text_IO; procedure Show_Reduction_Expression is A : array (1 .. 3) of Integer; I : Integer; begin A := [2, 3, 4]; I := A'Reduce ("+", 0); Put_Line ("A = " & A'Image); Put_Line ("I = " & I'Image); end Show_Reduction_Expression;

Here, we have the array `A`

with a list of values. The
`A'Reduce ("+", 0)`

expression reduces the list of values of `A`

into
a single value — in this case, an integer value that is stored in
`I`

. This statement is equivalent to:

```
I := 0;
for E of A loop
I := I + E;
end loop;
```

Naturally, we can reduce the array using the `*`

operator:

with Ada.Text_IO; use Ada.Text_IO; procedure Show_Reduction_Expression is A : array (1 .. 3) of Integer; I : Integer; begin A := [2, 3, 4]; I := A'Reduce ("*", 1); Put_Line ("A = " & A'Image); Put_Line ("I = " & I'Image); end Show_Reduction_Expression;

In this example, we call `A'Reduce ("*", 1)`

to reduce the list. (Note
that we use an initial value of one because it is the
identity element of a multiplication, so the
complete operation is: `1 * 2 * 3 * 4 = 24`

.)

In the Ada Reference Manual

### Value sequences

In addition to arrays, we can apply reduction expression to value sequences,
which consist of an iterated element association — for example,
`[for I in 1 .. 3 => I + 1]`

. We can simply *append* the reduction
expression to a value sequence:

with Ada.Text_IO; use Ada.Text_IO; procedure Show_Reduction_Expression is I : Integer; begin I := [for I in 1 .. 3 => I + 1]'Reduce ("+", 0); Put_Line ("I = " & I'Image); I := [for I in 1 .. 3 => I + 1]'Reduce ("*", 1); Put_Line ("I = " & I'Image); end Show_Reduction_Expression;

In this example, we create the value sequence `[for I in 1 .. 3 => I + 1]`

and reduce it using the `+`

and `*`

operators. (Note that the
operations in this example have the same results as in the previous examples
using arrays.)

### Custom reducers

In the previous examples, we've used standard operators such as `+`

and
`*`

as the reducer. We can, however, write our own reducers and pass
them to the `Reduce`

attribute. For example:

with Ada.Text_IO; use Ada.Text_IO; procedure Show_Reduction_Expression is type Integer_Array is array (Positive range <>) of Integer; A : Integer_Array (1 .. 3); I : Long_Integer; procedure Accumulate (Accumulator : in out Long_Integer; Value : Integer) is begin Accumulator := Accumulator + Long_Integer (Value); end Accumulate; begin A := [2, 3, 4]; I := A'Reduce (Accumulate, 0); Put_Line ("A = " & A'Image); Put_Line ("I = " & I'Image); end Show_Reduction_Expression;

In this example, we implement the `Accumulate`

procedure as our reducer,
which is called to accumulate the individual elements (integer values) of the
list. We pass this procedure to the `Reduce`

attribute in the
`I := A'Reduce (Accumulate, 0)`

statement, which is equivalent to:

```
I := 0;
for E of A loop
Accumulate (I, E);
end loop;
```

A custom reducer must have the following parameters:

The accumulator parameter, which stores the interim result — and the final result as well, once all elements of the list have been processed.

The value parameter, which is a single element from the list.

Note that the accumulator type doesn't need to match the type of the individual
components. In this example, we're using `Integer`

as the component type,
while the accumulator type is `Long_Integer`

. (For this kind of reducers,
using `Long_Integer`

instead of `Integer`

for the accumulator type
makes lots of sense due to the risk of triggering overflows while the reducer
is accumulating values — e.g. when accumulating a long list with larger
numbers.)

In the example above, we've implemented the reducer as a procedure. However, we can also implement it as a function. In this case, the accumulated value is returned by the function:

with Ada.Text_IO; use Ada.Text_IO; procedure Show_Reduction_Expression is type Integer_Array is array (Positive range <>) of Integer; A : Integer_Array (1 .. 3); I : Long_Integer; function Accumulate (Accumulator : Long_Integer; Value : Integer) return Long_Integer is begin return Accumulator + Long_Integer (Value); end Accumulate; begin A := [2, 3, 4]; I := A'Reduce (Accumulate, 0); Put_Line ("A = " & A'Image); Put_Line ("I = " & I'Image); end Show_Reduction_Expression;

In this example, we converted the `Accumulate`

procedure into a function
(while the core implementation is essentially the same).

Note that the reduction expression remains the same, independently of whether
we're using a procedure or a function as the reducer. Therefore, the statement
with the reduction expression in this example is the same as in the previous
example: `I := A'Reduce (Accumulate, 0);`

. Now that we're using a
function, this statement is equivalent to:

```
I := 0;
for E of A loop
I := Accumulate (I, E);
end loop;
```

### Other accumulator types

The accumulator type isn't restricted to scalars: in fact, we could use record types as well. For example:

with Ada.Text_IO; use Ada.Text_IO; procedure Show_Reduction_Expression is type Integer_Array is array (Positive range <>) of Integer; A : Integer_Array (1 .. 3); type Integer_Accumulator is record Value : Long_Integer; Count : Integer; end record; function Accumulate (Accumulator : Integer_Accumulator; Value : Integer) return Integer_Accumulator is begin return (Value => Accumulator.Value + Long_Integer (Value), Count => Accumulator.Count + 1); end Accumulate; function Zero return Integer_Accumulator is (Value => 0, Count => 0); function Average (Acc : Integer_Accumulator) return Float is (Float (Acc.Value) / Float (Acc.Count)); Acc : Integer_Accumulator; begin A := [2, 3, 4]; Acc := A'Reduce (Accumulate, Zero); Put_Line ("Acc = " & Acc'Image); Put_Line ("Avg = " & Average (Acc)'Image); end Show_Reduction_Expression;

In this example, we're using the `Integer_Accumulator`

record type in our
reducer — the `Accumulate`

function. In this case, we're not only
accumulating the values, but also counting the number of elements in the
list. (Of course, we could have used `A'Length`

for that as well.)

Also, we're not limited to numeric types: we can also create a reducer using strings as the accumulator type. In fact, we can display the initial value and the elements of the list by using unbounded strings:

with Ada.Text_IO; use Ada.Text_IO; with Ada.Strings.Unbounded; use Ada.Strings.Unbounded; procedure Show_Reduction_Expression is type Integer_Array is array (Positive range <>) of Integer; A : Integer_Array (1 .. 3); function Unbounded_String_List (Accumulator : Unbounded_String; Value : Integer) return Unbounded_String is begin return Accumulator & ", " & Value'Image; end Unbounded_String_List; begin A := [2, 3, 4]; Put_Line ("A = " & A'Image); Put_Line ("L = " & To_String (A'Reduce (Unbounded_String_List, To_Unbounded_String ("0")))); end Show_Reduction_Expression;

In this case, the "accumulator" is concatenating the initial value and individual values of the list into a string.