Implies operator
Elmar
chrehme at gmx.de
Sun Sep 12 11:36:33 UTC 2021
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.
More information about the Digitalmars-d
mailing list