Pascal.CodeCompared.To/Rust

println! is a macro (note the !), not a function. Unlike Pascal's writeln, it can accept any type implementing Display — no format-string types like %s or %d. Rust uses {} as the universal placeholder.

Cargo is Rust's integrated build system and package manager — like Free Pascal's FPC combined with a unit library registry. Cargo.toml declares dependencies; cargo build downloads and compiles them automatically from crates.io. No pkg-config, no vendoring.

Rust uses {variable_name} or {:.2} format specifiers directly in the format string. No uses SysUtils required — string formatting is built into the language macro system. Identifiers can appear inline: {name} is equivalent to {0} with the name variable.

Rust bindings are immutable by default — let without mut is a read-only binding. This is the opposite of Pascal, where every var is mutable. Immutability by default helps the compiler eliminate data races and often enables optimisations.

Rust's integer types spell out the size and signedness explicitly: i8, i16, i32, i64, i128 (signed), and u8–u128 (unsigned). isize/usize match the pointer width. The default inferred integer type is i32. Rust allows underscores in literals (1_000_000) for readability; Free Pascal 3.2.2 does not, so the Pascal side writes the digits unbroken.

Rust has f32 and f64 — matching Pascal's Single and Double. The default inferred float type is f64. Rust does not have Pascal's Extended (80-bit); use f64 for maximum precision.

Rust uses &&, ||, and ! for boolean operators — the same as C, unlike Pascal's and, or, and not. Rust's bool is a true 1-byte type; unlike C, Rust's if requires a bool — an integer is never truthy.

Rust's type inference is much more powerful than Free Pascal's: types are inferred from context across the entire function, including from how a variable is used later. Explicit type annotations are needed only when inference is ambiguous — usually for numeric literals that could be multiple types.

Rust constants require an explicit type annotation and are evaluated at compile time. They can be defined at module scope (outside functions), unlike Pascal's constants which also live at module scope. Rust also has static for values with a fixed memory address — use const for pure values.

Rust has two string types: &str is a borrowed slice (like a view into bytes) and String is an owned, heap-allocated buffer. Pascal's String corresponds to String; string literals in Rust are &str. Both types are always valid UTF-8.

The + operator works on String (it consumes the left operand), but format! is clearer and handles any mix of &str and String. For building strings incrementally, push_str appends without allocating extra memory.

Rust's string methods mirror Pascal's SysUtils functions but are method calls on the value. find returns Option<usize> (a byte offset, not a character position), reflecting Rust's UTF-8 safety. unwrap_or(0) extracts the value or a default — no crash if the substring is absent.

Rust's split returns a lazy iterator — no intermediate array is allocated. The iterator yields &str slices pointing into the original string. To collect into an owned Vec<&str>, call .collect() on the iterator.

Vec<T> is Rust's dynamic array — equivalent to Pascal's dynamic array but with a typed API. push appends, len() returns the count. Indexing with [] panics on out-of-bounds in debug builds and is checked in release builds too (unless you use get for safe access).

Rust fixed arrays are 0-indexed (unlike Pascal's 1-indexed), and the size is part of the type: [i32; 5] is a distinct type from [i32; 6]. Fixed arrays live on the stack. Iterate with &array to borrow elements rather than move them.

HashMap is in the standard library's std::collections module — a single use statement brings it in. No manual Free needed: the map is dropped when it goes out of scope. Accessing a missing key with [] panics; use .get(key) for safe access returning Option<&V>.

Pascal's built-in set of type is a compact bitset — elegant for small finite domains. Rust's HashSet works on any hashable type and any size, but is heap-allocated. Set operations use intersection, union, and difference — iterator methods, not operators.

Rust's ownership system tracks every heap allocation at compile time. When a value's owner goes out of scope, the compiler inserts a drop call automatically — no try/finally/Free pattern required. This is deterministic cleanup with zero runtime overhead, unlike a garbage collector.

Assigning a String to another variable moves ownership — the original binding becomes unusable. This prevents double-free bugs. To keep a copy, call .clone(). Primitive types like i32 and f64 implement Copy and are always copied, just like Pascal integers.

The & prefix creates a reference — a borrow of the value without transferring ownership. The function receives a read-only view; the caller retains ownership. &str accepts both &String and string literal &str — it is the general borrowed string type.

Box<T> is the Rust equivalent of a Pascal typed pointer (^T). It puts a value on the heap and owns it — no Dispose needed. Option<Box<Node>> replaces nullable PNode pointers: None is the safe equivalent of nil.

Rust structs and Pascal records are conceptually identical: named fields with types, stack-allocated by default. The main syntax differences: Rust uses struct, fields use commas not semicolons, and the type annotation comes after a colon. Rust structs are value types that move on assignment (unless they implement Copy).

Rust's impl block attaches methods to a struct. &self is a borrowed reference to the instance — the Rust equivalent of Pascal's implicit first parameter in object procedures. Methods are called with dot notation: rect.area(). The data definition and methods are separate, allowing methods to be added in multiple impl blocks.

The convention in Rust is an associated function named new (not a special language keyword). Self is an alias for the struct type inside impl. The shorthand Point { x, y } avoids repeating the field name when the variable name matches — called field init shorthand.

Rust's match must be exhaustive — if you forget a variant, it's a compile error. The #[derive(Debug)] attribute auto-generates a debug formatter so you can print enum values with {:?}. Variants are namespaced: Direction::North, not bare North.

Rust's enum variants can hold data — this is the modern, type-safe replacement for Pascal's variant records. The key difference: the compiler ensures you only access radius when the variant is Circle. In Pascal, nothing prevents reading shape.width when kind is shCircle — undefined behaviour.

Rust's match uses inclusive range patterns 90..=100 (note the =), matching Pascal's 90..100. The _ wildcard is the Rust equivalent of Pascal's else in a case statement. match is an expression that returns a value — no need for a separate variable and assignment.

Option<T> replaces nullable pointers. None is the safe equivalent of nil — but the compiler forces you to handle it before you can use the value. There is no null dereference in safe Rust. The if let syntax is shorthand for a one-branch match.

Result<T, E> is the Rust replacement for out-parameters and error codes. Ok(value) carries a success value; Err(error) carries the error. The compiler forces you to handle both cases — forgetting to check is a compile warning, not a silent bug. This is Rust's primary error-handling mechanism.

Rust has no exceptions. Errors are returned as Result values — they are explicit in every function signature. This makes error paths visible and prevents silent exception propagation. For truly unrecoverable errors (bugs, not expected failures), Rust has panic!, which unwinds the thread.

The ? operator short-circuits a function on Err: it either unwraps Ok(value) into value, or returns Err(e) immediately. This gives explicit, composable error propagation without exception machinery. The pattern reads as "try each step; bail out if any fails."

Rust closures are anonymous functions written with |params| body syntax. Unlike Pascal's nested functions, closures capture variables from their enclosing scope — factor is accessible inside the closure. Closures can be stored in variables, passed to functions, and returned from functions.

Rust iterators are lazy — map produces no values until consumed. .collect() drives the iterator to completion and gathers results into a Vec. The type annotation on doubled tells collect what container to build. This pattern replaces Pascal's explicit index loops.

filter keeps only the elements for which the closure returns true. Combining filter and map — filter_map, or chaining — replaces most hand-written accumulation loops. Iterator adapters compose: .iter().filter(...).map(...).collect() is a single lazy pipeline.

sum() and max() are common terminal operations on iterators. For a custom reduction, use .fold(initial, |accumulator, value| ...). max() returns Option<&i32> because an empty iterator has no maximum — unwrap() assumes it is non-empty.

Rust traits are like Pascal/Delphi interfaces — they define a contract that types implement. The key difference: trait implementations are explicit (impl Describable for Car), not declared in the type definition. &dyn Describable is a trait object — a pointer to any type implementing the trait, used for dynamic dispatch.

Rust generics use the same <T> syntax as Pascal's generic units. Trait bounds constrain what types are allowed: fn largest<T: PartialOrd>(list: &[T]) -> T restricts T to comparable types. The compiler monomorphises generics — one compiled version per concrete type used, with zero runtime overhead.

The #[derive(...)] attribute auto-generates trait implementations. Debug enables {:?} printing; Clone enables .clone(); PartialEq enables ==. This replaces the boilerplate Pascal requires for every record type. You can still implement traits manually for custom behaviour.

Rust modules can be inline (inside a file) or in separate files. A module in its own file is at src/math_utils.rs and declared with mod math_utils; in src/main.rs. The pub keyword controls visibility — like Pascal's interface section. Names not marked pub are private to the module.

Rust's use statement imports a single name (or glob with ::*), unlike Pascal's uses which imports an entire unit. Many standard types (Vec, String, Option, Result) are in the implicit prelude and need no use. Explicit imports make dependencies visible and avoid name collisions.