Glossary

Rebol Glossary

    Notes

Rebol: elative xpression ased bject anguage

Binding: Is a property of a Rebol word that makes it a member of a Rebol context. Rebol words having binding can be used as variables, i.e. they can refer to Rebol values.

Context: Rebol contexts are sets of Rebol words assigning meaning to their member words.

Context: There is a Rebol function context which is a short form for make object!.

Datatype: Rebol is a rich datatype language. Not only are more common computer programming types used by Rebol, such as integers and strings, but there are many other high and low level datatypes built into the core of Rebol. Each Rebol datatype is a Rebol value that has an associated symbol and functions that test if a value is of the given datatype.

datatype!: This is a Rebol datatype. All Rebol datatypes are of the datatype! datatype; including the datatype! datatype itself.

Dialect: Rebol dialects are sub-languages of Rebol. They are implemented as functions processing (one or more) Rebol blocks. From this it follows, that all Rebol dialects use the same lexical form for all data types but allow different interpretation of the values within a block. Languages defined on the string level (implemented as functions processing strings) are not Rebol dialects according to this definition. Dialects are able to provide greater expressive power for specific domains of use. A dictionary definition of dialect. Dialects may be named after the functions interpreting them. Therefore we speak about the Parse Dialect, which is the dialect the parse function "understands". An exception is the make function, which implements many dialects, like e.g. the Object Specification Dialect or the Function Specification Dialect. Another example of a Rebol dialect is the VID (Visual Interface Dialect), that is interpreted by the layout function. The main Rebol dialect is the dialect interpreted by the do function (the Do Dialect).

Face: A Rebol object serving as a VID element. A higher level than the gob! datatype.

Function: One of the main building blocks for Rebol evaluation. Functions perform computations on zero or more arguments and result in a value. There are various types of Rebol functions. Some functions in Rebol are native, being built into Rebol using the C programming language, many are Rebol mezzanines, and the rest are user defined.

function!: A Rebol datatype. E.g. all Rebol functions defined using the func function have this datatype.

GOB: Graphical OBject. The basic building block in Rebol's graphics system.

gob!: A Rebol datatype that defines a low-level graphical object.

Mezzanine: A function that comes built into Rebol implemented using Rebol source code.

VID: Visual Interface Dialect

view: The Rebol function to display graphical windows, and then handle user interface events.

Word: Rebol words are Rebol values that can play the roles of variables and keywords as used in other programming languages. To be able to play all the necessary roles there are five different word types in Rebol. We describe the properties of the , as interpreted by the do function, since it is the most important dialect. Other dialects can (and usually do) behave differently.

word: This is a syntactic form of the word! datatype. In the Do Dialect if the word refers to a function, do evaluates the function. So, this datatype can (in the Do Dialect) play the role keywords in other programming languages do. If the word is unset, i.e. if it refers to the #[unset!] value, do causes an error. This property is used as a typo protection. In addition to functions and the #[unset!] value there is a couple of other "word-active" datatypes causing specific behaviour. For the majority of values, that are "word-inactive" a much simpler behaviour is implemented in the Do Dialect: do yields the value the word is referring to, causing this syntactic form to behave like variables in other programming languages, representing the value the variable refers to.

word:: This is a syntactic form of the set-word! datatype. In the Do Dialect this syntactic form is used to implement the behaviour of variables on the left-hand side of the set statements known from other programming languages. As a protection measure, do causes an error when the expression to the right of the set-word evaluates to #[unset!]. For any other result the set-word evaluation succeeds setting the word to refer to the value of the right-hand expression and yielding the value.

:word: This is a syntactic form of the get-word! datatype. In the Do Dialect the value the word is referring to is yielded, so this syntactic form plays a role of a variable referring to a value without the exceptions discussed in the word! datatype case.

'word: This is a syntactic form of the lit-word! datatype. In the Do Dialect do yields the corresponding word, i.e. the corresponding value having the word! datatype.

/word: This is a syntactic form of the refinement! datatype. The Do Dialect does not use it for any special purpose, do simply yields the encountered refinement.