On 12/24/1999 at 6:13 PM [EMAIL PROTECTED] wrote: {{
Perhaps:
a -> {{* 1}}
|
V
<<string! | #"1" #"2" #"3" #"4">>
}}
How something like this?
<<string! | #"1" #"2" #"3" #"4">>
^ ^
a -> {{* 1}} |
b -> {{* 2}} |
c -> {{* 1}} |
In some ways, the words are like a list of references to the value.
When the list is empty, then the value can be disposed.
-Ted.
*********** REPLY SEPARATOR ***********
On 12/24/1999 at 6:13 PM [EMAIL PROTECTED] wrote:
Hello Joel,
Hope you're over your flu by now. I am truly amazed that anyone can
write
such a coherent and ground-breaking essay under such conditions!
I've read your essay, and think the model will be very useful. Overall
I
believe it is accurate, and it is also reasonably easy to understand.
I have a lot of comments to make, so I think I'll split them up into
two
messages. In the first post (this one) I'll comment on the diagrams,
and in
the second one I'll make some miscellaneous comments on your
explanations.
I'll try to copy your usage of series and sequence, although it's
likely that
I'll fall out of it somewhere along the line. Please forgive me if I
do. I
still prefer to use the term series in an ambiguous sense, with
disambiguation
wherever necessary through such expressions as "series value" to mean
series
in your strict sense, and "series itself" or "underlying series" to
mean
what you call a sequence. However, in describing series with the detail
and
rigor you are attempting, I recognise that your unambiguous terms can
be very
useful.
1. We need to stress the uniqueness of series values more.
>From essay/2
>The translation of the REBOL expression:
>
> [10 "1234" 11]
>
>could be described by the picture (not REBOL notation!):
>
> {{block! 1 *}}
> |
> V
> <<10 * 12>>
> |
> V
> {{string! 1 *}}
> |
> V
> <<#"1" #"2" #"3" #"4">>
You say that asterisks plus arrows denote references. I wonder if it
might
not be more accurate to say:
{{block! 1 *}}
|
V
<<10 {{string! 1 *}} 12>>
|
V
<<#"1" #"2" #"3" #"4">>
At least in my mental picture of blocks, series values are directly
embedded
within blocks, rather than being referenced. That might well be
inaccurate
somewhere within the implementation level, but on the model level I
think
your picture may be confusing. For example, in your next diagram:
> a -> {{string! 1 *}}
> ^ |
> | V
> b ---+ <<#"1" #"2" #"3" #"4">>
I think there's an error. 'a and 'b are bound to different (but
identical)
series values, although the underlying sequence is of course the same.
I
think it would be better to represent this situation as:
a -> {{string! 1 *}}
|
V
<<#"1" #"2" #"3" #"4">>
^
|
b -> {{string! 1 *}}
This revised diagram is very similar to one in essay/3:
> a -> {{string! 1 *}}
> |
> V
> <<#"1" #"2" #"3" #"4">>
> ^
> |
> b -> {{string! 2 *}}
Also, in essay/4 you have:
>After the last diagram above, evaluating:
>
> r: append b "X"
>
>produces the following state:
>
> a ---> {{string! 1 *}}
> |
> V
> <<#"1" #"2" #"3" #"4">>
> ^
> / \
> / \
> b -> {{string! 2 *}} \
> \
> r -------> {{string! 1 *}}
which I wouldn't quarrel with. Just as I've said before, the value of
'r is
a different but identical instance of the value of 'a.
(I assume you meant to represent the sequence as <<#"1" #"2" #"3" #"4"
#"X">>)
To flog this idea a little more, what would you do with a simple case
of
integers:
a: 5
b: a
? Does this give you:
a -> 5
^
|
b ---+
or:
a -> 5
b -> 5
? Obviously the latter picture is more accurate, since there's nothing
you
can do to 'b now to change the value that 'a is bound to. Further there
is no
way you can ask 'a or 'b whether there is another word bound to the
same
value.
So, in the same way, after:
a: "1234"
b: a
the only way to change the value 'a is bound to is by changing the
underlying
sequence - you cannot change the basic information in the value of 'a -
neither __which__ sequence is referenced, nor the index. Your diagrams
seem
to leave that possibility open.
NOTE: Please see my PS on lists.
2. We should graphically show the difference between binding and
reference.
As I understand it, the relationship between words and the values they
are
bound to, and the relationship between series values and the sequences
they
refer to are entirely different. One really should use a different form
of
arrow for these two, although that would be difficult with the ASCII
lower
128!
3. Sequences are typed, too.
Your diagrams seem to leave open the possibility of this kind of
situation:
a -> {{string! 1 *}}
|
V
<<#"1" #"2" #"3" #"4">>
^
|
b --> {{email! 1 *}}
which is of course impossible.
Perhaps:
a -> {{* 1}}
|
V
<<string! | #"1" #"2" #"3" #"4">>
would be better.
4. Couldn't indexes be portrayed graphically?
Your diagrams represent the index of a series value numerically, and
the
arrows that emanate from the * always point to the << >> shell around
the
representation of the sequence. That is perhaps ideal for the rigorous
approach that you are taking, but wouldn't it be more helpful, for
beginners
trying to develop a mental picture of what's going on, to have the
reference
arrow pointing directly to the element at the indexed position?
For example, one of the diagrams quoted above could be represented as:
a -> {{* 1}}
|
V
<<string! | #"1" #"2" #"3" #"4">>
^
|
b -> {{* 2}}
This has the advantage of showing us immediately where INSERT will
operate.
So if we do:
insert a "XYZ"
we get:
a -> {{* 1}}
|
V
<<string! | #"X" #"Y" #"Z" #"1" #"2" #"3" #"4">>
^
|
b -> {{* 2}}
I'm sure you must have considered this possibility and rejected it, but
I
do think it's more helpful for learning how to visualize series, and I
don't
see that there's any great harm in it. Of course it's redundant to
represent
the index numerically and graphically, but if that's a problem I'd
prefer to
ditch the numerical representation. After all, when you evaluate 'a you
see
the series, but you have to use a function to get the index. Perhaps
the
index is more fundamental in some ways, but I think a representation
closer
to what you experience when actually using REBOL is better.
See you soon,
Eric
-*-*-*-*-*-*-*-
PS I'm starting to enjoy playing around with your diagrams! Let me see
what
I can do with one from essay/5:
> a: "1234"
> x: [a: "987"]
[snip]
> do x
>
>the situation is different (and fairly distinctive to REBOL):
>
> a -------------------------+
> |
> |
> x -> {{block! 1 *}} |
> | /
> V /
> <<a: *>> /
> \ /
> V
> {{string! 1 *}}
> |
> V
> <<#"9" #"8" #"7">>
This is what I'd like to do (with a double-lined arrow for binding):
a ===============================> {{* 1}}
|
x ------------------> {{* 1}} |
| |
V |
<<block! | a: {{* 1}}>> |
\ |
\ |
\ |
\ |
\ |
\ |
\|
V
<<string! | #"9" #"8" #"7">>
Actually, I'm still leaving something out, which can be demonstrated as
follows:
>> x: [a: "987"]
== [a: "987"]
>> do x
== "987"
>> get x/1
== "987"
>> x/1
== a:
The set-word a: has the same binding as the word a, so we really should
also
draw =====> from the first element of the sequence <<block! | a: {{*
1}}>>
to the value {{* 1}} in the upper right corner. (In this case a and a:
really
are bound to the same instance of the series value.)
Let me do just one more!
In your diagram in essay/6 following:
a: [1 "st" 2 "nd"]
b: a
c: copy a
append b [3 "rd"]
insert a/2 a/1
insert a/4 a/3
you forgot to show the effects of the two inserts. Anyway, this is how
I'd
show the situation:
a ====> {{* 1}} {{* 1}} <===== b
| /
| ------
| /
|/
V
<<block! | 1 {{* 1}} 2 {{* 1}} 3 {{* 1}}>
| \ \
| \ --------------------
| ------------- \
/ \ V
/ \ <<string! | #"r"
#"d">>
V V
<<string! | #"1" #"s" #"t">> <<string! | #"2" #"n" #"d">>
^ ^
\ /
\ ---------------
| /
<<block! | 1 {{* 1}} 2 {{* 1}}>
^
|
c ====> {{* 1}}
PS on lists (as promised):
The behavior of lists is different from all other series!!!!
>> a: skip make list! [1 2 3 4 5] 2
== make list! [3 4 5]
>> b: head a
== make list! [1 2 3 4 5]
>> index? a
== 3
>> insert b [9 8 7]
== make list! [1 2 3 4 5]
>> index? a
== 6
A list value doesn't include a numerical index; it includes a "direct"
reference to an element in the list sequence, so that the numerical
index of
a list value may change. There are further surprises:
>> index? b
== 4 ; The index of the value of 'b changed too!
>> remove skip b 2
== make list! [4 5]
>> a
== make list! []
>> index? a
** Script Error: Out of range or past end.
** Where: index? a
>> back a
** Script Error: Out of range or past end.
** Where: back a
>> tail? a
** Script Error: Out of range or past end.
** Where: tail? a
>> head a
== make list! [9 8 7 1 2 4 5]
The element referenced through the value of 'a disappeared, so
apparently 'a
only references the list sequence, and has no valid index value.
End of PS on lists, end of post. Please read part 2!
Bye!
