[ruby-core:58027] Re: [ruby-trunk - Feature #9049] Shorthands (a:b, *) for inclusive indexing

On Oct 23, 2013, at 10:36 PM, boris_stitnicky (Boris Stitnicky) wrote:

> @david_macmahon: I do not think that the wish to make a : b an alias of a .. b
> can fit into the language anymore. "x > 0 ? 1 : 2 : 3" could be ambiguously
> parsed as "x > 0 ? ( 1 : 2 ) : 3" or as "x > 0 ? 1 : ( 2 : 3 )"...

I can think of two ways to work around this problem.

The more drastic option would be to change ?:.  Instead of it being a ternary operator, it would be two binary operators ? and :.  The right hand side of ? would be a Range constructed via the : operator.  If the left hand side of ? is truish, then the Range's "first" element would be used, otherwise the Range's "last" element would be used.  There could be (in theory, though I'm not sure how practical to implement) an optimization that would avoid creating the Range object in the case of the `predicate ? value_if_true : value_if_false` idiom.  In this case, the your expression would be equivalent to `x > 0 ? 1 : 3` since the "step_size" attribute (i.e. 2) would be ignored.

The other far less drastic option would be to use : as a Range "factory" only if it is not part of a ?: operator (this is kind of like operator precedence).  In this case, your expression would be equivalent to all of these:

```ruby
(x > 0 ? 1 : 2) : 3
(x > 0 ? 1 : 2) .. 3
x > 0 ? 1..3 : 2..3
```

In either case, the use of : as a Range "factory" would be disabled in a Hash context (unless used in parentheses) so that a:1 will always mean {:a => 1} in a Hash context (e.g. as the last argument to a method call).

{a:1} => {:a => 1}

{(a:1) => 2} => {a..1 => 2}

{a:(1:2)} => {:a => 1..2}

Using : when passing a Range as the second-to-last argument followed by a Hash as the last argument would require parentheses:

foo(a:1, k:2) => foo({:a=>b, :k=>2})

foo((a:1), k:2) => foo(a..b, {:k=>2})

Parentheses could also be used to pass a Range as the final argument instead of a Hash:

foo(a:1) => foo({:a => 1})
foo((a:1)) => foo(a..1)

Dave