View source for Ada Programming/Type System

<noinclude>{{Ada/Navigation|Subtypes}}
__TOC__</noinclude>

Ada's type system allows the programmer to construct powerful abstractions that represent the real world, and to provide valuable information to the compiler, so that the compiler can find many logic or design errors before they become bugs.  It is at the heart of the language, and good Ada programmers learn to use it to great advantage.  Four principles govern the type system:

* '''Type''': a way to categorize data. characters are types 'a' through 'z'. Integers are types that include 0,1,2....
* '''Strong typing''': types are incompatible with one another, so it is not possible to mix apples and oranges. The compiler will not guess that your apple is an orange. You must explicitly say my_fruit = fruit(my_apple). Strong typing reduces the amount of errors. This is because developers can really easily write a float into an integer variable without knowing. Now data you needed for your program to succeed has been lost in the conversion when the complier switched types. Ada gets mad and rejects the developer's dumb mistake  by refusing to do the conversion unless explicitly told.
* '''Static typing''': type checked while compiling, this allows type errors to be found earlier.
* '''Abstraction''': types represent the real world or the problem at hand; not how the computer represents the data internally.  There are ways to specify exactly how a type must be represented at the bit level, but we will defer that discussion to another chapter. An example of an abstraction is your car. You don't really know how it works you just know that bumbling hunk of metal moves. Nearly every technology you work with is abstracted layer to simplify the complex circuits that make it up - the same goes for software. You want abstraction because code in a class makes a lot more sense than a hundred if statements with no explanation when debugging
* '''Name equivalence''': as opposed to ''structural equivalence'' used in most other languages.  Two types are compatible if and only if they have the same name; ''not'' if they just happen to have the same size or bit representation.  You can thus declare two integer types with the same ranges that are totally incompatible, or two record types with exactly the same components, but which are incompatible.

Types are incompatible with one another.  However, each type can have any number of ''subtypes'', which are compatible with their base type and may be compatible with one another. See below for examples of subtypes which are incompatible with one another.

== Predefined types ==

There are several predefined types, but most programmers prefer to define their own, application-specific types.  Nevertheless, these predefined types are very useful as interfaces between libraries developed independently.  The predefined library, obviously, uses these types too.

These types are predefined in the {{Ada/package|Standard}} package:
; Integer: This type covers at least the range <math>-2^{15}+1</math> .. <math>+2^{15}-1</math> (RM {{Ada/RM|3|5|4|title=(21)}}). The Standard also defines <code>Natural</code> and <code>Positive</code> subtypes of this type.
{{Ada/Integer subtypes diagram}}
; Float: There is only a very weak implementation requirement on this type (RM {{Ada/RM|3|5|7|title=(14)}}); most of the time you would define your own floating-point types, and specify your precision and range requirements.
; Duration: A [[Ada Programming/Types/delta|fixed point type]] used for timing. It represents a period of time in seconds (RM {{Ada/RM|A|1|title=(43)}}).
; Character : A special form of [[Ada Programming/Types/Enumeration|Enumerations]]. There are three predefined kinds of character types: 8-bit characters (called <code>Character</code>), 16-bit characters (called <code>Wide_Character</code>), and 32-bit characters (<code>Wide_Wide_Character</code>). <code>Character</code> has been present since the first version of the language ([[Ada Programming/Ada 83|Ada 83]]), <code>Wide_Character</code> was added in [[Ada Programming/Ada 95|Ada 95]], while the type <code>Wide_Wide_Character</code> is available with [[Ada Programming/Ada 2005|Ada 2005]].
; [[Ada Programming/Strings|String]]: Three indefinite [[Ada Programming/Types/array|array types]], of <code>Character</code>, <code>Wide_Character</code>, and <code>Wide_Wide_Character</code> respectively.  The standard library contains packages for handling strings in three variants: fixed length (<code>{{Ada/package|Ada|Strings|Fixed}}</code>), with varying length below a certain upper bound (<code>{{Ada/package|Ada|Strings|Bounded}}</code>), and unbounded length (<code>{{Ada/package|Ada|Strings|Unbounded}}</code>).  Each of these packages has a <code>Wide_</code> and a <code>Wide_Wide_</code> variant.
; Boolean : A <code>Boolean</code> in Ada is an [[Ada Programming/Types/Enumeration|Enumeration]] of <code>False</code> and <code>True</code> with special semantics.

Packages <code>{{Ada/package|System}}</code> and <code>{{Ada/package|System|Storage_Elements}}</code> predefine some types which are primarily useful for low-level programming and interfacing to hardware.

; System.Address : An address in memory.
; System.Storage_Elements.Storage_Offset : An offset, which can be added to an address to obtain a new address.  You can also subtract one address from another to get the offset between them.  Together, <code>Address</code>, <code>Storage_Offset</code> and their associated subprograms provide for address arithmetic.
; System.Storage_Elements.Storage_Count : A subtype of <code>Storage_Offset</code> which cannot be negative, and represents the memory size of a data structure (similar to C's <code>size_t</code>).
; System.Storage_Elements.Storage_Element : In most computers, this is a byte.  Formally, it is the smallest unit of memory that has an address.
; System.Storage_Elements.Storage_Array : An array of <code>Storage_Element</code>s without any meaning, useful when doing raw memory access.

== The Type Hierarchy ==

Types are organized hierarchically.  A type inherits properties from types above it in the hierarchy.  For example, all scalar types (integer, enumeration, modular, fixed-point and floating-point types) have [[Ada Programming/Operators|operators]] "{{Ada/op|<}}", "{{Ada/op|>}}" and arithmetic operators defined for them, and all discrete types can serve as array indexes.

[[Image:Ada_types.png|thumb|550px|center|Ada type hierarchy]]

Here is a broad overview of each category of types; please follow the links for detailed explanations. Inside parenthesis there are equivalences in C and Pascal for readers familiar with those languages.

; [[Ada Programming/Types/range|Signed Integers]] <small>('''int''', '''INTEGER''')</small> : Signed Integers are defined via the [[Ada Programming/Types/range|range]] of values needed.
; [[Ada Programming/Types/mod|Unsigned Integers]] <small>('''unsigned''', '''CARDINAL''')</small> : Unsigned Integers are called [[Ada Programming/Types/mod|Modular Types]]. Apart from being unsigned they also have wrap-around functionality.
; [[Ada Programming/Types/Enumeration|Enumerations]] <small>('''enum''', '''char''', '''bool''', '''BOOLEAN''')</small> : Ada [[Ada Programming/Types/Enumeration|Enumeration]] types are a separate type family.
; [[Ada Programming/Types/digits|Floating point]] <small>('''float''', '''double''', '''REAL''')</small> : Floating point types are defined by the [[Ada Programming/Types/digits|digits]] needed, the relative error bound.
; [[Ada Programming/Types/delta|Ordinary and Decimal Fixed Point]] <small>('''DECIMAL''')</small> : Fixed point types are defined by their [[Ada Programming/Types/delta|delta]], the absolute error bound.
; [[Ada Programming/Types/array|Arrays]] <small>( '''[ ]''', '''ARRAY [ ] OF''', '''STRING''' )</small> : Arrays with both compile-time and run-time determined size are supported.
; [[Ada Programming/Types/record|Record]] <small>('''struct''', '''class''', '''RECORD OF''')</small> : A '''record''' is a [[Ada Programming/Types#List of types|composite type]] that groups one or more fields.
; [[Ada Programming/Types/access|Access]] <small>('''*''', '''^''', '''POINTER TO''')</small> : Ada's [[Ada Programming/Types/access|Access]] types may be more than just a simple memory address.
; [[Ada Programming/Tasking|Task & Protected]] <small>(similar to multithreading in C++)</small> : Task and Protected types allow the control of concurrency
; [[Ada Programming/Keywords/interface|Interfaces]] <small>(similar to virtual methods in C++)</small> : New in Ada 2005, these types are similar to the Java interfaces.

=== Classification of Types ===

Ada's types can be classified as follows.

'''Specific vs. Class-wide'''

 {{Ada/kw|type}} T {{Ada/kw|is}} ...  {{Ada/--| a specific type}}
   T'{{Ada/attribute|Class}}      {{Ada/--| the corresponding class-wide type (exists only for tagged types)}}

<code>T'{{Ada/attribute|Class}}</code> and <code>T'{{Ada/attribute|Class}}'{{Ada/attribute|Class}}</code> are the same.

Primitive operations with parameters of specific types are ''non-dispatching'', those with parameters of class-wide types are ''dispatching''.

New types can be declared by ''deriving'' from specific types; primitive operations are ''inherited'' by derivation. You cannot derive from class-wide types.

'''Constrained vs. Unconstrained'''

 {{Ada/kw|type}} I {{Ada/kw|is}} {{Ada/kw|range}} 1 .. 10;           {{Ada/--| constrained}}
 {{Ada/kw|type}} AC {{Ada/kw|is}} {{Ada/kw|array}} (1 .. 10) {{Ada/kw|of}} ...  {{Ada/--| constrained}}

 {{Ada/kw|type}} AU {{Ada/kw|is}} {{Ada/kw|array}} (I {{Ada/kw|range}} <>) {{Ada/kw|of}} ...          {{Ada/--| unconstrained}}
 {{Ada/kw|type}} R (X: Discriminant [:= Default]) {{Ada/kw|is}} ...  {{Ada/--| unconstrained}}

By giving a ''constraint'' to an unconstrained subtype, a subtype or object becomes constrained:

 {{Ada/kw|subtype}} RC {{Ada/kw|is}} R (Value);  {{Ada/--| constrained subtype of R}}
 OC: R (Value);            {{Ada/--| constrained object of anonymous constrained subtype of R}}
 OU: R;                    {{Ada/--| unconstrained object}}

Declaring an unconstrained object is only possible if a default value is given in the type declaration above. The language does not specify how such objects are allocated. GNAT allocates the maximum size, so that size changes that might occur with discriminant changes present no problem. Another possibility is implicit dynamic allocation on the heap and re-allocation followed by a deallocation when the size changes.

''' Definite vs. Indefinite'''

 {{Ada/kw|type}} I {{Ada/kw|is}} {{Ada/kw|range}} 1 .. 10;                     {{Ada/--| definite}}
 {{Ada/kw|type}} RD (X: Discriminant := Default) {{Ada/kw|is}} ...  {{Ada/--| definite}}

 {{Ada/kw|type}} T (<>) {{Ada/kw|is}} ...                    {{Ada/--| indefinite}}
 {{Ada/kw|type}} AU {{Ada/kw|is}} {{Ada/kw|array}} (I {{Ada/kw|range}} <>) {{Ada/kw|of}} ...  {{Ada/--| indefinite}}
 {{Ada/kw|type}} RI (X: Discriminant) {{Ada/kw|is}} ...      {{Ada/--| indefinite}}

Definite subtypes allow the declaration of objects without initial value, since objects of definite subtypes have constraints that are known at creation-time. Object declarations of indefinite subtypes need an initial value to supply a constraint; they are then constrained by the constraint delivered by the initial value.

 OT: T  := Expr;                       {{Ada/--| some initial expression (object, function call, etc.)}}
 OA: AU := (3 => 10, 5 => 2, 4 => 4);  {{Ada/--| index range is now 3 .. 5}}
 OR: RI := Expr;                       {{Ada/--| again some initial expression as above}}

'''Unconstrained vs. Indefinite'''

Note that unconstrained subtypes are not necessarily indefinite as can be seen above with RD: it is a definite unconstrained subtype.

== Concurrency Types ==

The Ada language uses types for one more purpose in addition to classifying data
+ operations. The type system integrates concurrency (threading, parallelism).
Programmers will use types for expressing the concurrent
threads of control of their programs.

The core pieces of this part of the type system, the '''task''' types and
the '''protected''' types are explained in greater depth in
[[Ada Programming/Tasking|a section on tasking]].

== Limited Types ==

Limiting a type means disallowing assignment.
The &ldquo;concurrency types&rdquo; described above are always limited.
Programmers can define their own types to be limited, too, like this:

 {{Ada/keyword|type}} T {{Ada/keyword|is}} {{Ada/keyword|limited}} &hellip;;

(The ellipsis stands for {{Ada/kw|private}}, or for a {{Ada/kw|record}} definition,
see the corresponding subsection on this page.)
A  limited type also doesn't have
an equality operator unless the programmer defines one.

You can learn more in the [[Ada Programming/Types/limited|limited types]] chapter.

== Defining new types and subtypes ==

You can define a new type with the following syntax:

 {{Ada/kw|type}} T {{Ada/kw|is}}...

followed by the description of the type, as explained in detail in each category of type.

Formally, the above declaration creates a type and its ''first subtype'' named <code>T</code>.  The type itself, correctly called the "type of T", is anonymous; the RM refers to it as <code>''T''</code> (in italics), but often speaks sloppily about the type T. But this is an academic consideration; for most purposes, it is sufficient to think of <code>T</code> as a type.
For scalar types, there is also a base type called <code>T'Base</code>, which encompasses all values of T.

For signed integer types, the type of T comprises the (complete) set of mathematical integers. The base type is a certain hardware type, symmetric around zero (except for possibly one extra negative value), encompassing all values of T.  

As explained above, all types are incompatible; thus:

 {{Ada/kw|type}} Integer_1 {{Ada/kw|is}} {{Ada/kw|range}} 1 .. 10;
 {{Ada/kw|type}} Integer_2 {{Ada/kw|is}} {{Ada/kw|range}} 1 .. 10;
 A : Integer_1 := 8;
 B : Integer_2 := A; {{Ada/comment|illegal!}}

is illegal, because <code>Integer_1</code> and <code>Integer_2</code> are different and incompatible types.  It is this feature which allows the compiler to detect logic errors at compile time, such as adding a file descriptor to a number of bytes, or a length to a weight.  The fact that the two types have the same range does not make them compatible: this is ''name equivalence'' in action, as opposed to structural equivalence.  (Below, we will see how you can convert between incompatible types; there are strict rules for this.)

=== Creating subtypes ===

You can also create new subtypes of a given type, which will be compatible with each other, like this:

 {{Ada/kw|type}} Integer_1 {{Ada/kw|is}} {{Ada/kw|range}} 1 .. 10;
 {{Ada/kw|subtype}} Integer_2 {{Ada/kw|is}} Integer_1      {{Ada/kw|range}} 7 .. 11;  {{Ada/comment|bad}}
 {{Ada/kw|subtype}} Integer_3 {{Ada/kw|is}} Integer_1'Base {{Ada/kw|range}} 7 .. 11;  {{Ada/comment|OK}}
 A : Integer_1 := 8;
 B : Integer_3 := A; {{Ada/comment|OK}}

The declaration of <code>Integer_2</code> is bad because the constraint <code>7 .. 11</code> is not compatible with <code>Integer_1</code>; it raises <code>Constraint_Error</code> at subtype elaboration time.

<code>Integer_1</code> and <code>Integer_3</code> are compatible because they are both subtypes of the same type, namely <code>Integer_1'Base</code>.

It is not necessary that the subtype ranges overlap, or be included in one another.  The compiler inserts a run-time range check when you assign A to B; if the value of A, at that point, happens to be outside the range of <code>Integer_3</code>, the program raises <code>Constraint_Error</code>.

There are a few predefined subtypes which are very useful:

 {{Ada/kw|subtype}} Natural  {{Ada/kw|is}} Integer {{Ada/kw|range}} 0 .. Integer'Last;
 {{Ada/kw|subtype}} Positive {{Ada/kw|is}} Integer {{Ada/kw|range}} 1 .. Integer'Last;

=== Derived types ===

A derived type is a new, full-blown type created from an existing one.  Like any other type, it is incompatible with its parent; however, it inherits the primitive operations defined for the parent type.

 {{Ada/kw|type}} Integer_1 {{Ada/kw|is}} {{Ada/kw|range}} 1 .. 10;
 {{Ada/kw|type}} Integer_2 {{Ada/kw|is}} {{Ada/kw|new}} Integer_1 {{Ada/kw|range}} 2 .. 8;
 A : Integer_1 := 8;
 B : Integer_2 := A; {{Ada/comment|illegal!}}

Here both types are discrete; it is mandatory that the range of the derived type be included in the range of its parent.  Contrast this with subtypes.  The reason is that the derived type inherits the primitive operations defined for its parent, and these operations assume the range of the parent type.  Here is an illustration of this feature:

 {{Ada/kw|procedure}} Derived_Types {{Ada/kw|is}}
 
    {{Ada/kw|package}} Pak {{Ada/kw|is}}
       {{Ada/kw|type}} Integer_1 {{Ada/kw|is}} {{Ada/kw|range}} 1 .. 10;
       {{Ada/kw|procedure}} P (I: {{Ada/kw|in}} Integer_1); {{Ada/comment|primitive operation, assumes 1 .. 10}}
       {{Ada/kw|type}} Integer_2 {{Ada/kw|is}} {{Ada/kw|new}} Integer_1 {{Ada/kw|range}} 8 .. 10; {{Ada/comment|must not break P's assumption}}
       {{Ada/comment|procedure P (I: in Integer_2);  inherited P implicitly defined here}}
    {{Ada/kw|end}} Pak;
 
    {{Ada/kw|package}} {{Ada/kw|body}} Pak {{Ada/kw|is}}
       {{Ada/comment|omitted}}
    {{Ada/kw|end}} Pak;
 
    {{Ada/kw|use}} Pak;
    A: Integer_1 := 4;
    B: Integer_2 := 9;
 
 {{Ada/kw|begin}}
 
    P (B); {{Ada/comment|OK, call the inherited operation}}
 
 {{Ada/kw|end}} Derived_Types;

When we call <code>P (B)</code>, the parameter B is converted to <code>Integer_1</code>; this conversion of course passes since the set of acceptable values for the derived type (here, 8 .. 10) must be included in that of the parent type (1 .. 10). Then P is called with the converted parameter.

Consider however a variant of the example above:

 {{Ada/kw|procedure}} Derived_Types {{Ada/kw|is}}
 
   {{Ada/kw|package}} Pak {{Ada/kw|is}}
     {{Ada/kw|type}} Integer_1 {{Ada/kw|is}} {{Ada/kw|range}} 1 .. 10;
     {{Ada/kw|procedure}} P (I: {{Ada/kw|in}} Integer_1; J: {{Ada/kw|out}} Integer_1);
     {{Ada/kw|type}} Integer_2 {{Ada/kw|is}} {{Ada/kw|new}} Integer_1 {{Ada/kw|range}} 8 .. 10;
   {{Ada/kw|end}} Pak;
 
   {{Ada/kw|package}} {{Ada/kw|body}} Pak {{Ada/kw|is}}
     {{Ada/kw|procedure}} P (I: {{Ada/kw|in}} Integer_1; J: {{Ada/kw|out}} Integer_1) {{Ada/kw|is}}
     {{Ada/kw|begin}}
       J := I - 1;
     {{Ada/kw|end}} P;
   {{Ada/kw|end}} Pak;
 
   {{Ada/kw|use}} Pak;
 
   A: Integer_1 := 4;  X: Integer_1;
   B: Integer_2 := 8;  Y: Integer_2;
 
 {{Ada/kw|begin}}
 
   P (A, X);
   P (B, Y);
 
 {{Ada/kw|end}} Derived_Types;

When <code>P (B, Y)</code> is called, both parameters are converted to <code>Integer_1</code>. Thus the range check on J (7) in the body of P will pass. However on return parameter Y is converted back to <code>Integer_2</code> and the range check on Y will of course fail.

With the above in mind, you will see why in the following program Constraint_Error will be called at run time, before <code>P</code> is even called.

 {{Ada/kw|procedure}} Derived_Types {{Ada/kw|is}}
 
   {{Ada/kw|package}} Pak {{Ada/kw|is}}
     {{Ada/kw|type}} Integer_1 {{Ada/kw|is}} {{Ada/kw|range}} 1 .. 10;
     {{Ada/kw|procedure}} P (I: {{Ada/kw|in}} Integer_1; J: {{Ada/kw|out}} Integer_1);
     {{Ada/kw|type}} Integer_2 {{Ada/kw|is}} {{Ada/kw|new}} Integer_1'Base {{Ada/kw|range}} 8 .. 12;
   {{Ada/kw|end}} Pak;
 
   {{Ada/kw|package}} {{Ada/kw|body}} Pak {{Ada/kw|is}}
     {{Ada/kw|procedure}} P (I: {{Ada/kw|in}} Integer_1; J: {{Ada/kw|out}} Integer_1) {{Ada/kw|is}}
     {{Ada/kw|begin}}
       J := I - 1;
     {{Ada/kw|end}} P;
   {{Ada/kw|end}} Pak;
 
   {{Ada/kw|use}} Pak;
 
   B: Integer_2 := 11;  Y: Integer_2;
 
 {{Ada/kw|begin}}
 
   P (B, Y);
 
 {{Ada/kw|end}} Derived_Types;

== Subtype categories ==

Ada supports various categories of subtypes which have different abilities. Here is an overview in alphabetical order.

=== Anonymous subtype ===

A subtype which does not have a name assigned to it. Such a subtype is created with a variable declaration:

 X : String (1 .. 10) := ({{Ada/kw|others}} => ' ');

Here, (1 .. 10) is the constraint. This variable declaration is equivalent to:

 {{Ada/kw|subtype}} Anonymous_String_Type {{Ada/kw|is}} String (1 .. 10);
 
 X : Anonymous_String_Type := ({{Ada/kw|others}} => ' ');

=== Base type ===

In Ada, all types are [[#anonymous|anonymous]] and only subtypes may be [[#named subtype|named]].
For scalar types, there is a special subtype of the anonymous type, called the ''base type'', which is nameable with <code>Subtype'{{Ada/attribute|Base}}</code> notation. This <code>Name'Attribute</code> (read "name tick attribute") is the special notation used in Ada for what is called an [[Ada Programming/Attributes|attribute]], i.e. a characteristic of a type, a variable, or some other program entity, that is defined by the compiler and can be queried. In this case, the base type (<code>Subtype'{{Ada/attribute|Base}}</code>) comprises all values of the ''first subtype''. Some examples:

  {{Ada/kw|type}} Int {{Ada/kw|is}} {{Ada/kw|range}} 0 .. 100;

The base type <code>Int'Base</code> is a hardware type selected by the compiler that comprises the values of <code>Int</code>. Thus, it may have the range -2<sup>7</sup> .. 2<sup>7</sup>-1 or -2<sup>15</sup> .. 2<sup>15</sup>-1 or any other such type.

  {{Ada/kw|type}} Enum  {{Ada/kw|is}} (A, B, C, D);
  {{Ada/kw|type}} Short {{Ada/kw|is}} {{Ada/kw|new}} Enum {{Ada/kw|range}} A .. C;

<code>Enum'Base</code> is the same as <code>Enum</code>, but <code>Short'Base</code> also holds the literal <code>D</code>.

=== Constrained subtype ===

A subtype of an indefinite subtype that adds constraints. The following example defines a 10 character string sub-type.

  {{Ada/kw|subtype}} String_10 {{Ada/kw|is}} String (1 .. 10);

You cannot partially constrain an unconstrained subtype:

  {{Ada/kw|type}} My_Array {{Ada/kw|is}} {{Ada/kw|array}} (Integer {{Ada/kw|range}} <>, Integer {{Ada/kw|range}} <>) {{Ada/kw|of}} Some_Type;
 
  {{Ada/--| {{Ada/kw|subtype}} Constr {{Ada/kw|is}} My_Array (1 .. 10, Integer {{Ada/kw|range}} <>);  illegal}}
 
  {{Ada/kw|subtype}} Constr {{Ada/kw|is}} My_Array (1 .. 10, -100 .. 200);

Constraints for all indices must be given, the result is necessarily a definite subtype.

=== Definite subtype ===

A definite subtype is a subtype whose size is known at compile-time. All subtypes which are not indefinite subtypes are, by definition, definite subtypes.

Objects of definite subtypes may be declared without additional constraints.

=== Indefinite subtype ===

An '''indefinite subtype''' is a subtype whose size is not known at compile-time but is dynamically calculated at run-time. An indefinite subtype does not by itself provide enough information to create an object; an additional constraint or explicit initialization expression is necessary in order to calculate the actual size and therefore create the object.

 X : String := "This is a string";

<code>X</code> is an object of the indefinite (sub)type <code>String</code>. Its constraint is derived implicitly from its initial value.  <code>X</code> may change its value, but not its bounds.

It should be noted that it is not necessary to initialize the object from a literal. You can also use a function. For example:

 X : String := Ada.Command_Line.Argument (1);

This statement reads the first command-line argument and assigns it to <code>X</code>.

A subtype of an indefinite subtype that does not add a constraint only introduces a new name for the original subtype (a kind of renaming under a different notion).

  {{Ada/kw|subtype}} My_String {{Ada/kw|is}} String;

<tt>My_String</tt> and <tt>String</tt> are interchangeable.

=== Named subtype ===

A subtype which has a name assigned to it. “First subtypes” are created with the keyword <code>{{Ada/kw|type}}</code> (remember that types are always anonymous, the name in a type declaration is the name of the first subtype), others with the keyword <code>{{Ada/kw|subtype}}</code>. For example:

 {{Ada/kw|type}} Count_To_Ten {{Ada/kw|is}} {{Ada/kw|range}} 1 .. 10;

<code>Count_to_Ten</code> is the first subtype of a suitable integer base type.
However, if you would like to use this as an index constraint on <code>String</code>, the following declaration is illegal:

 {{Ada/kw|subtype}} Ten_Characters {{Ada/kw|is}} String (Count_to_Ten);

This is because <code>String</code> has <code>Positive</code> as its index, which is a subtype of <code>Integer</code> (these declarations are taken from package <code>Standard</code>):

 {{Ada/kw|subtype}} Positive {{Ada/kw|is}} Integer {{Ada/kw|range}} 1 .. Integer'Last;
 
 {{Ada/kw|type}} String {{Ada/kw|is}} (Positive {{Ada/kw|range}} <>) {{Ada/kw|of}} Character;

So you have to use the following declarations:

 {{Ada/kw|subtype}} Count_To_Ten {{Ada/kw|is}} Integer {{Ada/kw|range}} 1 .. 10;
 {{Ada/kw|subtype}} Ten_Characters {{Ada/kw|is}} String (Count_to_Ten);

Now <code>Ten_Characters</code> is the name of that subtype of <code>String</code> which is constrained to <code>Count_To_Ten</code>.
You see that posing constraints on types versus subtypes has very different effects.

=== Unconstrained subtype ===

Any indefinite type is also an unconstrained subtype. However, unconstrainedness and indefiniteness are not the same.

  {{Ada/kw|type}} My_Enum {{Ada/kw|is}} (A, B, C);
  {{Ada/kw|type}} My_Record (Discriminant: My_Enum) {{Ada/kw|is}} ...;
 
  My_Object_A: My_Record (A);

This type is unconstrained and indefinite because you need to give an actual discriminant for object declarations; the object is constrained to this discriminant which may not change.

When however a default is provided for the discriminant, the type is definite yet unconstrained; it allows to define both, constrained and unconstrained objects:

  {{Ada/kw|type}} My_Enum {{Ada/kw|is}} (A, B, C);
  {{Ada/kw|type}} My_Record (Discriminant: My_Enum := A) {{Ada/kw|is}} ...;
 
  My_Object_U: My_Record;      {{Ada/--| unconstrained object}}
  My_Object_B: My_Record (B);  {{Ada/--| constrained to discriminant B like above}}

Here, My_Object_U is unconstrained; upon declaration, it has the discriminant A (the default) which however may change.

=== Incompatible subtypes ===

  {{Ada/kw|type}} My_Integer {{Ada/kw|is}} {{Ada/kw|range}} -10 .. + 10;
  {{Ada/kw|subtype}} My_Positive {{Ada/kw|is}} My_Integer {{Ada/kw|range}} + 1 .. + 10;
  {{Ada/kw|subtype}} My_Negative {{Ada/kw|is}} My_Integer {{Ada/kw|range}} -10 .. -  1;

These subtypes are of course incompatible.

Another example are subtypes of a discriminated record:

  {{Ada/kw|type}} My_Enum {{Ada/kw|is}} (A, B, C);
  {{Ada/kw|type}} My_Record (Discriminant: My_Enum) {{Ada/kw|is}} ...;
  {{Ada/kw|subtype}} My_A_Record {{Ada/kw|is}} My_Record (A);
  {{Ada/kw|subtype}} My_C_Record {{Ada/kw|is}} My_Record (C);

Also these subtypes are incompatible.

== Qualified expressions ==

In most cases, the compiler is able to infer the type of an expression; for example:

 {{Ada/kw|type}} Enum {{Ada/kw|is}} (A, B, C);
 E : Enum := A;

Here the compiler knows that <code>A</code> is a value of the type <code>Enum</code>.  But consider:

 {{Ada/kw|procedure}} Bad {{Ada/kw|is}}
    {{Ada/kw|type}} Enum_1 {{Ada/kw|is}} (A, B, C);
    {{Ada/kw|procedure}} P (E : {{Ada/kw|in}} Enum_1) {{Ada/kw|is}}... {{Ada/comment|omitted}}
    {{Ada/kw|type}} Enum_2 {{Ada/kw|is}} (A, X, Y, Z);
    {{Ada/kw|procedure}} P (E : {{Ada/kw|in}} Enum_2) {{Ada/kw|is}}... {{Ada/comment|omitted}}
 {{Ada/kw|begin}}
    P (A); {{Ada/comment|illegal: ambiguous}}
 {{Ada/kw|end}} Bad;

The compiler cannot choose between the two versions of <code>P</code>; both would be equally valid.  To remove the ambiguity, you use a ''qualified expression'':

    P (Enum_1'(A)); {{Ada/comment|OK}}

As seen in the following example, this syntax is often used when creating new objects. If you try to compile the example, it will fail with a compilation error since the compiler will determine that 256 is not in range of <code>Byte</code>.

 {{Ada/Sourceforge|convert_evaluate_as.adb}}
 
 {{Ada/kw|with}} {{Ada/package|Ada|Text_IO}};
 
 {{Ada/kw|procedure}} Convert_Evaluate_As {{Ada/kw|is}}
    {{Ada/kw|type}} Byte     {{Ada/kw|is}} {{Ada/kw|mod}} 2**8;
    {{Ada/kw|type}} Byte_Ptr {{Ada/kw|is}} {{Ada/kw|access}} Byte;
 
    {{Ada/kw|package}} T_IO {{Ada/kw|renames}} {{Ada/package|Ada|Text_IO}};
    {{Ada/kw|package}} M_IO {{Ada/kw|is}} {{Ada/kw|new}} {{Ada/package|Ada|Text_IO|Modular_IO}} (Byte);
 
    A : {{Ada/kw|constant}} Byte_Ptr := {{Ada/kw|new}} Byte'(256);
 {{Ada/kw|begin}}
    T_IO.Put ("A = ");
    M_IO.Put (Item  => A.all,
              Width =>  5,
              Base  => 10);
 {{Ada/kw|end}} Convert_Evaluate_As;

You should use qualified expression when getting a string literal's length.

<syntaxhighlight lang="ada">
"foo"'Length                  {{Ada/--| compilation error: prefix of attribute must be a name}}
                              {{Ada/--|                    qualify expression to turn it into a name}}
String'("foo" & "bar")'Length {{Ada/--| 6}}
</syntaxhighlight>

== Type conversions ==

Data do not always come in the format you need them. You must, then, face the task of converting them. As a true multi-purpose language with a special emphasis on "mission critical", "system programming" and "safety", Ada has several conversion techniques.  The most difficult part is choosing the right one, so the following list is sorted in order of utility. You should try the first one first; the last technique is a last resort, to be used if all others fail. There are also a few related techniques that you might choose instead of actually converting the data.

Since the most important aspect is not the result of a successful conversion, but how the system will react to an invalid conversion, all examples also demonstrate '''faulty''' conversions.

=== Explicit type conversion ===

An explicit type conversion looks much like a function call; it does not use the ''tick'' (apostrophe, ') like the qualified expression does.

 Type_Name (''Expression'')

The compiler first checks that the conversion is legal, and if it is, it inserts a run-time check at the point of the conversion; hence the name ''checked conversion''.  If the conversion fails, the program raises Constraint_Error.  Most compilers are very smart and optimise away the constraint checks; so, you need not worry about any performance penalty.  Some compilers can also warn that a constraint check will always fail (and optimise the check with an unconditional raise).

Explicit type conversions are legal:
* between any two numeric types
* between any two subtypes of the same type
* between any two types derived from the same type (note special rules for tagged types)
* between array types under certain conditions (see RM 4.6(24.2/2..24.7/2))
* and ''nowhere else''

(The rules become more complex with class-wide and anonymous access types.)

 I: Integer := Integer (10);  {{Ada/--|Unnecessary explicit type conversion}}
 J: Integer := 10;            {{Ada/--|Implicit conversion from universal integer}}
 K: Integer := Integer'(10);  {{Ada/--|Use the value 10 of type Integer: qualified expression}}
                              {{Ada/--|(qualification not necessary here).}}

This example illustrates explicit type conversions:

 {{Ada/Sourceforge|convert_checked.adb}}
 
 {{Ada/kw|with}} {{Ada/package|Ada|Text_IO}};
 
 {{Ada/kw|procedure}} Convert_Checked {{Ada/kw|is}}
    {{Ada/kw|type}} Short {{Ada/kw|is}} {{Ada/kw|range}} -128 .. +127;
    {{Ada/kw|type}} Byte  {{Ada/kw|is}} {{Ada/kw|mod}} 256;
 
    {{Ada/kw|package}} T_IO {{Ada/kw|renames}} {{Ada/package|Ada|Text_IO}};
    {{Ada/kw|package}} I_IO {{Ada/kw|is}} {{Ada/kw|new}} {{Ada/package|Ada|Text_IO|Integer_IO}} (Short);
    {{Ada/kw|package}} M_IO {{Ada/kw|is}} {{Ada/kw|new}} {{Ada/package|Ada|Text_IO|Modular_IO}} (Byte);
 
    A : Short := -1;
    B : Byte;
 {{Ada/kw|begin}}
    B := Byte (A);  {{Ada/--| range check will lead to Constraint_Error}}
    T_IO.Put ("A = ");
    I_IO.Put (Item  =>  A,
              Width =>  5,
              Base  => 10);
    T_IO.Put (", B = ");
    M_IO.Put (Item  =>  B,
              Width =>  5,
              Base  => 10);
 {{Ada/kw|end}} Convert_Checked;

Explicit conversions are possible between any two numeric types: integers, fixed-point and floating-point types. If one of the types involved is a fixed-point or floating-point type, the compiler not only checks for the range constraints (thus the code above will raise Constraint_Error), but also performs any loss of precision necessary.

Example 1: the loss of precision causes the procedure to only ever print "0" or "1", since <code>P / 100</code> is an integer and is always zero or one.

 {{Ada/kw|with}} Ada.Text_IO;
 {{Ada/kw|procedure}} Naive_Explicit_Conversion {{Ada/kw|is}}
    {{Ada/kw|type}} Proportion {{Ada/kw|is}} {{Ada/kw|digits}} 4 {{Ada/kw|range}} 0.0 .. 1.0;
    {{Ada/kw|type}} Percentage {{Ada/kw|is}} {{Ada/kw|range}} 0 .. 100;
    {{Ada/kw|function}} To_Proportion (P : {{Ada/kw|in}} Percentage) {{Ada/kw|return}} Proportion {{Ada/kw|is}}
    {{Ada/kw|begin}}
       {{Ada/kw|return}} Proportion (P / 100);
    {{Ada/kw|end}} To_Proportion;
 {{Ada/kw|begin}}
    Ada.Text_IO.Put_Line (Proportion'Image (To_Proportion (27)));
 {{Ada/kw|end}} Naive_Explicit_Conversion;

Example 2: we use an intermediate floating-point type to guarantee the precision.

 {{Ada/kw|with}} Ada.Text_IO;
 {{Ada/kw|procedure}} Explicit_Conversion {{Ada/kw|is}}
    {{Ada/kw|type}} Proportion {{Ada/kw|is}} {{Ada/kw|digits}} 4 {{Ada/kw|range}} 0.0 .. 1.0;
    {{Ada/kw|type}} Percentage {{Ada/kw|is}} {{Ada/kw|range}} 0 .. 100;
    {{Ada/kw|function}} To_Proportion (P : {{Ada/kw|in}} Percentage) {{Ada/kw|return}} Proportion {{Ada/kw|is}}
       {{Ada/kw|type}} Prop {{Ada/kw|is}} {{Ada/kw|digits}} 4 {{Ada/kw|range}} 0.0 .. 100.0;
    {{Ada/kw|begin}}
       {{Ada/kw|return}} Proportion (Prop (P) / 100.0);
    {{Ada/kw|end}} To_Proportion;
 {{Ada/kw|begin}}
    Ada.Text_IO.Put_Line (Proportion'Image (To_Proportion (27)));
 {{Ada/kw|end}} Explicit_Conversion;

You might ask why you should convert between two subtypes of the same type. An example will illustrate this.

 {{Ada/kw|subtype}} String_10 {{Ada/kw|is}} String (1 .. 10);
 X: String := "A line long enough to make the example valid";
 Slice: {{Ada/kw|constant}} String := String_10 (X (11 .. 20));

Here, <code>Slice</code> has bounds 1 and 10, whereas <code>X (11 .. 20)</code> has bounds 11 and 20.

=== Change of Representation ===

Type conversions can be used for packing and unpacking of records or arrays.

 {{Ada/kw|type}} Unpacked {{Ada/kw|is}} {{Ada/kw|record}}
   {{Ada/comment|any components}}
 {{Ada/kw|end}} {{Ada/kw|record}};
 
 {{Ada/kw|type}} Packed {{Ada/kw|is}} {{Ada/kw|new}} Unpacked;
 {{Ada/kw|for}}  Packed {{Ada/kw|use}} {{Ada/kw|record}}
   {{Ada/comment|component clauses for some or for all components}}
 {{Ada/kw|end}} {{Ada/kw|record}};

 P: Packed;
 U: Unpacked;
 
 P := Packed (U);  {{Ada/comment|packs U}}
 U := Unpacked (P);  {{Ada/comment|unpacks P}}

=== Checked conversion for non-numeric types ===

The examples above all revolved around conversions between numeric types; it is possible to convert between any two numeric types in this way.  But what happens between non-numeric types, e.g. between array types or record types?  The answer is two-fold:

* you can convert explicitly between a type and types derived from it, or between types derived from the same type,
* and that's all.  No other conversions are possible.

Why would you want to derive a record type from another record type?  Because of representation clauses.  Here we enter the realm of low-level systems programming, which is not for the faint of heart, nor is it useful for desktop applications.  So hold on tight, and let's dive in.

Suppose you have a record type which uses the default, efficient representation.  Now you want to write this record to a device, which uses a special record format.  This special representation is more compact (uses fewer bits), but is grossly inefficient.  You want to have a layered programming interface: the upper layer, intended for applications, uses the efficient representation.  The lower layer is a device driver that accesses the hardware directly and uses the inefficient representation.

 {{Ada/kw|package}} Device_Driver {{Ada/kw|is}}
    {{Ada/kw|type}} Size_Type {{Ada/kw|is}} {{Ada/kw|range}} 0 .. 64;
    {{Ada/kw|type}} Register {{Ada/kw|is}} {{Ada/kw|record}}
       A, B : Boolean;
       Size : Size_Type;
    {{Ada/kw|end}} {{Ada/kw|record}};
 
    {{Ada/kw|procedure}} Read (R : {{Ada/kw|out}} Register);
    {{Ada/kw|procedure}} Write (R : {{Ada/kw|in}} Register);
 {{Ada/kw|end}} Device_Driver;

The compiler chooses a default, efficient representation for <code>Register</code>.  For example, on a 32-bit machine, it would probably use three 32-bit words, one for A, one for B and one for Size.  This efficient representation is good for applications, but at one point we want to convert the entire record to just 8 bits, because that's what our hardware requires.

 {{Ada/kw|package}} {{Ada/kw|body}} Device_Driver {{Ada/kw|is}}
    {{Ada/kw|type}} Hardware_Register {{Ada/kw|is}} {{Ada/kw|new}} Register; {{Ada/comment|Derived type.}}
    {{Ada/kw|for}} Hardware_Register {{Ada/kw|use}} {{Ada/kw|record}}
       A {{Ada/kw|at}} 0 {{Ada/kw|range}} 0 .. 0;
       B {{Ada/kw|at}} 0 {{Ada/kw|range}} 1 .. 1;
       Size {{Ada/kw|at}} 0 {{Ada/kw|range}} 2 .. 7;
    {{Ada/kw|end}} {{Ada/kw|record}};
 
    {{Ada/kw|function}} Get {{Ada/kw|return}} Hardware_Register; {{Ada/comment|Body omitted}}
    {{Ada/kw|procedure}} Put (H : {{Ada/kw|in}} Hardware_Register); {{Ada/comment|Body omitted}}
 
    {{Ada/kw|procedure}} Read (R : {{Ada/kw|out}} Register) {{Ada/kw|is}}
       H : Hardware_Register := Get;
    {{Ada/kw|begin}}
       R := Register (H); {{Ada/comment|Explicit conversion.}}
    {{Ada/kw|end}} Read;
 
    {{Ada/kw|procedure}} Write (R : {{Ada/kw|in}} Register) {{Ada/kw|is}}
    {{Ada/kw|begin}}
       Put (Hardware_Register (R)); {{Ada/comment|Explicit conversion.}}
    {{Ada/kw|end}} Write;
 {{Ada/kw|end}} Device_Driver;

In the above example, the package body declares a derived type with the inefficient, but compact representation, and converts to and from it.

This illustrates that '''type conversions can result in a change of representation'''.

=== View conversion, in object-oriented programming ===

Within [[Ada Programming/Object Orientation|object-oriented programming]] you have to distinguish between ''specific'' types and ''class-wide'' types.

With specific types, only conversions in the direction to the root are possible, which of course cannot fail. There are no conversions in the opposite direction <small>(where would you get the further components from?)</small>; ''extension aggregates'' have to be used instead.

With the conversion itself, no components of the source object that are not present in the target object are lost, they are just hidden from visibility. Therefore, this kind of conversion is called a ''view conversion'' since it provides a view of the source object as an object of the target type (especially it does not change the object's tag).

It is a common idiom in object oriented programming to rename the result of a view conversion. (A renaming declaration does not create a new object; it only gives a new name to something that already exists.)

 {{Ada/kw|type}} Parent_Type {{Ada/kw|is}} {{Ada/kw|tagged}} {{Ada/kw|record}}
    <components>;
 {{Ada/kw|end}} {{Ada/kw|record}};
 {{Ada/kw|type}} Child_Type {{Ada/kw|is}} {{Ada/kw|new}} Parent_Type {{Ada/kw|with}} {{Ada/kw|record}}
    <further components>;
 {{Ada/kw|end}} {{Ada/kw|record}};
 
 Child_Instance : Child_Type;
 Parent_View    : Parent_Type {{Ada/kw|renames}} Parent_Type (Child_Instance);
 Parent_Part    : Parent_Type := Parent_Type (Child_Instance);

<code>Parent_View</code> is not a new object, but another name for <code>Child_Instance</code> viewed as the parent, i.e. only the parent components are visible, the child-specific components are hidden. <code>Parent_Part</code>, however, is an object of the parent type, which of course has no storage for the child-specific components, so they are lost with the assignment.

All types derived from a tagged type <code>T</code> form a tree rooted at <code>T</code>. The class-wide type <code>T'{{Ada/attribute|Class}}</code> can hold any object within this tree. With class-wide types, conversions in any direction are possible; there is a run-time tag check that raises <code>Constraint_Error</code> if the check fails. These conversions are also view conversions, no data is created or lost.

 Object_1 : Parent_Type'{{Ada/attribute|Class}} := Parent_Type'{{Ada/attribute|Class}} (Child_Instance);
 Object_2 : Parent_Type'{{Ada/attribute|Class}} {{Ada/kw|renames}} Parent_Type'{{Ada/attribute|Class}} (Child_Instance);

<code>Object_1</code> is a new object, a copy; <code>Object_2</code> is just a new name. Both objects are of the class-wide type. Conversions to any type within the given class are legal, but are tag-checked.

 Success : Child_Type := Child_Type (Parent_Type'{{Ada/attribute|Class}} (Parent_View));
 Failure : Child_Type := Child_Type (Parent_Type'{{Ada/attribute|Class}} (Parent_Part));

The first conversion passes the tag check and both objects <code>Child_Instance</code> and <code>Success</code> are equal. The second conversion fails the tag check. <small>(Conversion assignments of this kind will rarely be used; dispatching will do this automatically, see [[Ada Programming/Object Orientation|object oriented programming]].)</small>

You can perform these checks yourself with membership tests:

 {{Ada/kw|if}} Parent_View {{Ada/kw|in|}} Child_Type {{Ada/kw|then|}} ...
 {{Ada/kw|if}} Parent_View {{Ada/kw|in|}} Child_Type'{{Ada/kw|Class}} {{Ada/kw|then|}} ...

There is also the package <code>Ada.Tags</code>.

=== Address conversion ===

Ada's [[Ada Programming/Types/access|access type]] is not just a memory location (a thin pointer). Depending on implementation and the [[Ada Programming/Types/access|access type]] used, the [[Ada Programming/Types/access|access]] might keep additional information (a fat pointer). For example GNAT keeps two memory addresses for each [[Ada Programming/Types/access|access]] to an indefinite object &mdash; one for the data and one for the constraint informations <small>('{{Ada/attribute|Size}}, '{{Ada/attribute|First}}, '{{Ada/attribute|Last}})</small>.

If you want to convert an access to a simple memory location you can use the package <code>{{Ada/package|System|Address_To_Access_Conversions}}</code>.
Note however that an address and a fat pointer cannot be converted reversibly into one another.

The address of an array object is the address of its first component. Thus, the bounds get lost in such a conversion.

 {{Ada/kw|type}} My_Array {{Ada/kw|is}} {{Ada/kw|array}} (Positive {{Ada/kw|range}} <>) {{Ada/kw|of}} Something;
 A: My_Array (50 .. 100);
 
      A'{{Ada/attribute|Address}} = A(A'{{Ada/attribute|First}})'{{Ada/attribute|Address}}

=== Unchecked conversion ===

One of the great criticisms of Pascal was "there is no escape". The reason was that sometimes you have to convert the incompatible. For this purpose, Ada has the generic function ''Unchecked_Conversion'':

 {{Ada/kw|generic}}
    {{Ada/kw|type}} Source (<>) {{Ada/kw|is}} {{Ada/kw|limited}} {{Ada/kw|private}};
    {{Ada/kw|type}} Target (<>) {{Ada/kw|is}} {{Ada/kw|limited}} {{Ada/kw|private}};
 {{Ada/kw|function}} {{Ada/package|Ada|Unchecked_Conversion}} (S : Source) {{Ada/kw|return}} Target;

<code>''Unchecked_Conversion''</code> will bit-copy the source data and reinterpret them under the target type without any checks. It is '''your''' chore to make sure that the requirements on unchecked conversion as stated in RM {{Ada/RM2|13|9|}} are fulfilled; if not, the result is implementation dependent and may even lead to abnormal data. Use the 'Valid attribute after the conversion to check the validity of the data in problematic cases.

A function call to (an instance of) <code>Unchecked_Conversion</code> will copy the source to the destination. The compiler may also do a conversion ''in place'' (every instance has the convention ''Intrinsic'').

To use <code>Unchecked_Conversion</code> you need to instantiate the generic.

In the example below, you can see how this is done. When run, the example will output <code>A = -1, B = 255</code>. No error will be reported, but is this the result you expect?

 {{Ada/Sourceforge|convert_unchecked.adb}}
 
 {{Ada/kw|with}} {{Ada/package|Ada|Text_IO}};
 {{Ada/kw|with}} {{Ada/package|Ada|Unchecked_Conversion}};
 
 {{Ada/kw|procedure}} Convert_Unchecked {{Ada/kw|is}}
 
    {{Ada/kw|type}} Short {{Ada/kw|is}} {{Ada/kw|range}} -128 .. +127;
    {{Ada/kw|type}} Byte  {{Ada/kw|is}} {{Ada/kw|mod}} 256;
 
    {{Ada/kw|package}} T_IO {{Ada/kw|renames}} {{Ada/package|Ada|Text_IO}};
    {{Ada/kw|package}} I_IO {{Ada/kw|is}} {{Ada/kw|new}} {{Ada/package|Ada|Text_IO|Integer_IO}} (Short);
    {{Ada/kw|package}} M_IO {{Ada/kw|is}} {{Ada/kw|new}} {{Ada/package|Ada|Text_IO|Modular_IO}} (Byte);
 
    {{Ada/kw|function}} Convert {{Ada/kw|is}} {{Ada/kw|new}} {{Ada/package|Ada|Unchecked_Conversion}} (Source => Short,
                                                      Target => Byte);
 
    A : {{Ada/kw|constant}} Short := -1;
    B : Byte;
 
 {{Ada/kw|begin}}
 
    B := Convert (A);
    T_IO.Put ("A = ");
    I_IO.Put (Item  =>  A,
              Width =>  5,
              Base  => 10);
    T_IO.Put (", B = ");
    M_IO.Put (Item  =>  B,
              Width =>  5,
              Base  => 10);
 
 {{Ada/kw|end}} Convert_Unchecked;

There is of course a range check in the assignment <code>B := Convert (A);</code>. Thus if <code>B</code> were defined as <code>B: Byte {{Ada/kw|range}} 0 .. 10;</code>, <code>Constraint_Error</code> would be raised.

=== Overlays ===

If the copying of the result of <code>Unchecked_Conversion</code> is too much waste in terms of performance, then you can try overlays, i.e. address mappings. By using overlays, both objects share the same memory location. If you assign a value to one, the other changes as well. The syntax is:

 {{Ada/kw|for}} Target'{{Ada/attribute|Address}} {{Ada/kw|use}} ''expression'';
 {{Ada/pragma|Import}} (Ada, Target);

where ''expression'' defines the address of the source object.

While overlays might look more elegant than <code>Unchecked_Conversion</code>, you should be aware that they are even more dangerous and have even greater potential for doing something very wrong. For example if <code>Source'{{Ada/attribute|Size}} < Target'{{Ada/attribute|Size}}</code> and you assign a value to Target, you might inadvertently write into memory allocated to a different object.

You have to take care also of implicit initializations of objects of the target type, since they would overwrite the actual value of the source object. The Import pragma with convention Ada can be used to prevent this, since it avoids the implicit initialization, RM {{Ada/RM2|B|1|}}.

The example below does the same as the example from "Unchecked Conversion".

 {{Ada/Sourceforge|convert_address_mapping.adb}}
 
 {{Ada/kw|with}} {{Ada/package|Ada|Text_IO}};
 
 {{Ada/kw|procedure}} Convert_Address_Mapping {{Ada/kw|is}}
    {{Ada/kw|type}} Short {{Ada/kw|is}} {{Ada/kw|range}} -128 .. +127;
    {{Ada/kw|type}} Byte  {{Ada/kw|is}} {{Ada/kw|mod}} 256;
 
    {{Ada/kw|package}} T_IO {{Ada/kw|renames}} {{Ada/package|Ada|Text_IO}};
    {{Ada/kw|package}} I_IO {{Ada/kw|is}} {{Ada/kw|new}} {{Ada/package|Ada|Text_IO|Integer_IO}} (Short);
    {{Ada/kw|package}} M_IO {{Ada/kw|is}} {{Ada/kw|new}} {{Ada/package|Ada|Text_IO|Modular_IO}} (Byte);
 
    A : {{Ada/kw|aliased}} Short;
    B : {{Ada/kw|aliased}} Byte;
   
    {{Ada/kw|for}} B'{{Ada/attribute|Address}} {{Ada/kw|use}} A'{{Ada/attribute|Address}};
   {{Ada/pragma|Import}} (Ada, B);
   
 {{Ada/kw|begin}}
    A := -1;
    T_IO.Put ("A = ");
    I_IO.Put (Item  =>  A,
              Width =>  5,
              Base  => 10);
    T_IO.Put (", B = ");
    M_IO.Put (Item  =>  B,
              Width =>  5,
              Base  => 10);
 {{Ada/kw|end}} Convert_Address_Mapping;

=== Export / Import ===

Just for the record: There is still another method using the {{Ada/pragma name|Export}} and {{Ada/pragma name|Import}} pragmas. However, since this method completely undermines Ada's visibility and type concepts even more than overlays, it has no place here in this language introduction and is left to experts.

== Elaborated Discussion of Types for Signed Integer Types ==

As explained before, a type declaration

 {{Ada/kw|type}} T {{Ada/kw|is}} {{Ada/kw|range}} 1 .. 10;

declares an anonymous type <code>''T''</code> and its first subtype <code>T</code> (please note the italicization). <code>''T''</code> encompasses the complete set of mathematical integers. Static expressions and named numbers make use of this fact.

All numeric integer literals are of type <code>Universal_Integer</code>. They are converted to the appropriate specific type where needed. <code>Universal_Integer</code> itself has no operators.

Some examples with static named numbers:

  S1: {{Ada/kw|constant}} := Integer'{{Ada/at|Last}} + Integer'{{Ada/at|Last}};       {{Ada/--|"+" of Integer}}
  S2: {{Ada/kw|constant}} := Long_Integer'{{Ada/at|Last}} + 1;             {{Ada/--|"+" of Long_Integer}}
  S3: {{Ada/kw|constant}} := S1 + S2;                           {{Ada/--|"+" of root_integer}}
  S4: {{Ada/kw|constant}} := Integer'{{Ada/at|Last}} + Long_Integer'{{Ada/at|Last}};  {{Ada/--|illegal}}

Static expressions are evaluated at compile-time on the appropriate types with no overflow checks, i.e. mathematically exact (only limited by computer store). The result is then implicitly converted to <code>Universal_Integer</code>.

The literal 1 in <code>S2</code> is of type <code>Universal_Integer</code> and implicitly converted to <code>Long_Integer</code>.

<code>S3</code> implicitly converts the summands to <code>root_integer</code>, performs the calculation and converts back to <code>Universal_Integer</code>.

<code>S4</code> is illegal because it mixes two different types. You can however write this as

  S5: {{Ada/kw|constant}} := Integer'Pos (Integer'{{Ada/at|Last}}) + Long_Integer'Pos (Long_Integer'{{Ada/at|Last}});  {{Ada/--|"+" of root_integer}}

where the Pos attributes convert the values to <code>Universal_Integer</code>, which are then further implicitly converted to <code>root_integer</code>, added and the result converted back to <code>Universal_Integer</code>.

<code>root_integer</code> is the anonymous greatest integer type representable by the hardware. It has the range <code>System.Min_Integer .. System.Max_Integer</code>. All integer types are rooted at <code>root_integer</code>, i.e. derived from it. <code>Universal_Integer</code> can be viewed as <code>root_integer'{{Ada/attribute|Class}}</code>.

During run-time, computations of course are performed with range checks and overflow checks on the appropriate subtype. Intermediate results may however exceed the range limits. Thus with <code>I, J, K</code> of the subtype <code>T</code> above, the following code will return the correct result:

 I := 10;
 J :=  8;
 K := (I + J) - 12;
 {{Ada/--|1= I := I + J;  {{Ada/--| range check would fail, leading to Constraint_Error}}}}

Real literals are of type <code>Universal_Real</code>, and similar rules as the ones above apply accordingly.

== Relations between types ==

Types can be made from other types. Array types, for example, are made from two types, one for the arrays' index and one for the arrays' components. An array, then, expresses an association, namely that between one value of the index type and a value of the component type.

  {{Ada/keyword|type}} Color {{Ada/keyword|is}} (Red, Green, Blue);
  {{Ada/keyword|type}} Intensity {{Ada/keyword|is}} {{Ada/keyword|range}} 0 .. 255;
  
  {{Ada/keyword|type}} Colored_Point {{Ada/keyword|is}} {{Ada/keyword|array}} (Color) {{Ada/keyword|of}} Intensity;

The type <tt>Color</tt> is the index type and the type <tt>Intensity</tt> is the component type of the array type <tt>Colored_Point</tt>. See [[Ada Programming/Types/array|array]].

== See also ==

=== Wikibook ===

* [[Ada Programming]]

=== Ada Reference Manual ===

* {{Ada/RM|3|2|1|title=Type Declarations}}
* {{Ada/RM|3|3|title=Objects and Named Numbers}}
* {{Ada/RM|3|7|title=Discriminants}}
* {{Ada/RM|3|10|title=Access Types}}
* {{Ada/RM|4|9|title=Static Expressions and Static Subtypes}}
* {{Ada/RM|13|9|title=Unchecked Type Conversions}}
* {{Ada/RM|13|3|title=Operational and Representation Attributes}}
* {{Ada/RM|K|title=(informative) Language-Defined Attributes}}

<noinclude>
[[{{BOOKCATEGORY|Ada Programming}}|Type System]]
[[es:Programación en Ada/Tipos]]
</noinclude>