Nullable<T>: and overloaded operators, bool? & bool

Question

1. Why is operator '&' defined for bool?, and operator '&&' is not?
2. How exactly does this 1) bool? & bool? and 2) bool? and bool work?

Any other "interesting" operator semantics on Nullable? Any overloaded operators for generic T?

Answer 1

Operators on Nullable<T> are "lifted" operators. What this means is: if T has the operator, T? will have the "lifted" counterpart.

&& and || aren't really operators in the same sense as & and | - for example, they can't be overloaded - from the ECMA spec 14.2.2 Operator overloading:

The overloadable binary operators are: + - * / % & | ^ << >> == != > < >= <= Only the operators listed above can be overloaded. In particular, it is not possible to overload member access, method invocation, or the =, &&, ||, ??, ?:, checked, unchecked, new, typeof, as, and is operators.

Likewise, from the ECMA spec, 14.2.7 Lifted operators, the lifted operators are:

For the unary operators + ++ - -- ! ~

For the binary operators + - * / % & | ^ << >>

For the equality operators == !=

For the relational operators < > <= >=

So basically, the short-circuiting operators aren't defined as lifted operators.

[edit: added crib sheet]

• Lifted operator: a compiler provided operator on Nullable<T>, based on the operators of T - for example: the int "+" operator gets "lifted" onto int?, defined as:

  (int? x, int? y) => (x.HasValue && y.HasValue) ? (x.Value + y.Value) : (int?) null;

• Operator overloading: the act of providing a custom operator implementation for a given type; for example decimal and DateTime provide various operator overloads

• Short-circuiting: the normal behavior of && and || (in many languages, including C++ and C#) - i.e. the second operand might not be evaluated - i.e.

  (expression1, expression2) => expression1() ? expression2() : false;

Or perhaps a simpler example:

bool someFlag = Method1() && Method2();

if Method1() returns false, then Method2() isn't executed (since the compiler already knows that the overall answer is false). This is important if Method2() has side-effects, since as saving to the database...

Answer 2

There are no short-circuiting operators (&& ||) defined for bool?

Only are the logical AND, inclusive OR, operators and they behave like this:

x        y      x & y   x | y   
true    true    true    true
true    false   false   true
true    null    null    true
false   true    false   true
false   false   false   false
false   null    false   null
null    true    null    true
null    false   false   null
null    null    null    null