Ruby.CodeCompared.To/Pascal

Every Pascal program begins with program name; and ends with end. (a period, not a semicolon). The writeln procedure writes to standard output followed by a newline. Single-quoted strings are the Pascal convention; double-quoted strings are not standard Pascal.

Pascal has three comment styles. The { } brace style is the most traditional; (* *) is equally standard and predates brace comments; // single-line comments are a Free Pascal extension borrowed from C++. Unlike Ruby, multi-line comments are not delimited by special start/end keywords — any block comment syntax works across multiple lines.

Pascal uses a const block before the begin to declare compile-time constants. Unlike Ruby constants (which are uppercase by convention and mutable), Pascal constants are truly immutable — the compiler will reject any assignment to them. The Pi:0:5 notation in writeln formats the real number with 0 minimum width and 5 decimal places.

Pascal's type block creates named type aliases and new types. string[50] declares a fixed-length string of up to 50 characters. The 'A'..'F' syntax creates a subrange type that limits values to that range. Variable declarations must appear in a var block before begin, not inline — unlike some newer languages that support inline declarations.

Pascal enforces a strict declaration order: uses → const → type → var → subprogram definitions → main begin...end. block. Every identifier must be declared before it is used. This top-down structure means helper functions are always defined above the code that calls them, which is the opposite of Ruby's method-defined-anywhere approach.

Pascal requires every variable to be declared in a var block with an explicit type before any code runs. The := operator assigns values. Using a variable before assignment is a bug (the value is undefined, often zero for numbers but not guaranteed). Ruby's dynamic typing is entirely absent — every name has a fixed type for its lifetime.

Pascal provides fixed-width integer types: ShortInt (8-bit), SmallInt (16-bit), Integer (32-bit on most platforms), Int64 (64-bit), and unsigned variants like Byte, Word, and Cardinal. Overflow wraps silently without raising an error, unlike Ruby where integers grow to arbitrary size automatically.

Double is the standard floating-point type in Pascal (equivalent to Ruby's Float); Single is a 32-bit alternative with less precision. The value:width:decimals syntax in writeln formats floats inline: temperature:0:1 means minimum width 0, 1 decimal place. The Format function from SysUtils provides printf-style formatting for more complex cases.

Pascal prints booleans as TRUE / FALSE (uppercase). The logical operators are words: and, or, not, xor — not &&, ||, !. In standard Pascal, and and or do not short-circuit; Free Pascal adds and then / or else for short-circuit evaluation.

Pascal's Char type holds a single character, written with single quotes. Ord(ch) returns the ASCII code (equivalent to Ruby's String#ord), and Chr(n) converts a number back to a character (like Ruby's Integer#chr). Unlike Ruby, a Char is not a one-character string — it is a distinct type with its own operations.

Free Pascal's default string type is AnsiString — a variable-length, reference-counted string with no length limit (unlike the older string[255] short strings). String concatenation uses +, just like Ruby. Length(s) returns the byte count. Strings are 1-indexed in Pascal: the first character is at position 1, not 0.

Pascal requires explicit type conversion — there is no implicit coercion between numeric and string types. IntToStr and FloatToStr convert numbers to strings; StrToInt and StrToFloat parse strings (raising an exception if the string is invalid). Trunc truncates a float toward zero; Round rounds to the nearest integer. All string utilities come from SysUtils.

Pascal concatenates strings with the + operator, identical to Ruby. Unlike Ruby, you cannot mix strings and numbers in concatenation — numbers must be explicitly converted first with IntToStr or FloatToStr. There is no string interpolation syntax; building formatted strings uses concatenation or the Format function.

Length(s) returns the number of bytes in a string (for pure ASCII strings, this equals the character count). Pascal has no built-in empty? method; the idiom is to compare with '' or check Length(s) = 0. Free Pascal's default AnsiString measures length in bytes, not Unicode code points, so multi-byte UTF-8 characters will count as multiple bytes.

Copy(str, startPos, count) extracts a substring. Pascal strings are 1-indexed, so the first character is at position 1 — this is the opposite of Ruby's 0-based indexing. To extract to the end of the string, pass MaxInt as the count. There is no negative-index syntax; to index from the end you must calculate the position as Length(s) - offset + 1.

Pos(needle, haystack) returns the 1-based position of the first occurrence, or 0 if not found (unlike Ruby's index, which returns nil on failure). The argument order is reversed from Ruby: the search target comes first, the string to search comes second. A return value of 0 is the standard "not found" sentinel in Pascal.

UpperCase and LowerCase from SysUtils convert ASCII strings. They work correctly for the 26 English letters but do not handle non-ASCII characters — accented letters like ü or ñ pass through unchanged. For Unicode-aware case conversion, Free Pascal provides WideUpperCase and WideLowerCase in the LazUTF8 unit.

Trim, TrimLeft, and TrimRight in SysUtils correspond directly to Ruby's strip, lstrip, and rstrip. They remove ASCII whitespace (spaces, tabs, newlines) from the respective ends of the string. Unlike Ruby, there is no in-place variant — these functions always return a new string.

Format from SysUtils uses printf-style format specifiers: %s for strings, %d for integers, %f for floats. The arguments are passed in a square-bracket array. This is functionally equivalent to Ruby's format / sprintf or % operator. There is no string interpolation syntax in Pascal.

Pascal static arrays are declared with explicit bounds: array[low..high] of type. By convention arrays start at 1, though any integer bounds are valid (e.g. array[0..4] or even array[-2..2]). The size is fixed at compile time and cannot change at runtime. High(arr) and Low(arr) return the upper and lower bounds, making it easy to write generic loops.

Pascal array iteration uses a for loop over the index range. Using Low(arr) and High(arr) is the recommended style — it adapts automatically if the array bounds change. There is no each or map equivalent in standard Pascal; all higher-order collection operations must be written as explicit loops.

Dynamic arrays are declared with array of type (no bounds). SetLength(arr, n) allocates or resizes the array; existing elements are preserved on growth. Dynamic arrays are always 0-indexed, unlike static arrays which default to 1-based bounds. They behave like Ruby arrays in terms of sizing but require explicit calls to SetLength — there is no automatic push.

Low(arr) and High(arr) return the lower and upper bounds of any array at compile time. For static arrays these are constants; for dynamic arrays they return 0 and Length(arr) - 1 respectively. Always prefer Low/High over hardcoded values — it makes code resilient to bound changes and eliminates off-by-one errors.

Multi-dimensional arrays in Pascal use comma-separated bounds in a single bracket: array[1..3, 1..3] of Integer. Elements are indexed with matrix[row, col] (comma-separated, not double-bracket as in some languages). writeln with no arguments outputs a blank line. Pascal does not have a built-in array inspect or print method — displaying 2D arrays always requires nested loops.

Pascal's if syntax uses then after the condition and has no closing end for a single-statement branch. For multiple statements in a branch, wrap them in begin...end. The else if chain is written as two separate keywords (not elsif like Ruby). Critically, there is no semicolon before else — a semicolon there ends the if statement entirely.

When a branch needs multiple statements, Pascal wraps them in begin...end — a compound statement block. This is analogous to Ruby's if...end block, but the delimiter is explicit rather than the entire if construct having its own end. Forgetting begin...end and writing two statements after then is a classic Pascal bug: only the first statement belongs to the branch.

Pascal's case...of matches on ordinal values (integers, characters, booleans, enumerations). The syntax places the matching value(s) before a colon. Multiple values can share a branch using a comma-separated list (4, 5:). The else clause is optional. Unlike C's switch, Pascal's case never falls through — each branch ends automatically at the next case.

Pascal case branches can use subrange syntax (low..high) to match a range of values in a single branch. This is syntactically cleaner than a chain of or comparisons. Ruby's case/when supports the same range syntax — the two languages are nearly identical here. Note that case in Pascal is a statement, not an expression; it cannot be assigned directly.

Pascal uses English keywords for boolean operators: and, or, not, xor. Both operands are always evaluated (no short-circuit by default). Parentheses around comparison expressions are required because and/or have lower precedence than comparison operators — age >= 18 and flag would parse as age >= (18 and flag), which is wrong.

Pascal's for loop uses := start to finish do and always steps by exactly 1. The loop variable is a local copy — assigning to it inside the body has no effect on the loop progression (unlike some languages). The loop variable's value after the loop ends is undefined in standard Pascal. For loops over non-integer steps, use a while loop with explicit increment.

Replace to with downto to count downward by 1 each iteration. Pascal has no equivalent of Ruby's step option for arbitrary step sizes in a for loop; for steps other than ±1 you must use while with a manual counter. The downto keyword is one of Pascal's most recognizable idioms for Rubyists.

Pascal's while...do loop checks the condition before each iteration — identical to Ruby's while. When the loop body has multiple statements, wrap them in begin...end. There is no += compound assignment operator in Pascal; increment must be written as counter := counter + 1 or using the built-in Inc(counter) procedure.

repeat...until is Pascal's do-while loop: the body always runs at least once, and the condition is tested at the end of each iteration. The loop continues until the condition is True (the inverse of C's do...while which repeats while true). The repeat body never needs begin...end because repeat itself acts as the opening delimiter.

Break exits the enclosing loop immediately; Continue skips the rest of the loop body and proceeds to the next iteration. These are identical in behavior to Ruby's break and next. In Pascal, Break and Continue are capitalized by convention (though FPC accepts lowercase). They work inside for, while, and repeat loops.

A Pascal procedure is a named subprogram that has no return value — analogous to a Ruby method that returns nil. Procedures are declared before the main begin...end. block. The declaration ends with a semicolon after the closing end, while the main program's last end ends with a period. Pascal's explicit distinction between procedures and functions is one of its defining design choices.

Procedure parameters are declared with their types separated by semicolons. Parameters of the same type can be grouped: width, height: Integer. All parameters default to pass by value — the procedure receives a copy and cannot modify the caller's variable. This is the same default as Ruby's method arguments for immutable objects like integers and strings.

Prefixing a parameter with var makes it pass-by-reference: the procedure receives the caller's actual variable, not a copy, and any assignment modifies the original. This is Pascal's equivalent of Ruby's swap!(a, b) pattern or passing an array/hash to a method and mutating it. The classic use case is procedures that must "return" multiple values — each output goes into a var parameter.

Prefixing a parameter with const tells the compiler the procedure will not modify it. For large strings and records, const can be more efficient than value parameters because the compiler may pass a reference internally while still preventing modification. Any attempt to assign to a const parameter causes a compile-time error — a useful form of documentation that Ruby lacks.

A Pascal function is declared like a procedure but with a return type after the parameter list. The return value is set by assigning to the special variable Result (the Free Pascal ObjFPC way) or to the function's own name (the classic Pascal way: Square := number * number). Unlike Ruby, where every method returns the last expression automatically, Pascal requires an explicit assignment.

Parameters of the same type can be grouped with a comma in the declaration: value, minimum, maximum: Integer. The function body uses if...else if...else chains to set Result. Unlike Ruby, Pascal has no ternary operator (condition ? a : b) — conditional expressions must use if statements. A function must always set Result before it returns; leaving it unset is a bug.

Recursive functions in Pascal work exactly like in Ruby — the function calls itself with a modified argument until it reaches the base case. Using Int64 as the return type prevents overflow for factorials beyond 12 (where the result exceeds Integer range). Pascal has no tail-call optimization, so very deep recursion causes a stack overflow just as it does in Ruby.

Exit causes a function or procedure to return immediately, like Ruby's return. In Free Pascal you can also write Exit(value) to set Result and return in one step. An untyped Exit in a function returns whatever Result was last set to. The pattern of setting a sentinel default value for Result at the top and overriding it in the loop is idiomatic Pascal.

Free Pascal supports function overloading via the overload directive: multiple functions may share the same name as long as their parameter types differ. The compiler selects the correct version at compile time based on the argument types. Ruby achieves similar flexibility through duck typing and optional arguments rather than overloading.

A Pascal record is a value type that groups related fields — similar to Ruby's Struct but lower-level. Records are declared in the type block. By convention, user-defined type names are prefixed with T (for "type"). Records are stored by value, not by reference: assigning one record to another copies all its fields, unlike Ruby objects which are always references.

Arrays of records are a fundamental data structure in Pascal, equivalent to Ruby's array of hashes or array of structs. Each element is accessed by index, and each field by dot notation: students[2].name. Because records are value types, each array slot contains a complete copy of the record — there are no nil entries and no need to initialize with a constructor.

Records can be nested: a field can be of another record type. Access chains fields with dot notation: person.address.city. Because records are value types, nested records are embedded inline in the parent record's memory — there are no pointer indirections or nil checks. This differs from Ruby, where nested hashes or objects are always separate heap allocations connected by references.

The with record do statement opens the record's fields as local names inside the block, eliminating repetitive person.fieldName prefixes. It is convenient for long initialization blocks. However, with can cause subtle name-shadowing bugs when a local variable and a record field share a name — the field silently wins. Modern Pascal style avoids with in complex code for this reason.

Pascal's built-in set of type creates a bit-set over an ordinal type. The elements are stored as individual bits in a packed integer, making membership testing extremely fast (O(1)). Sets in Pascal are limited to ordinal types with at most 256 possible values: Char, small integers, or enumeration types. Unlike Ruby's Set, Pascal sets cannot hold arbitrary objects or grow beyond their declared element type.

Pascal set operators use arithmetic symbols: + for union, - for difference, * for intersection. The in operator tests membership. These map directly to Ruby's |, -, and & operators on Set. Enumeration types (type TDay = (Monday, Tuesday, ...)) are ordinal and work perfectly as set element types.

Pascal enumeration types define a sequence of named constants. Each constant has an ordinal value starting at 0 — Ord(North) is 0, Ord(West) is 3. Enumerations are ordinal types, so they work as set elements and as for loop bounds. Unlike Ruby's symbols (which are just names), Pascal enumerations are type-checked: you cannot assign North to a variable of a different enumeration type.

Free Pascal classes use Object Pascal (ObjFPC) syntax. The T prefix for type names is a strong convention. Fields are prefixed with F by convention. constructor Create is the initializer (initialize in Ruby). Objects are heap-allocated and must be explicitly freed with .Free — Pascal has no garbage collector.

Object Pascal properties are declared with property Name: Type read FField write FField. The read part names the backing field (or a getter method); the write part names the field or setter method. Omitting write makes the property read-only. Properties look like field access at the call site — person.Name — but can invoke arbitrary getter/setter logic behind the scenes, just like Ruby's attr_accessor.

A subclass is declared as TDog = class(TAnimal) — identical to Ruby's class Dog < Animal. Methods that can be overridden must be marked virtual in the parent and override in the child. Without virtual, a method cannot be overridden polymorphically; without override, the child's method shadows the parent's but does not participate in virtual dispatch.

Virtual method dispatch enables polymorphism: an array of TShape can hold TCircle and TRectangle objects, and calling .Area invokes the correct overridden version at runtime. This is identical in concept to Ruby's duck typing, but enforced via an explicit type hierarchy. All objects stored by base-class reference must be freed after use — Pascal does not track object lifetimes automatically.

Pascal's try...except...end corresponds to Ruby's begin...rescue...end. The on error: Exception do clause catches a specific exception type and names it for use inside the handler — equivalent to Ruby's rescue ExceptionClass => error. Exception.Create(message) is the base exception class analogous to Ruby's RuntimeError.

Multiple on type: Handler clauses in a single except block catch different exception types, tested in order from most specific to most general. EConvertError is raised by StrToInt when the string is not a valid integer. Common exception classes in Free Pascal's SysUtils include EConvertError, EDivByZero, ERangeError, and EInOutError.

try...finally guarantees the finally block runs whether or not an exception was raised — the Pascal equivalent of Ruby's ensure. Crucially, try...finally does not catch the exception; after the finally block completes, the exception continues propagating up the call stack. In this example, ProcessData cleans up its resource, then the exception travels to the caller's try...except. Use try...finally for guaranteed cleanup and try...except separately (typically in a caller) for error handling.

Custom exceptions inherit from Exception (or any more specific class) and are prefixed with E by convention. The constructor calls inherited Create(message) to initialize the base class message. Custom exception classes can add extra fields for structured error information — here, Field stores which form field failed validation. The pattern mirrors Ruby's custom exception subclasses exactly.

uses is Pascal's import system — the equivalent of Ruby's require. The System unit is always implicitly included and provides basic I/O, string functions, and math built-ins. SysUtils adds Format, IntToStr, type conversion, exception classes, and file utilities. Math provides trigonometric and advanced math functions. Unlike Ruby gems, Pascal units are part of the standard library and do not require installation.

The Math unit provides Floor, Ceil, Power, Log2, Log10, Ln, Sin, Cos, Tan, ArcTan, and more. Sqrt, Abs, Round, and Trunc live in the built-in System unit and are always available. MaxIntValue and MinIntValue find the extremes of an integer array.

Randomize seeds the random number generator from the system clock — call it once at program startup. Without it, the same seed is used every run and the sequence is deterministic. Random(N) returns an integer in 0..N-1; Random with no argument returns a Double in [0.0, 1.0). There is no built-in sample equivalent for arrays; generate a random index with Random(Length(arr)).

Pascal file I/O uses a three-step pattern: AssignFile (bind variable to path), Rewrite/Reset (open for write/read), then CloseFile when done. writeln(file, text) writes to the file; readln(file, variable) reads a line. The Eof function returns True when all lines have been read. This example cannot run in Compiler Explorer's sandbox environment, which does not allow filesystem access.

Pascal's most famous quirk: := assigns a value, and = tests equality. This is the opposite convention from Ruby (and almost every other language). Writing count = 10 in a statement context is a compile error in Pascal. This design was intentional — Niklaus Wirth chose := to make assignment visually distinct from comparison, eliminating the classic C bug of writing if (x = 5) instead of if (x == 5).

Pascal divides integer arithmetic from real arithmetic explicitly. The / operator always returns a Double, even when both operands are integers. Use div for integer division (truncates toward zero) and mod for the remainder. Ruby's / on two integers returns an integer; Pascal's does not. Assigning 10 / 3 to an Integer variable is a compile error without an explicit cast.

Semicolons in Pascal are statement separators, not terminators — they appear between statements, not after every statement. The most common pitfall: placing a semicolon before else accidentally ends the if and makes the else an orphan, causing a compile error. Similarly, no semicolon is needed after the last statement before end, before until in a repeat loop, or before end.

Pascal's case statement never falls through to the next branch — each branch ends automatically after its statement or block. This is the opposite of C and Java, where a missing break causes fall-through. Rubyists accustomed to Ruby's case/when (which also never falls through) will find Pascal's behavior natural. There is no Pascal equivalent of C's intentional fall-through pattern.

Pascal static arrays default to 1-based indexing, but you can declare any bounds you like: array[0..4] is perfectly valid. Dynamic arrays are always 0-based. This inconsistency surprises Rubyists who expect a single convention. There is no negative-index syntax for accessing from the end — use arr[High(arr)] for the last element. Picking up the wrong convention causes silent one-off errors that pass the compiler check.