Fortran.CodeCompared.To/Pascal

Fortran opens with program name and closes with end program name. Pascal opens with program Name; and closes with a lone end. — the trailing period, not a repeated name, marks the end of the whole program. writeln is Pascal's direct equivalent of Fortran's print *,.

Fortran comments use ! and run to the end of the line. Pascal comments are bracketed with { ... } (or, equivalently, (* ... *)) and can span multiple lines, unlike Fortran's single-line-only comment marker.

Both languages separate declarations from executable code, but the shape differs: Fortran interleaves integer ::/real :: declarations directly after implicit none, one type keyword per line (or per group). Pascal collects every declaration under a single var keyword, one name-and-type pair per line, all before the begin that starts the executable section.

Fortran places internal subprograms after the main body, introduced by contains. Pascal is the mirror image: every procedure or function must be fully declared before the main begin...end. block that uses it, since Pascal compiles top-to-bottom in a single pass and has no forward-reference mechanism for ordinary procedures.

A rare point of agreement: both Fortran and Pascal treat identifiers and reserved words as case-insensitive, so Total, total, and TOTAL all refer to the same variable in both languages. Convention in both is to pick one casing per identifier and use it consistently — the compiler does not enforce it.

Fortran controls integer width through the KIND system (integer(kind=int64)). Pascal instead offers a family of differently-named types for each width — ShortInt (8-bit), SmallInt (16-bit), Integer (32-bit), Int64 (64-bit) — chosen by picking the type name directly rather than parameterizing one generic integer keyword.

Fortran's real and double precision map directly onto Pascal's Single and Double — both languages give the programmer explicit 32-bit and 64-bit binary floating-point types with no default-precision ambiguity. Both are IEEE 754 under the hood, so both carry the same binary rounding error for values like 0.1.

Fortran's logical literals are .true./.false., surrounded by dots. Pascal's Boolean literals are the bare words True/False, capitalized by convention but not required to be (Pascal is case-insensitive). Both are genuine boolean types, unlike COBOL, which has none at all.

A single character is character(len=1) in Fortran (a 1-element string, since Fortran has no separate character-vs-string distinction) and Char in Pascal (a genuinely distinct type from string). Both use single quotes for character/string literals.

Fortran's character(len=10) is a fixed-width, blank-padded field — its length never changes, and appending text beyond 10 characters truncates. Pascal's string type is dynamically sized: appending text grows it automatically, with no declared maximum and no padding at all. This is a role reversal worth noting, since Pascal is otherwise the more manual, lower-level language of the two.

Fortran uses a bare = for assignment, the same symbol used for equality comparisons in an if. Pascal uses the two-character := for assignment specifically, reserving bare = exclusively for equality comparison — so count = 5 would be a comparison expression in Pascal, not an assignment, and would not even compile as a standalone statement.

Fortran's real, parameter :: and Pascal's const block both declare true compile-time constants that the compiler rejects any attempt to reassign — a direct, one-to-one mapping. Pascal collects all constants under one const keyword the same way var collects variables.

Both languages let a comma-separated list of names share one type declaration: Fortran's integer :: a, b, c and Pascal's a, b, c: Integer read almost identically, just with the type on opposite sides of the name list.

Fortran overloads / for both integer and real division, inferring integer division from operand types. Pascal keeps them syntactically distinct: div is always integer division (a dedicated keyword, not the / symbol, which is reserved for real division and would return a Double even given two integers), and mod is the remainder operator in both languages with the same spelling.

Fortran has a dedicated ** exponentiation operator built into the language. Pascal has no exponentiation operator at all — raising a number to a power always goes through the Power function from the Math unit. This is a genuine syntax trap for a Fortran programmer: writing 2 ** 10 in Pascal is simply a compile error, not an unexpected result.

sqrt, abs, and the trigonometric functions are intrinsic in Fortran — always available with no import. Pascal requires uses Math; for Sqrt, Sin, Cos, and friends, though Abs, Round, and Trunc live in the always-available System unit. A Fortran programmer's reflex of never needing an import for basic math needs adjusting for Pascal.

Fortran's max()/min() intrinsics are always available and accept two or more arguments directly. Pascal's Max/Min live in the Math unit and only accept exactly two arguments — comparing three or more values means nesting calls, Max(a, Max(b, c)), rather than a single flat call.

Fortran's nint() (nearest integer), int() (truncate toward zero), floor(), and ceiling() map directly onto Pascal's Round, Trunc, Floor, and Ceil — same four operations, same semantics, just different names for the first two.

Fortran concatenates with the dedicated // operator. Pascal reuses the ordinary + arithmetic operator for string concatenation — the compiler decides its meaning from the operand types. Because Pascal strings are dynamically sized, no trim()-equivalent padding cleanup is needed the way it is with Fortran's fixed-width fields.

Fortran needs two different length functions: len() for the declared field width and len_trim() for the length ignoring trailing padding. Pascal needs only one — Length — because a dynamic string has no padding to ignore in the first place; its length is always exactly the number of characters it currently holds.

Fortran's substring syntax phrase(1:5) takes a start and an end position, both inclusive, directly in the variable's own indexing brackets. Pascal has no bracket-based slicing at all — extracting a substring always goes through the Copy(string, startPosition, count) function, whose third argument is a character count, not an end position.

Fortran's index(haystack, needle) and Pascal's Pos(needle, haystack) both return the 1-based starting position of a substring (0 if not found) — functionally identical, but note the argument order is reversed: Fortran takes the string being searched first, Pascal takes the substring being searched for first.

Fortran has no built-in case-conversion intrinsic — converting case means writing a loop over character codes by hand with iachar()/achar(). Pascal's SysUtils unit provides UpperCase and LowerCase directly, a case where Pascal's standard library is considerably more convenient than Fortran's for a common text operation.

Both languages let the programmer choose arbitrary array bounds rather than being locked to 0-based indexing: Fortran's scores(1:5) and Pascal's array[1..5] both declare a 5-element array indexed 1 through 5. Either language could just as easily declare (0:4) or [0..4] — the bounds are a choice, not a language default, in both cases.

This is the headline structural difference between these two otherwise-similar languages. Fortran treats an array as a value you can operate on directly: prices = prices * 0.9 multiplies every element in a single statement, with no loop at all. Pascal, like C, has no whole-array operators whatsoever — scaling every element always requires an explicit for loop written out by hand, even though the two languages agree on almost everything else about arrays (bounds, declaration style, 1-based-by-choice indexing).

Fortran's sum() intrinsic totals an entire array in a single call. Pascal has no equivalent built-in for a plain static array — the standard idiom is a for loop that adds each element into an accumulator initialized to zero, one more consequence of Pascal's lack of whole-array operations.

Fortran and Pascal both index a 2D array with comma-separated subscripts in one set of parentheses/brackets — matrix(row, col) versus matrix[row, col] — an almost identical shape. Pascal's declaration array[1..3, 1..3] of Integer similarly parallels Fortran's integer :: matrix(3, 3), just with the dimension bounds spelled out explicitly rather than inferred as starting at 1.

Fortran's allocatable arrays are sized at runtime with allocate()/deallocate() and keep whatever bounds you give them. Pascal's dynamic arrays (array of Integer, no bounds in the declaration) are sized with SetLength and are always 0-indexed regardless of how a same-named static array might have been indexed elsewhere — a subtle trap, since Pascal static arrays commonly start at 1 but dynamic arrays never do.

Both languages support a flat multi-branch chain, but Pascal has no dedicated else if keyword — else if is simply an else clause whose body happens to be another if statement, which reads identically to a real elseif because Pascal statements need no begin/end wrapper when there is only one statement in a branch. Note also that Pascal never places a semicolon before an else — a semicolon there would terminate the if statement early and leave a dangling else with no matching if.

Fortran's select case/case/case default and Pascal's case...of/numbered branches/else are nearly interchangeable — both allow comma-separated value lists on one branch (case (4, 5) versus 4, 5:), and neither falls through to the next branch the way C's switch does.

Fortran writes a case range as lower:upper inside the parentheses. Pascal writes the same range as lower..upper — the same double-dot syntax Pascal already uses for array bounds (array[1..5]), so the two uses of .. reinforce each other once learned.

Fortran surrounds its logical operators with dots (.and., .or., .not.); Pascal spells the same operators as bare lowercase words (and, or, not) with no punctuation at all — otherwise the logic reads almost identically between the two languages.

Fortran's do i = 1, 5 and Pascal's for i := 1 to 5 do are functionally identical: both count an explicit loop variable upward through an inclusive range with a step of 1, with the variable available and readable inside the loop body in both languages.

Fortran counts downward by giving do a negative step: do i = 5, 1, -1. Pascal has a dedicated keyword for the same purpose — for i := 5 downto 1 do — with no explicit step argument at all, since downto always steps by exactly 1 in the negative direction.

Fortran's do while (condition) and Pascal's while condition do both test the condition before each iteration and may run zero times — identical semantics, with Pascal needing a begin...end wrapper only because its loop body here has more than one statement.

Pascal's repeat...until condition tests its condition after the loop body, guaranteeing at least one execution, and continues until the condition becomes true (the opposite sense of while). Fortran has no direct equivalent — a Fortran programmer must simulate a post-tested loop with a do while and a manually managed flag, as shown here, or an infinite do with an if/exit at the bottom.

Fortran's cycle (skip to next iteration) and exit (break out of the loop) map directly onto Pascal's continue and break — nearly identical vocabulary between the two languages, unlike COBOL, which has neither.

A Fortran subroutine is called with the call keyword; a Pascal procedure is called by name alone, with no equivalent keyword required. Both describe a callable unit that performs an action and returns no value — the direct structural counterpart of each other, unlike COBOL, which has no comparable parameterized unit at all outside a full subprogram.

Fortran's intent(in) and Pascal's const parameter modifier serve the identical purpose: both tell the compiler the parameter is read-only, and both cause a compile-time error if the procedure tries to assign to it. This is one of the closest one-to-one mappings between the two languages' feature sets.

Fortran's intent(inout) and Pascal's var parameter modifier both pass the caller's actual variable by reference, letting the procedure both read and modify it in place — another near-exact mapping. Pascal additionally has a write-only out parameter mode matching Fortran's intent(out), completing the correspondence across all three of Fortran's intent modes.

Unlike COBOL, Pascal has real user-defined functions with return values that can be used directly inside expressions, exactly like Fortran. The return value is set by assigning to the function's own name (ToFahrenheit := ...) — Free Pascal also accepts the more modern Result := ... — rather than Fortran's optional result() clause, but the calling convention is identical: ToFahrenheit(100.0) can be nested inside any expression exactly as to_fahrenheit(100.0) can in Fortran.

Fortran requires the explicit recursive keyword before a function or subroutine can call itself — an important safety default, since ordinary Fortran subprograms are not guaranteed reentrant. Pascal has no such keyword: every Pascal function and procedure may call itself freely with no special declaration at all.

Fortran's return statement exits a subprogram immediately, before reaching its natural end. Pascal's equivalent is the built-in Exit procedure — same purpose, different name, and both languages require the return value to already have been assigned before the early exit statement runs.

A Fortran type and a Pascal record are nearly identical concepts: both group named fields of possibly different types into one value, both are declared once and instantiated many times, and both use a member-access operator to reach a field — % in Fortran, . in Pascal. Pascal record type names are conventionally prefixed with T.

Both languages combine arrays and records the same way: an array whose element type is a record/derived type, accessed by combining the subscript and the member operator — points(1)%x versus points[1].x. The shape of the two lines is nearly a character-for-character translation of each other.

A record/derived type can contain another record/derived type as a field in both languages, and the member-access chain reads the same way in both: employee%home_address%city versus employee.homeAddress.city. Pascal declares both nested types in a single type block separated by semicolons; Fortran gives each its own separate type ... end type block.

Fortran's use module_name, only: names and Pascal's uses UnitName; both import a library of related declarations — the mechanism a Rubyist would compare to require. Fortran can selectively import only specific names with only:; a plain Pascal uses clause always imports everything a unit exports, with no selective-import syntax.

Fortran builds a formatted string by writing to a character variable used as an "internal file" — an sprintf-equivalent reached through the ordinary write statement. Pascal reaches the same result through SysUtils's Format function, whose %d-style placeholders and array-of-arguments syntax will look immediately familiar to anyone who has used C's printf.

print *, ... in Fortran and writeln(...) in Pascal both write a comma-separated list of values to standard output followed by a newline. Pascal additionally offers write (no trailing newline) for building up a line across several calls — Fortran has no equivalent no-newline print statement in its simple print *, form.

Fortran controls output layout with a separate FORMAT descriptor string passed to write, such as f10.2 (fixed-point, 10 characters wide, 2 decimal places). Pascal folds the same information directly into the writeln argument list using colon syntax: amount:10:2 means the same 10-wide, 2-decimal formatting, with no separate format string needed.

Fortran suppresses the trailing newline with advance='no' on a write statement — an unusually verbose piece of syntax for such a common need. Pascal's plain write (as opposed to writeln) never emits a newline at all, so building up a line piece by piece across a loop is simpler in Pascal: call write repeatedly, then call bare writeln once to finish the line.

Fortran statements are terminated by a newline, with nothing equivalent to a required trailing punctuation mark. Pascal semicolons are technically statement separators, not terminators — the last statement before an end does not strictly need one, as shown here. A stray extra semicolon (e.g. right after then) silently creates an empty statement rather than a syntax error, which can make an intended if body execute unconditionally — a subtle bug a Fortran programmer's newline-based intuition will not catch by habit.

Both languages agree here, unlike Ruby or Python: a fixed-width integer that overflows its range wraps silently to a nonsensical value (127 + 1 becomes -128 in an 8-bit signed field) with no error, no warning, and no exception raised in either Fortran or Pascal. Neither language has an automatically-growing arbitrary-precision integer type as a fallback.

Fortran arrays default to 1-based indexing but can be declared with any custom bounds, including 0-based, and that choice is consistent everywhere the array is used. Pascal static arrays follow the same "choose your own bounds" rule — but Pascal dynamic arrays (array of Integer, sized with SetLength) are always 0-indexed with no way to change it. Mixing static and dynamic arrays in the same Pascal program means living with two different indexing conventions side by side.

Fortran's where construct applies an operation only to the array elements that satisfy a condition — a whole-array conditional built directly into the language, with the condition itself expressed as a whole-array comparison (numbers > 0 produces a whole array of booleans). Pascal has neither piece: no whole-array comparison operators and no masked-assignment construct, so the equivalent logic always becomes an explicit for loop with an if inside it — one more instance of the whole-array-versus-element-by-element gap that runs through every array-related concept on this page.