第七章 資料的處理 : 堆疊和狀態 （States）
───────────────────────────────────────
符式以兩種方式來處理資料: 在堆疊上，或者在資料結構裡。本章的主題即在說明， 在何時、使用何種方法、以及如何來管理堆疊和資料結構。
優雅的資料堆疊
在符式的字間傳遞引數，最簡單的方法就是經由堆疊。此過程之所以"簡單"，是因為 所有從堆疊取出或堆入數值的動作都是隱含的。
───────────────────────────────────────
Moore的觀點:
資料堆疊使用了「資訊隱藏」的觀念。
在字間所傳遞的引數，並不需要在呼叫程 序中被明顯地表示出來。一個引數很可能潛行經過許多字而不被看到，甚至連程式設計
師都不會感覺到。原因很簡單，因為它根本不需要黑紙白字的寫出來才能被參考到。
───────────────────────────────────────
這種方式的一個重要結果是: 引數都未被命名。它們寄生在堆疊裡，而不是存在命了名 的變數裡。這是使符式成為簡潔語言的一個原因。但是它也是使寫作的不良的符式程式， 變的很難閱讀的一個原因。讓我們研究一下這種自相矛盾的情況。
堆疊的發明類比於語言中代名詞的發明。請參考下面一句話:
拿起這個禮物，將它以棉紙包好並將它放在盒子裡。
注意，詞"禮物"只提到一次。其後的"禮物"都是以"它"來代替。 "它"這種非正式的結構，增加了語言的可讀性（只要這個參考不是泛義的）。同樣 的，有了堆疊，這種隱藏式的引數傳遞，也會使程式有較高的可讀性。我們所重視的是 「程序」，而非程序之間的「引數傳遞」。 這個代名詞的比喻，也說明了為什麼有時符式會被寫的非常地難讀。如果有太 多的事物都使用著代名詞來參考的時候，即使是口語的說法也會變的語意混淆。
解開包裝紙並打開盒子。拿出禮物，將它丟掉。
這句話的問題在於，我們用"它"去參考了太多的事物。對於這個錯誤，有兩種解決的 辦法。最簡單的是使用一個真正的名稱，而不要用"它"：
解開包裝紙並打開盒子。拿出禮物，將盒子丟掉。
或者我們可以使用「前者」和「後者」這種詞。但是，最好的辦法還是將句子重新設計:
解開包裝紙並打開禮物。丟掉盒子。
在符式裡，也有類似的情況:
─────────────────────────────────────
提示
使用堆疊以簡化程式碼。但是，就單一個定義之內，不要堆的太深。 重新設計，或者，最後不得已時，使用一個命了名的變數。
─────────────────────────────────────
有些符式的初學者，看堆疊就像體操運動員看雙槓一樣: 是一個好玩的彈跳場所。但是， 畢竟堆疊是一個資料傳送的媒介，而不是特技表演的場所。 所以，下一個問題是，多深才算"太深"？ 一般來說，在一個定義裡，你最多祗能 管理三個堆疊元素。（對於雙整數長度的算術，每個"元素"佔有兩個堆疊位置，但邏輯 上，它們仍然被適當的運算元，諸如 2DUP 、2OVER 等等，當成一個元素來看待。） 在通常的堆疊操作詞集裡，ROT 是唯一可以存取堆疊第三個元素的字。除了 PICK 和 ROLL 之外（我們即將談到這些字），沒有任何字可以觸及更深層的元素。 從語言的類比關係來看，堆疊的三個元素等於三個代名詞：這個，那個和其它。
重新設計
讓我們看一個因方向錯誤而使堆疊混亂的例子。假設我們要寫一個 +THRU 的定義（參 考第五章，「程式列表的組織」一節中的"章節載入幕"部份）。我們的迴圈本體大概是 這樣的:
... DO I LOAD LOOP ;
也就是，我們將 LOAD 放在迴圈中，並安排"索引值"及"界限值"（index and limit） 以符合我們所要載入的絕對幕號。 我們的堆疊在開始時是:
lo hi
這裡的"lo"和"hi"是 BLK 的偏移值（offset）。 為了 DO 的運作，我們必需將它們變換為絕對冪號:
hi+1+blk lo+blk
最大的問題是將 BLK 的數值加到這兩個偏移值中。 我們已經走錯了方向，但現在還末發覺。所以繼續走下去。於是:
lo hi
BLK @
lo hi blk
SWAP
lo blk hi
OVER
lo blk hi blk
+
lo blk hi+blk
1+
lo blk hi+blk+1
ROT ROT
hi+blk+1 lo blk
+
hi+blk+1 lo+blk
搞好了，但卻是一團亂! 如果我們覺得受的罪還不夠，還有兩個更槽的做法，它們是:
BLK @ DUP ROT + 1+ ROT ROT +
和
BLK @ ROT OVER + ROT ROT + 1+ SWAP
所有的三個程序都做同樣的事，但是程式碼卻一個比一個糟，而不是更好。 經由過去的經驗，我們認識到『ROT ROT』的組合是個危險的信號：堆疊太擁擠了。 在還沒有找出別的辦法之前，我們已經看出了問題：一旦我們做了兩份"blk"的拷貝， 堆疊裡就會有四個元素。 這時，首先想到可以依賴的憑藉，就是返回堆疊：
BLK @ DUP >R + 1+ SWAP R> +
（參考隨後的"優雅的返回堆疊"一節。）這裡，我們將"blk"複製一份，先將其中的 一份存到返回堆疊中，另一份則與"hi"相加。 改善了一些。但是可讀性是否也增加了？ 下一步要考慮的是，"或許我們需要一個變數"。當然！我們原本就已經有了： 就是 BLK 。所以我們試著再定義：
BLK @ + 1+ SWAP BLK @ +
現在的可讀性比較高了，但還是太長，並且也太重複。『BLK @ +』出現了兩次。 『BLK @ +』？ 看起來似乎很熟悉。終於，我們的神經接上線了。我們回顧剛才 定義過的 +LOAD 的原始碼：
: +LOAD ( offset'--) BLK @ + LOAD ;
+LOAD 這個字應該是能被用來做這件事的。我們應該寫的是：
: +THRU ( lo hi--) 1+ SWAP DO I +LOAD LOOP ;
這裡，我們並沒有做出一個執行更快的版本，因為每當經過迴圈時，『BLK @ +』都
會被執行一次。我們製作的是一個更清楚，觀念更簡潔，並且更擁有可讀性的程式碼。在
這個例子裡，效率差（譯註：指的是執行速度）並不會被察覺到，因為它只在每個幕被載 入時，才會執行一次。
重新設計，或者重新思考，是在問題惡化之前，我們必需採取的步驟。
局部變數
大部份的時候，問題都能夠被適當的加以安排，使任何時刻的堆疊上，需要的引數 數量都只有幾個而已。但有時卻無能為力。 這裡有一個最壞情況的例子。假設有一個字 LINE ，它會在任意兩點之間畫一條線。 它所需要的座標順序為：
( x1 y1 x2 y2 )
其中 x1 y1 代表其中一點的座標，x2 y2 代表相對的另一點。 現在你需要定義出一個畫盒子的字 [BOX]。它以下列的次序取得四個引數：
( x1 y1 x2 y2 )
其中 x1 y1 代表盒子左上角的座標， x2 y2 代表右下角的座標。 你不僅有四個元素在堆疊上，而且當你畫線時，其中的每一項都會被參考到許多次。 雖然我們能自堆疊取得所需的引數，但是畫盒子的演繹法卻並不順著堆疊的本性。如果 你很急，不妨以最簡單的方法寫成：
VARIABLE TOP ( y coordinate: top of box)
VARIABLE LEFT ( x " left side)
VARIABLE BOTTOM ( y " bottom)
VARIABLE RIGHT ( x " right side)
: [BOX] ( x1 y1 x2 y2 --) BOTTOM ! RIGHT ! TOP ! LEFT !
LEFT @ TOP @ RIGHT @ TOP @ LINE
RIGHT @ TOP @ RIGHT @ BOTTOM @ LINE
RIGHT @ BOTTOM @ LEFT @ BOTTOM @ LINE
LEFT @ BOTTOM @ LEFT @ TOP @ LINE ;
我們製造了四個命了名的變數，每個座標一個。[BOX] 所做的第一件事就是先將堆疊 上的引數存入這些變數內，然後參考這些變數畫出四條線來。這種只在一個定義內被參考 的變數（有時是只在一個詞集內）稱為「局部變數」。 我有時會因為賣弄技巧而覺得內疚，因為我總是盡量地使用堆疊，而不願意去定義 一個局部變數。但是，有三個理由不應該這樣做： 第一，那種寫碼的方式很痛苦。第二，結果的可讀性會很差。第三，在設計上有所 改變時，或堆疊上的引數次序改變時，所有已經完成了的工作都要重新修正。『DUP』、 『OVER』和『ROT』這些字並不去解決問題，它們只是把東西安排到正確的位置上。 將這三個理由銘記在心，我的建議是：
─────────────────────────────────────
提示 特別是在設計階段，你只把要立即使用到的引數放在堆疊裡。其它的都做成局部 變數。（如果有必要，在最後的最佳化階段(optimization
phase)再來消除變數。）
─────────────────────────────────────
第四，如果這個定義對速度的需求很敏感，這些怪異的堆疊操作，（如 ROT ROT）真會把 時間都吃掉的。直接存取變數會比較快。 但是，如果時間真的很重要，你也許終究不得不改寫成組合語言的定義。此時所有的 堆疊問題也都迎刃而解，因為所有的資料都將參考到暫存器，或者間接地經由暫存器。幸 運的是，最混亂的堆疊引數的定義，通常都是以機器碼寫成。我們的 [BOX] 就是一個這 樣的例子，CMOVE> 是另一個例子。 在我們對 [BOX] 所採用的方法中，花了大約半小時在搞這些堆疊元素，但它仍不是 個最佳的解決辦法。最不舒服的是製造了四個變數，佔用了儲存名稱及其它東西所需的 記憶體，只是為了在這個常式中使用。這個代價也未免太高了些。 讓我再重複一次：這個例子所代表的是一種最壞的狀況，在大部份的符式應用裡很少 出現。如果字被分解的很好，則每個字會被設計得只做很少的事。做很少事的字通常就只 需要較少的引數。 在這個例子裡，我們面對的是兩個點，每個點以兩個座標表示。 我們能否改變設計？ 首先，LINE 可能是太基本了。它需要四個引數，因為它 要在任意兩點之間畫線，而且可能是條斜線。 其實我們畫盒子時，須要的是純粹的垂直和水平線。這個例子裡，我們可以將這些 畫線的字 VERTICAL 和 HORIZONTAL，寫的較有威力而又有通用性。每個字只要三個引數 ：起始位置 x y 及長度。這種功能上的分解，簡化了 [BOX] 的定義。 下面的語法對於使用者可能較為自然：
10 10 ORIGIN! 30 30 BOX
其中 ORIGIN! 將一個"兩元素的指標"設定為"origin"，也就是盒子的起點（左上角）。 然後『30 30 BOX』會相對於這個起點，畫出一個30單位高，30單位寬的盒子。 這種方法（也是設計的一部份）減少了 BOX 所需的堆疊引數的數量。
─────────────────────────────────────
提示
在決定哪一些引數要經由資料結構，而不是堆疊，來處理時，選擇那些較具永久性 的，或者是表示一個目前狀態的引數。
─────────────────────────────────────
PICK 和 ROLL
有些人喜歡字 PICK 和 ROLL。他們用這些字去存取堆疊任一層的元素。我不建議這樣的 用法。 其一是，PICK 和 ROLL 使程式設計師將堆疊看成是一個陣列，但事實上它並不是。 如果有許多堆疊元素需要 PICK 和 ROLL，這些元素應該放在陣列裡。 第二，它鼓勵程式設計師去參考一些由上層定義所留在堆疊上的引數，而這 些引數並沒有在這個定義中被明確的指出來。這會使得這個定義的運作要依賴其它 的定義。這是非結構化的 --並且很危險。 最後，一個元素在堆疊裡的位置，是由在它上面有多少個元素來決定，而在它上面 的元素數量卻是隨時會改變的。舉個例子，如果有一個地址在堆疊的第四個位置，你可 以寫
4 PICK @
來取得它的內容。但是你必需寫成
( n) 5 PICK !
來存入它。因為有"n"在堆疊上，現在它變成是第五個位置了。
類似這樣的程式碼很難讀，更難以修改。
製作堆疊圖表
當你要解決一個繁雜的堆疊情況，最好的方法是用紙和筆。有些人甚至製作表格，像圖
7-1所示。這種正式的工作（比使用電話賬單的背面要好）使堆疊記事成為清楚的輔助 性文件。
堆疊的提示
─────────────────────────────────────
提示 確定堆疊效果（stack
effects）在所有可能的控制流程下都能平衡。
─────────────────────────────────────
在圖7-1的 CMOVE> 堆疊註解裡，內層的左大括號標示出的部份代表 DO LOOP 的內容。 在進入此一迴圈時的堆疊深度與離開時一樣: 只有一個元素。在外層的大括號裡，IF 子 句的堆疊結果與 ELSE 子句一樣: 也只有一個元素留下。（留下的元素是什麼並不重要， 因此用"x"表示。）
─────────────────────────────────────
提示
當使用同一個元素去做兩件事時，先做那件執行的結果會留在堆疊較下方的事。
─────────────────────────────────────
例如:
: COUNT ( a -- a+1 # ) DUP C@ SWAP 1+ SWAP ;
（在這裏，你先取得計數值#）比較有效率的寫法是：
: COUNT ( a -- a+1 # ) DUP 1+ SWAP C@ ;
（在這裏，你先計算新地址 a+1）。
圖7-1 堆疊記事的例子
─────────────────────────────────────
提示
儘可能的使傳回的引數數量，在所有的狀況下都保持一樣。
─────────────────────────────────────
你經常需要一種定義，它平常做一些工作，但在有錯誤發生時，會傳回一個錯誤碼 以顯示出錯誤的發生。下面是一種可能的堆疊介面設計：
( -- error-code f | -- t)
如果旗號為真，操作就是成功的。如果旗號為假，就表示是失敗的，並且堆疊裡會有另一 個數值，用來表示錯誤的性質。 如果將介面重新設計，你可能會覺得堆疊的操縱變得比較容易些：
( -- error-code | 0=no-error )
它使用一個數值，同時代表旗號及（當錯誤情況時）錯誤碼。注意，在這裡使用了 相反的邏輯：非零表示一個錯誤。除了零以外，你可以用任何數值來代表錯誤碼。
優雅的返回堆疊****
使用返回堆疊來暫時地保存引數，將會如何？ 這是否是一種好的風格？ 有些人對這種用法，有著強烈的抗拒。但是，返回的堆疊確實對某種堆疊的雜亂 無章，提供了一個簡單的解決方法。CMOVE> 的定義就是個實際的例子。 如果你決定以這種目的來使用返回堆疊，請記住，你是使用著一個當初設計的目的 並不為此的詞集。（參看本章稍後「元件的共用」部份）。 這裡有一些避免傷害的建議：
─────────────────────────────────────
提示
1. 保持返回堆疊的運作是對稱的。 2.
在控制流程的各種條件下，都要將返回堆疊的運作保持對稱。 3. 在分解定義時，防止下面的情況：一部份包含著一個返回堆疊的運作元，而與
它互補的運作元卻在另一部份中。 4. 如果在『DO LOOP』裡使用，返回堆疊的運作元必需在迴圈裡是對稱的，而且
在被『>R』和『R>』所界定的程式段中，『I』不再有效。
─────────────────────────────────────
在一個定義裡，每一個『>R』必需有一個『R>』。有時候，運作元看起來是對稱的 ，可是由於控制結構的關係，它實際上並不對稱。例如：
... BEGIN ... >R ... WHILE ... R> ... REPEAT
如果這個結構被用在應用程式的最外層迴圈中，在你跳出以前，每一件事都會執行 的很順暢（可能是一小時之後），可是突然間程式就當掉了。怎麼回事？ 因為最後一次
經過迴圈時，平衡對稱的動作『R>』被跳過了。
變數的問題
雖然我們對目前有興趣的資料都放在堆疊上處理，但是我們卻仍然倚賴著變數來儲存大部 份的資料。一段程式碼可以在不知道任何有關這個變數是如何被使用的、是要被誰使用的 、或在何時何地能夠被使用的情況下，就能改變這個變數的內容。另一段程式碼也可以 取得變數的內容並且使用它，而不用知道這個數值是來自何方。 每一個將數值堆上堆疊的字，必定有另一個消耗掉該數值的字。堆疊給我們「點對 點」的通訊，就像郵局一樣。 變數，從另一個角度看來，可以被任一個命令設定，並且可以被任一個其他的命令 存取無限多次 --或者完全不去使用它。變數是為每一個人而準備的，誰管它看起來像 什麼。 因此，變數可以被用來反應出事物的目前狀態（current state）。 使用「目前狀態」可以簡化問題。在第四章的羅馬數字裡，我們使用變數 COLUMN# 代表目前處理的"X位數"； 字『ONER』『FIVER』『TENER』依此資料來決定該顯示什麼 符號。我們不必每次都提到所要處理的位數，如『TENS ONER』、『TENS FIVER』等等。 換一個角度來看，「目前狀態」卻增加了程式新一層的複雜度。為了使某物成為"目 前的"，我們必需先定義出一個變數，或某一種資料結構。如果在它被設定之前，程式中 就已經有其它的部份需要參考它，那麼就要記得做初值設定。 變數的另一個更嚴重的問題是，它們是不能被"再進入"（re-entrant）的。在多工 的符式系統裡，一件需要局部變數的"工作"（task），必需有它自己的一份這個變數的 拷貝。符式的 USER 變數就是為了這項任務而設。（參考Starting Forth 第九章， "Forth Geography" 部份。） 即使在單一的工作中，一個參考變數的定義，也比經由堆疊來傳送引數，更難測試、 驗證、及再使用（resue）。 假設我們要發展一個文書處理器。我們需要一個程序，它能計算出目前的游標位置與 前一個換行動作之間的字元數量。所以，我們必需有一個字，它使用『DO LOOP』，自目 前的游標位置（ CURSOR @ ）開始，直到第零個位置結束，在其間向前搜尋"換行"這個字 元。 一旦在迴路中找到這個字元，我們就將它的相對位置從目前的游標位置中減去
its-position CURSOR @ SWAP -
以決定它們之間的距離。 這個字的堆疊效果如下:
( -- distance-to-previous-cr/lf)
在稍後的程式碼裡，我們又發現需要另一個類似的字，它計算從任意一個字元 --不 在目前游標的位置上-- 至前面第一個換行字元之間的距離。結論是，我們要將『CURSOR @ 』分解出來，並將這個"開始位置"當做是一個堆疊引數來傳遞，結果是:
( starting-position -- distance-to-previous-cr/lf)
將變數的參考分解出來，我們就能使這個定義變的更有用。
─────────────────────────────────────
提示
除非會使堆疊變的雜亂而導至難以認讀的情況發生，否則應該儘量地經由堆疊來 傳遞引數，而不要經由變數。
─────────────────────────────────────
───────────────────────────────────────
Kogge的觀點：
從數學的意義來看，符式的模組性大多來自於：將符式的"字"像"功能"一樣的設計 和看待。在我的經驗裡，符式的程式設計師除了最重要的整體變數之外，都盡量避
免定義任何變數（我的一位朋友有個「拜託避掉變數」的貼紙在他的桌上），並且 試著寫出所謂「參考上是透明的（referential
transparency）」字；也就是，給 它相同的堆疊輸入，這個字總是產生相同的堆疊輸出，而不受它內部那些更具總體
性的文句的影響。事實上，這個特性正是我們在獨立測試一個字時所使用的。沒有 這種特性的字會非常地難以測試。在某種意義上，一個內容經常改變的「有名字的
變數」，是僅次於現在已經被"禁止使用"的 GOTO 敘述的次一糟糕的東西。
───────────────────────────────────────
稍早我們曾建議使用局部變數，特別是在設計階段中，用來避免堆疊的擁擠情況。應該注 意的是，這種做法需要變數只在一個定義內被參考到。在我們的例子裡，[BOX] 從堆疊 接收四個引數，並立刻將它們載入到局部變數，供它自身使用。這四個變數沒有在這個 定義之外被參考，因此，它的運作就會很安全。 對於不習慣一種「資料可以被隱含地傳遞」的電腦語言的程式設計師而言，總是 不能充份地使用堆疊。Michael Ham覺得，可能是因為符式的初學者不信任堆疊[1]。 他承認在開始時的感覺是：數值儲存在變數裡似乎要比留在堆疊上安全得多了。他懷疑， 「在堆疊經過劇烈的攪和之後，資料不知道會變成什麼模樣？」 經過一段時間之後，他才體會到「如果字能管好它自己的事，只在它們期待的輸入 和輸出上才去使用堆疊，而且在用完之後，會將它清理乾淨。那麼，字就可以被看成是一 種封閉的系統 ... 我能夠在一個迴圈開始時，先在堆疊上放個值，在它走過整個常式中 的每一個循環之後，在迴圈結束的地方，它又出現在堆疊的頂端，沒有一絲一毫位置 上的差錯。」
局部和整體變數／初值設定
就如我們先前所見，一個變數，若祗被使用在一個定義（或一個詞集）之內，並對其它 的程式碼隱藏起來，就稱為局部變數。一個使用在超過一個以上的詞集中的變數，稱為 整體變數。如前面的章節中所見，一組整體變數，若它綜合著描述出幾個詞集之間的介 面，就稱為「介面詞集」。 局部變數和整體變數對符式而言，是沒有差別的。但是，對符式的程式設計師卻是 不同的。
───────────────────────────────────────
Moore的觀點:
我們必需為讀程式碼的人而寫。如果某件事只是在局部被參考，例如一個暫時用來累積
總合的變數，那我們就該將它定義為局部變數。順手就將它定義在所使用的區塊內，讓 你可以看到它的註解。
但是，如果它被到處都使用著，我們就必須依其邏輯上的功能來歸類，將它們集中在分 開的一個幕中。一個一行，並且跟著一個註解。
問題是，你要在何處做它們的初值設定？有些人說可以緊接在定義之後。但這樣做會 弄亂註解，而且也就不能留下足夠的空間，做比較完整的註解。另外，這樣做也會使初
值設定的動作，散佈在應用程式中各處。 我傾向於，在載入幕中做所有的初值設定。在所有的區塊都載入了之後，再做必需的初
值設定，也許同時也設定一些表格，或做一些起始的動作。 如果你的程式最後是要做目標編譯（Target compiled），那麼，也很容易在此地寫出一
個執行所有初值設定的字。 它還可以做的更精巧些。我曾經在使用ROM的系統裡定義變數，它們的值存放在高記憶體
內的一個RAM陣列中，初值則被存在ROM中。做初值設定，就是將ROM初值拷貝到RAM陣列 中。但是，通常的情況是只需要設定幾個初值不為零的變數。
───────────────────────────────────────
狀態的保存和恢復
變數有一種特性，就是當你改變它的內容時，也同時毀掉了原先在該處的值。讓我們看 一下這件事所會引發的問題，以及我們解決的對策。 BASE 是一個變數，它表示所有輸入和輸出的數值，目前所遵循的進位制。以下的 字在符式系統裡經常可以見到：
: DECIMAL 10 BASE ! ;
: HEX 16 BASE ! ;
假設我們寫了一個字，用來"顯示"（dump）一堆記憶體的內容。目前我們工作在十進 制下，但是卻要用十六進制去顯示它的內容。所以我們寫:
: DUMP ( a # --)
HEX ... ( code for the dump ) ... DECIMAL ;
這種做法是可行的 --在大部份的時候。但這需要一個前題，就是，最後是要回到十進制 的。如果它原先就在十六進制下，做完後仍然要留在十六進制，這又該如何？在我們將 BASE 改成 HEX 之前，必需先保存它目前的值。在完成顯示之後，再將它還原。 這就是說，在我們做的時候，必需先暫時地將原先的數值保存起來。返回堆疊是個 可以用來做這件事的地方：
: DUMP ( a # -- )
BASE @ >R HEX ... (code for dump) ... R> BASE ! ;
如果事情變的太複雜，我們就必需定義一個暫時的變數:
VARIABLE OLD-BASE
: DUMP ( a # -- )
BASE @ OLD-BASE ! HEX ... (code for dump) ...
OLD-BASE @ BASE ! ;
你看，事情很快地就變得複雜了。 在這種情況下，如果一個變數的"目前"和"先前"的版本都只是屬於你的應用部份 （而不是系統部份），而且這種狀況出現不只一次，那麼就可以使用分解的技術:
: BURY ( a --) DUP 2+ 2 CMOVE ;
: EXHUME ( a --) DUP 2+ SWAP 2 CMOVE ;
然後，只需定義一個雙長度的變數，以取代原來必須定義的兩個變數，如 CONDITION 和 OLD-CONDITION。此變數為：
2VARIABLE CONDITION
使用 BURY 和 EXHUME 來保存和還原這個變數：
: DIDDLE CONDITION BURY 17 CONDITION ! ... (diddle) ...
CONDITION EXHUME ;
BURY 在『CONDITION 2+』之處保存了"舊"版本。 你還是要很小心。回到我們 DUMP 的例子，假設你要增加一個比較方便的功能， 讓使用者在任何時刻，只要按"escape"鍵，就立即離開DUMP，停止顯示。 所以，在迴圈裡，你構建了一個按鍵檢查，當"escape"鍵被按下時，就執行『QUIT』。 但是結果如何？ 使用者由十進制開始，鍵入『DUMP』。他在 DUMP 的途中跳出，發現他自己，很奇 怪的，竟然是在十六進制的狀態下。 在這個簡單的例子裡，最好的解決辦法是，不要使用『QUIT』，寧願使用一個受控制 的跳離指令（如 LEAVE，或其它指令）來跳出迴圈，而回到定義中 BASE 被還原的地方。 在非常複雜的應用裡，一個受控制的跳出，通常是不切實際的，因為可能還有許多 變數必需被還原為某一狀態。
───────────────────────────────────────
Moore對這個例子的反應：
你真是打了個死結。你是在自找麻煩。如果我需要一個十六進制的 DUMP ，我就會說 HEX DUMP。如果我要的是十進制的 DUMP，我就說
DECIMAL DUMP。我才不讓 DUMP 有 權弄亂我的環境。 在結束時恢復一種狀態和在開始時建立一種狀態，這兩者之間有一種哲理上的選擇。
有很長一段時間，我覺得必需在結束時將狀態恢復。並且我會盡量試著在各處都保 持一致的做法。但是，要決定什麼地方是"各處"並不容易。所以，現在我寧願在開始
前建立狀態。 如果我有一個字，它很在意東西的位置，那它最好自己去設定它們。如果另外有別人 改變了它們，它也不必費心地去重置（reset）。
出口總是比入口要多一些。（譯註：意思是說，如果選擇使用"恢復"狀態的做法， 那麼，就需要在每一個出口都做這些事，因此，也就多做了許多工作。）
───────────────────────────────────────
如果需要在完成一件事之前，做重置狀態的工作，在這種情況下若能有單一個字（我 稱它為 PRISTINE）來做這件工作，將會是很有幫助的。我使用 PRISTINE 的情況為：
• 在應用程式中，正常的離開（exit）之處。 • 在使用者有意離開之處 （在 QUIT 之前）。 • 在任何可能發生致命錯誤，引起中止（abort）之處。
最後，當你遇到這種必需保存／恢復一個數值的情況時，要確定它並不是因為不良的分解 而造成的。例如，假使我們已經寫了：
: LONG 18 #HOLES ! ;
: SHORT 9 #HOLES ! ;
: GAME #HOLES @ 0 DO I HOLE PLAY LOOP ;
目前的 GAME 不是 LONG 就是 SHORT。 稍後，我們決定需要一個字來玩任何數目的洞。所以我們借助 GAME， 以確定不 會毀掉 #HOLES 目前的數值：
: HOLES ( n -- ) #HOLES @ SWAP #HOLES ! GAME #HOLES ! ;
因為我們是在定義了 GAME 之後，才發覺需要 HOLES，所以它看起來似乎比較複雜；我 們是使用 GAME 來建立 HOLES。但是事實上 --也許你已經看出來了-- 再想一下它的順 序：
: HOLES ( n --) 0 DO I HOLE PLAY LOOP ;
: GAME #HOLES @ HOLES ;
我們用 HOLES 來建立
GAME，因此省去了那些無意義的儲存和恢復的動作。
應用上的堆疊
在上一節裡，我們學習了幾種保存和恢復一個先前數值的方法。在有些應用中，也許需要同時保存和恢復幾個數值。你會發現，解決這類問題的最好辦法是，定義出你自己的堆疊來。 這裡有一個建立使用者堆疊的程式碼，它也包含簡單的錯誤檢查（若錯誤發生，則堆疊會被清除）：
CREATE STACK 12 ALLOT \ { 2tos-pointer | 10stack [5 cells] }
HERE CONSTANT STACK>
: INIT-STACK STACK STACK ! ; INIT-STACK
: ?BAD ( ?-- ) IF ." STACK ERROR " INIT-STACK ABORT THEN ;
: PUSH ( n --) 2 STACK +! STACK @ DUP STACK> = ?BAD ! ;
: POP ( -- n ) STACK @ @ -2 STACK +! STACK @ STACK < ?BAD ;
字 PUSH
從資料堆疊上取出一個數值，並將它"堆入"這個新的堆疊。POP 則相反， 它從新的堆疊"取出"一個數值，並將它放到符式的資料堆疊上。
在實際的應用裡，你或許需要改變 PUSH 和 POP 的名字，以符合觀念上的意義。
元件的共享
─────────────────────────────────────
提示
將元件使用在與原先設計目的不同的場合中是可以的，只要：
1. 所有對這個元件的使用都是互不砥觸的。 2. 每當以中斷方式（不論是硬體或軟體）去使用一個元件時，在用完之後，必須 將這個元件的先前狀態恢復。
否則，你就需要增加一個元件，或者增加一層的複雜度。
─────────────────────────────────────
返回堆疊是這種原則的一個簡單例子。它是符式系統的一個元件，被設計來保存一個高 階字（冒號定義）的返回地址。因此，它能告知你曾在何處及將到何處。把返回堆疊當 做是數值的暫時儲存之所，是可能的，而且在有些情況下也是必要的。但是，如果忽視 了上面提到的限制，就會產生問題。 在我的文書排版器（text formatter）裡，輸出可以是"看不見的"（invisible）。 這種功能有兩個目的：（1）允許先一步向前查看（lookahead），看看是否有什麼東西 恰好可以填入空檔，以及（2）用來編排目錄（能對整個文件加以編排，以決定頁數， 但卻不必實際地輸出任何東西）。 我曾以為，一旦加上了能使輸出變為不可見的這種功能之後，就能使用它同時達 到上面那兩個目的。不幸的是，這兩個目的並不是互不砥觸的。 讓我們看一下，如果違反了提示中的規定會有什麼結果。假設『顯示』這個詞 負責輸出。而且，它能經由狀態的判斷，知道是否輸出是要可見的，或是隱藏的。 『可見』和『不可見』這兩個詞分別用來設定這兩種狀態。 我那個「往前查看」的程式碼首先執行『不可見』，然後假裝編排接下來的文 句，以決定它的長度是否合適，最後再執行『可見』將事情恢復為原來的樣子。 它這樣工作的很正常。 之後，我加上了編排目錄的功能。它首先執行『不可見』，然後編排整個文件以決定 頁數等等；最後執行『可見』將事情恢復為常態。 問題來了？假設我正編排一個目錄，並且碰到了一個需要使用「向前查看」功能的 地方。當我結束向前查看時，我執行了『可見』。突然間，在應該做編排目錄時，卻開 始印出文件來。 解決的方法？有好幾種。 其中之一認為，由於引起問題的原因是因為「向前查看」的程式碼毀掉了可見／不 可見的旗標，而這個旗標也許已經被「編排目錄」的功能設定了。因此「向前查看」的 程式碼就應該負責旗標的保存及恢復。 另一種解決的方法認為，需要保有兩個分別的變數，一個用來指示我們正在「向前查 看」，另一個用來指示我們正在「編排目錄」。『顯示』這個詞在兩個旗標都是"假"的 狀態時，才做真正的輸出。 後一種解決方案有兩種方法來完成，端視你要如何分解這個問題。首先，我們 可以將一個條件"巢入"（nest）另一個條件之中:
: [顯示] ... ( 原先做輸出的定義 ) ... ;
變數 做查看 ( t = 向前查看 )...
: <顯示> 做查看 讀取 不是 如果 [顯示] 然後 ;
變數 編目錄 ( t = 編排目錄)
: 顯示 編目錄 讀取 不是 如果 <顯示> 然後 ;
『顯示』檢查若不是在編排目錄，則呼叫『<顯示>』，它再檢查若不是在「向前查看」 ，則呼叫『[顯示]』。 在發展的過程中，做輸出的詞『[顯示]』原本是被命名為『顯示』的。之後，一 個新的『顯示』包含了「向前查看」的檢查，而將原來的定義改名為『[顯示]』。我們 向內增加了一層複雜度，但卻不用改變任何使用『顯示』的程式碼。 最後，當加入編排目錄的功能時，又一個新的『顯示』被定義出來，它包含編排目錄 的檢查，而『顯示』再度被重新命名為『<顯示>』。 這是使用兩個變數的兩種解決方法之一。 另一種是在單一個字裡包含兩種測試：
: 顯示 做查看 讀取 編目錄 讀取 或 不是 如果 [顯示] 然後 ;
但在這個特殊的例子，還有另一種方法可以把這些混亂簡化。我們可以使用一個變 數，不把它當做旗標，而是把它當做計數器使用。
變數 '不可見 (t = 不可見)
: 顯示 '不可見 讀取 0= 如果 [顯示] 然後 ;
: 不可見 1 '不可見 加存 ;
: 可見 -1 '不可見 加存 ;
「向前查看」的程式碼在開始時呼叫『不可見』，它將計數值加一。若以非零值表示 "真"，則『顯示』將不做輸出。在結束查看之後，程式碼再呼叫『可見』，它會將計數 值減一而回到零（假）。 「編排目錄」的程式碼也是以呼叫『不可見』開始，以『可見』結束。如果我們在 執行中叫用了「向前查看」的功能，第二個『不可見』的呼叫就會將計數值增加至2。 接下來的『可見』將計數值減一，所以輸出仍然是看不見的，直到編目錄的動作被完成。 （注意，我們必需以 0= 代替 NOT（不是）。在1983年的符式標準裡，NOT 的行為 被改成「產生1的補數」，所以，『1 NOT』的值（0FFFE）會被視為"真"，所以不能 使用在這個情況中。順便提一下，我個人覺得這種改變是個錯誤。） 但是，這種使用計數值的方法很危險。它要求指令成對地使用：連續做兩個『可見』 有可能會產生『不可見』的結果。除非『可見』的定義會限制計數值不會變為負值：
: 可見 '不可見 讀取 1- 0 取較大值 '不可見 存入 ;
狀態表（The State Table）
單一個變數可以表示單一種狀況，不論它是一個旗標，一個數值，或一個功能的地址。 許多狀況集合在一起，可以表示一個應用程式或特殊元件的狀態。有些應用需要能 夠將目前的狀態保存下來，並在稍後將它恢復，或者具有幾種可以變化的狀態。
─────────────────────────────────────
提示 當一個應用需要同時控制一組狀態時，可以使用狀態表（state table），而不要用 幾個變數。
─────────────────────────────────────
圖 7-2 相關變數的集合
VARIBLE TOP VARIBLE BOTTOM VARIBLE LEFT VARIBLE RIGHT VARIBLE INSIDE VARIBLE OUT
需要保存和恢復狀態的一個簡單的例子是，假設我們開始時有六個變數代表一個特殊元件的狀態，如圖7-2所示。
現在我們要將它們全部保存起來，以便其它的處理程序能夠進行，稍後再將它們全部恢復。我們定義：
: @STATE ( -- top bottom left right inside out )
TOP @ BOTTOM @ LEFT @ RIGHT @ INSIDE @ OUT @ ;
: !STATE ( top bottom left right inside out -- )
OUT ! INSIDE ! RIGHT ! LEFT ! BOTTOM ! TOP ! ;
這樣，我們就能將堆疊裡所有的數值都保存起來，直到恢復它們的時機到來。或者用另一種方法，對應以上的每一個變數，再定義出另一組變數，並用它們分別的儲存對應的每一個變數值。
但是，另外一種更好的技巧是，製造一個表，表裡的每一個元素都能以名字來參考。
然後，製造一個有相同長度的第二個表。如圖7-3所示。我們可以將稱為 POINTERS 的第一個表，拷貝到稱為 SAVED 的第二個表以保存狀態。
圖 7-3 保存一個狀態表的觀念模式
我們已經將這種方法的實現寫在圖7-4中。
圖 7-4 保存/恢復狀態表的程式碼
0 CONSTANT POINTERS \ address of state table PATCHED LATER
: POSITION ( o -- o+2 ) CREATE DUP , 2+
DOES> ( -- a ) @ POINTERS + ;
0 \ initial offset
POSITION TOP
POSITION BOTTOM
POSITION LEFT
POSITION RIGHT
POSITION INSIDE
POSITION OUT
CONSTANT /POINTERS \ final computed offset
HERE ' POINTERS >BODY ! /POINTERS ALLOT \ real table
CREATE SAVED /POINTERS ALLOT \ saving place
: SAVE POINTERS SAVED /POINTERS COMVE ;
: RESTORE SAVED POINTERS /POINTERS CMOVE ;
注意，這個程式碼裡的指標名稱，如『TOP』,『BOTTOM』等等，總是會傳回一個固定的地址。不論何時，對任一個狀態，都只有一個位置代表著它目前的數值。
也請注意，我們將 POINTERS（表的名稱）用 CONSTANT 定義，而不是用 CREATE ，並且先用了一個假數值（零）。這是因為我們在 POSITION 這個定義字之中，需要參考到 POINTERS（但並不去執行它，因為它是出現在"執行時區"之內），直到我們定義了全部的欄位名字，並且知道了表的大小之後，才能實際地去 ALLOT 它。
在我們建立所有的欄位名稱後，我們就將表的大小定義為常數 /POINTERS 。最後再依它的起始位址（HERE）去修正常數 POINTERS ，並且為表的本身保留下空間。（字>BODY 是用來將『'』所傳回的地址，轉換為儲存著常數數值的地址）所以 POINTERS就能傳回稍後才被配置出來的表的起始地址，就如同表是用 CREATE 所定義，並且空間也跟著立即配置的情形一樣。
雖然在編譯時，修改常數值是可行的，如同我們在此地所做的。但是有一個文體上的限制：
─────────────────────────────────────
提示 一但應用程式被編譯完成之後，一個常數的數值是絕對不應該去改變的。
─────────────────────────────────────
交替狀態（alternating states）的例子比較複雜。在這種情況下，我們需要在兩個 狀態（或者更多）之間轉換，而在我們跳到一個狀態時，絕不能毀掉另一個狀態。圖7-5 顯示這種狀態表的觀念模型。
圖7-5 交替狀態表的觀念模型
在這個模型裡，名稱『TOP』,『BOTTOM』等等，被設計成可以指到兩個不同的表， REAL 或 PSEUDO 中的一個。如果 REAL 表是目前的一個，則所有的指標名稱都會參考到它的地址，如果 PSEUDO 表是目前的一個，則會參考到 PSEUDO 表的地址。
圖7-6 實現交替狀態的機構的實際程式碼
VARIABLE 'POINTERS \ pointer to state table
: POINTERS ( -- adr of current table ) 'POINTERS @ ;
: POSITION ( o -- o+2 ) CREATE DUP , 2+
DOES> ( -- a ) @ POINTERS + ;
0 \ initial offset
POSITION TOP
POSITION BOTTOM
POSITION LEFT
POSITION RIGHT
POSITION INSIDE
POSITION OUT
CONSTANT /POINTERS \ final computed offset
CREATE REAL /POINTERS ALLOT \ real state table
CREATE PSEUDO /POINTERS ALLOT \ temporary state table
: WORKING REAL 'POINTERS ! ; WORKING
: PRETENDING PSEUDO 'POINTERS ! ;
圖7-6是這種交替狀態機構的實際程式碼。字 WORKING 和 PRETENDING 會依情況改變指標。
例如：
WORKING
10 TOP !
TOP ? 10
PRETENDING
20 TOP !
TOP ? 20
WORKING
TOP ? 10
PRETENDING
TOP ? 20
後一種方法的主要不同點是，它的名字經過額外的一層間接（indirection）才取得地址
（POINTERS 由原先的常數定義被改變為冒號定義）。欄位的名字因此可以指到兩個狀態表中的任一個。每個名字因此需要多做些工作。
前一個方法的名字都參考到固定的位置，所以在每次保存或恢復數值的時候，都需要做『CMOVE』。在後面這個方法裡，我們只需改變一個指標即可。
向量式的執行（Vectored Execution）
向量式的執行將"目前"（currentness）和"間接"（indirection）的觀念，從「資料」 擴展到「功能」。就如我們可以在變數裡保存數值和旗標一樣，我們也可以保存功能， 因為功能可以經由地址參考到。 傳統上實現向量式執行的技術，已在〈Starting FORTH〉一書的第九章裡解釋過。在 這節中，我們將討論一種我發明的新語法。我認為在許多情況下，它比傳統的方法要雅 緻得多了。 這個語法稱為 DOER/MAKE。（如果你的系統沒有這些字，可以參考附錄B中的程式碼 和實現細節）。它的工作方式是：你先使用定義字『DOER』定義出一個字來（我們稱它為 "DOER字"，或 DOER 的孩子，它的行為是向量式的），就像是：
DOER PLATFORM
開始時，『PLATFORM』不做任何事。然後，你可以定義一些字，並在其中使用『MAKE』 來改變『PLATFORM』所要完成的工作：
: LEFTWING MAKE PLATFORM ." proponent" ;
: RIGHTWING MAKE PLATFORM ." oponent" ;
當你呼叫『LEFTWING』時，片語『MAKE PLATFORM』會改變『PLATFORM』的工作。之後， 如果你鍵入『PLATFORM』，你將會看到：
LEFTWING ok
PLATFORM proponent ok
RIGHTWING 會使 PLATFORM 印出"opponent"。你可也以在一個定義裡使用 PLATFORM
: SLOGAN ." Our candidate is a longstanding" PLATFORM
." of heavy texation for business. " ;
命令
LEFTWING SLOGAN
將顯示出一個競選標語，而
RIGHTWING SLOGAN
將顯示出另一個。 "MAKE"這部份的程式碼可以是任何符式碼，不論多長或多少；只要記住，必需以分 號結束。在 LEFTWING 定義中的結束分號，同時供 LEFTWING 的定義和 MAKE 之後的 程式碼使用。當 MAKE 重定"DOER字"的執行向量時，它也同時結束目前含有 MAKE 這個字 的定義的執行。 例如，當你呼叫 LEFTWING 時，MAKE 重定 PLATFORM 的向量並離開 LEFTWING 。呼 叫 LEFTWING 並不會使"proponent"這個信息被印出。圖7-7試著使用一個概念化的字典 來解釋這點。
圖7-7 DOER 和 MAKE
如果你想要"繼續地"執行，就使用『;AND』這個字來代替分號。『;AND』在設定了 DOER 字的執行向量之後，（;AND 同時也是這個向量的執行碼的終點），再繼續執行接 在它後面的定義，如圖7-8所見。
圖7-8 使用『;AND』來並聯多個『MAKE』
最後，你還可以將設定"DOER字"的動作"串聯"起來（不是使用 ;AND）。圖7-9 所做 的解釋會比用寫的還要清楚些。
圖7-9 多個 MAKE 串聯
DOER/MAKE 的使用
有很多種狀況，可以從 DOER/MAKE 的結構得到益處。它們是：
1. 用來改變一個功能的狀態（當外部不需要測試並得知它的狀態時）。例如字 LEFTWING 和 RIGHTWING 改變 PLATFORM 的狀態。 2. 從相似的定義中分解出內部片語，即使它是在（例如 LOOP 的）控制結構之內。 考慮一個名為『DUMP』的定義，它被設計來顯示一段記憶體的內容。
: DUMP ( a# --)
0 DO I 16 MOD 0= IF CR DUP I + 5 U.R 2 SPACES THEN
DUP I + @ 6 U.R 2 +LOOP DROP ;
^^^^^^^^^^^^^^^^^
當你另要寫一個名為『CDUMP』的定義，它必須依照字元，而不是元素（cell）， 來安排輸出的內容時，問題就來了：
: CDUMP ( a# --)
0 DO I 16 MOD 0= IF CR DUP I + 5 U.R 2 SPACES THEN
DUP I + C@ 4 U.R LOOP DROP ;
^^^^^^^^^^^^^^^
除了被標示出的那兩段之外，這兩個定義的程式碼完全相同。但是此段出現在 『DO LOOP』迴路內，因而使得分解因子的工作變得很困難。 下面是使用 DOER/MAKE 的一個解決辦法。不同的那段程式碼已經被 .UNIT 取代， 它的行為會被 DUMP 和 CDUMP 所改變。（注意，1 +LOOP 和 LOOP 的效果相同。）
DOER .UNIT ( a -- increment ) \ display byte or cell
: <DUMP> ( a # --)
0 DO I 16 MOD 0= IF CR DUP I + 5 U.R 2 SPACES THEN
DUP I + .UNIT +LOOP DROP ;
: DUMP ( a # --) MAKE .UNIT @ 6 U.R 2 ;AND <DUMP> ;
: CDUMP ( a # --) MAKE .UNIT C@ 4 U.R 1 ;AND <DUMP> ;
注意 DUMP 和 CDUMP 是如何地先去"設置"向量，再繼續去"執行"其它整個部份 （字<DUMP>）。 3. 使用單一個指令，就能改變一些相關功能的狀態。例如：
DOER TYPE'
DOER EMIT'
DOER SPACES'
DOER CR'
: VISIBLE MAKE TYPE' TYPE ;AND
MAKE EMIT' EMIT ;AND
MAKE SPACES' SPACES ;AND
MAKE CR' CR ;
: INVISIBLE MAKE TYPE' 2DROP ;AND
MAKE EMIT' DROP ;AND
MAKE SPACES' DROP ;AND
MAKE CR' ;
在這裡，我們定義了一組向量化的輸出字，每個名字的尾端都有一個"單引號"。它 們被 VISIBLE 設定到所期望的功能。INVISIBLE 使它們不工作（通常是將傳送給 它們的引數丟掉），也就是說，這四個字在被呼叫時，都不會產生輸出。 4. 只是要改變事情下一次發生時的狀態，然後會再次地改變它（或者是恢復它）。 假設我們要寫一個探險遊戲。當玩的人首次到達一個特殊的房間時，遊戲會顯示 一個詳細的說明。稍後，如果遊戲者再回到同一個房間，遊戲就只顯示一個較短的 信息。我們寫出：
DOER ANNOUNCE
: LONG MAKE ANNOUNCE
CR ." You're in a large hall with a huge throne"
CR ." covered with a red velvet canopy. "
MAKE ANNOUNCE
CR ." You're in the throne room. " ;
字 ANNOUNCE 能夠顯示兩種信息。第一次我們說 LONG 時，會將 ANNOUNCE 設定 為"長信息"。現在，我們去測試 ANNOUNCE，並且發現它印出了"長信息"。在做完 印出的動作之後，它繼續去"MAKE"下一次的 ANNOUNCE，使它會顯示"短信息"。如果 我們第二次執行 ANNOUNCE ，它就會印出短信息。並且一直如此，直到我們再次說 LONG 為止。 實際上，我們是在將一些"行為"排隊。我們可以將任何數目的行為依序排列，讓每 一個都會自動地設定下一個。下面的例子（雖然並不是很實際）說明這點。
DOER WHERE
VARIABLE SHIRT
VARIABLE PANTS
VARIABLE DRESSER
VARIABLE CAR
: ORDER \ specify search order
MAKE WHERE SHIRT MAKE WHERE PANTS
MAKE WHERE DRESSER MAKE WHERE CAR
MAKE WHERE 0 ;
: HUNT ( -- a | 0 ) \ find location containing 17
ORDER 5 0 DO WHERE DUP 0= OVER @ 17 = OR IF
LEAVE ELSE DROP THEN LOOP ;
在這段程式碼中，我們先產生一組變數，然後定義出它們被搜尋的順序（字ORDER） 。字 HUNT 會一個一個的查看它們，尋找內容為17的第一個變數。HUNT 會傳回正 確的變數地址，或者，如果沒有一個變數是這個數值時，傳回一個零。 HUNT 只是將 WHERE 執行五次，以完成這件工作。每一次的 WHERE 會依 ORDER 所 決定的次序傳回一個不同的變數地址，最後是一個零。 我們甚至可以定義一個"DOER字"，它會無止盡的變換它自己的行為：
DOER SPEECH
: ALTERNATE
BEGIN MAKE SPEECH ." HELLO "
MAKE SPEECH ." GOODBYE "
0 UNTIL ;
5. 實現一個前向參考。前向參考通常出現在當你需要一個"替代性的前導符號"時，也 就是說，一個字，它先被一些較低層的定義所呼叫，但卻在後面較高層的元件中才 實現。要實現一個前向參考，需要在使用它之前，先用 DOER 建出它的頭部：
DOER STILL-UNDEFINED
在程式的稍後，使用 MAKE
MAKE STILL-UNDEFINED ALL THAT JAZZ ;
（記住，MAKE 是可以被使用在冒號定義之外的。） 6. 直接或間接的遞迴 當一個字呼叫它自己時，稱為直接遞迴。最大公約數的遞迴定義是個很好的例子:
GCD of a, b = a if b = 0
GCD of b, a mod b if b > 0
DOER GCD ( a b -- gcd )
MAKE GCD ?DUP IF DUP ROT ROT MOD GCD THEN ;
當一個字呼叫另一個字，而第二個字再呼叫第一個字時，稱為間接遞迴。 它可以使用下面的方式來完成：
DOER B
: A ... B ... ;
MAKE B ... A ... ;
7. 除錯。我通常先定義：
DOER SNAP
（SANPSHOT 的縮寫）然後，在我的應用中，每當我想查驗某處進行中的狀況時， 就將 SNAP 編輯進去。例如，我可以先將它的功能設定為；當 SNAP 在鍵盤解讀器 的主迴路中被呼叫時，它會顯示出當時的資料結構的內容。而且，不必經過重新 編譯的步驟，我就能改變 SNAP 的動作。
當你需要控制一個向量的內容（一個地址）時，使用「踢出並執行」（tick-and-execute ）的方法是比較合適的，像是需要經由一個判斷表（decision table）中的元素來完成指 向的動作時，或是想要將向量的內容保存及恢復時。
結語
在本章裡，我們分析了使用堆疊和使用變數及其它資料結構的利弊。為了測試及再使用性
，堆疊是比較有利的。但是，當一個定義需要操作太多的堆疊元素時，程式碼的可讀性和 可寫性就會受到傷害。 我們也說明了保存和恢復資料結構的技術，最後並以
DOER/MAKE 在向量式執行上的 探討做為結尾。
參考書籍
1. Michael Ham, "Why Novices Use So Many Variables" 符式 Dimen- sions, Vol 5, no.4, November/December 1983. 2. Daniel Slater, "A State Space Approach to Robotics" The Journal of FORTH Application and Research, 1, 1 (September 1983), 17.