If you need help, try to find the answer through the following path: `Help` in the console ⇒ [Red by Example](https://www.red-by-example.org/) ⇒ [Official Red Docs](https://github.com/red/docs/blob/master/en/SUMMARY.adoc) ⇒ [Rebol Core Manual](http://www.rebol.com/docs/core23/rebolcore.html ⇒ [Red Wiki](https://github.com/red/red/wiki ⇒ Net search "redlang + your-question" ⇒ Ask us, we are here to help!
* Stack: view layout layout layout cause-error
view compose/deep [
;your code
]
From you comments at the end of april I have realized the "code is data" concept.
In this example:
red>> do code
== func [input /local s][s: "hello world" append s input]
red>> test "x"
== "hello worldx"
red>> body-of :test
== [s: "hello worldx" append s input]
I have realized that you are directly modifing the data/code structure.
But why a: "" or a: [] lead to nothing ? Aren't we linking a: to an empty block or are "" and [] "non existant", so it is like doing nothing ?
copy or copy/deep, for "why" - series! values are passed as pointers to some memory location, then you say something like word: [], it means "allocate some space for series, initiate it with some content (no content in this case) and make word point to that storage space" . So, in fact,word from that moment is always bound to static memory address, while content of that address could be changed and extended freely.
>> foo: func [x][s: [no spoon] probe append s x poke body-of :foo 2 [no spoon]]
== func [x][s: [no spoon] probe append s x poke body-of :foo 2 [no spoon]]
>> foo 'whatsoever
[no spoon whatsoever]
== [no spoon]
>> body-of :foo
== [s: [no spoon] probe append s x poke body-of :foo 2 [no spoon]]self could be supported in specs?
>> foo: func [x][s: "before" probe append s x s: "after" probe s]
== func [x][s: "before" probe append s x s: "after" probe s]
>> foo "!!!"
"before!!!"
"after"
== "after"
>> body-of :foo
== [s: "before!!!" probe append s x s: "after" probe s]s:means next time when you sees, evaluate it to the result of an expression that follows me, whatever it might be;"before"is just a string to whichsword is bound now, as implied bys:syntax;appendis word that is bounded to a function, that function receives two arguments that followappendword;- the first argument,
s, evaluates to the thing that followss:, namely"before"string, or, more specifically second element offoo's body; - the second argument,
x, evaluates to whatever we've passed tofoo; - now, we have second element of foo's body and some value; what
appenddoes is just this: append some value to second element of foo's body; - next
s:, just like the first one, simply states next time when you sees, evaluate it to the result of an expression that follows me, whatever it might be; - and
"after"is what followss:, it's the 8th element of foo's body, all subsequentswords will be evaluated to it; probeis a word that is bounded to function that blah-blah-blah;- finally,
sis evaluated to the 8th element of foo's body, and it is what it is, just"after".
@GiuseppeChillemi, see https://github.com/red/red/wiki/Why-do-I-have-to-copy-series-values%3F
Or maybe this will help:
print-it: func [] [
""
insert first body-of :print-it "ha"
print first body-of :print-it
""
]>> print-it
ha
== ""
>> print-it
haha
== ""
>> print-it
hahaha
== ""str point to the second one, but it's never used. On the next call, str is set to refer to the first string, which has now been modified, and you print that.
From the end of the wiki page:
One more thing. The colon (:) suffix in a word is not an assignment operator (as in other languages), it's part of the set-word! datatype literal syntax. When evaluated, it binds the word to the result of next expression. It doesn't do anything more than that. So a: "" does not "reset" or "reinitialize" the "variable" a. That is an incorrect interpretation, it just makes the word a refer to the literal string "" which follows it.
