Ruby.CodeCompared.To/Pony

Every Pony program begins with an actor Main that has a new create(env: Env) constructor — this is the entry point. The env.out.print method writes a string followed by a newline, like Ruby's puts.

Pony statements inside a constructor or method are separated by newlines (no semicolons needed). Each env.out.print call adds a newline, like Ruby's puts.

env.out.write outputs text without a trailing newline, like Ruby's print. env.out.print appends a newline, like Ruby's puts. Both accept any ByteSeq, which includes string literals.

In Pony, env.out.print requires a string — numbers must be converted with .string(). Ruby's puts calls .to_s automatically; Pony requires the conversion to be explicit.

Pony has no string interpolation syntax. Instead, strings are built with the + concatenation operator, and non-string values must be converted with .string() first. This is more verbose than Ruby's #{...} but completely type-safe.

let creates an immutable binding — the variable cannot be reassigned after its initial value is set. This is analogous to frozen strings in Ruby 4.0: once bound, the reference cannot change. Attempting to reassign a let variable is a compile-time error.

var creates a mutable binding whose value can be reassigned. In Pony, let is preferred for values that never change; var signals intentional mutability. The distinction is enforced by the compiler.

Pony requires explicit type annotations on local variable declarations (though inference is available in some contexts). Comments use // rather than #. Pony's type system is static and checked entirely at compile time — there are no runtime type errors.

Pony has first-class tuple types written as (Type1, Type2). Tuple elements can be accessed by index with ._1, ._2, etc., or destructured in a single assignment. Unlike Ruby arrays, tuples are a distinct typed construct in Pony.

Pony uses underscores for multi-word identifiers, just like Ruby. Variable names must start with a lowercase letter (or underscore). Names beginning with an underscore are conventionally private — _count signals a field intended for internal use only.

Pony has distinct numeric types for different sizes and signedness: I8, I16, I32, I64, I128 for signed integers; U8, U16, U32, U64, U128 for unsigned; and F32, F64 for floating-point. Ruby unifies these into a single Integer type.

Type conversions in Pony are explicit method calls: .f64() converts to 64-bit float, .i64() converts to 64-bit signed integer, .u64() to unsigned, etc. Pony never coerces types silently — any mismatch is a compile error.

Pony uses the words and, or, and not for boolean logic — not &&, ||, and !. Both and and or are short-circuit operators. The xor keyword is also available for exclusive-or.

Pony has no nil. Instead, None is a real type — every value has a definite type and None cannot appear where another type is expected. Optional values use union types like (String val | None), and the compiler forces you to handle both cases via match.

String concatenation uses + in both Ruby and Pony. String literals in Pony are immutable (String val), which mirrors Ruby 4.0's frozen strings. Concatenation always returns a new string.

Pony uses .size() (returns USize) where Ruby uses .length or .size. Case conversion uses .upper() and .lower() instead of Ruby's .upcase and .downcase.

Pony's .contains(substring) checks whether a substring appears anywhere in the string, like Ruby's .include?. The .at(substring, offset) method checks whether the string matches at a specific byte offset — it returns true only if the substring starts exactly at that position.

Pony's .trim(from, to) returns a substring by byte offset, where from is inclusive and to is exclusive. Called with only one argument (.trim(from)), it returns the rest of the string from that offset. This is a lower-level operation than Ruby's [] — Pony works with bytes, not characters.

Pony's recover block creates an iso (exclusively owned) mutable string — you can build it up with .append() inside the block, then consume transfers ownership to the caller. This is Pony's safe alternative to a mutable string variable shared across scope boundaries.

Pony array literals use semicolons to separate elements (not commas). Element access with (index)? is a partial operation — the ? marks it as capable of failing (out-of-bounds), so it must be used inside a try block. The type annotation specifies the element type, e.g., Array[I64].

Mutable arrays use the ref reference capability. .push(value) appends an element, and .pop()? removes and returns the last element — the ? marks it as partial because the array might be empty. Both Ruby and Pony arrays grow dynamically.

Pony iterates arrays with for element in array.values() do ... end. The .values() call returns an iterator over the elements. There is no built-in .each with a block — Pony uses for loops for iteration. Higher-order operations like map and filter require manual loops.

Pony's Map[Key, Value] is in the collections package, imported with use "collections". Values are set with map(key) = value syntax and retrieved with map(key)? — the ? marks the access as partial because the key might not exist. Ruby's hash access raises KeyError for missing keys by default.

Pony tuples are typed heterogeneous groupings — (I64, String val) is a different type from (String val, I64). Tuple elements are accessed with ._1, ._2, etc. (1-indexed). Unlike Ruby arrays, Pony tuples are a distinct compile-time construct with fixed size and element types.

Pony's if/elseif/else/end is structurally similar to Ruby's, with two differences: then is required after the condition (like Ruby's then keyword, which is rarely used), and branches are closed with end rather than a standalone end after each branch.

Like Ruby, Pony's if is an expression that returns the value of the chosen branch. Every branch must return the same type (or a subtype). This makes if usable directly in assignments and function return positions without needing a separate variable or ternary operator.

Pony's while ... do ... end maps directly to Ruby's while ... end. The do keyword is required in Pony. Note that Pony has no += operator — mutation must be written as count = count + 1.

Range[I64](start, end) from the standard library creates an iterable range — the end is exclusive, so Range[I64](1, 6) produces 1 through 5. For array iteration, .values() returns an iterator. Pony's for loop uses do ... end like while.

Pony's repeat ... until condition end executes the body at least once before checking the condition, like Ruby's begin ... end until. This guarantees one execution even when the condition starts true.

Pony's match expression works like Ruby's case/when. Multiple patterns in a single branch use | as a separator (different from Ruby's comma). The else clause handles any unmatched cases. Pony's match is exhaustiveness-checked at compile time.

Pony match patterns can include guards with if condition. The let s: I64 part binds the matched value to a new name inside the pattern — necessary when the guard needs to reference the value. Guards are evaluated in order; the first matching pattern wins.

Like Ruby's case, Pony's match is an expression that returns the value of the matched branch. All branches must return values of compatible types. This allows match to be used directly on the right-hand side of a let or var binding.

Pony match can dispatch on union types — matching I64 or String val in a single expression. The type annotation in the pattern (let n: I64) both checks and binds the value. This is Pony's replacement for Ruby duck typing: the compiler guarantees that all union members are handled.

Functions in Pony are defined with fun inside a class or actor. The return type is declared after the parameter list. A function always returns the value of its last expression — there is no explicit return keyword (though return value is valid for early returns). By default, fun takes the receiver as box (readable but not writable).

Pony supports default parameter values, just like Ruby. Parameters with defaults must come after those without defaults. Default values are evaluated at the call site, not when the function is defined.

Pony supports recursive fun calls directly — a function can call itself without any special annotation (unlike OCaml's let rec). The last expression in each branch is the returned value, making this pattern clean and idiomatic.

Pony lambdas use curly-brace syntax: {(params): ReturnType => body}. They are called with () like a regular function call, not with .call(). Lambdas are first-class values with their own reference capability determined by what they capture.

Higher-order functions in Pony accept lambdas as parameters using the lambda type syntax: {(ParamType): ReturnType} val. The val capability means the lambda is immutable and can be freely shared. This is the functional equivalent of Ruby's Proc or lambda objects.

Pony classes declare all fields at the top with let (immutable) or var (mutable). The constructor uses a prime-suffix convention for parameters (name') to avoid shadowing the field name. Objects are created with ClassName(args) — no .new needed.

Methods that modify fields must be declared fun ref — the ref receiver capability signals that the method may mutate the object. Read-only methods use plain fun (which defaults to box receiver). The compiler rejects any mutation attempt in a non-ref method.

Pony classes can have multiple named constructors — any new method is a constructor. This is cleaner than Ruby's class-level factory methods: Point.origin() calls the named constructor directly. Each constructor must initialize all let fields.

Pony has no class inheritance. The composition-over-inheritance principle is enforced by the language: code reuse happens through trait (nominal subtyping with optional default implementations) and interface (structural subtyping). This eliminates the fragile-base-class problems common in deep Ruby inheritance hierarchies.

A Pony trait is like a Ruby module mixed in with include: classes opt in with is TraitName and can inherit default method implementations. Traits use nominal subtyping — a class must explicitly declare is Greetable to be recognized as one.

A Pony interface uses structural subtyping: any class that has matching method signatures automatically satisfies the interface — no explicit declaration needed. This is Pony's formalization of Ruby's duck typing, but checked at compile time. Both trait and interface are abstract; only classes and actors hold data.

Pony classes can implement multiple traits using the & conjunction syntax: is (Walkable & Swimmable). This is equivalent to Ruby's multiple include calls. The compiler verifies that all required methods are implemented.

A Pony actor is like a class but runs concurrently and has a mailbox for message passing. be (behavior) methods are the asynchronous entry points — calling counter.increment() sends a message to the actor's mailbox rather than blocking the caller. Actors are Pony's primary concurrency primitive.

fun methods on classes are synchronous and return values directly — the caller waits for the result. be behaviors on actors are asynchronous — the caller sends a message to the actor's mailbox and continues immediately without waiting. This distinction is fundamental to Pony: actors communicate only by sending behaviors, never by synchronous calls.

Actor state is completely isolated — no other actor or thread can read or write _balance directly. All mutations happen through behaviors (messages), processed one at a time in the actor's mailbox. This eliminates data races without any locks or mutexes — the Pony runtime guarantees safety at compile time.

actor Main with new create(env: Env) is mandatory — it is Pony's entry point, analogous to Ruby's top-level execution context. The env parameter provides access to standard I/O streams, command-line arguments (env.args), and environment variables (env.vars).

Reference capabilities are Pony's unique compile-time mechanism for safe concurrency. Every reference has one of six capabilities: iso (exclusively owned), val (immutable, shareable), ref (mutable), box (readable), tag (identity only), or trn (transition). The compiler rejects any sharing that could cause a data race.

A val reference guarantees that the object is globally immutable — no alias, anywhere, can ever modify it. This makes val objects safe to share between actors with no locking. String literals in Pony are String val by default, mirroring Ruby 4.0's frozen-by-default strings.

A ref reference is the default for class instances — it allows both reading and writing. The trade-off is that ref objects cannot be sent to other actors: only one actor may hold a writable reference to a mutable object at a time. The compiler enforces this at compile time with no runtime overhead.

An iso (isolated) reference guarantees exclusive ownership — no other alias to the object exists anywhere in the program. recover creates an iso from mutable operations inside a temporary scope. consume transfers ownership and invalidates the original variable — the compiler prevents any use after the transfer.

All actor references are tag — the lowest capability, providing identity (you can compare actors for equality and send them behaviors) but no ability to read or write fields. This is why actor state is perfectly isolated: outsiders literally cannot access it through the type system. The tag type annotation is usually omitted since it is the implicit type for all actor references.

The ? suffix on a function signature marks it as partial — it may fail. Callers must either use try/else or propagate the failure with ?. The error keyword raises the failure. This is a more explicit and composable alternative to Ruby's exception-raising conventions.

Pony's try ... else ... end is the equivalent of Ruby's begin ... rescue ... end. The else block runs only if any partial call (?) within the try block fails. Unlike Ruby exceptions, Pony errors carry no message or stack trace — they are purely a control flow signal.

Pony's then clause (after else) is equivalent to Ruby's ensure: it always executes regardless of whether the try block succeeded or failed. This is the standard pattern for cleanup operations like closing resources. The full form is try ... else ... then ... end.

The ? operator on a call site propagates a failure upward if the callee fails — similar to how Ruby exceptions propagate automatically up the call stack. In Pony, propagation is explicit: every call to a partial function must either handle the error with try or propagate it with ?.

Pony's idiom for optional values is a union type: (ValueType | None). The compiler forces you to handle both cases explicitly via match. This is safer than Ruby's nil returns because an unhandled None is a compile error, not a runtime NoMethodError.