Ruby.CodeCompared.To/Scheme

Scheme separates output and newline by design: display writes a value without surrounding quotes, and newline writes a single line break. There is no puts that does both in one step. The outer parentheses are a function call — display is the function, the string is the argument. Every call in Scheme uses this prefix form.

display is for human-readable output: strings appear without quotes, characters without the #\ prefix. write is for machine-readable output: strings appear quoted, characters as #\a, so the result is something the reader can parse back. The pair maps loosely to Ruby's puts vs p.

Scheme uses ; for line comments, with the convention that ;; opens a comment on its own line and ; follows code. Block comments use #|...|#. There is also #;, a reader-level "datum comment" that comments out the next entire form — #;(display 42) removes the call without touching characters around it.

define binds a name in the current scope — at the top level it creates a global, inside a body it creates a local. Scheme has no SCREAMING_SNAKE_CASE for constants: convention is kebab-case for ordinary identifiers. There is also no string interpolation in standard Scheme; concatenation happens by calling display repeatedly or with string-append.

let creates a fresh scope and binds names in parallel — each binding sees only what was visible before the let, not the other bindings being introduced. That is why this example needs a nested let to compute area from radius. For sequential bindings, use let*.

let* binds names one at a time, left to right — each binding can refer to the ones above it. This is the form to reach for when later values depend on earlier ones. Think of it as syntactic sugar for nested let expressions.

letrec makes every binding visible to every other binding in the same group — necessary when two functions need to call each other. Ruby has no direct equivalent: forward references between local lambdas require the workaround of declaring one variable first and assigning it afterwards. In Scheme the language ships the right tool.

set! mutates an existing binding — the trailing exclamation point is the universal Scheme convention for "this procedure mutates state". Idiomatic Scheme avoids mutation when it can: most functions return new values rather than modifying their inputs, and let/letrec bindings are immutable in spirit even though set! can change them.

Prefix notation eliminates the need for operator precedence — the parentheses tell you exactly which operands go with which operator. +, -, *, and / all accept any number of arguments: (+ 1 2 3 4 5) returns 15. There is no "operator" / "function" distinction in Scheme — every + is just a function call.

Scheme separates integer division (quotient) from generic division (/) — there is no quietly different behavior depending on whether both operands are integers. remainder takes the sign of the dividend; modulo takes the sign of the divisor (matching Ruby's %). The distinction matters for negative numbers.

expt raises the first argument to the second — (expt 2 10) is the integer 1024, not a float. sqrt returns an exact answer when the argument is a perfect square and an inexact one otherwise. Scheme is unusual in distinguishing "exact" (arbitrary-precision rationals) from "inexact" (floats) at the type level.

Predicates conventionally end with ? — Scheme writes zero? where Ruby writes zero?, with identical meaning. The convention is older than Ruby. Boolean output is #t (true) and #f (false), not the words. Every value in Scheme except #f is truthy — including 0, '(), and "" — so Rubyists must remember 0 is not falsy here.

Standard Scheme defines a "numeric tower": integer? ⊂ rational? ⊂ real? ⊂ complex? ⊂ number?. BiwaScheme implements integers and IEEE-754 floats (the JavaScript way) — it does not support exact rationals or complex numbers, despite the predicates being present. A full Scheme like Chez or Racket would let you write 1/3 as an exact value; here, anything fractional becomes a float.

In Scheme #f is the only false value — every other value, including 0, the empty string, and the empty list, is truthy. This trips up Rubyists who expect nil/false to both be falsy. Scheme has no nil: the empty list is '(), and the "no value" idiom is the unspecified value returned by set! or an empty begin.

and returns the last truthy value (or #f on the first false). or returns the first truthy value (or #f if none). These match Ruby's && and || exactly. not is the negation function — there is no ! sigil because every operator in Scheme is just a regular identifier.

Three flavors of equality, each cheaper than the last: eq? is pointer identity (fastest, only safe for symbols and small integers); eqv? handles numbers and characters correctly; equal? recurses into lists, vectors, and strings. Use equal? by default unless you have a reason not to — it is Ruby's ==.

string-append joins any number of strings — + is only for numbers. string-length returns the character count. Scheme has no string interpolation: you build output piece by piece with display calls or with string-append. This is more verbose than Ruby's "#{...}", and it is one of the reasons Schemers write macros (see the macros section).

substring takes a half-open range [start, end) — the end index is exclusive, like Ruby's .... There is no built-in "rest of string" syntax: pass (string-length line) explicitly. Indexing is zero-based.

string->list and list->string convert between strings and lists of characters. Once a string is a list, all the list operations (reverse, map, filter) become available — this is the standard Scheme idiom for any non-trivial string manipulation. Characters write as #\a, #\space, #\newline.

Scheme symbols are written with a leading quote and are interned the same way Ruby symbols are — two symbols spelled the same are eq?, making them ideal for tags and dispatch keys. 'ok is shorthand for (quote ok); the quote suppresses evaluation, leaving the bare identifier as a value.

string->number returns #f when the input is not a valid number — there is no exception to catch, just a falsy return value. Both directions take an optional radix argument (2, 8, 10, or 16). This is the conversion to reach for when reading or formatting numeric output.

Every list in Scheme is built from pairs: (1 2 3) is really (cons 1 (cons 2 (cons 3 '()))). car gets the first element of a pair, cdr ("could-er") gets the rest. The unusual names come from the original Lisp on the IBM 704 in 1958 — they are short for "Contents of Address Register" and "Contents of Decrement Register" of the underlying hardware.

(list 1 2 3) calls the list function with three arguments. '(1 2 3) is the same thing but as a literal — the quote suppresses evaluation. ` (quasiquote) is a literal you can punch holes in with , (unquote), giving you the closest thing Scheme has to Ruby's "#{...}" string interpolation, but for data instead of strings.

length, append, and reverse are all O(n) — Scheme lists are singly linked, so the operations that are O(1) on Ruby arrays (random access, length) are O(n) here, and the operations that are O(n) on Ruby arrays (prepend) are O(1) here. Match the data structure to the access pattern.

list-ref walks the spine — it is O(n), not the O(1) you get from Ruby's []. list-tail returns the sublist starting at the given index, the equivalent of Ruby's letters[2..]. If you find yourself reaching for these often, a vector is probably the right data structure.

member returns the tail of the list starting at the first match (or #f if absent) — not just true/false. assoc (and the faster assq for symbol keys) returns the matching pair from an association list. Assoc lists are how a Schemer expresses what a Rubyist would reach for a Hash for — fine for small collections, slow for large ones (use hashtables for those).

A proper list ends with the empty list '(); an improper list ends with anything else. The dot in (1 2 . 3) shows the final cdr explicitly. Improper lists appear most often as the result of (cons 'key 'value) — a single pair used as an entry in an assoc list. Most list functions (map, length) require proper lists and error on improper ones.

map in Scheme takes the function first and the list second — the opposite of Ruby's method-receiver order, but identical in meaning. lambda is the anonymous-function constructor; the symbol next to it is the parameter list. Functions are values: pass them, return them, store them in variables.

Scheme's map accepts any number of lists — the function is called with one argument per list. Ruby requires an explicit zip step. Note that + is just a function name here; there is no special "operators are different from functions" rule to work around.

filter keeps every element for which the predicate returns truthy. The predicate is just a function — here we pass even? by name. The result is always a list; the original is unchanged. Scheme has no in-place "destructive filter" by convention — operations that mutate end with !.

fold-left processes left-to-right (accumulator first in the lambda), fold-right right-to-left (element first, accumulator last). When the operation is associative — like + — either works. For building lists, fold-right with cons preserves order naturally; fold-left would reverse it.

for-each is the side-effect twin of map — it walks the list, calls the function on each element, and returns an unspecified value. Use it when you care about the work done (printing, mutating) rather than the result. Like map, it accepts any number of parallel lists.

apply calls a function with the elements of a list as separate arguments — Ruby's *splat at the call site. Extra arguments before the final list are prepended: (apply + 100 '(1 2 3)) is (+ 100 1 2 3). This is how to "unpack" a list back into positional arguments.

if in Scheme is always an expression — it has a value, like Ruby's if. The shape is fixed: condition, then-branch, else-branch. There is no elsif; nest ifs or reach for cond. Omitting the else-branch is legal but the value is unspecified, so it is bad form unless you are using if purely for its side effect.

cond tries each clause in order and returns the body of the first whose test is truthy. else is a special identifier recognized only in the last clause. Ruby's case-without-subject is the closest analogue — same idea, different surface syntax.

case compares its target against each list of candidates with eqv?. The candidates are wrapped in parentheses because multiple keys can share one body: ((red crimson scarlet) "#f00") matches three symbols. Ruby's case/when matches with === instead, which is much more flexible — and much more surprising.

when evaluates its body if the test is truthy; unless does so if the test is falsy. Both wrap their body in an implicit begin, so they can hold multiple expressions without parentheses. Ruby uses them as trailing modifiers more often; in Scheme they are most idiomatic at the head of a block.

begin groups expressions and returns the value of the last one. It is the Scheme way to write "sequence of statements" inside a single-expression slot — for example, in the body of an if when you want to do two things. Many forms (when, lambda, let) wrap their body in an implicit begin.

do is Scheme's only built-in looping form — every binding gets an initial value and a step expression, the loop runs while the test is false, and the body runs each iteration. It is rarely used in practice; idiomatic Scheme prefers map/fold/for-each or named-let recursion (see the recursion section).

Recursion is the idiomatic loop in Scheme. This version is not tail-recursive: the multiplication happens after the recursive call returns, so each call adds a stack frame. For small inputs this is fine; for inputs in the millions, the next example shows the fix.

When the recursive call is the last action in the function — nothing wraps it — Scheme is required by the standard to reuse the stack frame. This is "proper tail-call optimization": this loop runs in constant stack space, no matter how deep. Calling (factorial 1000000) would not overflow. Ruby has no such guarantee.

Named let defines and immediately calls a local recursive function. The name (loop here) is in scope only inside the body, so it cannot pollute the enclosing scope. This is the idiomatic Scheme replacement for while and for loops — declare the state variables in the binding list, recurse with new values.

Two top-level defines can refer to each other because both names exist in the same scope by the time either body is called. Inside a let, use letrec instead. Because Scheme guarantees tail-call optimization, mutually-recursive functions like this run in constant stack space — calling (is-even? 1000000) would work.

lambda creates an unnamed function. Unlike Ruby, Scheme has no separate concept of a "block" — functions are the blocks. (define (add a b) ...) is just shorthand for (define add (lambda (a b) ...)). Every function in Scheme is a first-class value: pass it, return it, store it.

The dot in a parameter list collects all remaining arguments into a list — Ruby's *splat in argument position. (lambda args ...) with no parentheses around args collects every argument into one list. There are no default values or keyword arguments in standard Scheme; these are conventionally simulated by checking the rest list.

The inner lambda captures the count binding from its enclosing let. Each call to make-counter creates a fresh binding, so independent counters do not interfere. This is the lexical-scope + closure model that Ruby, Python, and JavaScript all imitate — Scheme was where it was popularized in 1975.

Currying-by-hand is trivial in Scheme — adder takes one argument and returns a one-argument function. Because functions are values and closures capture their environment, this pattern is everywhere in idiomatic Scheme: configuration, partial application, building pipelines.

Vectors are Scheme's contiguous, mutable, O(1)-access arrays — the right structure when you need random access. The literal syntax is #(1 2 3); the constructor is vector. Unlike lists, vectors are not built from pairs and do not work with car/cdr. The trailing exclamation in vector-set! signals mutation.

vector-map mirrors map but operates on (and returns) vectors. vector->list and list->vector bridge the two worlds — useful when a function you want lives on the other side of that divide. For random-access workloads, store data in a vector and convert to a list only when chaining list operations becomes more convenient.

BiwaScheme ships R6RS hashtables: make-eq-hashtable for symbol keys, make-eqv-hashtable for numbers/characters, and the general make-hashtable that takes a hash function and an equality predicate. hashtable-ref takes a third argument: the default to return on a miss (here #f) — there is no exception to catch.

make-eq-hashtable is the cheapest variant — it uses pointer identity (eq?) for comparison, perfect for symbol keys because all symbols spelled the same are eq?. There is no built-in hashtable-walk with a callback; iterate by walking the keys vector.

define-record-type generates a constructor (make-point), a predicate (point?), and one accessor per field (point-x, point-y). The generated names follow strict conventions — there is no way to ask for camelCase. Records are the Scheme equivalent of Ruby's Struct or a no-method class.

Fields are immutable by default — mark them (mutable name) to get an additional setter procedure named typename-fieldname-set!. The immutable-by-default stance is the opposite of Ruby's attr_accessor idiom and reflects Scheme's preference for value-style programming.

The (name constructor predicate) form lets you override the default constructor name (make-animal → new-animal) and the predicate. Accessors and setters still follow the type-field / type-field-set! pattern. Marking a field immutable simply omits the setter.

A macro is a function that takes code as data (a list) and returns new code as data — the result is then compiled in place of the call. ` (quasiquote) builds a list with holes, , (unquote) plugs a value in, and ,@ (unquote-splicing) plugs a list in flat. The body of my-when after macro expansion is literally (if #t (begin (display "hello") (newline) ...) (begin)).

Macros run before evaluation, so they can introduce set! on names the caller passed in. A function-shaped swap! cannot do this — by the time the function runs, it sees only the values, not the variables. This is the killer feature that gives Lisp dialects their famous "language extensibility": new control structures look identical to built-ins.

Defining a brand-new conditional that looks built-in takes one line. With macros, you do not have to wait for the language committee — you ship the missing form yourself. BiwaScheme caveat: the R7RS-standard pattern-based syntax-rules is not implemented in BiwaScheme 0.8.3. The lower-level define-macro (CL-style) is what works here.

Unhygienic macros — the kind define-macro produces — can capture or shadow names from the call site. The fix in standard Scheme is syntax-rules, a hygienic, pattern-based macro form that automatically renames temporaries. When BiwaScheme adds syntax-rules support, every macro on this page becomes more robust.

call/cc (call-with-current-continuation) captures "the rest of the computation" as a callable value. Invoking it abandons the current work and jumps back to where call/cc was. Used this way it is a structured non-local return — like Ruby's return or throw/catch, but more general because the continuation is a first-class value you can also stash and call later.

A captured continuation can be invoked any number of times, jumping back to the same spot with a different value each time. Used carelessly this resembles a goto that respects lexical scope; used carefully it is the foundation for coroutines, generators, backtracking search, and exception systems — all of which can be implemented in Scheme without further language support.

dynamic-wind runs three thunks: the before thunk before the body, the after thunk after — and crucially, the after thunk also runs if a continuation jumps out of the body (and the before thunk runs again if a continuation jumps back in). This is the Scheme analogue of Ruby's ensure — and it stays correct even in the presence of call/cc.

Scheme has no Ruby-style mutable string buffer. The idiomatic way to build a string is to open a string-output port, write to it with the normal display/write procedures (passing the port as the second argument), then call get-output-string to harvest the result. Every output procedure takes an optional port argument that defaults to stdout.

Returning a freshly-built string from a function is a common Scheme pattern: open a port locally, write into it, return (get-output-string port). Because the port is local to the function, callers see only the finished string and never the intermediate state. The trailing 1.0 in the average computation forces a floating-point result — any operation that involves a float yields a float, a rule called "inexactness contagion".

Standard Scheme has no printf/format in the small base — formatted output is built from primitives. Many implementations ship a format SRFI as an extension, but BiwaScheme does not. The result is more verbose code, but also more visible: nothing about the output is hidden in a cryptic format string.

#f is the only false value. 0, "", '(), and even (if #f #t)'s unspecified value all count as truthy. Coming from Ruby, the trap is writing (if (assq 'key data) ...) expecting it to be falsy when missing — that part works, because assq returns #f on miss — but expecting 0 or '() to behave like Ruby's nil will burn you.

'(1 2 x) is a literal: every element is taken as-is. (list 1 2 x) calls list on three arguments, evaluating x. The mistake is reaching for the quote when you wanted construction — your symbol shows up where a value should be. Quasiquote (`) plus unquote (,) gives you a literal you can punch holes in.

eq? is pointer identity and is only reliable for symbols (which are interned) and small integers. Using eq? on strings or lists is undefined — sometimes the compiler shares a literal and you get #t, sometimes not. Use equal? for content comparison by default; reach for eq? only when you know you are comparing symbols or pointer-identity tags.

define creates a new binding; set! mutates an existing one. At the top level the two are often interchangeable, but inside a body all defines must come before any expressions — once the body has started executing, only set! can change bindings. Rubyists used to treating = as universal reassignment have to learn the distinction.

Scheme lists are linked lists of pairs — every "operation that looks like array access" is actually a walk. Random access, length, and "last element" are all O(n). For workloads that need O(1) access, use vectors. For workloads that prepend often (the natural list operation), lists are faster than vectors because cons is O(1).