Mailing List Archive: 49091 messages

## [REBOL] Meaning, Value, Binding and Context

### From: al::bri::xtra::co::nz at: 27-Aug-2000 23:24

```
> Rebol differs from human languages in some respects. One of them can be
found comparing Rebol Values vs. Human Values (see
http://www.geocities.com/lmecir.geo/evaluation.txt). This may be a surprise
for both  experienced and inexperienced programmer, because that fact is
hidden in other programming languages to some extent. Another difference can
be found comparing the behaviour of Rebol (CQSB/DRP) functions with the
behaviour of their Pure CQSB counterparts (see
http://www.geocities.com/lmecir.geo/contexts.txt). A set of the differences
can be found studying the behaviour of code - modifying functions like
Repeat, Make Object!, Use, Foreach, ... The latter difference can be
considered a bug, of course, but it is present in Rebol nowadays.

This is quoted from Ladislav's web page:
<Quote>
; create a block Blk containing a word 'a
blk: copy [a]
a: 12
; now append another word to Blk
b: make object! [append blk 'a a: 13]
probe blk
; test if blk contains equal words
equal? first blk second blk
equal? get first blk get second blk

What is the reason behind such a "mystery"? The answer is simple:

*Words have Bindings*

and the first Word in Blk has a different Binding, than the second.
</Quote>

I differ slightly in my interpretation.

>> ; create a block Blk containing a word 'a
>> blk: copy [a]
== [a]
>> a: 12
== 12
>> ; now append another word to Blk
>> b: make object! [append blk 'a a: 13]
>> probe blk
[a a]
== [a a]
>> ; test if blk contains equal words
>> equal? first blk second blk
== true
>> equal? get first blk get second blk
== false
>> first blk
== a
>> second blk
== a
>> get first blk
== 12
>> get second blk
== 13
>> a
== 12
>> b/a
== 13
>> probe a
12
== 12
>> probe b

make object! [
a: 13
]
>>

Words have meanings (or values). The meaning of a word depends on it's
context. Two words may look the same, but can have different meanings,
because of their different contexts. 'b is an object with a different
context to the surrounding context. The word 'a inside 'b has a different
meaning from the 'a defined inside the global context. While the two words:
first blk
and:
second blk
look the same, they both result in 'a, they have different meanings. The
first means:
12
and the second means:
13

That's all there is to it. It's very like human language. For example,
bear
. There's a bear in the woods. That's all it can bear. Two words
exactly the same like [a a], but with different meanings. Here the
surrounding words supply the context, enabling the reader to know that the
first "bear" (a) means a four legged mammal (12), while the second "bear"
(a) means an amount of weight (13).

One can change the meaning of the word by binding it into a different
context. Here I bind the block into the global context:

>> bind blk 'a
== [a a]
>> get first blk
== 12
>> get second blk
== 12

and so make both words in the block mean the same. I can reassign the
meaning of the words in the block by 'bind-ing the block's words into the
context of the object 'blk, like this:

>> bind blk in b second first b
== [a a]
>> get first blk
== 13
>> get second blk
== 13

And I really like the simplicity of the line:
bind blk in b
which really means what it says. The only confusing thing is:
second first b

>> first b
== [self a]

'first on a object gets you a list of words in the object. While 'second
simply gets the first word after 'self:

>> second first b
== a

so allowing the 'bind to work.

>> help in
USAGE:
IN object word

DESCRIPTION:
Returns the word in the object's context.
IN is a native value.

ARGUMENTS:
object -- (Type: object)
word -- (Type: word)

> My personal point of view is, that my previous experience with other
programming languages helped me to understand Rebol and appreciate its