Haskell.CodeCompared.To/Forth

There is no distinction here between a script and a program, and no IO to be inside — every word can print, and nothing in a type says which ones do. That is the first thing a Haskell reader gives up, and the rest of the page follows from it.

There is no show and no dispatch: . prints signed, U. prints the same bits unsigned, and choosing the word is choosing the rendering. A value carries nothing that could be consulted.

Haskell separates compilation from execution completely, and the type checker is the reason — there is nothing to check a string against until it is parsed. Forth has nothing to check, so the boundary never had to exist.

This is the framing that makes Forth click for a Haskell reader: a word is a function from stack to stack, and writing two words next to each other is composing them. Joy, the language that made this explicit, called it exactly that.

🚨 Note the order flips: Haskell's f . g applies g first and reads right to left, while DOUBLE DECREMENT runs left to right in the order written. Forth is the one that matches the arrow in the type, which is not what a Haskell reader expects.

This is the real cost of having no data structure to thread through: the three ideas stop being separable, and a reader has to disentangle them by eye. It is also why the loop allocates nothing and touches no memory, which is the trade Forth is making.

Specializing a word means writing another word that supplies the argument, as ADD-TEN does. The SWAP is there because 10 goes on top of the incoming value and ADD wants it underneath — the kind of bookkeeping currying does silently.

It is still the most important thing in a definition, because it is the only statement of what the word expects and leaves. WRONG above consumes a cell it was never given and compiles without complaint; the symptom arrives somewhere else entirely.

The saving is real and so is the loss: a tuple can be passed on, stored, and pattern-matched, while two cells on the stack are only ever "the two things on top". Note the comment says -- remainder quotient, because /MOD leaves the quotient on top.

RECURSE refers to the definition being compiled. Writing FACTORIAL inside its own body would find an earlier word of that name — which is how a redefinition can be written in terms of the version it replaces, and has no Haskell equivalent.

Nothing stops a Forth word from printing, writing to memory, or leaving a different number of cells each time it runs. The stack comment is the only statement of purity, and it is a comment — so the discipline Haskell puts in the type system lives here in the programmer's head.

The Haskell version is longer because the effect is tracked; the Forth version is shorter because it is not. Neither is careless — they are two answers to the same question, and one of them gives you a compiler that knows which functions can surprise you.

That works only because every word involved is balanced. A word that leaves one cell too many buries the 99 deeper, and one that consumes too many eats it — and neither is reported. This is the failure mode with no Haskell counterpart at all.

The same bits are printed twice here, two different ways, from one DUP. That is the whole type system: the value carries nothing, so the word decides, and handing an address to EMIT is a perfectly valid program.

The prefix convention does the grouping a class would do, and cannot do the part that matters: no word can accept "anything describable". Where that genuinely matters, Forth reaches for DEFER, which is one entry rather than a dispatch table.

This is late binding, opt-in, one word at a time, and it is how a Forth driver is retargeted without recompiling its callers. Nothing checks that the installed word has the right stack effect, which is exactly what a type class signature would have guaranteed.

Twenty factorial does not fit in 32 bits, so the Forth column prints a wrapped number rather than the real answer, and nothing says so. Reaching for arbitrary precision is not an option here; a program that needs it implements it.

🚨 /MOD's rounding is implementation-defined: this Forth truncates and prints -3 -1, while gforth floors and prints -4 1 for the same line. Code that cares must say SM/REM or FM/MOD, and take the double-cell dividend that S>D supplies.

The <# … #> sequence is pictured numeric output, which builds the text right to left one digit per #. It exists because . prints a trailing space and so cannot be used to build a number with anything after it.

A Haskell list is a value: it can be returned, stored in another structure, and consumed lazily. This is a region of memory whose meaning lives entirely in the words written around it, which is why #READINGS sits right beside it.

Passing the operation is possible — store an execution token and EXECUTE it — but nothing in the language encourages it, and the result is slower and harder to read than writing the loop twice. This is the clearest place where Haskell's abstraction has no cheap counterpart.

A token is an ordinary cell, so it can be stored in an array or reached by arithmetic; it can also be a number that was never a token, which does something undefined. Haskell's (Int -> Int) is checked, and (* 2) needs no separate definition.

Nothing binds the two cells together, so NIP can discard the address and keep the length. Taking a substring is adding to one and subtracting from the other, which is the compensation for having no string library at all.

There are no thunks and nothing to force, so a Forth word that computes something the caller turns out not to need has simply wasted the time. The upside is that performance is exactly what the code says it is, with no space leaks to reason about.

Producing values on demand means either a loop that already knows when to stop, or a word you call repeatedly that keeps its place in a VARIABLE. There are no coroutines and no generators to build the second one cleanly.

There is no short-circuiting operator, and writing DUP 0<> SWAP 100 SWAP / 1 > AND would divide by zero before the AND ever ran. IF … ELSE … THEN is the control structure that does what laziness was doing.

Nothing records that the two words address one object, and nothing stops a word from writing something else into >Y. What Haskell calls a field access is here an addition that has been given a name.

This is a constructor and a metaprogram at once, written with the same words as everything else — there is no separate language for it as there is with Template Haskell. What it cannot do is let the compiler check that PLUM is used as a color and not as a number.

🚨 There is no exhaustiveness check and no warning: a third shape added later leaves AREA silently treating it as a square. This is where a Haskell reader feels the loss most sharply, and there is no Forth idiom that recovers it.

Reading THEN as "and then carry on" makes the shape work. There is no otherwise to forget, but also no warning when a chain of conditions leaves a case unhandled — IF without ELSE simply does nothing.

DO takes the limit and then the start, so 5 0 DO is the half-open range [0, 5) — the limit is pushed first, which is the reverse of how the range reads aloud and a reliable source of off-by-one bugs.

?DO is the version that tests before the first iteration, and it is what you want whenever the count comes from a variable. This is the single most dangerous default in the language for a reader arriving from lists.

Forth has RECURSE and no tail-call optimization, so deep recursion overflows the return stack — the counted loop is not a stylistic preference but the only safe shape for anything large. The accumulator living on the stack is why no name is needed for it.

This is Maybe without the type: the two outcomes leave different numbers of cells, so a caller that skips the test is unbalanced for the rest of the program rather than merely wrong. UNLOOP before EXIT is mandatory — the loop's index and limit live on the return stack.

Both columns print the same words and mean quite different things by them. Where the reason genuinely matters, the Forth idiom is to return an error number alongside the flag and have the caller map it — which is Either Int a with the mapping left to you.

Standard Forth does define CATCH and THROW; this implementation omits them, and ABORT" is all that is left — which stops the program outright with no way for a caller to intervene. Testing first is therefore not merely the idiom but the only option.

There is no separate compile-time language with its own rules about what is allowed, because the same interpreter is running either way. That is the thing Template Haskell exists to provide and that CONSTANT gets for free.

This is a macro made of the same material as everything else: a word, on the same stack, able to read ahead in the source. Template Haskell needs a language extension, a separate compilation stage, and a quotation syntax to do the equivalent.

A genuinely new control structure — one that changes what the compiler does, like adding a loop form — needs an IMMEDIATE word, and Forth programs do this routinely. That is a step Haskell cannot take without Template Haskell or a preprocessor.

Both columns print the same two numbers, and the two source lines are mirror images of each other. This is the single most common slip for a Haskell reader writing Forth, and it goes unnoticed because both orders compile.

Most desktop Forths fold case, so an example typed in lowercase works in gforth and fails here. Defining : Greet does not define GREET, and nothing warns you that the two are different.

Haskell has no redefinition at all — a second let of the same name shadows rather than replaces, and the earlier binding is what earlier code captured. The behavior matches; the mechanism does not, and in Forth it applies to every word in the system.

5 TAKES-TWO supplies one argument, takes the 99 as the other, and answers 104 without complaint. Checking the stack with .S after any word you are unsure of is the habit this produces, because a wrong answer is the only symptom you will get.

🚨 Anything pushed with >R must be removed before the word returns, or the word returns to the wrong place and the system is gone. Inside a DO loop the index and limit are on that same stack, so R@ there reads a loop counter rather than what you stored. Note also that . . . prints the stack from the top down, which is why reversing it yields the original order.