Why does 'reverse returns the tail of the block?

Gabriele wrote:

HEAD REVERSE in expressions,... I suspect that 'reverse returns the 'tail of the block, because to return the 'head of the block could be wrong, if one is 'reverse-ing only part of a block? For example:

== []

== [1 5 4 3 2] Though I'm not sure why one would want to only reverse part of a block (or series)? Andrew Martin ICQ: 26227169 http://valley.150m.com/

a

Probably a little more accurate to say that reverse returns the tail of the changed sequence. Having reverse return a modified series reference probably gives a little more info than just returning the original series reference, especially when you include the /PART refinement:

== [5]

== [1 4 3 2 5]

== [5]

Insert, Change, Remove, Find, Copy, Uppercase all have a part sequence effect - seems reasonable for REVERSE to have one too :^) Regards, Brett.

== [1 2 3 4 5 6]

== []

== [2 1 4 3 6 5] However, maybe it is more common to have it chained with other functions, where returning the series at the same position as the argument would be more useful. What do you think? Regards, Gabriele. -- Gabriele Santilli <[g--santilli--tiscalinet--it]> -- REBOL Programmer Amigan -- AGI L'Aquila -- REB: http://web.tiscali.it/rebol/index.r

If someone wants to chain it why not define a chainable reverse?

== [4 3 2 1] Regards, Brett.

But those aren't the only two options! IMHO the more intuitive thing would be to return a block reference positioned at the same place as the beginning of the reversed sequence (see below for example). I'm inclined to wonder whether the resulting value is merely an artifact of the way REVERSE is implemented, rather than being carefully chosen for some strategic purpose.

In the variation I'd advocate, your example would behave as the following *H*Y*P*O*T*H*E*T*I*C*A*L* case

== [5 4 3 2]

== [1 5 4 3 2] As it is, we can get roughly the equivalent behavior only at the cost of some extra typing ...

== []

== [5 4 3 2] ... to preserve the position of the series (sub-) reference. REBOL seems in general to follow the principle of returning results that are most likely to be useful in a larger expression (e.g. INSERT returns a reference *after* the inserted content, making it easy to "chain" insertions into a single expression). That principle is broken here IMHO as every use I can recall making of REVERSE falls into one of two categories: 1) Imperative - purely for effect, in which case I don't *care* how the resulting value is positioned, or 2) In-line - needing to perform some additional manipulation on the result, in which case I *always* have to write the equivalent of ... head reverse ... to get back to the beginning of the REVERSEd content. I'd much rather have REVERSE return a preserved position.

Most (all?) operations on series values respect the current position within the underlying sequence. Consistency with that rule is A Good Thing IMHO. A specific example of how this could be used is the "line breaking" problem: given an ordered collection of values and a position within the collection, bring the value at that position to the "front of the line" without disturbing the relative order of the rest of the values in the collection. An obvious approach is to insert the designated value (i.e. the value at the designated position) into the front of the line, and remove it from its previous place. This is easy to write: breakline-ins-rem: func [ s [series!] p [integer!] ][ head remove at insert s pick s p p ] It behaves as specified ...

== [4 1 2 3 5 6 7 8 9] ... but we know that INSERTing and REMOVEing (in blocks with many values following the point of action) can be expensive. A subtler approach can be designed as follows: - REVERSEing a subseries at the beginning will put the desired element at the head of the line, but will mess up the relative order of the values that were before it:

== [4 3 2 1 5 6 7 8 9] - We can prevent that by REVERSEingthe *preceding* values first, and then REVERSEing the entire leading subseries:

== [3 2 1 4 5 6 7 8 9]

== [4 1 2 3 5 6 7 8 9] This gives us another design ... breakline-rev-rev: func [ s [series!] p [integer!] ][ head reverse/part head reverse/part s p - 1 p ] ... which only manipulates the part of the series that actually needs to change! This latter version can be *much* faster, depending on the length of the series and how close the desired position is to the front. -jn- -- ; Joel Neely joeldotneelyatfedexdotcom REBOL [] do [ do func [s] [ foreach [a b] s [prin b] ] sort/skip do function [s] [t] [ t: "" foreach [a b] s [repend t [b a]] t ] { | e s m!zauafBpcvekexEohthjJakwLrngohOqrlryRnsctdtiub} 2 ]

== [3]

== [3]

== [3] Rebol returns the end of the changed/removed/inserted/reversed part of series, if the part is all the serie, then it returns the tail of serie. --- Ciao Romano

I agree with preserving the position in the value yielded by REVERSE as I think that's the most likely value to be relevant in a larger expression. It would be really interesting to examine a reasonably-sized sample of REBOL scripts to see how often REVERSE is preceded by HEAD. -jn- -- ---------------------------------------------------------------------- Joel Neely joelDOTneelyATfedexDOTcom 901-263-4446

As your example suggests, REBOL series functions always return the end of the "affected area" because this might be the result of some computed operation. Always returning the head (or the current series index) would throw away the important information of the affected index. Salutations! -jeff