Pascal.CodeCompared.To/Ada

Ada packages replace Pascal's implicit I/O. The main unit is a procedure, not a program. GNAT, the usual Ada compiler, expects each file to be named after the unit it holds, and warns that the file name does not match the unit name when they differ. Every Ada example here lives in a file named example.adb, so the procedure is Example.

gnatmake compiles and links in one step. Individual phases use gcc -c, gnatbind, and gnatlink.

Put_Line accepts only strings. Numbers are printed with Ada.Integer_Text_IO.Put and Ada.Float_Text_IO.Put, or turned into a string first with 'Image. Their Put procedures share one name, but the types of the arguments tell them apart, so use-ing all three packages causes no ambiguity; writing them fully qualified, as here, is a choice of style.

with makes a package visible (you can qualify its names). use additionally brings names into direct scope — equivalent to Pascal's uses. You may with without use to keep namespaces explicit.

Ada declarations live between is and begin. Variables may carry an initializer (:= value) inline. Writing Ada.Integer_Text_IO.Put fully qualified is a choice of style: with use clauses, the argument types alone pick the right Put.

Ada provides Natural (≥ 0) and Positive (≥ 1) as predefined subtypes of Integer. Assigning a negative value to Natural raises Constraint_Error at runtime.

Ada keeps Pascal's and/or/not keywords but adds and then and or else for short-circuit evaluation. and then is idiomatic Ada; bare and always evaluates both sides.

Ada constants use constant as a modifier on the type annotation. A constant without a type (constant := 3.14159) is a universal numeric constant that adapts to context — like a Pascal untyped constant.

type Score is new Integer range 0..100 creates a derived type — a distinct type that cannot be mixed with plain Integer without an explicit conversion. Pascal's type Score = 0..100 creates a subrange that still interoperates freely with Integer.

Ada's String type is a fixed-length array of Character. A String variable's bounds are fixed when it is declared — assigning a ten-character string to a String(1..5) raises Constraint_Error. Use Unbounded_String when the length varies at runtime.

Unbounded_String from Ada.Strings.Unbounded is the variable-length string type, analogous to Pascal's AnsiString. To_String converts back to a fixed String when needed.

Ada uses & for string concatenation instead of Pascal's +. With Unbounded_String, concatenation extends the string dynamically. With fixed String, the result's length is fixed when the variable holding it is declared — which can be at run time: Label : constant String := "Count:" & Integer'Image (Count); takes whatever length the concatenation produces.

Ada strings support array slicing with (Low..High) notation. Attributes like 'Length, 'First, and 'Last replace Pascal's Length() function and manual indexing.

Ada's subtype plays the role of Pascal's subrange type. Assigning a value outside the range raises Constraint_Error at runtime. When the compiler can see the violation, GNAT also warns at compile time — but still builds the program, which then raises.

Ada's type T is new Base creates a genuinely distinct type. Meters and Seconds cannot be mixed arithmetically — accidental unit errors become compile errors. Pascal's type declarations create aliases that still freely interoperate.

Ada raises Constraint_Error for any range or type constraint violation. Exception handlers use exception when E => at the end of any begin...end block — no separate try keyword needed.

Ada uses elsif (not else if or elseif) and closes the whole chain with end if;. No begin/end pair is needed inside branches.

Ada uses when clauses with | for multiple values, closes with end case;, and requires when others => if not all values are covered. Pascal uses commas and colons instead.

Ada's and then and or else are short-circuit operators — the right side is not evaluated if the left side determines the result. Bare and/or always evaluate both sides. Ada also uses parentheses () for array indexing instead of [].

Ada uses in instead of :=/to, and closes with end loop;. The loop variable is declared implicitly, is read-only inside the loop, and does not exist after the loop ends.

Ada uses in reverse to count down; downto does not exist. The range is still written low..high — the reverse keyword drives iteration backwards.

Ada replaces Pascal's begin/end pair inside while with loop...end loop;. There is no Inc builtin — increment is written as Count := Count + 1.

Ada has no repeat...until. The idiom is loop ... exit when Cond; end loop;. The exit when can appear anywhere in the body, not just at the end.

Ada arrays use parentheses for indexing — Numbers(Index) not Numbers[Index]. The 'Range attribute yields the array's declared bounds, so the loop automatically covers all elements.

Ada procedures are declared in the declarative region between is and begin. The body starts with is (not a semicolon) and the end conventionally repeats the procedure name (optional, but checked when written). Parameters default to in mode (read-only).

Ada uses return in both the signature (return Integer) and the body (return N * N). Pascal's result := (or FunctionName :=) becomes an explicit return statement.

Pascal's var parameter becomes Ada's in out mode. Ada also distinguishes in (read-only, the default) and out (for results — reading one before assigning it compiles, but draws a warning that it may be referenced before it has a value).

Ada fully supports nested subprograms just as Pascal does. Inner subprograms can access outer variables and may themselves contain further nested declarations.

Ada's record...end record is nearly identical to Pascal's record...end. Field access uses the same dot notation. Ada convention capitalizes field names (X, Y).

Ada record aggregates use named associations (Field => Value) or positional order. Named form is preferred — it is self-documenting and immune to field reordering.

An Ada in parameter (the default) is read-only — the compiler chooses whether to copy the record or pass a reference to it, and assigning to its fields does not compile. Use in out to allow modification, where Pascal uses var. The Integer'Image attribute converts an integer to its string representation.

Ada splits a package into a spec file (.ads — the public interface) and a body file (.adb — the implementation); a package whose spec declares nothing that needs a body, such as one holding only constants, has no body at all. The spec is visible to callers; the body is private. This is a stricter version of Pascal's interface/implementation split.

with makes a package visible (you can qualify its names). use additionally brings names into direct scope — equivalent to Pascal's uses. You may with without use to keep namespaces explicit.

Ada uses access T instead of Pascal's ^T, and .all to dereference instead of ^. new Integer'(42) allocates and initializes in one step. There is no Dispose here: without garbage collection, the allocation simply lives until the program ends, and freeing it early goes through the deliberately loud Ada.Unchecked_Deallocation.

Ada automatically dereferences access values for record field access — Ptr.Name is shorthand for Ptr.all.Name. No ^. or -> needed. The compiler inserts the dereference transparently.

Ada exception handlers live at the end of any begin...end block, introduced by the exception keyword — no separate try. Multiple when clauses name specific exceptions; when others is the catch-all.

Ada's raise ExceptionName with "message" attaches a detail string without needing an exception object. The optional with clause provides the message that appears in Exception_Message(E).

Declaring a custom exception in Ada is a single line — no class definition needed. An exception in Ada is not an object of any type: Value_Error : exception; declares a name that raise and when can refer to, and using it as a value does not compile. Pascal (FPC) uses class declarations (class(Exception)) for the same purpose.