Haskell.CodeCompared.To/Scheme

Haskell requires a named main :: IO () entry point that the runtime calls once. Scheme has no entry-point requirement at all — top-level forms simply execute in the order they are read, closer to a scripting language. display prints without a trailing newline, so (newline) is a separate, explicit call.

Haskell needs do-notation to sequence IO actions, since it desugars to chained monadic binds. Scheme is strict and impure by default, so top-level expressions simply execute one after another in the order written — no monad or block syntax required for plain sequencing.

Haskell's print uses the Show typeclass, deriving a textual representation for (almost) any value. Scheme has no typeclass system to derive anything from at all — write is a built-in primitive that renders any value in a re-readable form (strings get quoted, for instance), the closest Scheme equivalent, but a plain built-in rather than something types opt into.

Haskell's let ... in bindings and Scheme's top-level define both introduce a name bound to a value — define is not an assignment statement, it is a declaration, closer in spirit to Haskell's let than to a mutable variable.

Haskell reaches for IORef and threads it explicitly through IO with newIORef/modifyIORef/readIORef. Scheme's set! offers plain, in-place mutation of an existing binding directly — the trailing ! is a Scheme naming CONVENTION marking any procedure that mutates state, not special syntax, but set! itself is a genuine special form built into the language.

This is the deepest throughline of this page. Every other Haskell target on the site — F#, Roc, ReScript, Scala, Swift, Kotlin, Rust — is still statically typed, even when it lacks type classes. Scheme has no static type system at all: add has no declared or inferred type whatsoever, and (add "two" 3) would compile (there is no separate compile step at all) and only fail — or silently produce nonsense — the moment that exact call actually runs.

Haskell's Int annotation is checked once, at compile time, and never needs re-checking at runtime. Scheme has no such compile-time guarantee, so idiomatic Scheme code frequently checks a value's runtime type with predicates like number?, string?, and pair? — a defensive style Haskell almost never needs, since the type checker already ruled out the wrong-type case before the program ever runs.

Haskell's ++ is the general list-concatenation operator, since a String is really [Char]. Scheme's string-append is a dedicated string procedure — Scheme strings are their own distinct type, not a list of characters, so a general list operator would not apply to them at all.

A Scheme symbol like 'ok is an interned, immutable atomic value — spring into existence at the point of use, compared by identity with eq?, with no declaration required anywhere. Haskell has no equivalent data type at all; the closest comparison is a nullary constructor of a data type, which — unlike a Scheme symbol — must be declared upfront and belongs to one specific, closed type rather than a shared, open universe of interned atoms.

Both languages model a list as a chain of cons cells terminated by an empty list — genuinely the same underlying representation, unlike most other languages on this site. Haskell's (first:rest) pattern destructures directly; Scheme has no pattern-matching syntax for this, so car (first element) and cdr (the rest) are called explicitly — the very names car/cdr come from 1950s IBM 704 hardware registers, a historical artifact with no Haskell parallel.

Both languages call these operations map and filter, with the same argument order (function, then list) — a genuinely close match, both being languages that treat lists as a foundational data structure rather than an afterthought.

Haskell's foldl and Scheme's fold-left take the same pieces in the same order — initial accumulator, then the list — with nearly identical names, one of the closer standard-library vocabulary matches on the whole site.

Because Scheme lists are just chains of cons cells by convention, not by type-level guarantee, nothing stops the final cdr from being something other than another list or '() — an "improper list" like (1 . "not a list"), printed with a dot. This is a real shape Haskell's type system makes literally inexpressible: a Haskell [a] is always proper by construction, so the closest comparison is an ordinary tuple, a genuinely different type rather than a malformed list.

Haskell spells a lambda \x -> ... (the backslash evoking the Greek letter lambda). Scheme spells out the full word: (lambda (x) ...) — no abbreviation at all, the etymological origin every other language's shorthand ultimately traces back to.

In Haskell, add 5 alone is already valid — every function is secretly a chain of one-argument functions. Scheme has no automatic currying at all; getting a one-argument version of a two-argument function means writing the wrapper explicitly, exactly as shown, much like Erlang or C would require.

Haskell's guarded case and Scheme's cond both try a sequence of conditions top to bottom, falling through to a final catch-all (_ in Haskell, else in Scheme). Scheme's cond is closer to a chained if/else if than to Haskell's value-DESTRUCTURING case, since Scheme has no structural pattern matching at all — only boolean conditions.

Haskell's compiler statically flags a case that might not cover every input. Scheme has nothing resembling this check: a cond where every clause fails to match simply returns an unspecified value silently — no warning at compile time (Scheme barely has a separate compile phase to check anything in), and no error at runtime either. This is a genuine safety regression a Haskeller should watch for.

Scheme does have a construct literally named case, and it reads close to Haskell's at a glance — but it only matches against literal values with eqv?, wrapped in a list of alternatives per clause; it cannot destructure a pair, a record, or any compound structure the way Haskell's case destructures a constructor's payload.

Haskell's record syntax generates a constructor, a predicate is implicit in the type system, and one accessor per field, all from one data declaration. Scheme's define-record-type generates the same three things automatically from the field list — make-point (constructor), point? (predicate, since Scheme has no static types to check this at compile time), and point-x/point-y (accessors) — genuinely close in spirit, and the strict naming convention means there is no way to ask for camelCase instead.

Haskell's point { y = 99 } produces a new record with one field replaced, in one expression. Scheme's define-record-type has no update syntax whatsoever — "updating" a record always means calling the constructor again, passing through every unchanged field by hand, considerably more ceremony for records with many fields.

A base-case clause and a recursive clause — Haskell writes them as separate pattern-matched equations, Scheme writes the single equivalent branch inside one if. Both are considered idiomatic in their own language for exactly this shape of recursion.

This is a genuine, formal guarantee both languages share: the Scheme standard (R7RS) MANDATES proper tail-call optimization as a language requirement, not just a compiler optimization that might or might not fire — and GHC reliably optimizes exactly this accumulator-passing shape too. An accumulator-passing recursive function runs in constant stack space in both languages, one of the strongest shared guarantees on the whole site.

Haskell's [1..] is an ordinary list that only works because Haskell is lazy, generating each element on demand as take asks for it. Scheme is strict by default, like almost every other language on this site — a genuinely infinite Scheme list has no direct representation at all; a bounded literal list is simply how Scheme gets "the first five numbers" directly.

In Haskell, every binding is lazy unless forced otherwise — expensive is not actually computed until print demands it, and the result is cached automatically. Scheme is unusual among this page's comparison languages in offering the identical guarantee, but opt-in: delay creates a "promise" that is not evaluated until forced, and — like a Haskell thunk — evaluating it twice only computes it once, caching the result for the second force.

This is a genuinely new capability for a Haskeller, not just different syntax for an old one: define-macro lets ordinary Scheme code write a form that controls whether and how its own arguments are evaluated, rewriting itself into different code at read time — a brand-new piece of syntax, indistinguishable in use from something built into the language. Haskell has no equivalent at this level of ease; Template Haskell exists but is heavyweight, rarely used machinery most Haskell code never touches.

BiwaScheme's define-macro, unlike the standard-Scheme syntax-rules it lacks, is unhygienic: a macro can accidentally capture or shadow a variable name from the code that calls it, since the macro's own template variables are not automatically renamed to avoid collision. Haskell has no comparable risk category at all — there being no macro system at this level, "variable capture from a macro expansion" is simply not a bug that can happen in ordinary Haskell code.

call/cc (call-with-current-continuation) captures "the rest of the computation" as a callable value; invoking it abandons the current work and jumps directly back to where call/cc was called. Used this way, it is a structured non-local return — like Ruby's return from a block. Haskell has nothing resembling this as a raw, always-available primitive; the closest comparison, the Cont monad, models continuations purely as an ordinary data value threaded explicitly through do-notation, rather than a control-flow primitive baked into the language itself.

Scheme's dynamic-wind runs three thunks — a "before" thunk, the body, and an "after" thunk that is GUARANTEED to run even if a continuation jumps out of the body early — a close structural cousin of Haskell's bracket_ (acquire, use, release, with release guaranteed even on exception). Scheme's version is subtly more general: it also correctly re-runs the "before" thunk if a stashed continuation later jumps back INTO the body, a scenario Haskell's exception-based bracket_ has no equivalent for at all, since Haskell has no continuations to jump back in with.

Haskell's Data.Map is a persistent, immutable balanced tree — every "insert" returns a new map, the old one untouched. Scheme's R6RS hashtable (make-hashtable with a hash function and equality predicate) is a genuinely mutable table updated in place with hashtable-set! — a real representational difference, not just naming: Haskell's map can be shared safely across time, Scheme's hashtable cannot.

Haskell's Map.lookup returns Maybe Int, an explicit, compiler-enforced "value or absence" type — the caller cannot forget to handle a missing key without a type error. hashtable-ref takes the DEFAULT to return on a miss as an explicit third argument (here #f) — there is no Maybe-equivalent wrapper type in Scheme to enforce that the caller ever checks it.

Haskell's Either String Int is a real, compiler-checked type — the compiler statically knows every value is either Left or Right, and rejects code that treats it as a bare Int. The closest Scheme idiom, a tagged cons pair like ('error . "message") or ('ok . value), is pure convention: nothing in the language enforces that a caller ever checks the tag before using the payload, since Scheme has no type system to enforce it with.

This is the sharpest practical consequence of Scheme's lack of a type system. Forgetting to check the tag in Haskell — treating an Either as if it were the bare success value — is a compile-time type error, caught before the program ever runs. Forgetting the equivalent check in Scheme is simply a runtime bug: (cdr result) on an error pair would silently return the error MESSAGE where a number was expected, with no error raised anywhere, until something downstream breaks in a confusing way.

Haskell has no escape hatch into ordinary in-place mutation outside of explicit IORef/STRef/MVar machinery threaded through IO. Scheme is not a pure language at all: set-car!/set-cdr! mutate a cons cell in place directly, no wrapper type required, and this is ordinary, everyday Scheme — not a special case reserved for genuinely imperative code the way Haskell treats IORef.

Haskell has exactly one equality operator, ==, dispatched through the Eq typeclass, and it always means structural equality. Scheme has three genuinely different equality predicates with no Haskell parallel: eq? (pointer/identity equality, unreliable for numbers), eqv? (identity plus a few built-in types like numbers and characters), and equal? (deep, structural equality — the one closest to Haskell's ==). Picking the wrong one is a genuine, common Scheme bug category with no equivalent in Haskell at all.