Ruby.CodeCompared.To/Roc

Ruby scripts start executing at the first line; a Roc program starts at main!, a function receiving the program arguments. The ! suffix on main! and echo! marks them as effectful — Roc tracks purity in the type system, a theme this page returns to. Ok({}) is the success return value: {} is the empty record, Roc's equivalent of returning nil from a method that exists only for its side effects.

This is the most foreign idea in Roc for a Rubyist. Ruby ships File, Net::HTTP, and Thread in the standard library, and any line of any method may use them. A Roc program cannot perform any I/O on its own: it is embedded by a platform — a host written in another language — and the platform decides exactly which effects exist. This page runs your code on the minimal "echo" platform, whose only effect is echo!. The upside is that a platform can make hard guarantees: a Roc plugin literally cannot touch the filesystem unless its host offers that effect.

Ruby signals failure by letting an exception escape; Roc has no exceptions, so main! returns a Try value instead: Ok({}) exits 0, and returning Err(SomeTag) makes the program exit with code 1. The same Ok/Err pair replaces begin/rescue everywhere — covered in the "No nil, No Exceptions" section below.

Roc uses Ruby's # comment character — one of many small choices that make Roc feel familiar. There is no equivalent of =begin/=end, which few Rubyists will miss. Doc comments use ## before a declaration.

Both languages make if an expression whose result can be assigned, and both make the last expression of a function its return value. Roc swaps elsif/end for braces, requires the branches to agree in type, and has no statements at all — there is nothing in the language that does not produce a value.

Interpolation works in every string literal in both languages — Roc just spells it ${...} instead of #{...}. The one difference that will bite: Roc interpolation accepts only Str values, with no automatic to_s conversion (see the Strings section).

Roc's Str.inspect is Kernel#p / Object#inspect: it renders any value in a readable debug format with no setup required. Note that record fields print in alphabetical order, not insertion order — records are sets of fields, not sequences like Ruby hashes.

A Ruby local variable is a name you can point at anything, as often as you like. A Roc binding is a permanent definition: name = value and it never changes. This is not a convention like Ruby's SCREAMING_CASE constants (which only warn on reassignment) — it is a compile error, with a separate opt-in syntax for the rare cases that need mutation (next row).

Ruby 4.0 finally made string literals frozen by default, after a decade of magic comments — but +"..." still unlocks a mutable copy, and arrays and hashes remain mutable everywhere. Roc goes all the way: every value of every type is immutable, so the "did some other code mutate this?" question that motivated frozen literals cannot arise for any value at all.

When you genuinely want a counter, Roc's var declares a reassignable local — and the $ sigil must appear on every use, so mutation is impossible to miss when reading code. A Rubyist's reflex may be "that looks like a global": it is the opposite, since a var is confined to the function that declares it and can never be shared. Roc also has no +=; write the addition out.

Ruby's parallel assignment and rightward hash-pattern matching both have direct Roc equivalents: tuples and records destructure on the left of =. The Roc restriction is that the pattern must be irrefutable — it can never fail — so you cannot destructure an Ok(value) this way; that requires match, because the Err case would be unhandled.

Ruby checks nothing until the moment a method call fails; Roc checks everything before the program runs — yet Roc code carries barely more annotation than Ruby, because full Hindley–Milner inference works out every type from usage. Delete the double : I64 -> I64 line and the example still compiles; the annotation is documentation the compiler verifies rather than a requirement.

Ruby's gradual-typing story (RBS files, Sorbet) keeps signatures in a parallel universe that can drift from the code. A Roc annotation is one line of the same file — name : Type above the definition — checked on every compile, and omittable wherever you would rather let inference do the work.

Roc has many number types (next section), so a literal can name its type with a dot suffix: 42.I64, 2.5.F64. The mechanism is extensible — any type with a from_numeral method can be used as a suffix, so a custom Money type could accept 19.99.Money, checked and evaluated at compile time.

Run the Roc side: the first list prints as [1.0, 2.0, 3.0]! Unconstrained number literals default to Dec — a 128-bit fixed-point decimal — not to an integer type. This surprises everyone once. Annotate the binding (or use a literal suffix) whenever the printed representation matters.

Ruby has one Integer that silently promotes to arbitrary precision. Roc asks you to pick a size — I8/U8 through I128/U128 — the price of compiling to machine integers with no interpreter underneath. Underscore digit separators work in both languages. List lengths and indices are always U64.

Ruby's float literals are IEEE 754 doubles, and exact decimal math means opting into BigDecimal with string constructors. Roc flips the default: an unconstrained decimal literal is a Dec — a 128-bit fixed-point decimal — so 0.1 + 0.2 is exactly 0.3. Hardware floats (F32/F64) are still there when you want speed, and they produce the same 0.30000000000000004 Ruby prints.

Ruby overloads / — integer operands truncate, float operands divide exactly — which is a classic beginner trap. Roc splits the two meanings into two operators: // always performs integer division, and plain / is reserved for exact division on Dec and floats, so 17 / 5 is 3.4 with no .0 coercion trick required.

The conversion-method naming convention carried straight over from Ruby — just with sizes attached: .to_i64(), .to_f64(), .to_str(). The big behavioral difference is parsing: Ruby's "abc".to_i silently returns 0, while Roc's I64.from_str returns a Try that forces you to handle the failure (here with the ?? default operator).

Ruby sidesteps overflow by promoting to bignum arithmetic at runtime. Roc's fixed-size integers can overflow — but the compiler evaluates every expression it can at compile time, so I64-max-plus-one is rejected before the program runs. Overflow that only happens at runtime crashes the program rather than silently wrapping.

Ruby interpolation quietly calls to_s on any object; Roc interpolation accepts only Str, so every number needs an explicit .to_str(). It feels noisy for a day and then becomes automatic — and it means nothing ever prints as an accidental #<Object:0x...>.

Roc has no + for strings — concatenation is the concat method, callable in method style or as Str.concat. There is also no <<, since nothing can be appended to in place; building strings from pieces is usually interpolation's job anyway.

The everyday operations all exist under slightly different names: strip is trim, "ab" * 3 is repeat, and the predicate methods drop Ruby's ? suffix — starts_with, ends_with, contains. Str.inspect renders the Bool results, since Bool has no .to_str() in the current build.

Ruby's split/join pair maps to split_on and Str.join_with(list, separator). Note that joining lives on Str rather than on the list — the reverse of Ruby's Array#join — so it is not available in method style on the list itself.

Both languages store strings as UTF-8, and the code-point escapes differ only in brackets: \u{1F680} in Ruby, \u(1F680) in Roc. Ruby offers both length (characters) and bytesize (bytes); Roc's pinned build exposes only the byte count, under the deliberately unambiguous name count_utf8_bytes() — grapheme-aware operations live in a separate unicode package.

The literal syntax is identical, but a Roc List(a) is homogeneous: every element has the same type. Where a Rubyist would mix types in one array, a Roc programmer uses a list of tags — [Count(1), Word("two"), Symbol] — which keeps the mixture fully type-checked. List is contiguous in memory like a Ruby array, not a linked list.

Squint and these are the same line: Roc's |word| ... closure syntax is Ruby's block-parameter syntax, and for_each! is each. The ! is not decoration — it marks that the closure performs effects (printing), which Roc tracks in the type system. The langref also specifies for word in words { } loops, but the pinned nightly build this page runs on rejects them; .for_each! is the working form today.

Enumerable chaining works exactly the way a Rubyist expects — map keeps its name, select is keep_if, and reject is drop_if (there is also count_if for count with a block). Thanks to compile-time reference counting, the chain mutates in place when nothing else holds the list, so the functional style does not cost a copy per step.

reduce is fold, with the same shape: an initial accumulator and a two-argument closure. Roc also ships fold_rev, fold_with_index, and fold_until (which can stop early by returning Break(value)) — covering the territory of Ruby's each_with_object and friends.

Ruby's numbers[9] returns nil, and that nil can travel far before something blows up with NoMethodError. Roc has no nil: .get(index) returns a Try, handled with match or the ?? default operator (Roc's || 0 idiom). The subscript syntax numbers[9] does not exist in the pinned build, so the unsafe path is not even available.

Ruby's bang-less sort and reverse already return new arrays, so the functional style is familiar — Roc just removes the mutating sort!/reverse! alternatives entirely. The pinned build has no comparator-free .sort(), so sort_with takes an explicit comparator returning LT/EQ/GT tags, Roc's spelling of Ruby's -1/0/1 spaceship values. reverse is abbreviated to rev.

The Enumerable predicates keep their names minus the question mark: any, all, and find_first (plus find_first_index for Ruby's index with a block). The difference is the miss case: Ruby's find hands back nil, Roc's find_first hands back a Try you must actually look at.

Where Ruby composes each_with_index with map through an intermediate Enumerator, Roc offers direct _with_index variants: map_with_index, fold_with_index, and friends. The index arrives as a U64, so interpolating it needs the usual .to_str().

The literal syntax is character-for-character Ruby's symbol-key hash shorthand, but a Roc record is closer to an anonymous Struct: fields are fixed at compile time, accessed with dot syntax instead of [:key], and a typo like point.z is a compile error rather than a silent nil.

Ruby's merge is Roc's { ..defaults, retries: 5 } spread-update syntax. Both produce a new value without touching the original. One Roc restriction Ruby does not have: the update can only replace existing fields, never add new ones — the record's shape is part of its type.

Ruby 3.2's Data.define brought immutable value objects to Ruby; Roc records are that idea as the language default. A type alias (single colon) names the shape for use in annotations. The alias is structural — any record with those fields satisfies it — where Data.define creates a distinct class. For a nominally distinct type, Roc uses := (see the "No Classes, No GC" section).

Ruby fakes tuples with two-element arrays; Roc has the real thing, with parentheses, positional .0/.1 access, and destructuring. Because a tuple's length and element types are part of its type, "forgot the second element" is a compile error instead of a nil.

Records cover Ruby's symbol-key "struct-like" hashes; for genuinely dynamic keys, Roc has Dict. Since values are immutable, insert returns a new dict — chained here — and get returns a Try, making .get(key) ?? default the equivalent of Ruby's fetch(key, default). As with lists, the compiler mutates in place when the dict is unshared.

A capitalized bare name like Morning is a tag — Roc's symbol. Like :morning, it needs no declaration and simply exists at the point of use. Unlike a symbol, the compiler infers that period has type [Morning, Afternoon] and then verifies the match handles every case — misspell Afternon in the Ruby version and you get a silent nil; in Roc you get a compile error.

Where Ruby bundles a symbol with its data in an array — [:circle, 2.0] — a Roc tag holds its payload directly: Circle(2). The function's type spells out exactly which tags it accepts and what each carries, and the match destructures the payloads, all checked at compile time. This is the workhorse pattern of Roc programs.

Ruby's missing-enum problem — validated by frozen arrays, raise, and discipline — is a one-line declaration in Roc: Color := [Red, Green, Blue] creates a nominal (named, closed) tag union. Passing anything that is not one of the three colors, or forgetting a case in match, is a compile error rather than a runtime ArgumentError.

A binary tree that takes two Data.define classes and a case/in in Ruby is a single self-referential type declaration in Roc. The compiler handles the heap allocation and reference counting behind the scenes, and the match is checked for exhaustiveness — add a Branch variant later and every match that misses it stops compiling.

Ruby 3's case/in pattern matching translates almost directly to Roc's match — in pattern then result becomes pattern => result, and else becomes _. The crucial upgrade: Ruby raises NoMatchingPatternError at runtime when nothing matches; Roc refuses to compile a non-exhaustive match in the first place.

Guards use the same pattern if condition shape in both languages. As in Ruby, a guarded branch does not count as covering its pattern, so the final catch-all is still required for exhaustiveness.

Alternative patterns use the same | separator in both languages — Ruby's pattern matching and Roc's match drew from the same well.

List patterns translate symbol-for-symbol: Ruby's splat *rest becomes Roc's .. as rest. Roc additionally proves the match exhaustive at compile time — remove the [] arm and the program stops compiling, where Ruby would raise at runtime on an empty array.

Roc has no nil — the billion-dollar mistake is simply absent, and NoMethodError for nil:NilClass cannot happen. Absence is expressed with tags: this function returns [Found(Str), Missing], and the compiler forces every caller to handle Missing. There is not even an Option type to learn; an ad-hoc union with domain-specific names usually reads better than Some/None anyway.

Roc has no exceptions, no raise, and no rescue — a fallible function returns Try(ok, err), and failure is an ordinary value: Ok(score) or Err(BadScore(text)). Nothing unwinds the stack, and nothing can be forgotten: the type signature advertises exactly what can go wrong, and the compiler makes sure callers deal with it. The error tag needs no class declaration the way ArgumentError subclassing does.

Ruby's || default idiom (and its safe-navigation cousin &.) collapses into Roc's ??: use the Ok payload, or fall back to the default on Err. Unlike ||, it cannot misfire on a legitimate false value — the classic Ruby bug where enabled = flag || true destroys an intentional false has no Roc equivalent.

Since Roc errors are return values, they do not propagate on their own — the ? suffix does it explicitly: unwrap the Ok, or return the Err to the caller immediately. It is Ruby's exception bubbling made visible, one character per hop. Here main! simply passes show_first!'s Try along as its own result.

Ruby organizes errors into class hierarchies so rescue ConfigError can catch a family at once. Roc's error tags are structural and its unions open, so errors from different functions merge automatically: a function calling two fallible helpers infers the union of both error sets, with no base classes and no raise/rescue choreography. A match can still handle specific tags and catch the rest with _.

Roc adopted Ruby's |number| block-parameter pipes as its only function syntax — every Roc function, named or anonymous, is written the way a Rubyist writes a block. And there is no & operator, because there is no block/proc divide to bridge: a function is a value, passed by name like any other argument.

Ruby has methods, blocks, procs, lambdas, and Method objects, each with its own calling convention and arity rules. Roc has exactly one callable thing. A top-level function is just a named value that happens to be a lambda — which is why its type annotation sits above it like any other value's, and why there is no .call: parentheses invoke anything.

Roc's where clause is duck typing with a compiler behind it: where [a.to_str : a -> Str] accepts any type that has a to_str method — the same "if it quacks" spirit as Ruby, except a non-quacking argument fails at compile time instead of raising NoMethodError in production. There is no interface or trait to declare; the constraint names the method directly.

Ruby's "everything except nil and false is truthy" — where even 0 and "" pass an if — has no Roc counterpart: a condition must be an actual Bool, and there is no nil to be falsy in the first place. There is also no unless, no modifier-if, and no ternary; if/else as an expression covers all of them.

Yes, the pure functional language has real while loops with break — mutation through var is confined to the enclosing function, so the compiler can allow honest imperative iteration without giving up its guarantees. Rubyists do not have to translate every loop into a fold.

The Ruby guard-clause style survives intact: Roc has a genuine return for early exits, and the final expression of a function body is its return value, exactly like Ruby's implicit return. Only the one-line modifier form (return 0 if ...) has no equivalent.

Every Rubyist knows the ! suffix means "watch out" — but it is folklore, unevenly applied and never checked. Roc turns the same visual convention into a type-system rule: a function whose body performs effects must be named with a !, and a function without one provably cannot print, mutate the outside world, or perform any I/O. Since nothing in Roc mutates in place, the "dangerous mutation" meaning disappears and only the effect meaning remains.

A Roc function type uses -> when pure and => when effectful, and a pure function cannot call an effectful one — the "surprise puts buried in a helper" of the Ruby example is a compile error in Roc. You always know from the call site whether a function can touch the outside world.

An inline expect checks a condition mid-program; if it fails, the program halts with a nonzero exit code — Ruby's raise unless idiom as a keyword. The same keyword doubles as Roc's unit-testing construct: top-level expect blocks are collected and run by roc test, playing the role of a Minitest assertion with zero framework setup.

Roc's crash is raise with no rescue anywhere: an unrecoverable abort for states that should be impossible, with the platform deciding what happens next. This row is display-only because the WASM host powering this page stops its instance on a crash (and the Ruby side's uncaught raise would likewise end with a nonzero exit). Expected failures should be Try values; crash is for bugs.

Every Rubyist has been bitten by two variables secretly sharing one mutable object — the bug that motivates all the defensive dup calls. In Roc, values are immutable, so sharing is always safe: append returns a new list and original is untouched, guaranteed. When the original's reference count is 1 the compiler mutates in place anyway, so the safety costs nothing.

Ruby discovers garbage while the program runs, pausing to mark and sweep. Roc has no garbage collector and no runtime memory manager at all: the compiler analyzes the program (the technique is called Perceus reference counting) and inserts precise allocate/free operations at compile time. Because Roc's immutable values cannot form reference cycles, the classic refcounting leak is unrepresentable.

A nominal type's trailing .{ } block holds its associated functions, and value.method(args) dispatches to them — so method chaining reads exactly like Ruby. What is missing is the object machinery: no @value instance variables (the data is just a record), no self, no inheritance, and no runtime dispatch. A "method" is an ordinary function whose first argument is the type.

Roc deliberately has no open classes, no method_missing, no define_method, and no runtime metaprogramming of any kind — every call is resolved statically at compile time. The Rails-style expressiveness this rules out is real, but so is the payoff: no action at a distance, no load-order-dependent behavior, and "jump to definition" always has exactly one answer.

The number-one surprise: Roc's unconstrained numeric literals default to Dec, so the first line prints [1.0, 2.0, 3.0]. The habit to build: annotate any binding whose value you intend to display as an integer, or suffix the literals (1.I64).

Because tags are structural, a bare False is just the tag False in an anonymous union — not necessarily a Bool — so operators like ! may fail to resolve without context. Annotate ready : Bool (or write Bool.False) and everything works. The same structural-tags superpower that gives Roc declaration-free symbols creates this one sharp edge.

The pinned build does not parse numbers[0] at all — element access is .get(index), which returns a Try. There is no negative indexing either; use .last(). Ten years of muscle memory will fight you on this one for about an afternoon.

Roc is pre-1.0 and this page pins a specific nightly compiler, so chunks of the string API a Rubyist reaches for daily are missing or renamed: no sub/gsub equivalent, no upcase/downcase/capitalize, string length is count_utf8_bytes(), and there are no regular expressions in the standard library at all. Expect this table to improve as Roc approaches its first stable release.