Correcting the last sentence in my previous post:
Who is guilty? (Reduce - in print's implementation, but nevermind, block is
still OK)
> Ahoj, Petre,
>
> in your previous post you suggested the KISS strategy.
> All, that I can offer, is a ASAICFO (As Simple As I Can Figure Out)
> strategy.
>
> Let's start with it:
>
> 1) meet the notion of Side-Effect Creating Function (or, Function
Modifying
> It's Argument, if you prefer)
>
> modify: func [blk [string!]] [
> ; the following row is causing the side-effect
> append blk "x"
> ]
>
> ;Example use:
> a: make string! 0
> modify a
> a ;this is the side-effect:
>
> The results are here:
> >> ;Example use:
> >> a: make string! 0
> == ""
> >> modify a
> == "x"
> >> a ;this is the side-effect:
> == "x"
>
> The former style of programming is considered as non-advisable by some
> (purists?). Russell suggested something different:
>
> don't-modify: func [blk [string!]] [
> ; the following row is not causing the side-effect, although Append
> normally is
> append copy blk "x"
> ]
>
> ;Example use:
> a: make string! 0
> don't-modify a
> a ;no side-effect observed:
>
> >> a: make string! 0
> == ""
> >> don't-modify a
> == "x"
> >> a ;no side-effect observed:
> == ""
>
> 2) Meet the notion of Self-Modifying Code
>
> smf: func [] [
> modify ""
> source smf
> ]
>
> >> smf
> smf: func [][
> modify "x"
> source smf
> ]
>
> Now some morals:
>
> The use of self-modifying code is not considered as advisable (not by me,
> it's an old rule). Every programmer should take care, if his code is clean
> from such effects.
>
> How do you recognize a self-modifying code? It contains e.g. something
like:
>
> modify "anything"
>
> or, more indirectly,
>
> a: "anything"
> modify a
>
> This is hard (no KISS). If you use or create Side-Effect Creating
Functions,
> there is no simple instruction how to recognize the Self-Modifying Code.
>
> 3) Two examples as a goodbye:
>
> ; warning, Self-Modifying Code, not advisable!
>
> counting-func: func [/local a counter] [
> a: "-1"
> counter: 1 + to-integer a
> ;warning, the code modification in the next two rows!
> clear a
> append a to-string counter
> ]
>
> ;Example use:
> counting-func
> counting-func
> counting-func
> counting-func
> counting-func
> counting-func
> counting-func
> counting-func
>
> Results:
> >> counting-func
> == "0"
> >> counting-func
> == "1"
> >> counting-func
> == "2"
> >> counting-func
> == "3"
> >> counting-func
> == "4"
> >> counting-func
> == "5"
> >> counting-func
> == "6"
> >> counting-func
> == "7"
>
> The non Self-Modifying code:
>
> block: [
> a: "-1"
> counting-func: func [/local counter] [
> counter: 1 + to-integer a
> a: to-string counter
> ]
> ]
> do block
>
> ;Example use:
> counting-func
> counting-func
> counting-func
> counting-func
> counting-func
> counting-func
> counting-func
> counting-func
>
> Results:
> >> counting-func
> == "0"
> >> counting-func
> == "1"
> >> counting-func
> == "2"
> >> counting-func
> == "3"
> >> counting-func
> == "4"
> >> counting-func
> == "5"
> >> counting-func
> == "6"
> >> counting-func
> == "7"
>
> How can I be so sure that this code isn't Self-Modifying? I am not. By can
> make sure:
>
> >> source block
> block: [
> a: "-1"
> counting-func: func [/local counter] [
> counter: 1 + to-integer a
> a: to-string counter
> ]
> ]
>
> So, it looks good. Until we don't use Print:
>
> >> print block
> -1 ?function?
>
> So, we can see, that even in this case block got modified. Who is guilty?
> (Do).
>
> Howgh
>
> Ladislav
>
> > Hi,
> >
> > reading all the emails in the "logical" value referencing thread, I
> > always learn something new. After reading each email, I always think -
> > heh, finally conclusion came out and everythink seems to be explained
> > now, but then another email arrives to the list and there is something
> > new to learn in it.
> >
> > What about taking all the experience of what was said, tested, and write
> > any guide from the info available? It would even be worth buying for
> > some $X ...
> >
> > Just a thought ...
> >
> > See you ...
> >
> > -pekr-
> >
> >
>
>
