On Tuesday, 14 November 2006 at 13:04:20 UTC, Mariano wrote:
> Wouldn't it be nice to have an ''implies'' operator?
if(A -> B)
I know this can be written as
if(!A || B)
but the implication makes it far more clear for common day speach
if( check_boundaries -> a.length <= max_int )
process(a);
makes more sence than
if( !check_boundaries || a.length <= max_int )
process(a);
or
if( ! (check_boundaries && a.length > max_int ) )
process(a);
besides, I don't think the '->' notation should be a big problem for the parser, and the front end can easily convert this structure to the corresponding not + or/and.
There is, of course, still the issue of precedence, but I think it should match that of || and &&.
And since Walter likes Wikipedia links: http://en.wikipedia.org/wiki/ Logical_implication
Mariano
There is a cruel answer to this request.
For boolean type values, this operator exists in all C-like languages. The problem however only is, the arrow points into the wrong direction!
You might get what I'd like to say:
if (a implies b) { ... }
is
if (a <= b) { ... }
in C-derived languages. I wouldn't call Java to be C-derived.
It's opposite to logic which would write
if (a => b) { ... }
to mean the same thing.
You also could write
if (b >= a) { ... }
if (!a >= !b) { ... }
if (!(a > b)) { ... }
If you would define an "implies" operator like which is available in current generation programming languages then the definition would look like:
a => b := !(cast(bool)a >= cast(bool)b)
Funny enough though, the IEC logic gate symbols use >= 0 to denote the OR-gate.
The bi-implication works better:
if (a == b) { ... } // eqv. to if (a >= b && a <= b) { ... }
if (a != b) { ... } // negated bi-implication
We would need to get used to writing the arrow in the wrong direction! Probably possible, but I find the confusion pretty terrible. At least, there is a mnemonic to say, that the symbol => does not exist and therefore <= is reused instead and implication always is from left to right (in my university it really is).
Or we use this close notation instead:
if (a ? b : true) { ... }
The best syntax for an implication probably would be
if (a ? b) { ... }
and less
if (a !| b) {} := if (!a || b ) { }
which is equivalent.
Only dumb that the null-coalescing operator if (a ?? b) ... in other languages already has the meaning if (!a ? b) ... (which is equivalent to the or operator like in Python).
My guess is though, that rather C++ would come up with something like => than D would. C++ now introduced the spaceship operator which is useful when working with comparators:
a <=> b := (int(a > b) - int(a < b))
(Looks like >-< would have described the meaning better.)
A last solution would be adding this to your global utility functions:
```
pragma(inline) pure @safe @nogc nothrow
bool implies(in bool a, in bool b) {
return a <= b;
}
unittest {
static assert(false .implies (false));
static assert(false .implies (true));
static assert(! true .implies (false));
static assert(true .implies (true));
}
```
The operator precedence is still wrong.
Permalink
Reply
