World: r3wp

Using ALSO returns some data. If your code look like this:

mp3-data: load-mp3-function


and that load-mp3-function ends with an ALSO, setting the local var 
to none, you still have a full copy in mp3-data. Actually you end 
up having 2 copies for some time, until the garbage collector frees 
the local version. Later in your code, you need to set mp3-data to 
none to free to memory (which the garbage collector does). Now, is 
this how you use ALSO and why you need it?

Most of mine are for conciseness - for example, when no data needs 
to be returned:

Client: first wait Listen
Data: also (copy Client) (close Client)

but, like before, say that happened in a function

Process: func [Client][
   ..do stuff..
   return also (copy Client) (close Client)
]

Client: first wait Listen
Logfile/add Process Client

I'll look for some actual code I'm using soon

Pread: func [URL /local Port][
   Port: open/binary URL
   Port/timeout: 3 * 60
   return also (copy Port) (close Port)
]

What happens, if the connection fails?

Does my version work the same as yours beside the timeout?

newPread: func [URL] [read/binary URL]

And can the timeout be set somewhere in the system object?

f: has [file][file: read %somefile also copy/part file 30 file: none]

My guess is, that your version using ALSO use the double memory, 
that mine does (because of the copy).

Paul:

f: does [copy/part read %somefile 30]

John, yes true but what if you want to do several things with the 
local in the function?  Are you going to copy it every time?

Then do:


f: has [file] [file: copy/part read %somefile 30 comment "do something 
with the file" return file]

Yeah my example used copy so that might defeat it.

f: has [q][q: [] append q read %blah remove/part q 20 also q q: none]

That doesn't work. your local q holds data after returning from F. 
(maybe an error)

>> f: has [q] [q: [] append q "kdfjkd" also q q: none]
>> a: f
== ["kdfjkd"]
>> a
== ["kdfjkd"]
>> source f

f: func [/local q][q: ["kdfjkd"] append q "kdfjkd" also q q: none]

It seems, q has data in the end.

I didn't try it :-)

My opinion right now is, that ALSO sucks big time! :-)
Maybe someone can convince me otherwise.

I couldn't but I see the difference using it.

It seems hard to use, it often result in using twice the memory, 
that people expect. And it might even lead to pad program structure.

pad -> bad

newPread: func [URL] [read/binary URL]  ;  I only want the large 
timeout in this function, not in other 'read calls


f: has [file] [file: copy/part read %somefile 30 comment "do something 
with the file" return file] ; I'm also going for readability, otherwise 
I would have done something like this with the original code

John, actually the piece I think I was showing you the first time 
is what I meant.  The series in the second one is actually desired 
behavior.

f: func [/local q][q: "blahblahblahblahblah" also q q: none]

Is this expected behaviour?

>> f: func [/local q][q: "blahblahblahblahblah" also q q: none]
>> a: f
== "blahblahblahblahblah"
>> source f
f: func [/local q][q: "blahblahblahblahblah" also q q: none]
>> insert a "hmm"
== "blahblahblahblahblah"
>> source f
f: func [/local q][q: "hmmblahblahblahblahblah" also q q: none]
>> a: none
== none
>> source f
f: func [/local q][q: "hmmblahblahblahblahblah" also q q: none]

Izkata, you got a point with your Pread. But it's not a secure function, 
because it may crash. Let me see, how I would make such a function...

Works for me John

>> a: f: has [q][q: "blahblahblahblahblah" also q q: none]
>> a
== "blahblahblahblahblah"

Now do:
source f

>> f
== "blahblahblahblahblah"
>> a: f
== "blahblahblahblahblah"
>> source f
f: func [/local q][q: "blahblahblahblahblah" also q q: none]

what is wrong with it?

So what does your q: none at the end do? It doesn't release any memory.

I believe it does.  I believe that q will be freed.

You can see, it doesn't this way:

>> f: func [/local q][q: "blahblahblahblahblah" also q q: none]
>> a: f
== "blahblahblahblahblah"
>> insert a "more blahblahblahblah"
== "blahblahblahblahblah"
>> source f

f: func [/local q][q: "more blahblahblahblahblahblahblahblahblah" 
also q q: none]

Look at the source of f. Notice the "more blahblah...."

Oh, I see.

then what about this:

a: f: has [q][q: copy "blahblahblahblahblah" also q q: none]

That last one I forgot is no different then the one I showed you 
earlier.

So I don't know in this case.  Is q actually set to none or would 
it be anyway on the return from the function since it used copy? 
 Dunno.

unfortunatly the same story...
does anybody knows why a replace on the second and third also
changes the first letter?  ^JKSE = %5E/KSE and  ^IKSE = %5E-KSE
but ^MERV = %5EMERV and therefore okay.

	probe load replace/all  mold "^MERV" #^ "%5E"
	probe load replace/all  mold "^JKSE" #^ "%5E"
	probe load replace/all  mold "^IKSE" #^ "%5E"

any advise is highly appreciated...
tom

Paul, in your last example with copy, the q memory is released, and 
the string after copy remains. So this actually is a version with 
something gained. Now I have to think, if I would do it this way.

Tom: it's not the replace that's doing it...
>> "^IKSE"
== "^-KSE"
>> "^MERV"
== "^MERV"
>> "^JKSE"
== "^/KSE"
>> "^IKSE"
== "^-KSE"

but I have no actual answer

Well, ^I is a control-i.. and in vim, that inserts a tab.  ^- is 
the tab character in Rebol

I must go to class now

thx for the info izkata.

Paul, I would probably do:

o: context [q: "blahblah" f: does [insert q "more blah" q]]


And my that have full control over q. It depends on the application, 
I guess.

my -> by