Ruby.CodeCompared.To/D

Every D program needs a main() function as the entry point and must import std.stdio to use writeln. Unlike Ruby, D is a compiled, statically-typed language — there is no top-level script mode. The import statement is roughly equivalent to Ruby's require.

D's output family mirrors Ruby's: write() omits the newline (like Ruby's print), writeln() appends one (like puts), and writefln() formats like C's printf but adds a newline. The f variants use C-style format specifiers: %d, %s, %f, %.2f.

D does not have Ruby-style string interpolation (#{}). Instead, use writefln() for direct formatted output or format() from std.format to build a formatted string. D 2.x does have experimental string interpolation via i"..." literals, but it is not yet stable — format() is the idiomatic approach.

D has three comment styles: // for single-line (like Ruby's #), /* ... */ for block comments (like most C-family languages), and the unique /+ ... +/ style which supports nesting. Nested comments are useful for commenting out large code blocks that already contain comments — something /* */ cannot do.

D's writeln() accepts any number of arguments and prints them all consecutively without separators. Passing an array prints it in [1, 2] notation. This is more flexible than Ruby's puts, which calls .to_s on one argument and prints each array element on its own line.

D's auto keyword infers the variable's type at compile time from the right-hand side — similar in feel to Ruby's implicit typing, but resolved at compile time rather than at runtime. The typeof() intrinsic returns the compile-time type; .stringof gives its name as a string. Once assigned, an auto variable has a fixed type that cannot change.

D's core integer types are int (32-bit), long (64-bit), uint, ulong, and smaller variants. Floating-point types are float (32-bit), double (64-bit), and real (80-bit on x86). Numeric literals accept underscores as separators — the same convention Ruby uses.

immutable means the value can never change and is safe to share across threads without locking — stronger than Ruby's freeze. const means the current variable cannot modify the value, but something else might (like a non-const alias). In practice, prefer immutable for true constants. Note that D's string type is immutable(char)[] — strings are immutable by default, which matches Ruby 4.0's frozen string behavior.

D's typeof(expr) returns the compile-time type of an expression, and is(T == U) checks type equality at compile time. These are compile-time constructs, not runtime reflection — the check happens during compilation, not execution. For runtime type checking on class hierarchies, D uses cast(T) which returns null on failure.

D's primitive types (int, double, etc.) cannot be null — they always have a value. Nullable!T from std.typecons wraps any type to add an optional absent state, similar to Haskell's Maybe or Rust's Option. This is more explicit than Ruby where any variable can be nil. D class references can be null, following C++ conventions.

D's string type is an alias for immutable(char)[] — a slice of immutable UTF-8 bytes. The .length property returns the byte count, not the Unicode character count (the same distinction Ruby draws between .bytesize and .length). Because strings are immutable slices, string operations typically return new slices rather than modifying in place.

D uses 0-based indexing like Ruby. Slices use start..end where the end is exclusive (not inclusive like Ruby's 1..3). The $ symbol inside index brackets refers to the length of the array or string — so word[$-1] is the last character, equivalent to Ruby's word[-1].

D uses the ~ operator for concatenation and ~= for append-in-place — analogous to Ruby's + and <<. The tilde is D's dedicated concatenation operator, keeping + strictly for numeric addition. join() from std.array works identically to Ruby's Array#join.

std.string provides the most common string operations. Note that UFCS (Universal Function Call Syntax) lets you write message.toUpper instead of toUpper(message) — making free functions feel like methods, similar to Ruby's method call style. indexOf() returns -1 when not found, so checking >= 0 replaces Ruby's .include?.

split() and strip() from std.string are direct equivalents of Ruby's .split and .strip. D's split() returns a string[] (dynamic array of strings). UFCS makes the call chain readable: " hello ".strip is strip(" hello ") written in method-call style.

std.conv.to!(T) is D's universal conversion function — it converts between any two compatible types, including string-to-numeric and numeric-to-string. The ! is D's template argument syntax: to!int("123") means "call to with type parameter int". UFCS lets you write this as "123".to!int, which reads exactly like Ruby's "123".to_i.

D dynamic arrays (T[]) use the same [...] literal syntax as Ruby. Unlike Ruby arrays, D arrays are homogeneous — all elements must be the same type. The type is inferred from the elements if you use auto. Dynamic arrays in D are reference types backed by a garbage-collected heap, not value types — assigning one to another creates a reference, not a copy.

D uses ~= to append to an array (like Ruby's << or .push) and ~ to concatenate two arrays (like Ruby's +). The ~ operator is consistent: it concatenates arrays just as it concatenates strings. There is no separate push method — ~= is the idiomatic way to append a single element.

D slice syntax array[start..end] is end-exclusive (Python-style), so numbers[1..4] gives elements at indices 1, 2, and 3 — equivalent to Ruby's numbers[1..3]. Slices are zero-copy views into the original array — they share the same memory. Modifying a slice element also modifies the original unless you call .dup first.

sort() from std.algorithm sorts in place and requires a mutable (non-slice) array — .dup creates a copy first. sum() works directly on any numeric range. UFCS makes these read like Ruby method calls. Note that sort in D returns a special SortedRange type which reverse can then operate on.

D's T[N] is a static array — size is fixed at compile time and the data lives on the stack, not the heap. sizeof returns the byte size (here, 5 × 4 bytes = 20). Static arrays are value types — assigning one to another copies all the data. They are more efficient than dynamic arrays for small, fixed-size collections, unlike Ruby which has only one array type.

iota(start, end) from std.range generates a lazy integer range (end-exclusive), equivalent to Ruby's (start...end).to_a. The three-argument form iota(start, end, step) mirrors Ruby's .step(). .array materializes the lazy range into a concrete int[] — equivalent to Ruby's .to_a. Most functions accept lazy ranges directly without materializing.

map! from std.algorithm transforms each element — identical in purpose to Ruby's .map. The ! after map is D's template instantiation syntax (not "bang" or mutation — D mutation methods use no special naming). UFCS lets you write numbers.map!(n => n * 2) even though map is a free function in std.algorithm, not a method on arrays.

filter! is D's equivalent of Ruby's .select — it keeps elements for which the predicate returns true. Like all std.algorithm functions, it returns a lazy range, so the actual filtering is deferred until you iterate or call .array. This lazy evaluation is a performance advantage: chaining filter! and map! makes a single pass, not two separate allocations.

reduce! from std.algorithm folds a range left, equivalent to Ruby's .reduce or .inject. The accumulator starts as the first element if no seed is given. D also provides fold! which accepts an explicit seed: fold!((sum, n) => sum + n)(numbers, 0). For simple operations, sum(numbers) and numbers.minElement / numbers.maxElement are more direct.

D's range pipeline composes lazily, just like Ruby's Enumerator chain. The chain filter! → map! → filter! makes a single pass through the data — no intermediate arrays are allocated until .array is called at the end. This is equivalent to Ruby's lazy enumerator (.lazy.select.map.first(n)) but is the default behavior in D, not an opt-in.

find() returns a range starting at the found element (or empty if not found); checking .empty is the idiomatic "exists" test. any! and all! correspond directly to Ruby's .any? and .all?. All of these live in std.algorithm and accept lazy ranges as well as concrete arrays.

zip() from std.range pairs elements from two or more ranges, equivalent to Ruby's .zip. D's foreach supports index-and-value iteration directly — foreach (index, value; collection) is the idiomatic equivalent of Ruby's .each_with_index, with no need for a separate enumerate() call.

D's associative arrays use the type syntax ValueType[KeyType] — note the reversed order compared to what most languages use. The literal syntax ["key": value] uses a colon separator like Ruby's "key" => value hash rockets. Unlike Ruby, D's associative array type is homogeneous — all keys and all values must be the same type.

The in operator returns a pointer to the value if the key exists, or null if not — truthy/falsy like Ruby's .key? but with direct value access. .get(key, default) is equivalent to Ruby's Hash#fetch(key, default). Accessing a missing key with [] throws a RangeError in D, unlike Ruby which returns nil.

D's foreach (key, value; assocArray) destructures key-value pairs directly — identical in structure to Ruby's .each do |key, value|. The .keys and .values properties return dynamic arrays. Iteration order is not guaranteed (same as Ruby's Hash before 1.9, and unlike Ruby's current insertion-ordered hash).

Assigning to a new key inserts it; assigning to an existing key updates it — identical to Ruby. .remove(key) deletes a key and returns true if it was present, false if not. There is no delete method (Ruby's name); D uses remove consistently for associative array deletion.

D uses else if (two words with a space) where Ruby uses elsif. Parentheses around the condition are required in D (unlike Ruby). Single-statement branches don't need braces — though style guides recommend always using them. D has no unless keyword; use if (!condition) instead.

D's foreach (item; collection) is the idiomatic loop — equivalent to Ruby's .each block. For integer ranges, foreach (i; start..end) iterates from start to end-1 (end-exclusive). Unlike Ruby's .each, there is no functional-style return value — foreach is a statement, not an expression.

D's while is syntactically identical to C — condition in parentheses, body in braces. Unlike Julia (which had a soft-scope issue), D's while loop body shares the enclosing function scope, so modifying countdown inside the loop modifies the outer variable as expected. D also has a do { } while (condition); form that tests the condition after the first iteration.

D's switch requires explicit break to prevent fall-through, unlike Ruby's case/when which never falls through. D also provides final switch for enum types: the compiler checks that every enum value is handled, producing an error rather than a silent default. This is equivalent to exhaustiveness checking in pattern matching languages.

D uses continue (not next like Ruby) to skip to the next iteration, and break to exit the loop — following C and most other languages' convention. D also supports labeled break and continue for nested loops: outer: foreach ... { foreach ... { break outer; } } — equivalent to Ruby's break with a label.

The ternary operator is identical in D and Ruby: condition ? value_if_true : value_if_false. This is one of the few pieces of syntax shared exactly between the two languages. In D, the ternary is an expression (returns a value), not a statement — same as Ruby, and unlike some languages that restrict it.

D functions live at module scope (outside main()), declared with return type, name, and typed parameters. The return type is required — there is no implicit typing of function signatures. void means no return value. Unlike Ruby, D's implicit last-expression return does not apply to functions; you must write return explicitly (unless using lambda assignment form for trivial functions).

Using auto as the return type tells the compiler to infer it from the return statement. This is similar in spirit to Ruby 4.0's one-liner method syntax, though still requires a function body. The compiler verifies that all return paths return the same type. auto return types work at the function level but are restricted in some contexts (virtual functions, for example, must have explicit return types).

Default argument values work identically in D and Ruby — declare them in the function signature with = value. Default parameters must come after all required parameters. Unlike Python and Ruby, D does not support calling with named arguments by default — arguments are positional only (unless using keyword argument syntax available in some metaprogramming contexts).

pure declares that a function only depends on its arguments and has no side effects — the compiler can optimize calls aggressively and the function is safe to run at compile time (CTFE). @safe restricts the function from using unsafe features (pointer arithmetic, casting, @system code). These are opt-in correctness guarantees that D provides but Ruby has no equivalent for.

D's typed variadic parameter T[] name... collects extra arguments into a typed array — equivalent to Ruby's splat (*args). The arguments must all be the same type. D also has untyped C-style variadics (... with no type) for interoperating with C, but the typed form is idiomatic D and provides full type safety.

Universal Function Call Syntax (UFCS) is D's most Ruby-like feature: any free function f(a, b) can be called as a.f(b). This means std.string.toUpper(str) and str.toUpper are identical. UFCS enables fluent method-chaining on any type without opening or monkey-patching a class — a powerful but less chaotic version of Ruby's open-class extension.

UFCS makes D's std.algorithm feel like Ruby's Enumerable — the data flows left to right through a chain of transformations. This is intentional: D's standard library is designed for UFCS chaining. The entire pipeline is lazy and evaluated in a single pass when .sum consumes it — more efficient than Ruby's eager intermediate arrays.

UFCS lets you "add methods" to any type by writing a free function whose first parameter is that type. This is safer than Ruby's open classes: the function is only available in modules that import it, and it cannot accidentally override existing behavior. 5.factorial calls factorial(5) — no class reopening, no module_function, no refine.

D's lambda syntax (params) => expression is concise and directly analogous to Ruby's ->(x) { }. For multi-statement lambdas, use (params) { body; return value; }. Lambdas are called with regular parentheses — no .call needed. Inline lambdas inside map! do not need to capture outer variables.

D closures capture outer variables by reference — modifying counter inside the closure modifies the outer counter. This is identical to Ruby's closure behavior with blocks and lambdas. The closure type in D is called a delegate — it bundles a function pointer with a context pointer (the captured environment).

D distinguishes function pointers (no captures) from delegates (closure with captured context). A lambda that captures no outer variables compiles to a function pointer; one that captures local state is a delegate. Ruby's blocks and procs don't have this distinction — they always carry their closure.

scope(exit) runs at the end of the current scope regardless of success or failure — like Ruby's ensure. scope(failure) runs only on exception; scope(success) only on normal exit. These are placed at the resource acquisition site (near the open), not wrapped around usage — which makes the code read in acquisition order rather than requiring nesting. This is unique to D.

D's struct is a value type (stored on the stack) — assigning it to another variable copies all the data. This contrasts with Ruby's Struct, which is a reference type (class instance). D structs support member functions, constructors, operator overloading, and all OOP features except inheritance — they are not "plain C structs".

D structs can contain method definitions directly — unlike Julia where methods live outside types. The this pointer (implicit, like Ruby's self) gives access to fields. Methods on structs can also be defined externally as free functions and called via UFCS — both styles are idiomatic.

D struct constructors use this(params) (called in Ruby as initialize). The built-in assert validates preconditions and throws an AssertError in debug builds. D uses ^^ for exponentiation (not ** or ^). The constant PI is available in std.math.

D overloads operators through specially named methods: opBinary!"+" for +, opUnary!"-" for unary minus, opIndex for [], and others. The string template parameter selects which operator to handle. toString() is called automatically by writeln, equivalent to Ruby's to_s.

D classes are reference types allocated on the heap with new — Ruby's model exactly. The constructor is this() (not initialize). Fields declared in the class body are public by default, unlike Ruby's instance variables which are always private. D uses this.field to disambiguate parameter names from field names, equivalent to Ruby's @name vs name.

D uses : for inheritance (where Ruby uses <). The override keyword is mandatory when overriding a parent method — unlike Ruby, where silently redefining a method is always allowed. This prevents accidental overrides: if the parent class removes or renames a method, the compiler flags any override that no longer overrides anything.

D uses private, protected, and public access modifiers on individual members (not a section keyword like Ruby's private). By default, class members in D are public. Unlike Ruby's attr_reader/attr_writer, D has no built-in property syntax — getter and setter methods are written manually, though the @property attribute can mark them for special calling conventions.

abstract class cannot be instantiated — only its subclasses can. abstract methods must be overridden by every non-abstract subclass; the compiler enforces this. final class prevents subclassing entirely. final on a method prevents overriding in subclasses. These are compile-time guarantees that Ruby's conventions (not enforced) can only approximate.

D interfaces declare method signatures without implementations — equivalent to Ruby modules used purely as abstract interfaces. A class implements an interface by using the same : syntax as inheritance. A class can implement multiple interfaces but inherit from only one class. Unlike Ruby modules, D interfaces cannot contain state or default implementations (for that, use abstract classes).

D's mixin template injects code at the point of use — the closest equivalent to Ruby's module / include. The mixin has access to the including class's fields and methods (it becomes part of the class). Unlike Ruby modules which remain separate in the method lookup chain, D mixins are textually inlined — closer to Ruby's prepend or a language-level copy-paste.

alias this designates a field (or method) as the implicit conversion target — when a Celsius is used where a double is expected, D automatically uses the degrees field. This is analogous to Ruby's to_str / to_int implicit conversion protocol but works at compile time and applies to all types uniformly, not just a special few methods.

D's try/catch/finally maps directly to Ruby's begin/rescue/ensure. The exception is accessed via a typed variable — catch (Exception error) — rather than Ruby's rescue => error. error.msg holds the message string. D also has Error (for unrecoverable errors like AssertError) which is distinct from Exception (for recoverable errors).

D's exception hierarchy has Throwable at the root, with Error (fatal, like out-of-bounds) and Exception (recoverable) as the two branches. Array out-of-bounds throws core.exception.RangeError (an Error, not an Exception). In practice, catch Exception for recoverable errors and let Errors propagate — the same philosophy as Java's checked exceptions.

enforce(condition, message) from std.exception throws an Exception if the condition is false — a compact replacement for if (!cond) throw new Exception(msg). This is equivalent to Ruby's guard clauses (raise ... unless condition) but as a function call. enforceEx!MyException(cond, msg) throws a specific exception type.

scope(failure) runs only when an exception propagates out of the scope — it is placed at the resource acquisition site and handles only the error path, unlike ensure which always runs. This makes intent clearer: scope(exit) = "always clean up", scope(failure) = "clean up on error only", scope(success) = "post-process on success". All three can coexist in the same scope.

D's contract programming is a first-class language feature: in blocks declare preconditions (what must be true when the function is called), out(result; ...) declares postconditions (what must be true about the return value). Contracts are checked in debug builds (dmd default) and elided in release builds (dmd -release). This is design-by-contract from Eiffel, built into the language — not a testing framework.

D's template syntax T maximum(T)(T a, T b) reads as "a function named maximum with type parameter T, taking two T arguments". The compiler generates a specialized version for each type used. Unlike Ruby's duck typing (resolved at runtime), D's templates are monomorphized at compile time — every type combination gets its own optimized machine code.

Generic structs use the same (T) template parameter syntax as functions. Stack!int instantiates the template for int — the ! is D's template argument operator. size_t is the platform-native unsigned integer type (like C's size_t), appropriate for sizes and array indices. Attempting Stack!int.push("hello") is a compile error.

D's enum with a value expression runs the right-hand side at compile time — this is CTFE. Any pure function can be used in a enum or static context and will execute during compilation. The result is baked into the binary as a literal constant. static assert verifies the value at compile time — if the assertion fails, it is a compile error, not a runtime error. Ruby constants are evaluated once at parse time but are not true compile-time constants.

static if evaluates its condition at compile time and includes only the matching branch in the compiled code — the other branches are not compiled at all. This is how D implements conditional compilation without preprocessor macros. When combined with templates, static if enables compile-time polymorphism: the compiler generates different code for each type, with zero runtime overhead for the type dispatch.

unittest blocks are a built-in D language feature — no test framework import required. They live next to the code they test and run automatically before main() when compiled with -unittest (which this runner does). If any assertion fails, the program aborts before reaching main(). This zero-friction testing model encourages inline tests, similar to Rust's #[test] attribute.