World: r4wp

The first position of the block is called its head.
 - that is actually false

Hasn't Carl wrote that? :-)

(It would be true only if we defined "the first position" to be compatible 
with the sentence)

Or, in a special case.

(like one example...)

Frankly, I do not care who wrote what.

Hehe. Note that it's "the first position" with plain english first, 
not "the <tt>first</tt> position" with first as reference to the 
FIRST native.

the first position of the block is called its head

 is true if we define "the first position is the position with INDEX? 
 = 1"

Yes.

Which differs from the notion used by FIRST.

which is what I meant by "It would be true if we defined..."

To be clear we should write "the position of the block with INDEX? 
= 1 is called its head"

Or we should come up with better nomenclature :)

Any other consistent nomenclature would do as well.

>> head? []          
== true
>> tail? []
== true
>> first []
** Script Error: Out of range or past end
** Where: halt-view
** Near: first []

Do you consider R2's nomenclature to be particularly consistent and 
simple?

I think you (Ladislav) generally reduce R2's nomenclature to an offset-based 
interpretation?

(i.e. "SKIP-based")

Which differs from the notion used by FIRST.
 You lost me there...how so?

The first position of the block is called its head

 is only true if we define "the first position" as the position with 
 INDEX? = 1.


FIRST, on the other hand, does not follow this "the first position" 
interpretation, but rather gives the value at the current position, 
where current position is the value returned by INDEX?.

I do not, I am just sure that the nomenclature discussed above *is 
inconsistent*

In effect, we have to different notions of "first position": one 
used in HEAD, one used in FIRST.

two* different notions

also, yet another inconsistency (PICK help string):

Returns the value at the specified position in a series.

Andreas: right.

In this case, PICK is consistent with FIRST, but not with "the first 
position of the block is called its head"

In the light of these, taking the INDEX? help string we may actually 
say that the formulation:

Returns the index number of the current position in the series.

is actually indefinite, not determining anything at all

(or not explaining anything at all)

My thought behind the "tail position" complaint above was, that series, 
position, and index are already used rather exchangably, and lax 
in a few parts of REBOL's documentation. Adding "tail position" to 
the mix, only further contributes to that confusion.

As "tail position" severely weakens the definition possibilities 
for "position".

Yes, the nomenclature problem...

If you realize that indices are one degree vectors.   A lot of this 
discussion becomes moot.   vectors of length 0 are considered impossible 
when considering only natural numbers (due to 0 divide).  This is 
why I consider R2's handling of indices proper.   


As such, any series "position" is not AT a value it is LOOKING AT 
a value (oriented in positive direction, starting at a point in space 
which is "0").   like extending your arm to grasp the nth thing in 
front of you.  


Tail are 0 length vectors (thus mathematically imposible), when we 
are beyond  the last item edge we are at the edge of space.   you 
cannot "take" the tail item, there is nothin in front of you, just 
as you cannot "take" the 0th item, there is no such thing, 0 is the 
origin of the vector).


when we consider series indices to be vectors, we see the natural 
relationship which Ladislav pointed with SKIP and other methods.


with vectors, things like COPY/PART make sense in the negative direction, 
just as well as in the positive direction.



In R3, this was changed to indices being OVER a value , with the 
first item requiring you to look down and then away for other values. 
 The issue is that index 0 is looking backwards... that doesn' map 
to any good reasoning.  In fact it creates many weird inconsitencies 
in the model, when you try to describe it.


R3's series changes seem like a kludge work-around to map non-vectorial 
infinite integer space to a bounded vectorial space. sacrificing 
model integrity in the process (while trying to ease its mathematical 
properties).  R3's series *may* be "easier to count in a loop"  but 
the values being used make no sense.   counting backwards requires 
us to manipulate the indice for it to "make sense", whereas before, 
counting backwards was the same as counting forward.  we where just 
LOOKING in the opposite direction (the vector's orientation is inversed).

Moreover, something like "the head position" is actually a "permanent 
characteristic", while "the tail position" is in a sense "ephemeral" 
as demonstrated by the following:

block: [a b c]
pos-a: head block
pos-b: next pos-a
pos-c: next pos-b

; now, POS-C is not tail
tail? POS-C ; == false
remove back tail block
tail? POS-C; == true
append block 'c
tail? pos-c ; false again

, while the POS-C is not ephemeral, continuing to exist no matter 
what

Maxim, unfortunately this does not help at all, because we have no 
built-in way to compute with those vectors.

exactly.  we don't have an index! type.

My note to Max's contribution:


- in REBOL, blocks of length 0 are not "impossible", that is, we 
have to use a nomenclature compatible with this fact

The issue is that index 0 is looking backwards... that doesn' map 
to any good reasoning.  In fact it creates many weird inconsitencies 
in the model, when you try to describe it.

 - it may not be a "weird inconsistency", but it is almost imposible 
 to describe to a newbie in a reasonable way

empty blocks are not impossible to describe.  but all functions will 
provide special cases to manage them (return another infinitely small 
block or none, or raise an error) because as such, they are vectorially 
equivalent to null.    an empty  block is just a starting place without 
any room to move.  when only looking forward, it is exactly the same 
as the tail (when you read my original post) and hence in actual 
code, tail [1 2 3] and  [ ]   are exactly the same, if only positive 
indices are being used.

Too many constraints.

REBOL allows you to look backwards, REBOL allows you to use negative 
indices.

As such R3's model is actually not only _not_ "weirdly inconsistent", 
but actually more consistent than R2's model, when having to use 
in-language properties to describe it.

Yes, Andreas, but I am not the one willing to explain to newbies 
"Why 0 'points backwards?"

I am still sure that once we have negative numbers, we cannot do 
without zero (to maintain compatibility with the continuity of the 
underlying series). Then, actually, the SKIP behaviour is the only 
one easy to describe and use as the base of the "nomenclature".

Ladislav... what about adding another helper function: last? pos-c 
== true :-)

Ladislav, I fully agree. I don't think that "0 points backwards" 
is particularly elegant either, but I'm willing to explain it ("0 
points to the element before 1") and find it much better than having 
to explain when and why you have to very careful with computing indices, 
or even debug (R2) code that was written unaware of this fact.

No problem, but that is also and "ephemeral characteristic" exactly 
like TAIL?

The only other realistic option I see, is to disallow negative indices-as-ordinals 
completely (but still keep the possibility to use negative indices-as-offsets, 
such as in SKIP or BrianH's proposed PICKZ/POKEZ).

(I meant that LAST? is as ephemeral as TAIL?, while HEAD? is not 
ephemeral at all)

Anyway.. reading this discussion, I'm feeling like deja vu... I would 
stay with REBOL way of indexing. Although I don't have any problem 
to switch into 0-based indexing in other languages. The problem is, 
that the other languages don't have functions like next, back, tail.. 
which enable series traversing, do they?