Made range operators explicit about whether the last value is included

The original design was to support `...` (implicitly half-open, last value is excluded) and `..=` (explicitly closed, last value is included). This changes that to `..<` (explicitly half-open, last value is excluded) and `..=` (explicitly closed, last value is included).

Rationale: Originally I made `...` the default because it's the safe default, for common cases like iterator ranges where including the last element is a bounds violation error. It would be creating a terrible pitfall to make the "default" syntax be an out-of-bounds error on every use with iterators.

However, feedback on Reddit and elsewhere quickly pointed out that for numeric ranges `...` not including the last value is also surprising. What to do?

One way out is to not support iterators. However, that would be a needless loss of functionality if there was a better answer.

And there is: A better way out is to simply embrace that there should not be a default, but make it  convenient for programmers to be explicit every time about whether the last element is included or not. Supporting `..<` and `..=` as the range operators achieves that goal.

I appreciate the feedback, and I think it led to a superior design for a C++-compatible ecosystem that heavily uses iterators today. Thanks to everyone who gave feedback!

Author: hsutter

docs/cpp2/expressions.md

@@ -223,18 +223,18 @@ test(42);
 For more examples, see also the examples in the previous two sections on `is` and `as`, many of which use `inspect`.
 
 
-## <a id="ranges"></a> `...` and `..=` — range operators
+## <a id="ranges"></a> `..<` and `..=` — range operators
 
-`...` and `..=` designate a range of things. In addition to using `...` for variadic parameters, variadic pack expansion, and fold expressions as in Cpp1, Cpp2 also supports using `begin...end` for a half-open range (that does not include `end`) and `first..=last` for a closed range (that does include `last`).
+`..<` and `..=` designate a range of things. Use `begin ..< end` for a half-open range (that does not include `end`) and `first ..= last` for a closed range (that does include `last`). These operators work for any type that supports `++`; they start with the first value, and use `++` to increment until they reach the last value (which is included by `..=`, and not included by `..<`).
 
 For example:
 
-``` cpp title="Using ... and ..= for ranges" hl_lines="5 11"
+``` cpp title="Using ..< and ..= for ranges" hl_lines="5 11"
 test: (v: std::vector<std::string>) =
 {
     //  Print strings from "Nonesuch" (if present) onward
     i1 := v.std::ranges::find("Nonesuch");
-    for i1 ... v.end() do (e) {
+    for i1 ..< v.end() do (e) {
         std::cout << "  (e*)$\n";
     }
 

regression-tests/pure2-range-operators.cpp2

@@ -4,20 +4,20 @@ main: () = {
         ( "Aardvark", "Baboon", "Cat", "Dolphin", "Elephant", "Flicker", "Grue", "Wumpus" );
 
     std::cout << "We have some alpabetical animals:\n";
-    for v.begin()...v.end() do (e) {
+    for v.begin() ..< v.end() do (e) {
         std::cout << "  (e*)$\n";
     }
 
     std::cout << "\nAnd from indexes 1..=5 they are:\n";
-    for 1..=5 do (e) {
+    for 1 ..= 5 do (e) {
         std::cout << "  (e)$  (v[e])$\n";
     }
 
     all_about: std::list = 
         ( "Hokey", "Pokey" );
 
     std::cout << "\nMake sure non-random-access iterators work:\n";
-    for all_about.begin()...all_about.end() do (e) {
+    for all_about.begin() ..< all_about.end() do (e) {
         std::cout << "  (e*)$\n";
     }
 

regression-tests/test-results/version

@@ -1,5 +1,5 @@
 
-cppfront compiler v0.7.2   Build 9729:1513
+cppfront compiler v0.7.2   Build 9729:2320
 Copyright(c) Herb Sutter   All rights reserved
 
 SPDX-License-Identifier: CC-BY-NC-ND-4.0

source/build.info

@@ -1 +1 @@
-"9729:1513"
+"9729:2320"

source/lex.h

@@ -85,7 +85,8 @@ enum class lexeme : std::int8_t {
     Dot,
     DotDot,
     Ellipsis,
-    EllipsisEq,
+    EllipsisLess,
+    EllipsisEqual,
     QuestionMark,
     At,
     Dollar,
@@ -184,7 +185,8 @@ auto _as(lexeme l)
     break;case lexeme::Dot:                 return "Dot";
     break;case lexeme::DotDot:              return "DotDot";
     break;case lexeme::Ellipsis:            return "Ellipsis";
-    break;case lexeme::EllipsisEq:          return "EllipsisEq";
+    break;case lexeme::EllipsisLess:        return "EllipsisLess";
+    break;case lexeme::EllipsisEqual:       return "EllipsisEqual";
     break;case lexeme::QuestionMark:        return "QuestionMark";
     break;case lexeme::At:                  return "At";
     break;case lexeme::Dollar:              return "Dollar";
@@ -1440,10 +1442,11 @@ auto lex_line(
 
             //G
             //G punctuator: one of
-            //G     '.' '..' '...' '..='
+            //G     '.' '..' '...' '..<' '..='
             break;case '.':
                 if      (peek1 == '.' && peek2 == '.') { store(3, lexeme::Ellipsis); }
-                else if (peek1 == '.' && peek2 == '=') { store(3, lexeme::EllipsisEq); }
+                else if (peek1 == '.' && peek2 == '<') { store(3, lexeme::EllipsisLess); }
+                else if (peek1 == '.' && peek2 == '=') { store(3, lexeme::EllipsisEqual); }
                 else if (peek1 == '.')                 { store(2, lexeme::DotDot); }
                 else                                   { store(1, lexeme::Dot); }
 

source/parse.h

@@ -61,7 +61,8 @@ auto is_postfix_operator(lexeme l)
           case lexeme::Tilde:
           case lexeme::Dollar:
           case lexeme::Ellipsis:
-          case lexeme::EllipsisEq:
+          case lexeme::EllipsisLess:
+          case lexeme::EllipsisEqual:
               return true;
     break;default:
         return false;
@@ -6031,8 +6032,8 @@ class parser
                 || curr().type() == lexeme::LeftParen
                 || curr().type() == lexeme::Dot
                 || curr().type() == lexeme::DotDot
-                || curr().type() == lexeme::Ellipsis
-                || curr().type() == lexeme::EllipsisEq
+                || curr().type() == lexeme::EllipsisLess
+                || curr().type() == lexeme::EllipsisEqual
                 )
             )
         {
@@ -6127,8 +6128,8 @@ class parser
             }
             else if (
                 ( 
-                    term.op->type() == lexeme::Ellipsis
-                    || term.op->type() == lexeme::EllipsisEq
+                    term.op->type() == lexeme::EllipsisLess
+                    || term.op->type() == lexeme::EllipsisEqual
                     )
                 && n->expr->to_string() != "sizeof"
                 )

source/to_cpp1.h

@@ -3472,9 +3472,12 @@ class cppfront
                 {
                     prefix.emplace_back( "cpp2::range(", i->op->position() );
                     auto print = print_to_string( *i->last_expr );
-                    if (i->op->type() == lexeme::EllipsisEq) {
+                    if (i->op->type() == lexeme::EllipsisEqual) {
                         print += ",true";
                     }
+                    else {
+                        assert(i->op->type() == lexeme::EllipsisLess);
+                    }
                     suffix.emplace_back( "," + print + ")", i->last_expr->position());
                 }