Programming-Idioms.org

Put_Line ("Hello World!");

for I in 1 .. 10 loop
  Put_Line ("Hello");
end loop;

procedure Finish (Name : String) is
begin
   Put_Line ("My job here is done. Goodbye " & Name);
end Finish;

function Square (X : Integer) return Integer is
begin
   return X * X;
end Square;

type Point is
   record
      X : Float;
      Y : Float;
   end record;

for Item of Items loop
   Do_Something (Item);
end loop;

for I in Items'Range loop
   X := Items (I);
   Put_Line (Integer'Image (I) & " " & Integer'Image (X));
end loop;

declare
   package Maps is new Indefinite_Hashed_Maps (Key_Type => String,
                                               Element_Type => Integer,
                                               Hash => Ada.Strings.Hash,
                                               Equivalent_Keys => "=");
      
   use Maps;
      
   X : Map := Empty_Map;
begin
   X.Insert ("One", 1);
   X.Insert ("Two", 2);
   X.Insert ("Three", 3);
end;

type Tree_Node;
type Tree_Node_Access is access Tree_Node;
type Tree_Node is record
   Value: Integer;
   Left, Right: Tree_Node_Access;
end record;

subtype Element_Type is Integer;
type List_Type is array (Positive range <>) of Element_Type;

function Pick_Random (X : List_Type) return Element_Type is
   subtype Index_Range  is Positive range X'Range;
   package Random_Index is new
     Ada.Numerics.Discrete_Random (Index_Range);
   Generator : Random_Index.Generator;
begin
   Random_Index.Reset (Generator);
   return X (Random_Index.Random (Generator));
end Pick_Random;

Result := List.Contains (X);

for C in My_Map.Iterate loop
   Put_Line ("Key = " & Key (C) & ", Value = " & Element (C));
end loop;

declare
   subtype Random_Range is Integer range A .. B;
   package Rand is
      new Ada.Numerics.Discrete_Random (Random_Range);
   use Rand;
   Gen    : Generator;
   Result : Random_Range;
begin
   Reset (Gen);
   Result := Random (Gen);
end;

X.Reverse_Elements;

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

function Search (M : Matrix; X : Integer; I, J : out Integer) return Boolean is
begin
   for K in M'Range (1) loop
      for L in M'Range (2) loop
         if M (K, L) = X then
            I := K;
            J := L;
            return True;
         end if;    
      end loop;
   end loop;

   return False;
end Search;

procedure swap(a, b: in out Integer)
is
    temp : Integer;
begin
    temp := a;
    a := b;
    b := temp;
end swap;

I : Integer := Integer'Value (s);

declare

   task Greeter is
      entry Greet (Name : String);
   end Greeter;

   task body Greeter is
   begin

      accept Greet (Name : String) do
         Ada.Text_IO.Put_Line ("Hello, " & Name);
      end Greet;

   end Greeter;

begin
   Greeter.Greet ("Alan");
end;

X : array (1 .. M, 1 .. N) of Float := (others => (others => 1.0));

X : array (1 .. M, 1 .. N, 1 .. P) of Float := (others => (others => (others => 1.0)));

declare
   function Compare_Function (Left, Right : Item) return Boolean is (Left.P < Right.P);
   
   package Item_Vector_Sorting is new Item_Vectors.Generic_Sorting (Compare_Function);

   use Item_Vector_Sorting;
begin
   Sort (Items);
end;

Items.Delete (I);

function F (I : Natural) return Natural is (if I < 2 then 1 else I * F (I - 1));

T : String := S (I .. J - 1);

Ok : Boolean := Index (S, Word) > 0;

Outer_loop:
for A in M'Range (1) loop
   Inner_Loop:
   for B in M'Range (2) loop
      if M (A, B) < 0 then
         Put_Line (M (A, B)'Image);
         exit Outer_Loop;
      end if;
   end loop Inner_Loop;
end loop Outer_Loop;

delay 5.0;

T : String := S (1 .. 5);

s : String := "Will this compile? " &
     "Oh yes it will";

loop
   null;
end loop;

M.Contains (K)

declare
   Last : Cursor := X.Last;
   Y : Unbounded_String;
         
begin
   for C in X.Iterate loop
      Y := Y & Element (C) & (if C = Last then "" else ", ");
   end loop;
end;

for E of x loop
   S := S + E;
end loop;

S : String := Integer'Image (I);

for Item of X loop
   if P (Item) then
      Y.Append (Item);
   end if;
end loop;

Put_Line (Standard_Error, Integer'Image (X) & " is negative");

D : Ada.Calendar.Time := Ada.Calendar.Clock;

declare
   Package Rand is new Ada.Numerics.Discrete_Random (Integer);
   Gen : Rand.Generator;
begin
   Rand.Reset (Gen, Initiator => S);
end;

procedure Main is
begin
   for I in 1 .. Argument_Count loop
      Put (Argument (I) & (if I = Argument_Count then "" else " "));
   end loop;
   
   New_Line;
end Main;

declare
   use Ada.Numerics.Complex_Types;
   X : Complex := (Re => -2.0, Im => 3.0);
begin
   X := X * i;
end;

loop
   stuff();
   if not c then
      exit;
   end if;
end loop;

Y : constant Float := Float (X);

Y : constant Integer := Integer (Float'Truncation (X));

Y : constant Integer := Integer (Float'Rounding (X));

function Adding_Will_Overflow (X, Y : Integer) return Boolean is
begin
   return X > 0 and Y > 0 and X > Integer'Last - Y;
end Adding_Will_Overflow;

type Byte is range 0 .. 255
  with Size => 8;
      
type Byte_Array is array (Positive range <>) of Byte;  
      
Buf : Byte_Array (1 .. 1_000_000);

package Foos is
      
   type Foo is private;
      
   function X (Self : Foo) return Integer;
      
private
   type Foo is
      record
         X : Integer;
      end record;
      
end Foos;
   
package body Foos is
      
   function X (Self : Foo) return Integer is (Self.X);
      
end Foos;

procedure Control (F : access procedure) is
begin
   F.all;
end Control;

X : constant File_Size := Size (Path);

B := Ada.Strings.Fixed.Index (S, Prefix) = S'First;

X : constant String :=
    Ada.Calendar.Formatting.Image (D) (1 .. 10);

type Integer_Comparator is not null access function (Left, Right : Integer) return Boolean;
      
package Integer_Vectors is new Vectors (Positive, Integer);
use Integer_Vectors;
      
procedure Sort_Using_Comparator (V : in out Vector; C : Integer_Comparator) is
   package Vector_Sorting is new Generic_Sorting (C.all);
   use Vector_Sorting;
         
begin
   Sort (V);
end Sort_Using_Comparator;

S : String := (Simple_Name (Command_Name));

Dir : String := Current_Directory;

N : Integer := (T'Size + 7) / 8;

Blank := Index_Non_Blank (Str) = 0;

N : Count_Type := X.Length;

type Suit is (Spades, Hearts, Diamonds, Clubs);

if c1 then
    f1;
elsif c2 then
    f2;
elsif c3 then
    f3;
end if;

B := (for all Char of S => Char in '0' .. '9');

B : constant Boolean := Ada.Directories.Exists (FP);

function Only_ASCII (S : String) return String is
   subtype ASCII is Character range
      Character'Val (0) .. Character'Val (127);
   T    : String (S'Range);
   Last : Natural := T'First - 1;
begin
   for Char of S loop
      if Char in ASCII then
         Last := Last + 1;
         T (Last) := Char;
      end if;
   end loop;
   return T (T'First .. Last);
end Only_ASCII;

S : constant String := "" & C;

t : String := s & Integer'Image (i);

Ada.Directories.Delete_File (filepath);

planet : constant String := "Earth";

for E of elements loop
   E := E * c;
end loop;

X := Items'Last

n : Integer := s'Length;

procedure C_Foo (A : access Interfaces.C.double;
                 N : Interfaces.C.int) with
   Import        => True,
   Convention    => C,
   External_Name => "foo";

procedure Test_Foo is
   type Double_Array is array (Positive range <>) of aliased Interfaces.C.double;
   A : Double_Array (1 .. 10) := (1.0, 2.0, 3.0, 4.0, 5.0,
                                  6.0, 7.0, 8.0, 9.0, 10.0);
begin
   C_Foo (A (A'First)'Access, A'Length);
end Test_Foo;

Foo : constant String :=
      Ada.Environment_Variables.Value (Name    => "FOO",
                                       Default => "none");

Ada.Directories.Create_Directory (New_Directory => Path);

use Ada.Directories;
B : constant Boolean :=
    Exists (Path) and then Kind (Path) = Directory;

Items.Delete_Last (Count => 1);

Ada.Directories.Copy_File (Source_Name => Src,
                           Target_Name => Dst);

if condition() then
   x := "a";
else
   x := "b";
end if;

x := (if condition() then "a" else "b");

x := (if condition() then "a" else "b");

for A in reverse 0 .. 5 loop
   Put_Line (A'Image);
end loop;

X : constant String :=
    Ada.Calendar.Formatting.Image (D) (12 .. 19);

use Ada.Strings.Fixed;
S : constant String := N * V;

declare
   type T is (Bike, Car, Horse);
   E : constant T      := Horse;
   S : constant String := T'Image (E);
begin
   Ada.Text_IO.Put_Line (S);
end;

Line : constant String := Ada.Text_IO.Get_Line;

declare
   package String_Vectors is new
      Ada.Containers.Indefinite_Vectors
         (Index_Type => Positive, Element_Type => String);
   use String_Vectors, Ada.Text_IO;
   Lines : Vector;
begin
   while not End_Of_File loop
      Lines.Append (Get_Line);
   end loop;
end;

S : constant String := A & B;

declare
   A : array (1 .. 3) of Integer := (1, 12, 42);
begin
   for I in A'Range loop
      Ada.Text_IO.Put (A (I)'Image);
      if I /= A'Last then
         Ada.Text_IO.Put (", ");
      end if;
   end loop;
end;

X : T := T'Value (S);

-- This is a comment

A : array (42 .. 47) of Integer;

declare
   X : Vector;
begin
   Reserve_Capacity (X, Capacity => 200);
end;

Value := Base ** Exponent;