Next: Aliases, Previous: User-defined Defining Words, Up: Defining Words
The defining word
Defer allows you to define a word by name
without defining its behaviour; the definition of its behaviour is
deferred. Here are two situation where this can be useful:
In the following example,
foo always invokes the version of
greet that prints “
Good morning” whilst
always invokes the version that prints “
Hello”. There is no way
foo to use the later version without re-ordering the
source code and recompiling it.
: greet ." Good morning" ; : foo ... greet ... ; : greet ." Hello" ; : bar ... greet ... ;
This problem can be solved by defining
greet as a
word. The behaviour of a
Deferred word can be defined and
redefined at any time by using
IS to associate the xt of a
previously-defined word with it. The previous example becomes:
Defer greet ( -- ) : foo ... greet ... ; : bar ... greet ... ; : greet1 ( -- ) ." Good morning" ; : greet2 ( -- ) ." Hello" ; ' greet2 IS greet \ make greet behave like greet2
Programming style note: You should write a stack comment for every deferred word, and put only XTs into deferred words that conform to this stack effect. Otherwise it's too difficult to use the deferred word.
A deferred word can be used to improve the statistics-gathering example
from User-defined Defining Words; rather than edit the
application's source code to change every
: to a
: real: : ; \ retain access to the original defer : \ redefine as a deferred word ' my: IS : \ use special version of : \ \ load application here \ ' real: IS : \ go back to the original
One thing to note is that
IS has special compilation semantics,
such that it parses the name at compile time (like
: set-greet ( xt -- ) IS greet ; ' greet1 set-greet
In situations where
IS does not fit, use
A deferred word can only inherit execution semantics from the xt (because that is all that an xt can represent – for more discussion of this see Tokens for Words); by default it will have default interpretation and compilation semantics deriving from this execution semantics. However, you can change the interpretation and compilation semantics of the deferred word in the usual ways:
: bar .... ; immediate Defer fred immediate Defer jim ' bar IS jim \ jim has default semantics ' bar IS fred \ fred is immediate
Defer"name" – gforth “Defer”
Define a deferred word name; its execution semantics can be
is (and they have to, before first
defer!xt xt-deferred – gforth “defer-store”
deferred word xt-deferred to execute xt.
IScompilation/interpretation "name-deferred" – ; run-time xt – gforth “IS”
deferred word name to execute xt.
Its compilation semantics parses at compile time.
defer@xt-deferred – xt gforth “defer-fetch”
xt represents the word currently associated with the deferred word xt-deferred.
action-ofinterpretation "name" – xt; compilation "name" – ; run-time – xt gforth “action-of”
Xt is the XT that is currently assigned to name.
deferscompilation "name" – ; run-time ... – ... gforth “defers”
Compiles the present contents of the deferred word name into the current definition. I.e., this produces static binding as if name was not deferred.
Definitions of these words (except
defers) in ANS Forth are
provided in compat/defer.fs.