Lua.CodeCompared.To/Ruby

puts appends a newline like Lua's print, but it also unwraps arrays and prints each element on its own line. p is the one to reach for when debugging: it prints an inspectable form, so a string arrives with its quotes.

So Lua's print is closest to Ruby's puts, and Lua's io.write is closest to Ruby's print. p has no Lua equivalent at all: it shows the value as you would type it, which makes an empty string distinguishable from nil.

Ruby's block comment exists and is almost never seen, because =begin and =end must start at column zero and cannot be indented with the code they surround. In practice Rubyists prefix each line with #, exactly as Python programmers do.

The differences are that Ruby drops Lua's then and needs no do on a while. Both languages treat newlines as statement terminators and accept an optional semicolon that nobody writes.

In Ruby every value is an object with a class, including nil (whose class is NilClass) and true. That is why 7.even? and nil.to_a work, and it is the single largest conceptual difference in how the two languages are organized.

The hierarchy is what is_a? exercises: an Integer is also a Numeric and a Comparable, so a check can ask about capability rather than exact type. Lua has nothing comparable — the closest is inspecting a metatable by hand.

The &:upcase form is a symbol converted to a block — shorthand for { |word| word.upcase }. Chaining is the dominant Ruby style and the reason its code reads so differently from Lua's despite the languages being close underneath.

Almost everything in Ruby is an expression with a value, including if, case and even method definitions. That removes the need for the and/or idiom entirely, and with it the bug where the middle value is falsy.

An explicit return is still legal and is used for early exits, but writing it at the end of a method marks you out as coming from somewhere else. The endless form on the last line is Ruby 3.0's one-line method definition, and it is genuinely handy for small computations.

Only nil and false are falsy, so 0, "", [] and {} are all true, exactly as in Lua. Every truthiness guard you have written in Lua means the same thing here, which removes the largest single source of ported bugs.

The one addition is that Ruby's nil is an object of class NilClass, so it has methods — nil.to_a is [] and nil.to_s is "". Calling any other method on it raises NoMethodError, which is Ruby's version of "attempt to index a nil value".

On the Python, JavaScript and GDScript pages this same idiom silently replaces a valid zero and needs a warning. Here it does not. Ruby also has real default parameters (greeting = "Hello"), which is the cleaner spelling and what the Methods section uses.

delete is the removal method, and it returns the removed value. The Lua habit produces a Hash whose size never goes down — and, because nil is falsy in both languages, the lookup still reads as absent, which is what makes the leak so easy to miss.

The sigils also encode scope: a bare name is local, @name is an instance variable, @@name a class variable, $name a global, and NAME a constant. Lua carries none of that in the name, so scope has to be read from the declarations.

Ruby goes further with the splat, which collects the rest into an array, and with nested destructuring. Lua's multiple assignment does neither — it pairs names to values positionally and discards the excess.

The warning covers the binding, not the object — a constant array can still be mutated, which is why freeze exists. Lua 5.4 added a real <const> attribute, but Fengari implements 5.3, so this page cannot show it.

That is the surprise for a Lua programmer — a method cannot see a local defined outside it, even in the same file. Anything a method needs must arrive as an argument, an instance variable or a constant, which is why Ruby code passes so much more explicitly.

Reading an instance variable that was never assigned gives nil rather than raising, exactly like a missing Lua table key — which is convenient and hides typos in the same way. Note also that these are genuinely private: there is no way to read @count from outside without a method or explicit reflection.

Interpolation only works in double-quoted strings; single quotes are literal, which is a distinction Lua does not make. format takes the same printf placeholders string.format does, so that half transfers unchanged.

So upcase returns a new string and the original is unchanged, exactly as in Lua. The bang methods — upcase!, gsub! — still mutate in place and will now raise on a frozen literal, which is a much better failure than silently editing a shared string.

Lua's sub(2, 3) is Ruby's [1..2]: shift both bounds by one and the inclusive end carries over. The [start, length] form is a different shape and is easy to confuse with it. Negative indices count from the end in both languages.

The trap is that :width and "width" are different Hash keys, which is the most common source of confusion in Ruby configuration code. The convention is symbols for keys and identifiers, strings for data. Lua needs none of this because interning is automatic.

The character classes translate — %a to [a-z], %s to \s, %d to \d — with the percent sign becoming a backslash. gsub keeps its name and meaning, which makes this one of the easier translations on the page.

A Ruby string carries its encoding, so length is the character count you meant and bytesize is there when you need the other answer. This is the same split Python makes, arrived at differently — Ruby keeps one String class and tags it, where Python has separate str and bytes types.

This is the same split JavaScript, Python and GDScript make, so it is the least surprising difference on the page. The one advantage Ruby keeps over JavaScript here is that a Hash preserves key identity — 1 and "1" stay distinct, exactly as in Lua.

Reading past the end gives nil rather than raising, exactly as Lua gives nil — so an off-by-one fails quietly in both, which is one of the few places Ruby is no safer. fetch is the raising version when you want the noise.

Hash iteration order is insertion order and guaranteed, where Lua's pairs order is explicitly unspecified and can vary between runs. Ruby also has no equivalent of ipairs stopping at the first nil — an array with a nil in it iterates straight through.

That last point is the interesting one: Enumerable is a mixin, so defining each on your own class gets you map, select, sort_by, group_by and the rest for free. The Classes section shows how.

The block form is the one to know: it runs on each missing key and, by assigning into the hash, stores the default so subsequent reads see the same object. Passing a mutable default directly (Hash.new([])) shares one array between every key — the same trap as Python's mutable default argument.

Both dup and Lua's table.unpack idiom are shallow, leaving nested collections shared. Ruby has no deep copy in the core library either — the usual trick is Marshal.load(Marshal.dump(object)), which is exactly as inelegant as it looks.

The block goes outside the parentheses and yield calls it. There is no parameter for it in the signature, which is why a method's block is invisible in its definition — and why block_given? exists to ask whether one was passed.

The do is a false friend: Lua's do opens a plain scope block, while Ruby's introduces a block passed to the method on its left. The braces are a worse one — in Ruby they mean a block here and a Hash literal in expression position, which the parser resolves by context.

The result is a Proc, which is what a Lua function already is. The same & converts back on the way out — numbers.each(&runner) passes a Proc as a block, and &:upcase works because a Symbol converts to a Proc that calls that method.

A lambda returns from itself, like a Lua function. A Proc's return returns from the enclosing method — which is what makes each { return } work as an early exit, and what makes a stored Proc dangerous. Lambdas also check their argument count; Procs, like Lua, do not.

block_given? is how a method decides whether to yield or return a collection instead — the pattern behind most of Enumerable, where map without a block returns an Enumerator rather than raising. Calling yield with no block raises a LocalJumpError.

So the counter behaves identically, with no nonlocal declaration as Python needs and no boxing as GDScript needs. Of every target on this anchor, Ruby's closures are the closest match to Lua's.

That one letter is a reliable typo for anyone moving between the two. Ruby also has unless, which is if not and reads better for a guard clause, and both are available as trailing modifiers.

The form is idiomatic for short guards and early returns — return nil if list.empty? reads exactly as it says. It becomes unreadable on anything longer than a line, which is the only rule about using it.

Each when uses ===, so it matches ranges, classes and regular expressions as well as values — when Integer and when /^a/ both work. There is no fall-through and no break, and the whole thing is an expression with a value.

upto mirrors Lua's inclusive numeric for most closely, step takes the third argument, and times counts from 0. All of them take a block, so this section is really the Blocks section applied to iteration.

The name is worth noting because next in a block also supplies the block's value — map { |x| next 0 if x.nil?; x * 2 } — which has no parallel in Lua's goto form. break works as expected and can also carry a value out of the method that yielded.

Omitting parentheses is idiomatic for methods that read as commands (puts, attr_reader) and discouraged where an argument list could be ambiguous. Coming from Lua, where they are mandatory, the safe habit is to keep writing them except for puts.

The payoff is the commented line: a misspelled keyword is an ArgumentError at the call, where the Lua version silently ignores the unknown key and uses the default. That single check catches a large share of real configuration bugs.

The double splat **options collects keyword arguments into a Hash, which Lua approximates with the options table from the previous row. Note that Ruby returns a single Array here rather than two values — the next row covers why.

The difference shows when you do not destructure: Lua discards the extras, while Ruby hands you the Array itself. That is usually better — the result can be stored or passed on — and it is the same trade Python makes with tuples.

? marks a predicate returning true or false. ! does not mean "mutates" — it means "the more surprising of a pair", which is usually mutation but sometimes raising instead of returning nil. There is no bang method without a non-bang sibling.

attr_reader :count generates the getter method — instance variables are private, so without it counter.count would raise. That is a real difference from Lua, where an object's state is just table keys and readable by anyone.

Instance variables are reached with @ rather than through self, so the receiver rarely appears at all. self is still available and is needed in two places: calling a setter (self.name = …) and defining a class method (def self.create).

The Lua version needs two setmetatable calls and an __index on each level, and one mistake gives a silent nil. The < does all of it, and super reaches the parent method — which in Lua means calling Animal.speak(self) directly.

A module inserted with include takes a real place in the ancestor chain, so overriding still works and super finds it. This is how Enumerable and Comparable work: define each or <=>, include the module, and get dozens of methods.

Defining each and including Enumerable brings map, select, sort_by, group_by, to_a, min, sum and dozens more. This is the clearest demonstration on the page of what Ruby's object model buys over Lua's.

The mapping is __add→+, __eq→==, __lt→<, __len→length, __tostring→to_s, __call→call. Ruby writes them as ordinary methods with operator names rather than as entries in a metatable, which is the only real difference.

Both fire only after normal lookup fails, so neither slows the ordinary path. respond_to_missing? has no Lua counterpart and should always be defined alongside — without it, respond_to? lies and things like method(:anything) break.

The block passed to define_method closes over field, which is what makes the loop work. This is the machinery behind attr_reader and behind most of Rails — and a Lua programmer already has the right mental model for it, since assigning a function to a table key is the same idea.

Ruby's version is syntactically ordinary, which is precisely why the community treats it with caution — two libraries adding the same method to String silently conflict. refine scopes such a change to one file, and has no Lua equivalent at all.

send ignores visibility, which makes it powerful and a little dangerous — public_send is the version that respects private. Lua has no visibility to respect, so the question does not arise there; its equivalent of "list the methods" is iterating the metatable with pairs.

freeze is shallow — the Hash cannot gain keys, but a mutable value inside it can still change — which is exactly the limitation Lua's __newindex has too. Ruby 4.0 freezes string literals by default, as the Strings section noted, so this is machinery you meet whether or not you ask for it.

Because pcall returns rather than branching, Lua code tests a boolean where Ruby code nests a block. Ruby also has else (ran without raising), ensure (always runs), and retry — none of which Lua 5.3 has any counterpart for.

Ruby selects the handler by exception class, so unrelated failures are not swallowed by a handler meant for something else. A bare rescue catches StandardError and its subclasses — deliberately not Exception, which would also trap interrupts and syntax errors.

An ensure clause runs whether the block completed, raised, or returned early, which is what makes File.open with a block safe. Lua 5.4's <close> attribute is the nearest equivalent and Fengari does not implement it.

The idiomatic replacement is raise … unless, using the trailing modifier from the Control Flow section. Note that it raises a specific class — ArgumentError — which is what lets a caller rescue this failure without catching everything else.

Fiber.new is coroutine.create, Fiber.yield is coroutine.yield, and resume is resume. Ruby returns the yielded value directly where Lua returns a success flag first, which is why the Lua column needs select(2, …).

The correspondence extends to the detail that the first resume's argument goes to the block's parameters rather than to a waiting yield, because none is suspended yet. A Lua programmer needs to learn no new concept here, only new spelling.

Resuming a dead Fiber raises FiberError, where Lua's coroutine.resume returns false with a message — the usual difference between a language with exceptions and one without. Check alive? first, or rescue.

An Enumerator is Enumerable, so it gets map, select and first — including over an infinite sequence, as the last line shows. Lua has the same power in coroutine.wrap and no library that consumes it, which is the difference in one sentence.

The lookup returns nil and the truthiness check passes, so the code behaves correctly while the Hash grows without limit. size and key? are the only things that notice. Use delete.

This is the most common Ruby bug for anyone handling parsed JSON, which produces string keys, against code written with symbol keys. transform_keys(&:to_sym) at the boundary is the standard fix; the alternative is to be consistent and never mix.

Blocks and lambdas do close over the enclosing scope, which is why the last line works — so the rule is about def specifically, not about Ruby callables generally. Anything a method needs must arrive as an argument, an instance variable or a constant.

The parser resolves it by context and occasionally guesses differently than you meant, which is why a Hash literal passed as the only argument sometimes needs explicit parentheses. Coming from Lua, where { } is always a table, this takes a while to stop registering as odd.

So 7 / 2 is 3 with no warning. fdiv is the explicit float division and is the clearest fix; making one operand a float works too. This is the one numeric trap on a page that otherwise agrees with Lua almost everywhere.