World: r3wp

*aware* of a way ...

You still need to get easy access to all the locals. Like having 
them in a series.

If you know the "name" of the function, then you can get at the variables:
f: func [a b /local c d e] [print mold first :f]
f 1 2
Then you could run a loop for all those after /local

Ah, that's right! :-)

1) what is the purpose of clearing the locals?

2) how often do you need to do this, where the list is large? i.e. 
does it indicate a design issue?

I tried  that after I posted Sunanda but even though I could get 
to them I was still able to out put a value of the local before setting 
them to none that way so what that  meant was that even though I 
attempted to set them to none! that way that it didn't take (and 
didn't give me an error either).

Gregg, to reduce memory overhead and allow the garbage collector 
to give back some memory.

Gregg, I don't think your second question matters to me.  What matters 
is efficiency to me.

Sundanda , here is a test:

I found a way to set all locals to none, while just specifying one 
of the locals, and it isn't beautiful, I'm afraid:

f: func [/local a b c][
	a: 1 b: 2 c: 3
	print [a b c]

	; This next line set all locals to none:
	set next bind first :f 'a none
	print [a b c]
]

Running the function in the console:
>> f
1 2 3
none none none
>>

myfunc: func [ /local lcl lcl2][
    lcl: "I still have a value"
    print mold lcl2: next find third get 'myfunc /local
    foreach item lcl2 [print mold item]
    foreach item lcl2 [print mold get :item]
    foreach item lcl2 [set :item none!]
    print lcl
]

Grrr, I see something I did wrong in my test.

myfunc: func [ /local lcl lcl2][
    lcl: "I still have a value"
    print mold lcl2: next find third get 'myfunc /local
    foreach item lcl2 [print mold item]
    foreach item lcl2 [print mold get :item]
    foreach item lcl2 [set :item none]
    print lcl
]

Yeah John, that is the way I think it has to be done by using 'bind.

My example only works for functions, which doesn't take arguments. 
If a function take argument, you need:

f: func [v /local a b c][
	a: 1 b: 2 c: 3
	print [a b c]

	set next find bind first :f 'a /local none
	print [a b c]
]

right

Hard to read that setting-to-none line, and I haven't found a way 
to do it by a function call (like a clear-locals function).

Its a good idea though - isn't it?

Yes, a native clear-locals seem like a good idea.

I agree

Remember, all of the parameters are locals, not just the ones after 
the /locals refinement.

yeah true.  We should be setting the args to none also.

If you don't want to corrupt things before you return the value from 
the function, use ALSO - that is what it was designed for.

Yeah I love Also Brian and glad you implemented that.  But this is 
really related to all the other non returned values.

R3 doesn't have this problem, so you are not likely to get a native.

:-) It gets worse, if all parameters should be set to none:

f: func [v /local a b c][
	a: 1 b: 2 c: 3
	print [v a b c]

	set bind head remove find first :f /local 'a none
	print [v a b c]
]

Try:
>> f 42

Keep in mind that unless you have a known name reference to a function, 
the code inside the function has no idea which function it is inside, 
so a native would need a reference to a function or a word with the 
function assigned to it or it won't work - natives aren't magic.

Hm, I don't need the HEAD, so it can be:
set bind remove find first :f /local 'a none

Brian, do you know, if it's possible from outside a function to specity 
its context? (To be used in the second parameter for BIND.)

*specify*

You don't need the find either. John, your example with ALSO:

f: func [v /local a b c][
	a: 1 b: 2 c: 3
	print [v a b c]

	also
		print [v a b c]
		set bind remove first :f 'a none
]

nah, doen't work.

*doesn't*

:-) It has to find the /local and remove it.

use difference

difference first :f [/local]

In answer to your question, in R2 it is only possible from outside 
a function to retrieve its context. You were doing so in your example. 
It doesn't have any meaning when the function isn't running, but 
you can't get a reference to the function from the inside.

But Brian, what if an other function is called inside the function 
your trying to release from?

just as an ending line in your function that says:

clear-locals this-function

I was thinking about making a clear-locals function, but then I need 
to access the context of the function calling clear-locals (from 
clear-locals).

Remember, the /local refinement is also a local variable, so if you 
want to clear *all* the locals you also need to clear the word versions 
of the refinements.

For the most part you don't need to clear *all* of the locals, just 
a select few that still refer to large series or structures.

Brian, it is one of those "While were at it" scenarios

John, you can't just access the context of a calling function or 
even the current function, even from a native. The code block your 
code is in can be assigned to many functions, and isn't bound to 
any context. Words are direct bound individually. If you want to 
clear a context, yo have to specify which one in a parameter.

fun: func [spec body /local me][
	me: construct append copy/deep [
		clear-all: [set bind copy next next first self self none]
	] body	
	me/clear-all: does me/clear-all
	clear find spec /local
	func spec bind body me 
]

f: fun [/local c d ][ c: d: 1 probe self print [c d ] clear-all print 
[c d]]
f

a function with a context for local vars

but not perfect, all vars which are set (including globals) are redefined 
as locals

but there is an idea

You can't get access to a function's context without having a known 
word that is already bouund to that context. When you do first :f, 
the words retrn are not bound to the function's context. In R2, when 
you do third :f you get words that are bound, but you can only guess 
to what., since words are bound individually. The only safe way to 
do clear-words is to pass both the function and a known word bound 
to the function's context, and even then you have to copy the fuunction's 
argument block and convert any refinements to words before you bind 
the copy.

exactly