Rust.CodeCompared.To/Forth

The definition and the call are two separate acts, and the second one is what a reader would type at a prompt on the device. ." and CR only work inside a definition, which is why the greeting is wrapped in one rather than written at the top level.

The base is global mutable state that changes how every number is both printed and read from that moment on, which is why the last line switches back to DECIMAL. Forgetting to switch back is a classic Forth bug and has no Rust equivalent, because {:X} cannot leak into the next statement.

This is the debugging tool a Forth programmer reaches for first, and it has no Rust counterpart because Rust has no single place where in-flight values live. Note that .S leaves the stack exactly as it found it — unlike ., which consumes.

There is no build step to separate compile time from run time, so a program can extend itself while it runs — which is how a Forth system is debugged on hardware with no debugger attached. Rust deliberately gives this up in exchange for knowing the whole program before it ships.

Nothing in Forth is freed when a value is dropped, because nothing was allocated — the cell is simply no longer addressed by the stack pointer. The discipline Rust enforces at compile time is the programmer's own responsibility here, and the compiler will not mention it.

Forth has no way to express "another view of the same value" for something on the stack, so a copy is the only option and aliasing questions never arise. That is also why there are no lifetimes to annotate: nothing on the stack points at anything.

The stack comment is the whole interface, and it is a comment — nothing checks it. Note that it reads -- remainder quotient: /MOD leaves the quotient on top, so that is the one . prints first, and writing the comment the other way round would be a lie nothing would catch.

The dictionary entry BUFFER lives as long as the program does, so this particular address happens to stay good — but nothing said so, and a word returning the address of a temporary would compile and run exactly the same way. Lifetimes are the thing Rust adds; they are not a thing Forth removed.

Shadowing and stack depth look similar here and are not the same idea — Rust's inner binding disappears at the closing brace whether or not you use it, while the value on the stack stays until something consumes it. A word that forgets to consume leaves rubbish for its caller.

The body is point-free in the way a Rust iterator chain sometimes is, except that it is the only style available. There is no place to write i32, so SQUARE is equally willing to square an address, a character code, or a boolean flag.

This is why - subtracts the top of the stack from the cell beneath it: it is the spelling that makes 10 3 - mean what a reader expects. Getting the order wrong produces a perfectly valid program that computes the wrong thing.

This is a direct consequence of the dictionary being built as the source is read. Writing FACTORIAL inside its own body would find an earlier word of that name if one existed, and otherwise fail — which is occasionally what you want, and is how a redefinition can be written in terms of the version it replaces.

Swapping the two Forth definitions makes the file fail with "undefined word: DOUBLE", which is the single most common error when porting code into a Forth. It is not a style rule — it falls out of there being no separate resolution pass.

The comment is still the most important thing in a Forth definition, because it is the only statement of what the word expects and leaves. WRONG above compiles without complaint and consumes a cell it was never given, which will surface as a wrong answer somewhere else entirely.

Because the width is a property of the system rather than of the value, a program that assumes 32 bits is a program that will behave differently on a 64-bit Forth. Gforth on a desktop has 64-bit cells, so this row genuinely prints something else there.

The two columns agree here only because the Rust side spells out the behavior Forth gives you unconditionally. An embedded Rust programmer already knows this distinction from choosing between wrapping_, checked_ and saturating_; Forth offers the first and expects you to build the others.

The mask is the whole of the conversion, and nothing afterwards remembers that the value is supposed to be a byte — storing it with C! would truncate again, and storing it with ! would not. In Rust the type carries that intent from the cast to every later use.

🚨 /MOD's rounding is implementation-defined, and Forths genuinely differ: this one 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 — which is why the second line spells it out.

The <# … #> sequence is Forth's pictured numeric output: it builds the text right to left, one digit per #, with HOLD inserting the point — which is exactly what {:03} asks for. It has to build the whole number, not just the fraction, because . prints a trailing space and would put one in the middle.

A fixed-size array is the closest Rust analogue because nothing here is growable: ALLOT moves a pointer at the moment the source is read, so the size is fixed when the word is defined. Indexing past the end reads whatever word was defined next.

A Rust &mut guarantees it is the only live reference to that location; the address CELL-STORE pushes carries no such promise and can be copied freely. The two symbols read as "store" and "fetch", and getting their argument order backwards writes to the value instead of the address.

Using @ on this buffer would read four bytes at once and produce a number that depends on the machine's byte order. ERASE zeroes the region first because ALLOT does not — freshly allotted space holds whatever was there before.

Nothing is ever freed, which is the point: a Forth system's memory use is decided when the source is read, and there is no allocator to fail, fragment, or need a heap size chosen up front. The exact total is this system's own — a Forth with wider cells or a larger header reports more — so read it as "the eight bytes plus the bookkeeping", not as a number to depend on.

Neither word knows how large either buffer is, so a count larger than the destination quietly overwrites whatever follows it. copy_from_slice panics on a length mismatch, which is the whole difference between the two columns.

Nothing stops another word from writing a cell into POINT-Y that is not a coordinate, and nothing records that these two cells are one object. What Rust calls a field access is here an addition that happens to have a name.

This is the closest thing Forth has to a macro that generates an impl, and it is an ordinary word rather than a separate language. A Rust programmer coming from macro_rules! should note that nothing is expanded — PLUM is built at run time by running COLOR.

Writing the stride as a named constant rather than a literal 8 is the discipline that keeps this maintainable, since adding a field means changing one definition. Rust gets the same effect from size_of::<Sample>(), which it computes for you.

Storing in reverse order is the small piece of bookkeeping that a named-field struct literal does for you. Every Forth program of any size grows a naming convention to stand in for the namespaces it does not have — NEW- here, and / for sizes above.

The two cells are not bound together by anything, so NIP can throw the address away and keep the length. Rust makes the pair indivisible and guarantees the bytes are valid UTF-8; here they are bytes, and nothing checks what is in them.

Having two representations means every string-taking word must document which it expects, and COUNT is the bridge between them. The length byte caps a counted string at 255 characters, which is why the address-and-length form won and is what modern Forth code uses.

EXIT returns from the word early, and UNLOOP is required before exiting from inside a DO loop because the loop's index and limit are sitting on the return stack. Forgetting UNLOOP leaves them there and the word returns to the wrong place.

It returns rather than fails: the leftover string is how you discover it stopped early, which is the whole of the error reporting. Rust's parse returns a Result that names the failure, and unwrap is the choice to ignore it.

Reading THEN as "and then carry on" makes the shape make sense, and it is the word most often misread by newcomers as the start of the consequent. Any non-zero value counts as true, so a flag is not a distinct type the way Rust's bool is.

The limit is pushed first and the start second, which is the reverse of how the range reads aloud and is a reliable source of off-by-everything bugs. Here COUNT-TO receives the limit and pushes its own 0, so the order is visible in one place.

?DO is the version that tests first and is what you almost always want when the count comes from a variable. This is the single most dangerous default in the language for someone arriving from a language with real iterators.

The value being tested stays on the stack the whole time, so the loop ends with it still there and DROP has to clean up — the bookkeeping a let mut binding does for free. Forgetting that DROP is how a Forth word silently returns one cell too many.

The DROP before LEAVE is required because the reading is still on the stack and nothing else will remove it. A Rust break takes no such care, because the value belonged to a binding that is simply going out of scope.

This is Option without the type: the two outcomes leave different numbers of cells, so a caller that forgets to test is not just wrong, it is unbalanced. Rust makes the two cases the same size and the compiler refuses to let you read the value without checking.

Every level of the chain has to repeat that test, and a level that forgets it reads a value that was never produced. What ? really buys is not brevity but the impossibility of skipping the check.

Running 30 CHECKED would end the whole program, and because this Forth has no CATCH there is nothing a caller could do about it. That is why a Forth library tends to return a flag rather than abort — the decision to give up belongs to the application, not the word.

This Forth has no CATCH and THROW, so there is no stack unwinding to recover from an abort either. Standard Forth does define them; an example that needs them must define its own or say plainly that it cannot be done here. The two columns print the same words and mean quite different things by them.

The prefix convention is doing the work a trait does: it groups the words that belong to SENSOR and keeps them from colliding with RELAY's. What it cannot do is let a third word accept "anything describable", which is the next row.

This is a vtable with one entry, built by hand, and it is how a Forth driver is retargeted without recompiling its callers. Rust's &dyn Output carries the pointer and the table together and proves the type implements the trait; IS will happily install a word with the wrong stack effect.

A token being an ordinary cell means it can be stored in an array, passed through several words, or arrived at by arithmetic — and also that executing a number that was never a token will do something undefined. Rust's fn(i32) -> i32 is checked at the call site.

This Forth has no CASE statement, so a table is the idiomatic answer once there are more than two or three branches. There is no default arm and no bounds check: an index of 3 reads the cell after the table and executes it.

Because the value is computed at definition time by ordinary Forth, the expression can be as involved as you like — there is no separate const-evaluation language with its own rules about what is allowed. Rust's const fn exists precisely to widen that boundary.

Nothing marks the word as usable at compile time, because in Forth there is no such distinction to mark: the same interpreter is running either way. const fn is Rust naming a subset of the language that the compiler is willing to run itself.

This is a macro made of the same material as everything else: it is a word, it runs on the same stack, and it can do anything a word can do, including read ahead in the source. A Rust macro operates on token trees in a separate language with its own matcher.

This is the tool for interactive work on a device: load an experiment, try it, roll it back, and the system is exactly as it was. Rust has no equivalent because there is no dictionary and nothing is added at run time in the first place.

The interactive prompt is the runtime, and on a microcontroller it is typically a few kilobytes. That is the trade the two languages make in opposite directions: Rust removes what it does not need at build time, and Forth never had it.

A real device address would be a CONSTANT holding the number from the datasheet, and the store would look exactly like this one. There is no unsafe keyword because there is no safe subset to be outside of — which is the honest summary of the whole comparison.

Rust prints true where Forth prints -1, because a Forth true flag is all bits set, which is what makes AND and OR work on flags as well as on numbers. That is worth knowing before comparing a flag against 1.

The Rust version is bounds-checked on every write and the Forth version is not, which for this code costs Rust a comparison and buys it the guarantee that a wrong SIZE panics instead of corrupting whatever follows the buffer. The rest is identical.

Most desktop Forths fold case, so an example typed in lowercase works there and fails here — which means a snippet copied from a book or from gforth will often need its case corrected. Defining : Greet does not define GREET.

Rust's closure prints the same pair for the same reason: it captured the first scale, and the later let shadowed the name without reaching back. The difference is that Forth does this to every word in the system, so fixing a bug in a low-level word does not fix its callers until they are recompiled.

Checking the stack with .S after any word you are unsure of is the habit this produces. Rust's arity check is one of the things an embedded programmer gives up entirely when moving to Forth, and no amount of care fully replaces it — a wrong answer is the only symptom.

Nothing distinguishes an address from a measurement, a character code or a flag, so a word that expects one and gets another produces a number rather than a complaint. This is the root of most of the differences on this page, and it is also what makes the language fit in a few kilobytes.