Ruby.CodeCompared.To/Clojure

println writes a string to stdout followed by a newline, just like Ruby's puts. The outer parentheses are a function call — println is the function, "Hello, World!" is the argument. In Clojure, all calls use this prefix form.

println appends a newline; print does not — the same distinction as Ruby's puts vs print. Both accept any value and convert it to a string. prn is like println but prints in a machine-readable form (strings include quotes).

Clojure uses semicolons for comments, not #. By convention, ;; opens a standalone comment on its own line, while a single ; follows code on the same line. Clojure also has a #! shebang comment and a #_ reader macro that comments out the next form entirely.

def creates a var in the current namespace. By convention, Clojure uses kebab-case for all names — no SCREAMING_SNAKE_CASE for constants. str concatenates any number of values as strings, replacing Ruby's #{} interpolation.

let creates immutable local bindings scoped to its body. The binding vector is evaluated in order, so later bindings can reference earlier ones — area can reference radius. There is no standalone assignment statement in Clojure; let replaces Ruby's local variable assignment.

let bindings cannot be reassigned — they are immutable. conj does not modify numbers; it returns a new vector. The original binding is untouched. This is the fundamental difference from Ruby: Clojure never mutates data in place. All "updates" produce new values.

In Clojure, every form returns a value — if, let, do, cond, and defn bodies all return their last expression. Ruby shares this property. Unlike many C-family languages, there is no distinction between expressions and statements.

Use quot for integer division (Ruby's / on integers) and mod for remainder. JVM Clojure also has exact Ratio types — (/ 1 3) produces 1/3 as a ratio, not a float — but this feature is not available in the browser. Math/pow calls the JavaScript Math.pow function.

Clojure keywords (:active) are similar to Ruby symbols — self-evaluating, interned, and very fast to compare. They are the idiomatic key type for maps. Keywords are also functions: (:name person) looks up :name in the map person, which is more readable than (get person :name).

Clojure's nil is equivalent to Ruby's nil. true? and false? test for the exact boolean values. boolean coerces any value to true or false — only nil and false produce false. some? returns true for anything that is not nil.

Clojure and Ruby agree: only nil and false are falsy — everything else, including 0, "", and empty collections, is truthy. This differs from JavaScript (where 0 and "" are falsy) and Python (where empty collections are falsy).

str concatenates any number of arguments, converting non-strings automatically. Clojure has no string interpolation — str is the idiomatic replacement. For formatted output, use format (e.g., (format "Hello, %s!" name)), which works the same as Ruby's sprintf.

count returns the length of a string or any collection. subs extracts a substring by start and end index. The clojure.string namespace contains case conversion, trimming, searching, and splitting functions — equivalent to Ruby's built-in String methods.

clojure.string/split takes a regex pattern (the #"" literal). clojure.string/join takes a separator and a collection. The #"\s+" regex splits on any whitespace, matching Ruby's default split behavior.

The clojure.string namespace provides trim, triml, trimr, capitalize, upper-case, and lower-case. These are pure functions that return new strings — like Ruby's non-bang string methods (strip, not strip!).

Clojure vectors ([...]) are the closest equivalent to Ruby arrays — indexed, ordered, and persistent. They are immutable by default. Vectors are also functions: (numbers 2) looks up index 2, so vectors can be used directly as data accessors.

Clojure lists ('(...)) are linked lists — fast at prepending with cons, slow at indexed access. Vectors are fast at indexed access and appending. The quote prevents the list from being evaluated as a function call. In practice, prefer vectors for data and use lists mainly for representing code.

Clojure maps use keywords as keys by convention. Keywords and maps are both callable as functions: (:name person) looks up :name in the map, and (person :name) does the same. The keyword-as-function form is more idiomatic and reads naturally: "get the name of this person".

Clojure sets (#{...}) are unordered collections of unique values. Like maps, sets are functions of their elements: (primes 5) returns the element if present or nil if absent. Ruby requires require "set"; sets are built into Clojure's core.

assoc returns a new map with the given keys set. The original map is untouched — this is the core of Clojure's immutability. dissoc removes keys. The underlying data structure uses structural sharing, so creating a "modified" copy is efficient — it shares most of its memory with the original.

get-in navigates nested collections using a path vector — like Ruby's dig. assoc-in returns a new structure with one nested value changed, leaving the original intact. update-in applies a function to a nested value: (update-in data [:user :age] inc).

defn defines a named function. The argument vector uses square brackets. The last expression in the body is the return value — there is no return keyword. defn is a macro that expands to (def greet (fn [name] ...)).

fn creates an anonymous function. The #(...) shorthand is convenient for simple expressions — % is the first argument, %2 the second, and so on. Like Ruby's ->() lambdas, these are first-class values that can be stored, passed, and returned.

Clojure functions can have multiple arities — a separate implementation for each argument count. Each arity is a parenthesized group within defn. By convention, lower-arity versions call the higher-arity version with defaults. This is more explicit than Ruby's default arguments, but equally expressive.

& in the argument vector collects remaining args into a sequence, like Ruby's splat *. apply unpacks a collection as arguments — the Clojure equivalent of Ruby's method(*array) splat call. Any function can be applied to a collection with apply.

partial returns a new function with the first arguments pre-filled. It is the direct equivalent of Ruby's curry. (partial add 5) produces a function that adds 5 to any argument. partial is a core language function in Clojure; Ruby requires calling .curry on a lambda.

comp composes functions right-to-left: (comp f g) applies g first, then f. Ruby's >> applies left-to-right, so add1 >> double-it in Ruby equals (comp double-it add1) in Clojure — both apply add1 first. Think of it as reading the composition in the order the data flows through.

mapv returns a vector (like Ruby's map). Plain map returns a lazy sequence. The function comes before the collection — the opposite of Ruby's method chaining. map can also zip multiple collections: (map + [1 2] [3 4]) gives (4 6).

filter keeps elements where the predicate returns truthy — like Ruby's select. remove is the complement — like Ruby's reject. filterv returns a vector; plain filter returns a lazy sequence. Clojure includes built-in predicates like even?, odd?, nil?, string?, and number?.

reduce takes the function first, then an optional initial value, then the collection. Clojure's core arithmetic functions (+, *, str) work as reducing functions directly — no need for the :+ symbol Ruby requires. Without an initial value, the first element is used.

into pours one collection into another, adapting to the target type. Pouring into a vector appends; into a set deduplicates; into a map takes key-value pairs. into with a transducer is also the most efficient way to chain filter and map in a single pass without intermediate collections.

sort returns a sorted sequence. sort-by takes a key function — keywords work here because they are functions of maps. (sort-by :name people) is equivalent to Ruby's people.sort_by { |p| p[:name] }. For reverse order, use (sort-by :name #(compare %2 %1) people).

Clojure sequences are lazy by default — they compute values on demand. range with no arguments produces an infinite sequence. iterate generates an infinite sequence by repeatedly applying a function to a seed value. Laziness enables working with infinite or very large data sets without loading everything into memory.

Clojure's if accepts exactly three forms: condition, then, else. For multiple branches, use cond, which evaluates conditions top-to-bottom and returns the value of the first truthy branch. The :else keyword at the end serves as the default — any truthy value works there, but :else is the convention.

when is if without an else branch, and it accepts multiple body expressions (an implicit do). Use when when you only care about the truthy case. when-not is the inverse. when returns nil when its condition is falsy, which is often useful in threading macros.

case dispatches on a constant value using fast equality. Multiple matches for one result are listed in a parenthesized group. The final bare expression is the default (no condition needed). Unlike cond, case does not evaluate test expressions — they must be compile-time constants.

Like Ruby, Clojure's and and or short-circuit and return the deciding value rather than just true or false. (or nil "default") is the idiomatic nil-coalescing pattern, equivalent to Ruby's nil || "default". and returns the last value if all are truthy, or the first falsy value.

do evaluates multiple expressions in order and returns the last one — like Ruby's begin/end block. Most forms that accept a body (when, let, defn) include an implicit do, so explicit do is mainly needed inside if's then/else branches when multiple side effects are required.

Destructuring in let mirrors the collection syntax. [head & tail] is Clojure's equivalent of Ruby's first, *rest. Unused trailing elements can be discarded with _ by convention: [a b _]. Destructuring works in let, fn, defn, and for.

{:keys [name age]} destructures a map and binds each key's value to a local variable of the same name. This is extremely common in idiomatic Clojure, especially in function arguments. For different local names, use {local-name :map-key}: (let [{person-name :name} p] ...).

{:keys [...] :or {...}} in a function argument both destructures the map and provides default values. This is Clojure's idiomatic equivalent of Ruby's keyword arguments. The entire map is always passed as a single argument — there are no separate keyword parameters at the call site.

-> threads a value through a series of functions, inserting it as the first argument of each step. It mirrors Ruby's method chaining (.method) and makes left-to-right data flow readable in a language that normally reads inside-out. Wrapping a step in parens adds extra arguments: (split #", ") → (split value #", ").

->> threads the value as the last argument, matching the convention for sequence-processing functions like map, filter, and reduce. Use -> for object-like operations (string methods, map lookups), and ->> for sequence pipelines. Together they replace nearly all deeply-nested function calls.

some-> is a nil-safe version of ->: if any step returns nil, the entire chain short-circuits and returns nil. This is the Clojure equivalent of Ruby's &. safe navigation operator. some->> does the same for thread-last pipelines.

atom is Clojure's primary tool for managing mutable state. Unlike Ruby's direct variable mutation, an atom holds a value that can only be changed with swap! or reset!. @atom (or (deref atom)) reads the current value. Atom updates are atomic and thread-safe — no mutex needed.

swap! applies a function to the current atom value and stores the result. reset! replaces the value unconditionally. (swap! scores conj 95) calls (conj @scores 95) and stores the result. swap! may retry if the atom is updated concurrently — the function must be pure and free of side effects.

In Clojure, prefer pure transformation functions (mapv, reduce, into) over accumulation with atoms. Atoms are for state that genuinely changes over time — a counter, a cache — not for building up results. doseq is a side-effectful loop (like Ruby's each), and its return value is nil.

try / catch / finally map directly to Ruby's begin / rescue / ensure. In ClojureScript (the browser runtime used here), (catch :default e ...) catches any thrown value. In JVM Clojure, use (catch Exception e ...) or a specific exception class.

ex-info creates a structured error with a message string and an arbitrary data map. ex-message retrieves the message; ex-data retrieves the map. This is idiomatic Clojure error handling — no need to define custom exception classes. The data map carries typed, queryable context, far richer than a string message alone.

{:pre [...]} is Clojure's built-in precondition system — each expression in the vector must be truthy or an AssertionError is thrown. Preconditions are a concise replacement for defensive guard clauses. {:post [...]} does the same for return values. Both are disabled if *assert* is bound to false.

Clojure has no infix operators — all operations are prefix function calls. The nesting structure is unambiguous: there are no operator precedence rules to memorize. The trade-off is a lot of parentheses. The upside is that + and * take any number of arguments: (+ 1 2 3 4) is valid.

= is value equality for all types — like Ruby's ==. identical? is reference equality — like Ruby's equal?. == is numeric equality across types, so (== 1 1.0) is true even though 1 and 1.0 are different types. Keywords and small integers are always identical to themselves.

map, filter, and most sequence functions return lazy sequences, not vectors. This is a common surprise for Ruby developers. Use mapv and filterv to get vectors, or wrap in (vec ...). Lazy sequences print with parentheses; vectors print with brackets. Both support the same sequence operations.

In Clojure, nil and empty collections are interchangeable in many contexts — this is called nil-punning. Most sequence functions accept nil safely. seq returns nil for empty collections, enabling the idiom (when (seq coll) ...) to check for non-empty. This is more idiomatic than (not (empty? coll)).

In Clojure, every opening parenthesis starts a function (or macro) call — the first element is always the operator. Parentheses never just group expressions. Square brackets ([...]) are data vectors. Curly braces ({...}) are maps. This regularity is Lisp's core insight: code and data use the same notation, enabling macros to manipulate code as data.