Data Types

Data Types

What is the role of data types in Ada?

The purpose of data types in any programming language is to define the type of data that can be stored in variables and used in computations. This helps ensure type safety and allows the compiler to catch type mismatches.

Ada has a rich set of built-in data types to cover the basic needs of most applications. The main built-in data types in Ada are:

  • Numeric types:

    • Integer - Represents discrete whole numbers, of various sizes

    • Float - Represents floating point numbers with single or double precision

    • Fixed - Fixed point numbers with a specified precision

    • Modular - Numbers modulo a given value

  • Character type:

    • Character - Represents a single character like 'a', 'b', 'A' etc.
  • Enumeration types:

    • Enumeration - User defined type with a list of named literals
  • Array types:

    • Array - Represents a collection of elements of the same type, indexed by integers
  • Access types:

    • Access - Represents a pointer or reference to an object
  • Boolean type:

    • Boolean - Represents true/false values
  • String type:

    • String - Represents a sequence of characters

Each of these built-in types have various subtypes and constraints that can be applied to make them more specific for a particular use case.

The purpose of defining data types in a programming language is to:

  • Ensure type safety - The compiler can catch type mismatches

  • Optimize storage - Different types require different amounts of memory

  • Optimize computations - Operations on different types have different efficiencies

  • Document the intent - The type conveys the intended usage of the data

  • Enforce abstraction - Hides implementation details from the user

So in summary, data types are an essential part of any programming language. They define the set of values that variables can hold and allow computations to be performed on those values in a meaningful way.


In Ada, variables are declared using the keyword 'variable' followed by the variable name and type. For example:

variable Number : Integer;
variable Name  : String := "John";
variable Salary: Float := 2000.50;

You can optionally assign an initial value to the variable at the time of declaration using := as shown above.

Ada does not support variable hoisting, which means variables are only in scope from the point of declaration onwards. So the following code would result in an error:

Put(Salary);  -- Error! Salary is not defined yet

variable Salary : Float := 2000.50;

Ada requires variables to be declared before they can be used. This is different from languages like JavaScript where variables are hoisted and can be used before they are declared.

Here is an example of multiple variable declarations in Ada:

variable Number : Integer := 0;
variable Name  : String := "John";
variable Salary: Float  := 2000.50;
variable Age   : Integer range 1..100 := 25;

We can also declare variables of the same type together on one line:

variable X, Y, Z : Integer;

And assign initial values later:

X := 1;
Y := 2; 
Z := 3;

In summary, variables in Ada are declared using the 'variable' keyword, followed by the name, type and optional initial value. Ada does not support variable hoisting, so variables must be declared before they can be used.

Note: The keyword variable is not mandatory for declaring variables in Ada. It is optional and can be omitted in most cases. However, using the variable keyword explicitly indicates that you are declaring a variable, which can improve code readability and clarity.

Here's an example of declaring a variable without the variable keyword:

Code snippet

Count : Integer := 0;

This declaration defines an integer variable named Count and initialize it to the value 0. The := operator is used to assign an initial value to the variable.

Using the variable keyword would look like this:

Code snippet

variable Count : Integer := 0;

Both declarations are equivalent and produce the same result. However, some programmers prefer to use the variable keyword explicitly to emphasize that they are declaring a variable. This can be especially helpful when you have multiple declarations in a row, making it clearer which identifier belongs to which declaration.

In general, the decision of whether or not to use the variable keyword is a matter of personal preference. There are no strict rules or requirements regarding its usage.


In Ada, constants are declared using the keyword 'constant' instead of 'variable'. For example:

constant PI : Float := 3.14;  
constant NEWLINE : Character := ASCII.LF;

Once a constant is initialized, its value cannot be changed. So the following would result in an error:

constant PI : Float := 3.14;

PI := 3.15; -- Illegal! Cannot modify a constant

Constants in Ada have the following characteristics:

  • They are declared using the 'constant' keyword.

  • They must be initialized when declared.

  • Their value cannot be modified after initialization.

  • They allow for more readable and secure code since their value is fixed.

Constants can be of any data type, including user-defined types. They can also be array or record constants:

constant DAYS : array(1..7) of String := ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");

constant POINT : record 
   X : Integer := 0;
   Y : Integer := 0;
end record;

Constants in Ada provide the following benefits:

  • Readability - They give symbolic names to magic values

  • Security - Once initialized, their value cannot change accidentally

  • Optimization - The compiler can substitute the constant value directly

  • Understanding - They document the purpose and meaning of values in code

In summary, constants in Ada are declared using the 'constant' keyword instead of 'variable'. Once initialized, their value cannot be modified. They make code more readable, secure and optimized.


Ada supports both global and local variables.

Global variables:

  • Are declared outside any subprogram (function or procedure).

  • Have global scope - They can be accessed from any subprogram.

  • Exist for the whole duration of the program.


variable Num : Integer;  -- Global variable

procedure Do_Something is  
   Num := 10;  
end Do_Something;

procedure Do_Something_Else is  
   Num := 20;  
end Do_Something_Else;

Here Num is a global variable that can be accessed from both procedures.

Local variables:

  • Are declared within a subprogram.

  • Have local scope - They can only be accessed within that subprogram.

  • Exist only for the duration of the subprogram call.


procedure Do_Something is  
variable Num : Integer;  -- Local variable
   Num := 10;  
end Do_Something;

procedure Do_Something_Else is  
   Num := 20;  -- Error! Num is not visible here.  
end Do_Something_Else;

Here Num is a local variable that exists only within Do_Something. It is not visible outside that subprogram.

So in summary, Ada supports both:

  • Global variables: Declared outside subprograms, accessible everywhere

  • Local variables: Declared within subprograms, accessible only within that subprogram

Local variables take precedence over global variables - if a local variable has the same name as a global one, the local one will be used within that subprogram.

No Context

Ada does not have context variables like other languages and does not support closures.

Some key points:

  • Ada does not have lexical closures or functions as first-class objects. It does not support function literals or function pointers.

  • This means Ada does not have context variables that are accessible to inner functions, like you see in languages like JavaScript.

  • When a function is called in Ada, it only has access to its formal parameters, global variables and any local variables declared within the function. It does not capture variables from the context in which it was defined.

  • Functions in Ada are not closures - they do not have access to variables that are out of scope.

For example:

variable Num : Integer := 10;

procedure Outer() is
   variable Num2 : Integer := 20;

   function Inner() return Integer is  
      return Num;  -- Error! Num is out of scope  
   end Inner;

   Num2 := Inner;  -- Not possible, Inner is not a first-class function  
end Outer;

Here the inner function Inner does not have access to the outer variable Num - it is out of scope. And we cannot assign Inner to a variable, showing Ada does not treat functions as first-class objects.

So in summary, due to the lack of support for function literals, function pointers and closures, Ada does not have context variables like other languages. Variables are only accessible within their scope.

Best Practice

Here are some best practices for declaring variables in Ada:

  1. Use meaningful, descriptive names for variables. Avoid short, cryptic names.

  2. Use consistent naming conventions. For example, use underscores to separate words in variable names.

  3. Declare variables as locally as possible. Declare variables within the innermost block where they are used. This minimizes their scope.

  4. Declare variables at the point of first use. This makes the code self-documenting.

  5. Group related variables together. For example, declare all loop variables at the start of the loop.

  6. Use constants instead of variables wherever possible. Constants make the code more readable and secure.

  7. Initialize variables when declaring them. This ensures they have a defined initial value.

  8. Use meaningful initial values. Avoid initializing variables to arbitrary values like 0 or 1.

  9. Use descriptive comments to document the purpose of variables.

  10. Use consistent indentation and spacing to improve readability.

Some examples:

-- Declare related loop variables together    
Index : Integer;  
Total : Integer := 0;  

for Index in 1..100 loop

   -- Variable declared within innermost block
   Some_Value : Integer := 0;  

   Total := Total + Some_Value;

end loop;

-- Use constants instead of variables 
PI : constant := 3.14;

-- Initialize variables with meaningful values
Success : Boolean := False;
Result : Integer := 0;

Following these guidelines can help make your Ada code more readable, maintainable and robust by promoting good variable naming and scoping practices.

Disclaim: This article was create by Rix AI bot.