syntax vocabulary - Factor Documentation (original) (raw)

Documentation
Syntax

Metadata

Words

Builtin classes

f

Singleton classes

t

Parsing words

Word	Syntax
"	"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:	BUILTIN: class slots ... ;
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: word ( stack -- effect ) definition... ;
IDENTITY-MEMO::	IDENTITY-MEMO:: word ( stack -- effect ) definition... ;
IH{	IH{ { key value }... }
IN:	IN: vocabulary
INITIALIZED-SYMBOL:	INITIALIZED-SYMBOL: word [ ... ]
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:	PRIMITIVE: word ( stack -- effect )
PRIVATE>	<PRIVATE ... PRIVATE>
QUALIFIED-WITH:	QUALIFIED-WITH: vocab word-prefix
QUALIFIED:	QUALIFIED: vocab
RENAME:	RENAME: word vocab => new-name
REUSE:
SBUF"	SBUF" string... "
SHUTDOWN-HOOK:	SHUTDOWN-HOOK: word/quotation
SINGLETON:	SINGLETON: class
SINGLETONS:	SINGLETONS: words... ;
SLOT:	SLOT: name
STARTUP-HOOK:	STARTUP-HOOK: word/quotation
SYMBOL:	SYMBOL: word
SYMBOLS:	SYMBOLS: words... ;
SYNTAX:	SYNTAX: foo ... ;
TUPLE:	TUPLE: class slots... ;
T{	T{ class }
UNION:	UNION: class members... ;
UNUSE:	UNUSE: vocabulary
USE:	USE: vocabulary
USING:	USING: vocabularies... ;
VOCAB:
V{	V{ elements... }
W{	W{ object }
[	[ elements... ]
[let	[let code :> var code :> var code... ]
[|	[| bindings...	body... ]
\	\ word
_
auto-use
call(	call( stack -- effect )
call-next-method	call-next-method
delimiter	: foo ... ; delimiter
deprecated	: foo ... ; deprecated
execute(	execute( stack -- effect )
f	f
final	TUPLE: ... ; final
flushable	: foo ... ; flushable
foldable	: foo ... ; foldable
inline	: foo ... ; inline
intersection{	intersection{ elements... }
maybe{	maybe{ elements... }
not{	not{ elements... }
predicate{
recursive	: foo ... ; recursive
union{	union{ elements... }
{

Symbol words

initial:
read-only

Ordinary words

Word	Stack effect
;	( -- * )
>>	( -- * )
]	( -- * )
}	( -- * )

Class predicate words

Word	Stack effect
t?	( object -- ? )

Files

resource:core/syntax/syntax.factor
resource:core/syntax/syntax-docs.factor

Metadata files

resource:core/syntax/authors.txt
resource:core/syntax/summary.txt

Children from resource:extra

Vocabulary	Summary
syntax.terse