World: r4wp

I see that some folks use 'copy' on top-level bindings (i.e., foo: 
copy [], bar: copy "", bas: copy #{}). Is this simply stylistic (for 
consistency with initialisation inside of blocks) or am I overlooking 
a potential pitfall?

The pitfall is the copy trap.

and the copy trap may occur anywhere.

http://www.rebol.net/wiki/Forgoing_faux_pas#The_COPY_Trap

sure, but that example is inside a block

( f: has [t] [t: [] append t 1] )

i'm asking why (if) i should do:

rebol [] foo: copy []

instead of

rebol [] foo: []

it does not matter. it occurs anywhere.

If you use foo: [], you can.


There are perfectly legitimate ways to use the block that way. You 
should simply be aware of this fact, when assigning the word to that 
block.

so is there any reason for using copy at the top level (global assignments) 
with binding to literals?

(i.e., i'm asking about 'foo: [1 2 3]' rather than 'bar: [1 2 3] 
foo: copy bar')

i guess a related question is whether i'll run into difficulties 
with 'context [ foo: [] ]' versus 'context [ foo: copy [] ]'

(typo: 'with binding' should read 'when binding')

that again depends on how the word is meant to be used. if you use 
the context as a copyable prototype, then the original 'foo block 
will be re-used, if you don't copy it on creation of the context.

at the top level, there may not be a reason, but through various 
tricks, it's still possible that it may be relevant to copy it, such 
as if the code itself is later used in a context, which means the 
code is no longer top level.

if you don't copy it on creation of the context.

 => "if you don't copy it on creation of each new copy of the original 
 context."

hmm

maybe i'm misunderstanding your clarification, but i don't see any 
difference between copying the literal block: http://pastebin.com/L2Qx4djY

oops, 'when copying the literal block'* (sorry for all the typos)

hmm... I clearly remember it being not copied, but I seem to be wrong 
about that.

aha, it's the case for contexts inside contexts.

so is there any reason for using copy at the top level (global assignments) 
with binding to literals?
 - certainly, there are reasons. See these two examples:

; example #1
repeat i 2 [
    a: []
    append a i
    print mold a
]

and

; example #2
repeat i 2 [
    a: copy []
    append a i
    print mold a
]

ladislav: i meant when not binding inside a block

What does it have in common with "binding"?

BTW, the examples both use binding in a way

i just mean assigment

actually, you cannot use assignment "outside of a block" in REBOL

henrik: but - http://pastebin.com/3s30AxY4

(there is always a block somewhere)

ladislav: sorry, i'm using terminology sloppily

i guess: assigning to a word in the global (system?) context

that is what both the examples above do

(the 'A word is not local)

yes, but the other part was: not inside a(nother literal) block

That cannot be done.

okay, not inside another explicit literal block

MarcS, yes, now you are in X and Y pointing at the same context.

In REBOL, there is always a block somewhere

henrik: oh, right

ladislav: yes, okay - i'm just saying that i understand the pitfalls 
of not copying when you're re-entering a block (be it a loop, function, 
etc. body)

for example, something like:

do "a: []"

first "converts" the string to a block

but where i'm assigning to a "global" (which i understand is just 
another context) outside of an explicit (one i write myself) literal 
block, are there pitfalls in not using copy

yes, if you are running the same script several times in the same 
console.

also, i get that x: [ append [] 1 ] then 'do x do x' differs from 
x: [ append copy [] 1 ] 'do x do x'

henrik: so if i load the script, then do it, rather than doing the 
file?

makes sense, hadn't considered that

so: best practice is to consider everything to be inside a block, 
and hence copy even toplevel literals?