Pascal.CodeCompared.To/Ruby

Ruby has no program header, no begin/end. wrapper, and no compilation step. Top-level code runs top to bottom the moment the file is loaded. puts writes its argument followed by a newline — the everyday equivalent of writeln.

Free Pascal compiles to a native executable you ship on its own. Ruby ships the source and interprets it at run time — there is no separate compile phase, and the script you edit is exactly the program that runs. The trade is portability and edit-run speed against the native performance and standalone binary you get from fpc.

Ruby has a single line-comment character, #, used for everything. Its block-comment form (=begin/=end) exists but is rare — Rubyists simply prefix each line with #. There is no equivalent of Pascal's three interchangeable comment styles.

Ruby's format (also written "...".%(...)) uses the same %s/%d/%.2f specifiers as Pascal's Format. But the idiomatic way to build a string is interpolation: #{...} inside a double-quoted string evaluates any expression and inserts its value. There is no uses SysUtils to add — these are built in.

Ruby has no var block and no type annotations. A variable springs into existence the first time you assign to it, and it can hold any object — an integer now, a string later. Assignment is plain =, not Pascal's :=; Ruby reserves = for assignment and == for comparison, so the two can never be confused.

In Pascal a variable is its type — the compiler binds the two and rejects any mismatch. In Ruby a variable is only a name that points at an object, and the same name may point at objects of different classes over its life. Every object carries its own class, which you can ask for at any time with .class.

There are no primitives in Ruby. Integers, floats, booleans, and even nil are objects with classes and methods — (-5).abs, 42.even?, 3.times. Where Pascal offers stand-alone functions like Abs and Sqr that take a value, Ruby sends a message to the value itself. This single rule — everything is an object — shapes the entire language.

Ruby marks a constant by capitalising its first letter — any identifier starting with an uppercase letter is a constant, and that includes every class and module name. Unlike Pascal's const, the value is not truly immutable: reassigning it merely prints a warning. The capital letter signals intent rather than enforcing it.

Pascal's nil is strictly a null pointer; ordinary values can never be nil. Ruby's nil is a universal "no value" that any variable may hold, and it is itself an object (the sole instance of NilClass) with methods like .nil?. Crucially, only nil and false are falsy — 0 and the empty string are both truthy, unlike in many other languages.

A Ruby string is a full object that knows its own length: full.length, not Length(full). Concatenation with + works as in Pascal, but interpolation ("#{greeting}, #{name}!") is the idiomatic way to assemble text. Single-quoted strings are literal; only double-quoted strings interpolate and honour escapes like \n.

Where Pascal calls SysUtils functions on a string (Trim(text), UpperCase(text)), Ruby calls methods on the string (text.strip, text.upcase). The method library is enormous and chainable: text.strip.upcase.reverse. Note index returns a zero-based offset or nil if not found, where Pascal's Pos returns a one-based position or 0.

Ruby strings are mutable objects, and like Pascal you can assign to an individual character — but Ruby indexes from zero. As of Ruby 4.0 string literals are frozen by default, so mutating one raises FrozenError; prefix the literal with unary + (or call .dup) to get a fresh mutable copy. The << operator appends in place, avoiding the new-string allocation that Pascal's + performs.

Both languages split a string into pieces on a delimiter and join them back. In Ruby, split and join are methods on the string and array respectively, and the resulting array is a first-class object you can immediately iterate with a block. Free Pascal has no string-array literal type, so the conventional route is a TStringList whose DelimitedText property both parses and reassembles a delimited string.

Regular expressions are part of Ruby's syntax, written between slashes (/\d+/) with no library to import and no object to create and free. The =~ operator tests a match; scan returns every match as an array. Compare the RegExpr unit in Pascal, where you create a TRegExpr, call Exec, and must Free it in a finally block.

Ruby has a single Integer type with arbitrary precision: when a value exceeds machine-word size, Ruby transparently switches to a bignum representation, so 2 ** 200 is exact. There is no shortint/integer/int64 ladder to choose from and no silent overflow to guard against. Underscores may be used as digit separators, just as in Pascal.

Ruby has no separate div operator: / performs integer division when both operands are integers (so 7 / 2 is 3) and float division when either is a float. This catches Pascal programmers who expect / to always yield a real. Use .fdiv or convert one operand with .to_f to force a floating-point result; % is the remainder, like mod.

Trigonometric and transcendental functions live in the Math module (Math.sqrt, Math.sin), parallel to Pascal's Math unit. But rounding and absolute value are methods on the number itself: 3.7.round, (-5).abs. Exponentiation has a dedicated operator, **, rather than a Power function.

A Ruby array is written as a literal in square brackets and grows on demand — no fixed bounds, no SetLength. It can hold objects of mixed classes. Indexing is zero-based like a C-mode Pascal array, and negative indexes count back from the end (numbers[-1] is the last element), a convenience Pascal lacks.

Ruby arrays resize themselves: numbers << value (or push) appends in place, with no SetLength call and no manual High bookkeeping. Because the runtime manages the backing storage and a garbage collector reclaims it, the explicit grow-by-one pattern that Pascal forces simply disappears.

This is the single biggest shift for a Pascal programmer. Instead of an index loop that builds a result array element by element, Ruby gives every collection higher-order methods: map transforms each element, select keeps those matching a condition, and reduce folds the collection to one value. The { |number| ... } is a block — a chunk of behaviour passed to the method.

Ruby slices an array with a range (numbers[1..3]) or a start/length pair (numbers[1, 2]), returning a new array. Arrays support + to concatenate, - to subtract elements, & for intersection, and dozens of query methods — operations that in Pascal you would write out by hand with index loops.

Ruby's Hash is the built-in key-value map, written as a literal with => between key and value. There is no generic type parameter to specialise, no Create, and no Free — the garbage collector owns it. Keys and values may be any objects, and a hash literal is as ordinary as an array literal, where Pascal needs the Generics.Collections unit and an explicit TDictionary.

Ruby has a type with no Pascal analogue: the symbol, written :name. A symbol is an immutable, interned identifier — the same :host is one shared object everywhere it appears, which makes symbols ideal, memory-cheap hash keys. The { host: "..." } shorthand is sugar for { :host => "..." }. Think of a symbol as a name used as a value.

Iterating a hash yields each key and value straight into the block's two parameters — |name, age| — with no TPair wrapper to unpack. Ruby hashes also guarantee insertion order when iterated, which Pascal's TDictionary does not promise. And the same map/select/reduce family that works on arrays works on hashes too.

Passing a default to Hash.new(0) makes every missing key read back as 0 instead of nil, so the classic count-the-occurrences loop becomes a one-liner counts[fruit] += 1. In Pascal you must TryGetValue and supply the fallback yourself on every access — Ruby folds that into the hash itself.

Here Pascal is the more elegant language: set of is a first-class type with in, +, -, and * operators built straight into the syntax. Ruby keeps Set in the standard library, so you require "set" first; thereafter it offers include?, & (intersection), | (union), and - (difference). Pascal's sets are bit-packed and limited to small ordinal types; Ruby's hold any objects.

A Pascal subrange like 1..12 is a compile-time type that constrains a variable. A Ruby Range like 1..12 is a runtime object you can iterate, test with include?, convert to an array, or sum. Two dots include the endpoint; three dots (1...5) exclude it. Ranges also span characters and other comparable objects, not just integers.

Ruby's conditional needs no then and no parentheses around the condition, and it closes with a single end rather than relying on statement nesting. The chained keyword is elsif — one word, no second e — which trips up newcomers. Any block (if, while, def, class) terminates with end, Ruby's universal equivalent of Pascal's begin/end pairs.

Ruby lets you append if, unless, or while to the end of a statement — puts "Adult" if age >= 18 reads almost like English and is the preferred form for a one-line guard. unless is simply if not, with no Pascal counterpart. There is no equivalent in Pascal, where every conditional must be a full if...then statement.

Ruby's case/when mirrors Pascal's case/of — multiple values per branch (when 6, 7), an else fallback, and no fall-through. Two differences matter: each branch compares with the === operator (so a when can match a range, class, or regex, not just a constant), and the whole case is an expression that returns a value you can assign directly.

Because when uses ===, a Ruby case can match a range (0..9), a class (Integer tests whether the value is an integer), or a regular expression — all in the same statement. Pascal's case supports range labels too, but it can only ever branch on ordinal constants; it has no way to ask "is this value of this type?" at runtime.

Ruby has a for keyword, but Rubyists almost never use it. The idiomatic counting loop is a method on a range or integer: (1..5).each, 5.downto(1), 3.times. The loop variable arrives as a block parameter and is scoped to the block. This reflects the deeper pattern — iteration in Ruby is a method call that yields to a block, not a built-in control structure.

Modern Pascal's for...in walks a collection, and Ruby's each is its direct counterpart — except each is a method that hands each element to a block. When you also need the index, each_with_index yields both, sparing you the manual counter. The block form ({ |fruit| ... } or do |fruit| ... end) is the heartbeat of Ruby iteration.

Ruby's while matches Pascal's, closing with end instead of begin/end. In place of Pascal's repeat...until, Ruby offers until, which loops while a condition is false — the negation of while. Ruby has no Inc; use the compound assignment count += 1.

Ruby's break matches Pascal's Break, and next plays the role of Pascal's Continue — skipping to the next iteration. Ruby adds loop do ... end, an unconditional infinite loop you exit with break, handy when the exit test is most natural in the middle of the body.

Ruby has one keyword, def, for what Pascal splits into procedure and function. There is no return-type declaration and no parameter types. Most strikingly, there is no Result variable and usually no return: a method implicitly returns the value of its last expression, so square just ends with n * n.

Both languages support default parameter values. Ruby adds keyword arguments — salutation: names the parameter at the call site, so argument order stops mattering and the call documents itself. The def power(base, exponent = 2) = ... form is Ruby's "endless method", a one-line definition mirroring Pascal's compact functions.

Pascal returns extra values through var parameters that the caller must declare in advance. Ruby returns an array and lets the caller destructure it in one assignment: quotient, remainder = div_mod(17, 5). Parallel assignment like this works anywhere, and it removes the need for pass-by-reference output parameters entirely.

Ruby's splat operator, *, gathers any number of trailing arguments into an array inside the method (def sum_all(*values)) and, at a call site, expands an array back into separate arguments (sum_all(*numbers)). Pascal's array of open-array parameter is the closest analogue, but it requires the caller to wrap the values in an array literal.

The block is the feature with no real Pascal equivalent. In Pascal you declare a procedure type, define a named procedure, and pass @ShowSquare as a function pointer. In Ruby you pass an inline, anonymous block right at the call, and the method runs it with yield. Almost every iteration method you have already seen — each, map, times — is built on this one mechanism.

A block has two interchangeable forms: curly braces { |x| ... } for a single line, and do |x| ... end for multi-line bodies. The pipes around the parameters (|number|) are how a block declares the arguments it receives. By convention braces are for short, value-returning blocks and do/end for blocks run for their side effects — a stylistic distinction Pascal's begin/end never needs to make.

A Ruby lambda (->(n) { ... }) or proc is a block you store in a variable and call later, and it closes over the variables in scope when it was created — each make_adder call captures its own base. Call it with .call (or .()). Free Pascal's nested functions and anonymous methods can capture variables too, but the lightweight, store-and-pass-anywhere closure is far more central to everyday Ruby.

When a block does nothing but call one method on each element, Ruby offers a terse shorthand: &:upcase is equivalent to { |word| word.upcase }. The & converts the symbol :upcase into a block. You will see map(&:to_i), select(&:even?), and the like constantly — there is simply no Pascal equivalent, because Pascal has neither blocks nor symbols.

Ruby's class declaration puts the method bodies inside the class — there is no split between interface and implementation as in a Pascal unit. The constructor is always named initialize and is invoked by Person.new. Instance variables are prefixed with @ and need no declaration; they appear when first assigned. And because Ruby is garbage-collected, there is no Free and no try...finally to balance it.

Pascal's property Value read FValue write FValue generates getter/setter access to a field. Ruby's attr_accessor :value does the same in one line, creating both a value reader and a value= writer. Use attr_reader for read-only or attr_writer for write-only. Under the hood counter.value = 10 is a real method call to value= — assignment syntax that dispatches to a method.

For a simple bundle of named fields — Pascal's record — Ruby offers Struct.new(:x, :y), which manufactures a class complete with a constructor and accessors. You can attach methods to it in the block, blurring the line Pascal draws between a passive record and an active class. (Ruby 3.2+ also has Data.define for immutable value objects.)

Both languages use a self-reference for the current instance: Pascal's Self and Ruby's lowercase self. Returning self from a method enables fluent chaining (account.deposit(100).deposit(50)). Inside a Ruby method you rarely write self to read an instance variable — @balance is already in scope — but you do return it explicitly when you want the method to be chainable.

Ruby denotes inheritance with < (class Dog < Animal) and supports only single inheritance, like Pascal. The big simplification: every method is "virtual" automatically. There is no virtual/override bookkeeping — defining a method with the same name in a subclass simply overrides it, and method lookup is always dynamic. Call the parent's version with the keyword super.

Where Pascal writes inherited Create to invoke the parent method, Ruby writes super. A bare super forwards the current method's arguments to the parent automatically; super(x, y) passes explicit ones, and super() passes none. It works in any method, not just the constructor.

A Pascal interface declares method signatures a class must implement. A Ruby module goes further: it supplies actual method bodies that you mix into a class with include. This is composition by mixin, and it sidesteps single inheritance — a class can include any number of modules. Standard mixins like Comparable and Enumerable hand you dozens of methods in exchange for implementing just one or two.

Implement the single <=> ("spaceship") method — which returns -1, 0, or 1 like Pascal's CompareTo — then include Comparable, and Ruby gives your class <, <=, ==, >, >=, between?, clamp, and array min/max/sort for free. This is the payoff of mixins: a little protocol unlocks a large, consistent interface.

Ruby has no enumerated type. The idiomatic substitute is a set of symbols — :red, :green, :blue — which are self-documenting, comparable, and usable as case labels. You lose the compiler's guarantee that a variable holds only a declared value, and there is no built-in Ord; if you need ordinal positions, store the symbols in an array and use index.

When you need enum members with explicit integer values — Pascal's (Low = 1, ...) — group plain constants inside a module, which provides a namespace. You reach them with :: (Priority::HIGH), the scope-resolution operator. This is just integers with names, so there is no type safety, but it reads clearly and keeps the names from polluting the global scope.

Ruby's begin/rescue/end is the counterpart to Pascal's try/except/end. raise matches Pascal's raise; given a bare string it creates a RuntimeError with that message. The rescue => error clause binds the exception object, whose .message holds the text — directly analogous to on E: Exception do and E.Message.

Multiple rescue clauses match by exception class, most specific first, exactly like Pascal's stacked on E: SomeType do handlers. A bare rescue with no class catches StandardError (the everyday base class) — not every possible error, which protects you from accidentally swallowing signals and exits. Ruby's exception hierarchy parallels Pascal's, with StandardError playing the role of Exception.

Ruby's ensure is Pascal's finally: its body runs whether the protected code succeeds or raises. Because Ruby manages memory, ensure is needed less often than Pascal's finally — there is no Free to guarantee — but it remains essential for closing files, releasing locks, and other non-memory cleanup. Note ensure can attach directly to a method body, without an explicit begin.

A custom exception is just a class that inherits from StandardError (Pascal subclasses Exception). The raise ValidationError, "message" form constructs the exception and sets its message in one step. Defining domain-specific exception classes — and rescuing them precisely — works the same in both languages; only the base class name differs.

This is the philosophical heart of the difference. Pascal binds a parameter to a type and accepts only that type or its descendants; sharing behaviour across unrelated classes requires a common base class or interface. Ruby asks no such question — announce calls thing.speak and works for any object that responds to speak, related or not. "If it walks like a duck and quacks like a duck, it is a duck."

Ruby objects are fully introspectable at run time. You can ask any object for its .class, whether it .respond_to? a method, whether it .is_a? some class, or for the entire list of .methods it understands. Pascal has RTTI, but it is comparatively limited and verbose; the casual, everywhere-available reflection Ruby offers is a different category of capability, and it is what makes duck typing safe to rely on.

Ruby classes are open: you can reopen any class — even a built-in like Integer or String — and add or replace methods at run time. Suddenly every integer in the program has a factorial method. Pascal classes are sealed once compiled (class helpers offer a constrained, scoped imitation). This power demands restraint — carelessly patching core classes is the much-warned-about "monkey patching" — but it underlies much of Ruby's expressiveness, Rails included.

When you call a method an object does not define, Ruby invokes method_missing with the method name and arguments — a hook that lets an object respond to messages it was never explicitly given, here turning arbitrary config.anything = x into hash storage. Pascal resolves every call at compile time and has nothing comparable. This run-time method dispatch is how Rails conjures methods like find_by_email that no one ever wrote.

Ruby's gets reads one line from standard input — but unlike Pascal's ReadLn it keeps the trailing newline, so the idiom is gets.chomp to strip it. print writes without a newline (use it for prompts); puts adds one. This example cannot run in the browser, since there is no console to type into.

Pascal's file workflow is a four-step ritual: AssignFile, Rewrite, write, CloseFile — with a finally to guarantee the close. Ruby collapses this into File.open(name, "w") do |file| ... end: the block receives the open file and Ruby closes it automatically when the block exits, even on an exception. This block-with-cleanup pattern is everywhere in Ruby. (File I/O is unavailable in the browser sandbox.)

Reading collapses just as dramatically. File.read returns the entire file as one string; File.foreach streams it line by line for large files; File.readlines returns an array of lines. None require the explicit Reset/Eof/ReadLn/CloseFile loop Pascal needs — and each closes the file for you. (This example is marked non-runnable because the browser has no filesystem.)