REBOL 3 Guide: Code: Words and variables

Words are the key to REBOL.

Contents

Meaning of words

Words are commonly used in both code and data.

In code, words can be variables that holds values (including functions), but they can also be just symbols.

For example, here we use the word join three different ways:

join a b
actions: [split join copy]
get 'join

The first is using join as a function value, but the second and third are using join as a symbol.

Basically, the meaning of a word is defined by its:

Each of these will be explained below.

Special notations for words

A word can be written in several ways. Special notations can be used.

We want to introduce these now, so you can start to recognize them in the examples that follow throughout this document.

In essence, these notations modify the action or meaning related to the word.

Most of the time, you will use the first two, the natural notation and the set-word notation. But, the other notations are useful too, and you need to know them.

Words as symbols

REBOL is a symbolic language. You need to think of words as symbols of their own right, not just as variables, keywords, commands, or functions.

Above we wrote the line:

actions: [split join copy]

This block is not evaluated, so the words split, join, and copy are symbols.

We might use it in code like:

action: 'join
...
if find actions action [do something]

A lot more will be said about words as symbols, because they are widely used in REBOL for creating dialects (domain specific languages).

Words as variables

Variables are words with values associated within a specific context, such as in an object, module, or a function.

To set the value of a variable, this notation is used:

size: 12

You can now write this line to get the value of the variable:

print size
12

A lot more needs to be explained about variables, and it will be discussed later in this guide as we explain code: defining functions and data: objects provide context.

Words for refinements

Words are also used for refinements.

A refinement! specifies a variation, option, or clarification in meaning. It is an abstraction that applies to functions, objects, indexing, file paths, and other data types.

For example, the copy function normally copies it's entire input:

print copy "example string"

But, when the /part refinement is provided, a partial copy is made:

print copy/part "example string" 7

In this way, we don't need another function for partial copies. We can have a single copy function with a number of refinements. This makes it easier to remember.

Examples of refinements for objects are similar. They are used to select fields of an object. You will be seeing this a lot.

print system/options/home
%/users/carl

That example finds the home field in the options object of the system object.

system/options/home

system.options.home

file-dir: %user/data
names: load file-dir/names.r

load/header/only system/options/home/database.r

Of course, this is a good time to remind you that all words and values in REBOL must be separated by spaces.

So, divide is:

m: n / 2

but:

m: n/2

is an indexing refinement to n (assuming it is a series).

Context provides meaning

For a word to have meaning, its context must be known.

That context can be the meaning of the word:

• relative to you. That is, as interpreted by a human.
• relative to REBOL. Interpreted by its definition within a section of the code, such as a function or an object.
• relative to a dialect. Interpreted by other code written in REBOL.

Let's clarify this with three examples.

First, take this example:

sizes: [large medium small]
print sizes
large medium small

The words large, medium, and small are just symbols. Defined this way, they are not variables, and they have no meaning to REBOL, only meaning to you, the reader.

Second, look at this:

large:  1000
medium: 100
small:  10
print [large medium small]
1000 100 10

Here, the words have been defined to have specific values within the scope that is known when the print function is evaluated by REBOL. These words are used as variables.

And, the third example is:

rules: ['data 'is ['large | 'medium | 'small]]
parse [data is medium] rules
true

parse [data is huge] rules
false

As in the first example, the words large, medium, and small are symbols, but their meaning is defined by the rules provided to parse. Their meaning is relative to those rules. They define a dialect of the language (although a trivial one at that.)

Usage changes the meaning

The meaning of words can also vary depending on how they are used. Like verbs and nouns, sometimes a verb can be a noun, and vice versa.

For example, these lines all use the same word, print, but it's meaning is different for each.

print 123
probe [print]
source print
do get second [probe print] 456
parse [time to print 10:30] [thru 'print set time time!]
database/print data

Each of these uses print in a different way.