Names with trailing question mark

[Timon Gehr]

On 04.10.2011 01:37, bearophile wrote:
> Predicates are quite common. In D I presume the standard way to write them is with a name like "isFoo". In other languages they are written in other ways:
>
>
> if (foo.isEven) {}
> if (foo.isEven()) {}
> filter!isEven(data)
>
> if (foo.evenQ) {}
> if (foo.evenQ()) {}
> filter!evenQ(data)
>
> if (foo.even?) {}
> if (foo.even?()) {}
> filter!even?(data)
>
> Other usages:
>
> contains?
> areInside ==>  inside?
>
>
> I don't remember serious recent discussions here about that last form. Allowing a single trailing question mark in D names has some advantages:
>
> 1) It gives a standard way to denote a predicate, so it becomes very easy to tell apart a predicate from other non predicate things.
>
> 2) It allows for short names.
>
> 3) A single question mark is easy and quick to write on most keyboards.
>
> 4) It is used in other languages, as Ruby, and people seem to appreciate it.
>
> 5) Its meaning is probably easy enough to understand and remember.
>
>
>
> Some disadvantages:
> 1) "?" makes code less easy to read aloud.
>
> 2) It is less good to use the trailing "?" in functions that aren't properties, the syntax becomes less nice looking:
> if (foo.even()?)
>
> 3) The usage of the trailing "?" in names forbids later different usages for it, like denoting nullable types.
>
> 4) In expressions that use the ternary operator and a property predicate (without leading ()) it becomes a bit less easy to read (example from http://stackoverflow.com):
>
> string customerName = user.loggedIn? ? user.name : "Who are you?";
>
> I think this too gets accepted:
> string customerName = user.loggedIn??user.name:"Who are you?";
>
> I vaguely like the idea of using a trailing question mark in predicate names.
>
> Bye,
> bearophile

This would break lexer/parser separation and make the parsing of 
conditional expressions painfully complicated and ambiguous.

For example, how would you parse the following?

foo?+foo?(a):b;

it could be

foo ? (+foo?(a)) : b;

or

((foo?)+foo) ? (a) : b;


I'd like to have trailing ' in identifiers though, having them would not 
introduce ambiguities or break existing code.

immutable x=1;
immutable x'=x+2;