World: r3wp

ladislav, that in C is just what a reference is... you pass not the 
value, but the pointer which refers to it... in REBOL that is a word. 
 under the hood, in REBOL everything really is a pointer to a value, 
with an offset within a context, no?

ladislav, that in C is just what a reference is

 - that looks like an error to me - references are in C++ actually. 
 Pointers are passed "by value" in C

in REBOL everything really is a pointer to a value, with an offset 
within a context, no?

 - you can explore how REBOL values look using my hints in this world 
 and at REP

lad: a reference to a number is a common usage term which means get 
the pointer to the memory area where the number is contained... not 
the value at that pointer.  in C series variables have to be pointers, 
but numbers aren't usually pointers.  thus the reference to that 
number is its pointer.

if you pass the reference, and chance the value at that adress and 
change it in place... all "references" to it will change.

so I think you are both talking the same language, but with different 
terminology.... based on your usage of C..  :-)

(or C++)

what you are saying is terminologically misleading. "Pass by value" 
has got a broadly accepted meaning as well as "pass by reference". 
If you pass a pointer in C, then you pass it "by value" according 
to the definition.

hehe, but you are passing the "value by reference"  ;-)

hehe isn't programming fun?  :-D

Isn't the real difference between passing a pointer by value or by 
reference is that when you are explicitly passing a pointer it is 
by value and when you are implicitly passing a pointer then it is 
by reference.

(Well that is my understanding from the difference in Pascal).

that is correct

but what about values which are not defined as pointers like an int.

so what, are you trying to convince me, that in REBOL ints are "passed 
by reference"?

(if you speak about the C/C++ family then it is easy - in C++ you 
can pass int by reference, in C you cannot)

REBOL passes values unless the function requires a "pointer" to them. 
 (not really a pointer, but in use pretty much the same result).

so I guess in your terminology, only series can be "references" in 
rebol right?

Surely one of the distinctions of pass by value and pass by reference 
is that in pass by value you work on a copy of the value not the 
value originally refered to:

>> a: 1                          
== 1
>> b: func [a [integer!]][ a: 2]
>> print b a                     
2
>> a: 1                         
== 1

yes.

series can be references
 - actually not

so in your terms, how could a reference be "simulated" in rebol?

or can they?

why not?, but it does not influence the fact, that when you are passing 
a word to a function, then you are "passing it by value", not by 
reference, I can easily show you a proof

(almost the same Peter wrote above)

I think I just see the nuance in our statements... you're talking 
about the word supplied to the function I'm really talking about 
its value.  so yess I agree.

except my example was wrong

I'm with Ladislav on the C front, but it can be said that words are 
associated with their values, so they are pointers to them.

yes, that is OK

you never get the actual word submitted to the function, even in 
the lit-word arg passing, you still get a new word within the function. 
 but its pointing to the same value.

ah.. what a little scribble on a piece of paper would do in these 
instances  ;-)

...that is the "pass by value" business

one exception regarding "pointer business" in REBOL: only words bound 
to a context can "point" to values

yes... the act of binding creates the association (to use Anton's 
term :-)

question: do you think that the binding "act" changes the word in 
question?

well, my research (of making a single block with 3 word of the same 
spelling with 3 different contexts and values) lets me to think that 
it only really sets the word with 2 values.  1) its context 2) its 
offset within that context (thus the data it should manipulate). 
 otherwise, it stays in place...

I did not do a lot of tests with aliases, cause I never found them 
of "obvious" use  (man I like that word, since terry used it so often 
 ;-)

I guess everybody would agree with you regarding the "obious" use

obvious
, sorry

hehe

Okay, what then if INC/DEC are introduced in the language in a way, 
so they work more like we're used to with e.g. NEGATE, but at the 
same time allow, that variables can be changed? We have to use call-by-word 
(the REBOL way of call-by-reference) to have the variables changed. 
Like this:

>> a: 4
>> inc a
== 5
>> a
== 4
>> inc 'a
== 5
>> a
== 5


So INC has to check, if it's called with a word, and then get it's 
value before adding one, and in the end do a set-word. We could have 
the same with NEGATE and other functions (actions) of the same kind:

>> negate a
== -5
>> a
== 5
>> negate 'a
== -5
>> a
== -5

Does that make sense? And is it REBOLish?

but this tricky word usage usually breaks in situations like path 
notation

a word, and a literal word are two things.  using a literal to access 
the associated word in the current context, means you can hardly 
break free of that word's spelling.

and it gets hard to support when going through loads and parse, and 
all that.

referentially nontransparent argument passing always "breaks", since 
it disallows you to use a result of an expression and therefore I 
don't like it

My suggestion is close to Ladislav's ++ function above and is something 
like:

>> inc: func [x] [either word? x [set x 1 + get x] [x + 1]]


But as Maxim point out, there are ploblems with paths. But what is 
the path representing? A block or an object or what? If it's in an 
object, it'll work this way:

>> o: make object! [a: 0]
>> inc in o 'a

It's harder to deal with values inside blocks.

that is the real one for me... using literals as words is not predictable, 
or limited, or complicated.

And why this cannot be correct:    inc o/'a ?

maybe it's just too cryptic

in this special case: does it make sense toincrementsomething except 
a word or path? Everything else is a constant.

The thing is, if the argument to INC is written as a word (representing 
a value) or as a lit-word.
>> inc a
or
>> inc 'a

With my INC function, the first example wont change a, while the 
second example will. Or did you mean something else, Volker?