Python.CodeCompared.To/Forth

A Forth program is a stream of words separated by spaces, and the interpreter runs each one as it reads it. : starts defining a new word — here named GREET — and ; ends the definition. Inside it, ." prints the text up to the next " (the space after ." is required, because ." is itself a word), and CR ends the line. The last line simply names the word, which runs it.

A number on its own does not print anything: it is pushed onto the data stack. The word . ("dot") takes the number on top of the stack and prints it, followed by a space. So 42 . means "push 42, then print what is on top".

Forth has two comment words. \ skips the rest of the line, and ( skips everything up to the next ). Both are ordinary words, so each needs a space after it: (comment) without the space would be read as an unknown word named (comment).

EMIT prints the character whose code is on the stack — 42 is * and 65 is A — and SPACES prints that many spaces. STARS uses a counted loop (DO … LOOP, covered below) to emit a star that many times.

." is meant for use inside definitions. To print text immediately, from the top level of a program, the standard word is .(, which prints everything up to the closing ).

Every Forth operator works on the stack: + removes the top two numbers and pushes their sum. Reading 2 3 + 4 * left to right: push 2, push 3, add them (leaving 5), push 4, multiply (leaving 20). The order the words are written is the order of evaluation, so there are no parentheses and no precedence rules.

Because values have no names, a Forth program reorganizes the stack instead. The four essential words are DUP (copy the top item), DROP (discard it), SWAP (exchange the top two) and OVER (copy the second item onto the top). In 10 3 OVER - +, OVER makes the stack 10 3 10, - leaves 10 −7, and + leaves 3.

.S prints everything on the stack, bottom first, without removing any of it, and DEPTH pushes how many items there were. Both exist for exactly the moment when a word leaves the stack in a shape you did not expect.

Three more shufflers cover most of what remains. ROT rotates the third item up to the top (1 2 3 becomes 2 3 1). NIP removes the item under the top. TUCK slips a copy of the top item underneath the second (1 2 becomes 2 1 2). SHOW3 prints three items in their stack order, bottom first.

Both inputs are needed twice, so 2DUP copies the top pair: 7 3 becomes 7 3 7 3. + turns the top pair into 10, leaving 7 3 10. Two ROTs move the 10 underneath (10 7 3), - leaves 10 4, and * leaves 40.

A word takes its arguments from the stack and leaves its results there, so there is no parameter list and no return. SQUARE duplicates the number and multiplies. CUBE uses SQUARE exactly the way it uses a built-in word — there is no difference between the two.

A word may leave any number of results, because returning is simply leaving values on the stack. /MOD is a built-in that leaves the remainder and then the quotient; DIVIDE swaps them so the quotient is underneath. The final SWAP . . prints the quotient first to match Python's order.

EXIT leaves the current word immediately, like a bare return. 0< replaces the number with a true or false flag, and IF … THEN runs its body only when the flag is true.

While a word is being defined, its own name is not yet visible, so a word calls itself with RECURSE. 1- subtracts one. When the number is 1 or less, ELSE drops it and leaves 1 instead.

Defining a word a second time does not replace the first definition — it adds a newer one that hides it. Words compiled earlier keep calling the definition that existed when they were compiled.

The usual operators are words that take two numbers and leave one. The one to watch is -: 17 5 - is 17 minus 5, because the item underneath is always the left-hand operand. / is integer division and MOD the remainder. NEGATE flips the sign, since a - in front of a word would just be part of its name.

Python's // rounds toward negative infinity, so -7 // 2 is −4. Plain / in Forth is allowed to round either way — the standard leaves the choice to each implementation — so a Forth program that cares names the rule. FM/MOD is floored division and SM/REM is symmetric (truncating toward zero). Both divide a double-width number, which S>D makes from an ordinary one, and both leave the remainder under the quotient.

Every value on the Forth stack is a cell: a fixed-size integer, the natural word size of the machine. Arithmetic past the end of a cell wraps around silently. LSHIFT shifts bits left, so 1 31 LSHIFT 1- is the largest positive 32-bit number.

Forth's answer to fractions is to work in whole units — cents instead of dollars — and scale by ratios. */ multiplies by the second number and divides by the third, and it keeps the intermediate product in double width so the multiplication cannot overflow before the division brings it back down.

Forth has a single current number base, stored in the variable BASE, and it governs both reading numbers in the source and printing them with .. HEX and DECIMAL set it to 16 and 10; 2 BASE ! stores any other base directly.

AND, OR and XOR work bit by bit, and INVERT flips every bit. LSHIFT and RSHIFT take the number and then the shift count.

A comparison in Forth leaves a flag on the stack, and a flag is an ordinary number: FALSE is 0 and TRUE is −1. There is no separate boolean type.

IF treats zero as false and any other number as true, just as Python treats 0 as falsy.

Forth's AND is the bitwise one. With real flags (0 and −1) that is the same as a logical "and", but 1 and 2 share no bits, so 1 2 AND is 0 — false — even though both numbers count as true. 0<> turns any number into a proper flag first.

WITHIN takes a number, a low bound and a high bound, and leaves true when the number is at least the low bound and less than the high one — the same half-open range as Python's 13 <= age < 20, and as range(13, 20).

The condition comes first, as a flag on the stack; then IF, the true branch, ELSE, the false branch, and THEN to close. 0= is true when the number is zero.

There is no elif. The usual Forth shape is a series of tests that each EXIT once they have handled the value. The first test needs the temperature again afterward, so it DUPs it and DROPs the copy when it matches; the second test consumes it.

?DUP duplicates the top item only if it is not zero. That makes the stack come out right on both branches: a nonzero count is still there to print after IF consumes its copy, and a zero leaves nothing behind to clean up.

DO … LOOP takes the limit and then the start: 5 0 DO is range(0, 5). Inside the loop, I pushes the current index. The limit is excluded, as in Python.

+LOOP adds the number on the stack to the index instead of adding one, so it can step by any amount, including negative ones.

In a nested loop, I is the index of the innermost loop and J is the index of the loop around it. Both are read from the return stack, where each DO keeps its counter.

BEGIN … WHILE … REPEAT is a while loop with the test in the middle: the code between BEGIN and WHILE computes a flag, and the loop continues while it is true. The step count rides underneath the number, and SWAP 1+ SWAP reaches under to increment it.

LEAVE ends a DO loop at once, like break. The arguments arrive in the order DO itself wants — the stop value, then the start — so the word does nothing to them before the loop begins.

VARIABLE SCORE reserves one cell of memory and defines SCORE as a word that pushes that cell's address. Nothing is read or written until you ask: ! ("store") writes a value to an address, @ ("fetch") reads one, and +! adds to what is stored there.

CONSTANT takes the number on the stack and defines a word that pushes it. Unlike a variable, a constant's name gives the value itself, so no @ is needed.

A VALUE is the middle ground: its name pushes the current value, like a constant, and TO changes it, like a variable.

>R moves the top item to the return stack — the stack Forth uses to remember where each word should return to — and R> brings it back. In between, the data stack is free to work on what was underneath.

CREATE SCORES defines a word that pushes an address, and 5 CELLS ALLOT reserves room for five cells right after it. CELLS converts a count of cells into a count of bytes. SCORE turns an index into the address of that element, which ! and @ then use like any other address.

, ("comma") stores a number in the next free cell of memory and moves past it, so a row of commas after CREATE builds an initialized array one element at a time. The loop fetches each element and adds it to a running total kept on the stack.

A word that works on an array receives its address and its count, the Forth equivalent of passing a list. 2 PICK copies the item two below the top — here the factor — without disturbing anything, and 2DROP removes the address and factor once the loop is done.

A record is a block of cells, and a field is the distance from the start of the block. POINT-X adds nothing, because x is the first cell, so its body is empty; POINT-Y adds one cell with CELL+. Applying a field word to a record's address gives the address of that field.

S" compiles the text into the word and, when the word runs, leaves two numbers on the stack: the address of the first character and the number of characters. TYPE takes that pair and prints it. NIP drops the address and keeps the length.

C@ fetches a single byte, so address I + C@ is the character at index I. [CHAR] s compiles the code of the letter s. The count is kept under the address, and SWAP 1+ SWAP reaches past the address to increment it.

A string literal's bytes should not be changed in place, so MOVE first copies them into WORKSPACE, a buffer reserved with ALLOT. MOVE takes a source address, a destination address and a length. UPPERCASE then subtracts 32 from every byte between a and z — the distance between lowercase and uppercase letters in ASCII — and stores it back with C!.

Joining strings means copying bytes into a buffer that is large enough, and keeping track of how much of it is in use. APPEND copies a string to the end of what is already in MESSAGE, then adds its length to MESSAGE-LENGTH. The length is saved on the return stack across the MOVE, which consumes it.

Two strings are equal when their lengths match and every byte matches. The first line compares the lengths and gives up early if they differ. The loop then compares byte by byte, and UNLOOP must come before an EXIT from inside a DO loop, so the loop's counters are cleared off the return stack first.

>NUMBER converts digits into a double-width number, starting from a double-width value already on the stack — the 0 0 here. It stops at the first character that is not a digit and leaves whatever is left of the string, so 2DROP discards the unconverted remainder and DROP keeps the low half of the result.

Forth converts a number to text with pictured numeric output. <# begins an empty picture, #S converts all the digits, and #> finishes, leaving an address and length ready for TYPE. The 0 before it widens the number to double width, which is what these words work on.

Each # converts exactly one digit, supplying a zero when the number has run out, so # # always produces two digits. HOLD inserts a character. The picture is built from the right: in .MONEY the two cent digits come first, then the decimal point, then the remaining dollars, and the dollar sign last.

To right-align, build the text first, then print as many spaces as the width has left over. SIGN adds a minus sign when the number it is given is negative, so the digits are converted from the absolute value while the original number waits underneath, and ROT brings it up for SIGN at the end. OVER - computes the width minus the text length.

' ("tick") reads the next word's name and pushes its execution token — a number identifying the word — instead of running it. EXECUTE takes an execution token off the stack and runs that word.

SHOW-EACH takes an array, its length and an execution token, and runs that word on every element. Built-in words have execution tokens exactly like defined ones, so ' NEGATE works as well as ' SQUARE.

:NONAME compiles a definition that has no name and, at the ;, leaves its execution token on the stack. VALUE TRIPLE stores that token under a name of our choosing, and TRIPLE EXECUTE runs it.

DEFER GREETING creates a word whose behavior is filled in later. IS stores an execution token into it. START-DAY is compiled once, but because GREETING looks up its current behavior every time it runs, changing it with IS changes what START-DAY does.

An array of execution tokens is a dispatch table. ' + , lays the token for + down in memory, exactly the way , laid down numbers in the arrays above. CALCULATE fetches the token at the chosen index and executes it, and the arithmetic word finds its two operands already waiting on the stack.

COUNTER is a defining word: using it defines a new word. The part before DOES> runs when COUNTER APPLES is executed — it creates APPLES and stores a 0 in its body. The part after DOES> becomes the behavior of every word made this way; it starts with the address of that word's own body on the stack, then increments the number stored there and leaves the new value.

An IMMEDIATE word runs while other words are being compiled, instead of being compiled into them. POSTPONE compiles a word into the definition in progress. So when CHECK is compiled, UNLESS runs and writes 0= IF into CHECK — a new keyword that closes with THEN just like IF.

Inside a definition, [ switches the interpreter back to running words instead of compiling them, and ] switches compiling back on. The arithmetic between them runs once, while WEEKS>SECONDS is being compiled, and LITERAL compiles the answer into the word as a plain number.

EVALUATE takes a string and interprets it exactly as if it had been part of the program's source, so the text can define words, print or leave values on the stack.

When the interpreter meets a word it cannot find in the dictionary and cannot read as a number, it reports it and abandons the rest of the input. The first GREET has already run by then; the last never does.

ABORT" takes a flag and, if it is true, prints its message, empties both stacks and returns control to the outermost interpreter, skipping everything still pending. If the flag is false it does nothing and the word carries on.

The everyday Forth way to report failure is to leave a flag on top of the results. SAFE-DIVIDE leaves the quotient and TRUE when it can divide, and only FALSE when it cannot. The vertical bar in the stack comment separates the two possible outcomes.

Forth's optional exception word set adds CATCH and THROW. CATCH executes a word and leaves 0 if it finished normally; THROW with a nonzero number unwinds back to the nearest CATCH, which leaves that number instead. An exception is identified by a number, not a class. Programs use positive numbers, because −1 through −4095 are reserved for the standard and the system.

Turtle graphics come from Logo, the 1967 teaching language, and Python ships them as its turtle module. A turtle has a position and a heading: FORWARD moves it the given distance, drawing a line, and RIGHT turns it clockwise by a number of degrees. Here those are Forth words that take their arguments from the stack like any other.

A star is five lines with a 144-degree turn after each. HOP lifts the pen, moves and puts it down again, so the turtle can travel without drawing. RING-OF-STARS repeats a star and a hop six times, turning 60 degrees each time to make the circle. SETPENCOLOR takes a color as a single number, written most easily in hexadecimal.

Each branch draws its trunk, turns left and draws a smaller tree, turns right and draws another, then turns back and retraces its trunk so the turtle ends exactly where it started. 3 4 */ scales the length to three quarters. The length stays on the stack through both recursive calls because each call begins with DUP, and the final BACKWARD consumes it.

?DO is DO with a safety check: if the start and the limit are equal, it skips the loop entirely, as range(0) does.

OVER copies the first argument, so AVERAGE consumes two numbers but leaves two: its answer and a stray 10 underneath. . prints the answer, and DEPTH reveals the item still on the stack.

= compares two cells, and a string is two cells — an address and a length. Comparing the lengths says they match; comparing the addresses says the two literals live in different places. Neither says anything about the characters.

When Forth reads a token, it looks it up in the dictionary before trying to read it as a number. Defining a word named 3 therefore changes what 3 means for everything that follows.