Moritz Lenz wrote:
Darren Duncan wrote:
However, I still don't see how one would retrieve the distinction between say "1..10" and "1^..^10". I suggest that an extra 2 methods such as .min_is_outside and .max_is_outside (each returns a Bool) could fit the bill, and in fact since I have Pugs write access I think I'll go make that addition myself in the above S03 section.

Rakudo currently uses from_exclusive and to_exclusive, but since ranges
now always have $.from < $.to, I see no reason to stick with "from" in
favor of "min", and "to" in favor of "max".

As seen in r28612, I went and made my change, but I decided to use shorter and probably better-descriptive names .min_excl and .max_excl, since both in math parlance as well as the existing S03 docs I was adding to, the base terms "include" and "exclude" were already in use.

Now I was going to ask how to represent endpoints that are "whatever" if "whatever" is orthogonal to type, but then I realized the answer is simply to use a Whatever object, which is one of the 4 "Undefined types" mentioned in S02.

For example, if someone said:

   my $r = $foo..*;
   my $min = $r.min;  # $foo's value
   my $max = $r.max;  #

Now maybe it would be reasonable for .max to return +Inf if $foo was an Int, but I would expect that for any type where $foo doesn't have a concept of positive-infinity, a * would just be by default.

I'd just say that Range.min and Range.max return exactly what you put
into it - (1..*).max should return * (which is a Whatever object),
(1..Inf).max should return Inf.

That sounds like exactly what I would prefer to happen.

Now, another tangent that I was going to raise ideas order-comparison-sensitive operations in general.

While it makes perfect sense for some type definitions to have "cmp" et al built-in, meaning that all order-comparison-sensitive operations such as "cmp" and "sort" and "before" and "minmax" and Range/interval value membership just work for them without extra help, I believe that it should be possible to apply a "cmp" at the place where any order-comparison-sensitive operations are *used*, not just in the type definitions of their operands.

For example, we already have:

  map { $^a mycmp $^b } @values  # spelling ?

But I believe one should be able to do that with "minmax" or Range uses or "before" or what-have you in a generic sense as well; for example:

  $a ∈ $b..$c ordered using { $^a mycmp $^b }  # ordered ... applies to ∈
  minmax @values ordered using { $^a mycmp $^b }

Now mind you, its possible that support for what I'm saying already exists with another syntax, perhaps using :trait syntax, but I don't recall.

But this is important, especially since often a type may have multiple innate conceptions of order, and you are best to pick one at time of use; for example, what collation to use for sorting text, you may not want to encode into the Str objects but just declare at the time of sorting/etc.

And it is important because it what lets you potentially order values of any types at all.

-- Darren Duncan

Reply via email to