Documentation
Syntax

Metadata
Authors:Slava Pestov


Words

Builtin classes
f


Singleton classes
t


Parsing words
WordSyntax
""string..."
'HS{
'H{
'['[ code... ]
'{
(( inputs -- outputs )
:: word ( stack -- effect ) definition... ;
:::: word ( vars... -- outputs... ) body... ;
:>:> var:> var!:> ( var-1 var-2 ... )
<<<< ... >>
<<<<<<
<<<<<<<
<PRIVATE<PRIVATE ... PRIVATE>
======
=======
>>>>>>
>>>>>>>
@
ALIAS:ALIAS: new-word existing-word
B
B:
BUILTIN:
BV{BV{ elements... }
B{B{ elements... }
C:C: constructor class
CHAR:CHAR: token
CONSTANT:CONSTANT: word value
CS{
C{C{ real-part imaginary-part }
DEFER:DEFER: word
ERROR:ERROR: class slots... ;
EXCLUDE:EXCLUDE: vocab => words ... ;
FORGET:FORGET: word
FROM:FROM: vocab => words ... ;
GENERIC#:GENERIC#: word n ( stack -- effect )
GENERIC:GENERIC: word ( stack -- effect )
HOOK:HOOK: word variable ( stack -- effect )
HS{HS{ members ... }
H{H{ { key value }... }
IDENTITY-MEMO:
IDENTITY-MEMO::
IH{
IN:IN: vocabulary
INSTANCE:INSTANCE: instance mixin
INTERSECTION:INTERSECTION: class participants... ;
M:M: class generic definition... ;
M::M:: class generic ( vars... -- outputs... ) body... ;
MACRO:MACRO: word ( inputs... -- quot ) definition... ;
MACRO::MACRO:: word ( vars... -- outputs... ) body... ;
MAIN:MAIN: word
MATH:MATH: word
MEMO:MEMO: word ( stack -- effect ) definition... ;
MEMO::MEMO:: word ( vars... -- outputs... ) body... ;
MIXIN:MIXIN: class
M\M\ class generic
NAN:NAN: payload
P"P" pathname"
POSTPONE:POSTPONE: word
PREDICATE:PREDICATE: class < superclass predicate... ;
PRIMITIVE:
PRIVATE><PRIVATE ... PRIVATE>
QUALIFIED-WITH:QUALIFIED-WITH: vocab word-prefix
QUALIFIED:QUALIFIED: vocab
RENAME:RENAME: word vocab => new-name
SBUF"SBUF" string... "
SINGLETON:SINGLETON: class
SINGLETONS:SINGLETONS: words... ;
SLOT:SLOT: name
SYMBOL:SYMBOL: word
SYMBOLS:SYMBOLS: words... ;
SYNTAX:SYNTAX: foo ... ;
TUPLE:TUPLE: class slots... ; TUPLE: class < superclass slots ... ;
T{T{ class } T{ class f slot-values... } T{ class { slot-name slot-value } ... }
UNION:UNION: class members... ;
UNUSE:UNUSE: vocabulary
USE:USE: vocabulary
USING:USING: vocabularies... ;
V{V{ elements... }
W{W{ object }
[[ elements... ]
[let[let code :> var code :> var code... ]
[|[| bindings... | body... ]
\\ word
_
call(call( stack -- effect )
call-next-methodcall-next-method
delimiter: foo ... ; delimiter
deprecated: foo ... ; deprecated
execute(execute( stack -- effect )
ff
finalTUPLE: ... ; final
flushable: foo ... ; flushable
foldable: foo ... ; foldable
inline: foo ... ; inline
intersection{intersection{ elements... }
maybe{
not{
recursive: foo ... ; recursive
union{
{


Symbol words
initial:
read-only


Ordinary words
WordStack effect
;( -- * )
>>( -- * )
]( -- * )
}( -- * )


Class predicate words
WordStack effect
t?( object -- ? )


Files


Metadata files