syntax vocabulary
Factor handbook > Vocabulary index


Documentation
Syntax

Meta-data
Authors:Slava Pestov


Words

Builtin classes
f


Tuple classes
ClassSuperclassSlots
malformed-complex tupleobj


Singleton classes
t


Parsing words
WordSyntax
""string..."
(( inputs -- outputs )
:: word ( stack -- effect ) definition... ;
<<<< ... >>
<<<<<<
<<<<<<<
<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 }... }
IN:IN: vocabulary
INSTANCE:INSTANCE: instance mixin
INTERSECTION:INTERSECTION: class participants... ;
M:M: class generic definition... ;
MAIN:MAIN: word
MATH:MATH: word
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 ... ;
TH{
TUPLE:TUPLE: class slots... ;
T{T{ class }
UNION:UNION: class members... ;
UNUSE:UNUSE: vocabulary
USE:USE: vocabulary
USING:USING: vocabularies... ;
V{V{ elements... }
W{W{ object }
[[ elements... ]
\\ 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{
{{ elements... }


Symbol words
initial:
read-only


Ordinary words
WordStack effect
;( -- * )
>>( -- * )
]( -- * )
malformed-complex( obj -- * )
parse-complex( seq -- complex )
}( -- * )


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


Files