Author: larry Date: Wed Feb 28 13:21:47 2007 New Revision: 14308 Modified: doc/trunk/design/syn/S03.pod
Log: Distinguish Range's intervalic .min and .max from its directed .from and .to. Modified: doc/trunk/design/syn/S03.pod ============================================================================== --- doc/trunk/design/syn/S03.pod (original) +++ doc/trunk/design/syn/S03.pod Wed Feb 28 13:21:47 2007 @@ -12,9 +12,9 @@ Maintainer: Larry Wall <[EMAIL PROTECTED]> Date: 8 Mar 2004 - Last Modified: 27 Feb 2007 + Last Modified: 28 Feb 2007 Number: 3 - Version: 102 + Version: 103 =head1 Overview @@ -1993,19 +1993,26 @@ =item * -The C<..> range operator has variants with C<^> on either -end to indicate exclusion of that endpoint from the range. It always -produces a C<Range> object. Range objects are lazy iterators, and can -be interrogated for their current C<.min> and C<.max> values (which -change as they are iterated). The C<.minmax> method returns both as -a two-element list. Ranges are not autoreversing: C<2..1> -is always a null range, as is C<1^..^2>. To reverse a range use: +The C<..> range operator has variants with C<^> on either end to +indicate exclusion of that endpoint from the range. It always +produces a C<Range> object. Range objects are lazy iterators, and +can be interrogated for their current C<.from> and C<.to> values +(which change as they are iterated). The C<.minmax> method returns +both as a two-element list representing the interval. Ranges are not +autoreversing: C<2..1> is always a null range. Likewise, C<1^..^2> +produces no values when iterated, but does represent the interval from +1 to 2 excluding the endpoints when used as a pattern. To iterate +a range in reverse use: 2..1:by(-1) reverse 1..2 (The C<reverse> is preferred because it works for alphabetic ranges -as well.) +as well.) Note that, while C<.minmax> normally returns C<(.from,.to)>, +a negative C<:by> causes the C<.minmax> method returns C<(.to,.from)> +instead. You may also use C<.min> and C<.max> to produce the individual +values of the C<.minmax> pair, but again note that they are reversed +from C<.from> and C<.to> when the step is negative. Because C<Range> objects are lazy, they do not automatically generate a list. So smart matching against a C<Range> object smartmatches the @@ -2015,13 +2022,13 @@ 1.5 ~~ 1^..^2 # true, equivalent to 1 < 1.5 < 2 2.1 ~~ 1..2 # false, equivalent to 1 <= 2.1 <= 2 -If a C<*> (see the "Whatever" type in S02) occurs on -the right side of a range, it is taken to mean "positive infinity" -in whatever space the range is operating. A C<*> on the left means -"negative infinity" for types that support negative values. If the -C<*> occurs on one side but not the other, the type is inferred from -the other argument. A star on both sides will match any value that -supports the C<Ordered> role. +If a C<*> (see the "Whatever" type in S02) occurs on the right side +of a range, it is taken to mean "positive infinity" in whatever space +the range is operating. A C<*> on the left means "negative infinity" +for types that support negative values. (The sign of those infinites +reverses for a negative step.) If the C<*> occurs on one side but +not the other, the type is inferred from the other argument. A star +on both sides will match any value that supports the C<Ordered> role. 0..* # 0 .. +Inf 'a'..* # 'a' .. 'zzzzzzzzzzzzzzzzzzzzzzzzzzzzz...' @@ -2032,6 +2039,22 @@ Note: infinite lists are constructed lazily. And even though C<*..*> can't be constructed at all, it's still useful as a selector object. +Range objects may be iterated on either end as long as it is not +infinite. (Iterating an infinite end does not fail but just produces a +lot of infinities.) Ordinary iteration iterates the C<.from> value by +adding the step. Either C<< prefix:<=> >> or the C<shift> function +may be used to iterate the front of a range object. The C<pop> +function iterates the C<.to> end by subtracting the step. In either +case, the value returned is either the old value if the endpoint +was inclusive, or the next value if the endpoint was exclusive. +In the case of ranges that are not an integral multiple of the step, +no check is done to see that iterating the front would produce the +same list as interating from the back and reversing. So we have + + $range = 1..^42.5; + $front = $range.shift; # $front = 1, $range = 2..^42.5 + $back = $range.pop; # $back = 41.5, $range = 2..^41.5 + For any kind of zip or dwimmy hyper operator, any list ending with C<*> is assumed to be infinitely extensible by taking its final element and replicating it: