Hi Ladislav
I showed that with b: "" the code for 'f was NOT modified by successive
executions
by using 'source to display the function's words after a number of
executions. You apparently ignored that; you seem to think that SMC is
proven
when successive executions accumulate in 'b - my demonstration of SMC relies
on what 'source 'f returns.
Using b: copy "" globally, external to 'f's definition, would give the same
result as b: "", as Elan has pointed out.
I think this is getting to the "tempest in a tea pot" stage! I've learned
not to use a global literal inside a function definition
without an external variable assignment - simply from the viewpoint of
writing clearer, easier to understand, code.
- - Even if it does "work".
I recall that, when, as a chief engineer, reviewing my engineers' software,
a statement that "It works" was a danger signal. I much preferred "It works
the way anyone reading the code would expect."
Russell [EMAIL PROTECTED]
----- Original Message -----
From: <[EMAIL PROTECTED]>
To: <[EMAIL PROTECTED]>
Sent: Thursday, December 23, 1999 3:39 AM
Subject: [REBOL] "logical" value referencing ... Re:(11)
>
> Hi, Russell,
>
> only one change and you have got a non-SMC, which is preferrable
>
> b: copy ""
> f: func[/local a][a: b insert a "1" b]
> f
> f
> f
>
> Results:
> >> b: copy ""
> == ""
> >> f: func[/local a][a: b insert a "1" b]
> >> f
> == "1"
> >> f
> == "11"
> >> f
> == "111"
>
> You can write it even like this, if you prefer:
>
> f: func [] [
> if not value? 'str [str: copy ""]
> insert str "1"
> ]
>
> this is non-SMC either and the results are:
>
> >> f
> == ""
> >> f
> == "1"
> >> f
> == "11"
> >> f
> == "111"
>
> ----- Original Message -----
> From: <[EMAIL PROTECTED]>
> To: <[EMAIL PROTECTED]>
> Sent: Thursday, December 23, 1999 1:37 AM
> Subject: [REBOL] "logical" value referencing ... Re:(10)
>
>
> > Hi Elan. This is not really a reply to your message, which I'm still
> > digesting.
> > I used 'reply" as a cheap way to stay on the thread.
> >
> > But here's a new approach to the problem of executing a function
modifying
> > its source.
> > Look at this console stuff:
> >
> > >> b: ""
> > == ""
> > >> f: func[/local a][a: b insert a "1" b]
> > >> f
> > == "1"
> > >> f
> > == "11"
> > >> f
> > == "111"
> > >> b
> > == "111"
> > >> source f
> > f: func [/local a][a: b insert a "1" b]
> > >>
> > I started by defining a global variable, 'b, referencing a null string.
> > In the function defn I used 'b instead of a literal "".
> > It's quite clear (to me) that the local, 'a, is simply another "pointer"
> to
> > the same data as 'b points to.
> > Repeated executions of 'f show the same effect, but note that the source
> for
> > 'f has not been changed.
> >
> > Somehow, this makes me a lot more comfortable about the results with
> > f: func[/local a][a: "" insert a "1" a]
> > in which case repeated executions change the "" to "1" "11" etc.
> >
> > Russell [EMAIL PROTECTED]
> > ----- Original Message -----
> > From: <[EMAIL PROTECTED]>
> > To: <[EMAIL PROTECTED]>
> > Sent: Wednesday, December 22, 1999 1:00 PM
> > Subject: [REBOL] "logical" value referencing ... Re:(9)
> >
> >
> > > Hi Ladislav,
> > >
> > > At 04:01 AM 12/22/99 -0800, I wrote. And I should have been in bed
fast
> > > asleep. Sorry for taking up so much unnecessary bandwidth. My
> imagination
> > > was running wild.
> > >
> > > Two points I'd like to make:
> > >
> > > in 1. I comment on the unlikelyhood of there being a "return context".
> > >
> > > in 2. I provide a simple illustration for what I spent too much time
on
> > > earlier this morning.
> > >
> > > 1. I mentioned the "return context of reduce". I have no proof that
> there
> > > is a return context. On the contrary, it appears much more likely that
> > > there is no return context. The following code certainly demonstrates
> that
> > > a word returned from a function is bound in the function's context and
> not
> > > in some return context:
> > >
> > > >> f: func [/local a] [ a: 4 return 'a ]
> > > >> b: f
> > > == a
> > > >> get b
> > > == 4
> > >
> > > As expected. Now let us modify the value of a in the function's
> evaluation
> > > block:
> > >
> > > >> set first second :f 10
> > > == 10
> > >
> > > b's version of 'a is apparently bound the context of the function's
> body,
> > > since it also returns the new value:
> > >
> > > >> get b
> > > == 10
> > >
> > > 2. After a few hours of sleep, I think I also came up with a much
better
> > > example to illustrate what I'm driving at with the literal string
thing:
> > >
> > > Assume the following function
> > > >> f: func []
> >
> > > insert "" "bcd"
> > > insert make string! 0 "xyz"
> > > ]
> > >
> > > Before we evaluate 'f, let's see what the function's body contains:
> > >
> > > >> token: second :f
> > >
> > > ;- You could use probe or mold here:
> > >
> > > >> forall token
> >
> > > print [
> > > rejoin [mold first token ":"]
> > > mold type? first token
> > > ]
> > > ]
> > > insert: word!
> > > "": string!
> > > "bcd": string!
> > > insert: word!
> > > make: word!
> > > string!: word!
> > > 0: integer!
> > > "xyz": string!
> > >
> > > Now we evaluate 'f:
> > >
> > > >> f
> > > == ""
> > >
> > > Let's see what the function's body contains after the evaluation:
> > > >> token: second :f
> > >
> > > ;- You could use probe or mold here:
> > >
> > > >> forall token
> >
> > > print [
> > > rejoin [mold first token ":"]
> > > mold type? first token
> > > ]
> > > ]
> > > insert: word!
> > > "bcd": string!
> > > "bcd": string!
> > > insert: word!
> > > make: word!
> > > string!: word!
> > > 0: integer!
> > > "xyz": string!
> > >
> > > a) The literal string retains its modification: it was "", has now
> become
> > > "bcd". We expected that.
> > > b) Where did the string returned by make string! 0, into which we
> inserted
> > > "xyz" go?
> > >
> > > I conclude from 2 that besides - as you pointed out - 'b being
assigned
> to
> > > a new string returned by copy each time your function was called,
there
> is
> > > another, underlying phenomenon. That phenomenon is documented in my 'f
> > > function above: The return value of make string! (or copy ""), is not
> > > retained from one function call to the next. In this respect the
literal
> > > string and the string returned by make string! "" are different. It
was
> > > this difference I had been commenting on.
> > >
> > > The literal string continues to exist - and with it the modifications
> made
> > > to it. The string returned by copy is not retained and the
modifications
> > > made to it disappear with it.
> > >
> > > What determines whether a value continues to exist or not? The extent
of
> > > its context. The literal string is created in the global context. The
> > > string returned by copy is created in the context of the function body
> at
> > > the time the expressions in the body are evaluated.
> > >
> > > My hypothesis is that as a result of being created during the time the
> > > function's body is evaluated, its context is the function's evaluation
> > > context. In saying that I'm assuming that a function has an evaluation
> > > context. When the function ceases to be evaluated, its context ceases
to
> > be
> > > valid and the string returned by copy is eventually garbage collected.
> > >
> > > When I assign a word as a reference to the string returned by copy, I
> > > extend that string's context. The extent of the set-word! b: is the
> > > function body's context. When the string returned by copy becomes
> > > referenced by 'b, the string's context is extended. That is why you
can
> > > retrieve the string returned by copy after the function body has been
> > > evaluated, provided you reference it with a word:
> > >
> > > >> f: func [/local b] [ b: copy "xyz" ]
> > > >> f
> > > == "xyz"
> > > >> get first second :f
> > > == "xyz"
> > >
> > > Last I remember, the REBOL Tech crew commented on the extent of words
> > local
> > > to the body of a function saying that the persistence of their value
> > > binding between function calls is not guaranteed.
> > >
> > > Hope this helps,
> > >
> > > Elan
> > >
> > >
> > >
> > >
> >
> >
>
