14.12 The null coalescing operator
The ?? operator is called the null coalescing operator.
null-coalescing-expression:
conditional-or-expression
conditional-or-expression ?? null-coalescing-expression
A null coalescing expression of the form a ?? b requires a to be of a nullable type or reference type. If a is
non-null, the result of a ?? b is a; otherwise, the result is b. The operation evaluates b only if a is null.
The null coalescing operator is right-associative, meaning that operations are grouped from right to left.
[Example: An expression of the form a ?? b ?? c is evaluated as a ?? (b ?? c). In general terms, an
expression of the form E1 ?? E2 ?? ... ?? EN returns the first of the operands that is non-null, or null if all
operands are null. end example]
The type of the expression a ?? b depends on which implicit conversions are available between the types
of the operands. In order of preference, the type of a ?? b is A0, A, or B, where A is the type of a, B is the
type of b, and A0 is the type that results from removing the trailing ? modifier, if any, from A. Specifically,
a ?? b is processed as follows:
• If A is not a nullable type or a reference type, a compile-time error occurs.
• If A is a nullable type and an implicit conversion exists from b to A0, the result type is A0. At run-time, a
is first evaluated. If a is not null, a is unwrapped to type A0, and this becomes the result. Otherwise, b is
evaluated and converted to type A0, and this becomes the result.
• Otherwise, if an implicit conversion exists from b to A, the result type is A. At run-time, a is first
evaluated. If a is not null, a becomes the result. Otherwise, b is evaluated and converted to type A, and
this becomes the result.
• Otherwise, if an implicit conversion exists from A0 to B, the result type is B. At run-time, a is first
evaluated. If a is not null, a is unwrapped to type A0 (unless A and A0 are the same type) and converted
to type B, and this becomes the result. Otherwise, b is evaluated and becomes the result.
Otherwise, a and b are incompatible, and a compile-time error occurs.

using System.Console;

using Nemerle;
using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;
using Nemerle.Compiler.Typedtree;
using Nemerle.Text;

namespace Iae.Macro
{
  /** This module is used to simplify work with op_Implicit operator.

      This module is stateless.
   */
  module OpImplicitHelper
  {
    /**
     * Used to print all implicit operators of some type
     */
    public PrintAll(cl : MType.Class) : void
    {
      def members = cl.tycon.LookupMember("op_Implicit");
      foreach (m is IMethod in members)
        WriteLine(m);
    }

    /**
     * Used to determine has a `from' type implicit conversation 
     * to a `to' type or hasn't.
     */
    public HasImplicit(from : MType.Class, to : MType.Class) : bool
    {
      def members = to.tycon.LookupMember("op_Implicit") 
                    + from.tycon.LookupMember("op_Implicit");
      ret : 
      {
        foreach (m is IMethod in members)
        {
          def tyRet = m.ReturnType;
          def tyPar = m.GetParameters().Head.ty;
          when (tyRet.Equals(to) && tyPar.Equals(from))
            ret (true);
        }  
        false;
      }
    }
  }

  macro @printImplicit(expr)
  {
    def typer = Macros.ImplicitCTX ();
    def tx = typer.TypeExpr (expr);
    match (tx.Type.Hint) 
    {
      | Some (Class (_ti, _args) as cl) => 
          OpImplicitHelper.PrintAll(cl);
          <[]>
      | _ => 
          Message.FatalError ("PrintImplicit macro can not be used with such expression.");
    }
  }

  macro @test(expr)
  {
    <[ if ($expr != null) $expr.Value; else (CI () : int) ]>
  }

  macro @?? (exprA, exprB)
  {
    def typer = Macros.ImplicitCTX ();
    def tx = (typer.TypeExpr(exprA).Type.Hint, typer.TypeExpr(exprB).Type.Hint);
    def teA = typer.TypeExpr(exprA);
    def teB = typer.TypeExpr(exprB);
    def tyA = typer.TypeExpr(exprA).Type;
    def tyB = typer.TypeExpr(exprB).Type;

    def upCast = 
      (texpr, ty) => 
        TExpr.TypeConversion (texpr.loc, ty, texpr, ty, 
                              ConversionKind.UpCast());
    def _implicit = 
      (texpr, ty) => 
        TExpr.TypeConversion (texpr.loc, ty, texpr, ty, 
                              ConversionKind.Implicit());

    match (tx) 
    {
      | (Some(Class(tiA, [tyA0]) as clA), Some(Class(_, _) as clB)) 
        when tiA.IsValueType && tiA.FullName == "System.Nullable" =>

          def clA0 = tyA0 :> MType.Class;
          if (clA0.Equals(clB) 
              || OpImplicitHelper.HasImplicit(clB, clA0))
          {
            /**
             *  BUG: 'Nullable[T]' can not be converted to 'T', 
             *       but it should.
             *  Example:
             *    def inull : int? = 10
             *    // cannot convert System.Nullable[int] to int:
             *    def i : int = inull :> int
            **/
            def st = <[ 
              if ($exprA != null) 
                $exprA.Value
              else 
                $(upCast(teB, tyA0) : typed)
            ]>;
            WriteLine($"nullable: B -> A0: $st");
            st
          }
          else if (clA.Equals(clB) 
                   || OpImplicitHelper.HasImplicit(clB, clA))
          {
            /**
             *  BUG: 'Nullable[T1]' can not be converted to 
             *       'Nullable[T2]' when 'T1' has implicit 
             *       conversation to 'T2', but it should.
             *  C# Example: 
             *    int? i = 10;
             *    double? d = i;
            **/
            def st = <[ 
              if ($exprA != null) 
                $exprA 
              else 
                $(upCast(teB, tyA) : typed)
            ]>;
            WriteLine($"nullable: B -> A: $st");
            st
          }
          else if (OpImplicitHelper.HasImplicit(clA0, clB))
          {
            /**
             *  BUG: 'T1' can not be converted to 'Nullable[T2]' 
             *       when 'T1' has implicit conversation to 'T2', 
             *       but it should.
             *  C# Example: 
             *    int i = 10;
             *    double? d = 0.1;
             *    d = i;
            **/
            def st = <[ 
              if ($exprA != null) 
                $(upCast(typer.TypeExpr(<[ $exprA.Value ]>), tyB) : typed)
              else 
                $exprB
            ]>;
            WriteLine($"nullable: A0 -> B: $st");
            st
          }
          else
          {
            Message.FatalError ($"Operator `??' cannot be applied to "
                                "operands of type `$clA' and `$clB'");
          }

      | (Some(Class(tiA, _)), Some(Class(_, _))) 
        when tiA.IsValueType =>

          Message.FatalError (exprA.Location, 
                              $"`$tiA' is not a reference or nullable type "
                              "as required by the `??' operator");

      | (Some(Class(_, _) as clA), Some(Class(_, _) as clB))
        when clA.Equals(clB) || OpImplicitHelper.HasImplicit(clB, clA) =>

          /**
           * ?BUG: This match case and next one can be replaced with single
           *       one, but followed by code doesn't compile. Is this a design
           *       decision or a bug? (C# compile such code with no problems)
           *  Example: 
           *    #pragma indent
           *    class A {}
           *    class B
           *      public static @:(_ : B) : A
           *        A()
           *    def a = A()
           *    def b = B()
           *    // expected B-, got A in computation branch:
           *    def c = if (a==null) b else a 
          **/
          def st = <[ 
            if ($exprA != null) 
              $exprA 
            else 
              $(upCast(teB, tyA) : typed)
          ]>;
          WriteLine($"reference: B -> A: $st");
          st

      | (Some(Class(_, _) as clA), Some(Class(_, _) as clB))
        when OpImplicitHelper.HasImplicit(clA, clB) =>

          def st = <[ 
            if ($exprA != null) 
              $(upCast(teA, tyB) : typed)
            else 
              $exprB
          ]>;
          WriteLine($"reference: A -> B: $st");
          st

      | _ => 
          Message.FatalError ($"Operator `??' cannot be applied to "
                              "operands of type `$tyA' and `$tyB'");
    }
  }
}

#pragma indent

using System.Console;
using Iae.Macro;


class C1
  public override ToString() : string
    "C1"
  public Test() : void
    WriteLine("C1::Test");

class C2
  public static @:(_ : C2) : C1
    C1()
  public override ToString() : string
    "C2"

class CI
  public static @:(_ : CI) : int
    2

def getType['t] (_ : 't)
  $"$(typeof('t))"


def c1 = null : C1
def c2 = C2()
def r1 = c1 ?? c2 // (***)compile-time message: "reference: B -> A: if (c1 != null) c1; else (c2 : C1)"
def c1 = C1()
def t1 = getType(r1)
WriteLine($"TEST REFERENCE B -> A (result):  $r1")
WriteLine($"TEST REFERENCE B -> A (type):  $t1")
// run-time messages:
// TEST REFERENCE B -> A (result):  C2
// TEST REFERENCE B -> A (type):  C1

def r2 = c2 ?? c1 // compile-time message: "reference: A -> B: if (c2 != null) (c2 : C1); else c1"
def t2 = getType(r2)
WriteLine($"TEST REFERENCE A -> B (result):  $r2")
WriteLine($"TEST REFERENCE A -> B (type):  $t2")
// run-time messages:
// TEST REFERENCE B -> A (result):  C2
// TEST REFERENCE B -> A (type):  C1

def r0 = if (c1 == null) (c2 : C1) else c1 // собственно, тоже самое, что и в (***)
def t0 = getType(r0)
WriteLine($"TEST REFERENCE B -> A (result):  $r0")
WriteLine($"TEST REFERENCE B -> A (type):  $t0")
// run-time messages: выводит то, что ожидается в предыдущих случаях
// TEST REFERENCE B -> A (result):  C1
// TEST REFERENCE B -> A (type):  C1



def inull_v : int? = 10
def inull_n : int? = null
def r3 = inull_v ?? 1 // compile-time message: "nullable: B -> A0: if (inull_v != null) inull_v.Value; else (1 : int)"
def t3 = getType(r3)
WriteLine($"TEST NULLABLE B -> A0 (result):  $r3")
WriteLine($"TEST NULLABLE B -> A0 (type):  $t3")
// run-time messages:
// TEST NULLABLE B -> A0 (result):  10
// TEST NULLABLE B -> A0 (type):  System.Int32

def r4 = inull_n ?? 1 // compile-time message: "nullable: B -> A0: if (inull_n != null) inull_v.Value; else (1 : int)"
def t4 = getType(r4)
WriteLine($"TEST NULLABLE B -> A0 (result):  $r4")
WriteLine($"TEST NULLABLE B -> A0 (type):  $t4")
// run-time messages:
// TEST NULLABLE B -> A0 (result):  1
// TEST NULLABLE B -> A0 (type):  System.Int32


def r5 = test(inull_n) // это макрос, см. выше
def t5 = getType(r5)
WriteLine($"TEST NULLABLE B -> A0 (result):  $r5")
WriteLine($"TEST NULLABLE B -> A0 (type):  $t5")
// run-time messages:
// TEST NULLABLE B -> A0 (result):  2
// TEST NULLABLE B -> A0 (type):  System.Int32

def r5 = inull_n ?? CI() // compile-time message: "nullable: B -> A0: if (inull_n != null) inull_n.Value; else (CI () : int)"
// Compile-time exception:
//test.n:59:21:59:23: debug: Internal compiler error, please report a bug to bugs.nemerle.org. You can try modifying program near this location.
//error: internal compiler error: assertion failed in file ncc\generation\ILEmitter.n, line 801:
//_N_AutoModule::Main: failed to convert non-value type CI to a value type int
// .............

def r5 = if (inull_n != null) inull_n.Value; else (CI () : int)
def t5 = getType(r5)
WriteLine($"TEST NULLABLE B -> A0 (result):  $r5")
WriteLine($"TEST NULLABLE B -> A0 (type):  $t5")
// run-time messages:
// TEST NULLABLE B -> A0 (result):  2
// TEST NULLABLE B -> A0 (type):  System.Int32

public struct Nullable<T> where T: struct

    // без наллаблов:
    public bool GetValue(out int value)
    {
        if (надоВернутьЗначение)
        {
            value = 10;
            return true;
        }
        else
        {
            value = 0;
            return false;
        }
    }

        int z;
        if (GetValue(out z))
            // do something

    // с наллаблами:
    public int? GetValueN()
    {
        return надоВернутьЗначение ? 10 : (int?)null;
    }

        int? zn = GetValueN();
        if (zn != null)
            // do something

C#:
class A {}

class B : A {}

class C
{
    public static implicit operator B(C c)
    {
        return new B();
    }
}

A a = new A();
B b = new B();
C c = new C();

B b1 = c ?? b;
A a1 = c ?? a;
B b2 = c == null ? b : c;
A a2 = a == null ? c : a;

Nemerle:
class A
  ;
    
class B : A
  ;

class C
  public static @:>(c : C) : B
    B();


def a = A();
def b = B();
def c = C();
// expected B-, got C in computation branch: common super type of types [B, C] is just `System.Object', 
// please upcast one of the types to `System.Object' if this is desired
def b2 = if (c == null) b else c;
// expected C-, got A in computation branch: common super type of types [C, A] is just `System.Object', 
// please upcast one of the types to `System.Object' if this is desired
def a2 = if (a == null) c else a;

макрос

  macro @??? (exprA, exprB)
  {
    def typer = Macros.ImplicitCTX ();
    def teB = typer.TypeExpr(exprB);
    def tyA = typer.TypeExpr(exprA).Type;
    def tyB = typer.TypeExpr(exprB).Type;
    def tx = (tyA.Hint, tyB.Hint);

    def upCast = 
      (texpr, ty) => 
        TExpr.TypeConversion (texpr.loc, ty, texpr, ty, 
                              ConversionKind.UpCast());

    match (tx) 
    {
      | (Some(Class(_, _)), Some(Class(_, _))) =>

          def st = <[ 
            if ($exprA != null) 
              $exprA 
            else 
              $(upCast(teB, tyA) : typed)
          ]>;
          WriteLine($"Generated expression: $st");
          st

      | _ => 
          Message.FatalError ($"Operator `???' cannot be applied to "
                              "operands of type `$tyA' and `$tyB'");
    }
  }

тестовый пример
class C1
  public override ToString() : string
    "C1"

class C2
  public static @:(_ : C2) : C1
    WriteLine("Implicit!")
        C1()
  public override ToString() : string
    "C2"

def c1 = null : C1
def c2 = C2()
def r = c1 ??? c2
WriteLine($"r: $r")

Generated expression: if (c1 != null) c1; else (c2 : C1)

def r = if (c1 != null) c1; else (c2 : C1)
WriteLine($"r: $r")

Implicit!
r: C1

r: C2

    C1 c1 = null;
    C2 c2 = new C2();
    C1 c3 = (c1 == null) ? ((C1) c2) : c1;
    StringBuilder builder1 = new StringBuilder();
    builder1.Append("r: ");
    builder1.Append(c3);
    Console.WriteLine(builder1.ToString());
    C1 c4 = (c1 == null) ? ((C1) c2) : c1;
    StringBuilder builder2 = new StringBuilder();
    builder2.Append("r: ");
    builder2.Append(c4);
    Console.WriteLine(builder2.ToString());

c1 ??? c2
      L_0008: ldloc.0 
      L_0009: ldnull 
      L_000a: ceq 
      L_000c: ldc.i4.0 
      L_000d: ceq 
      L_000f: ldc.i4.1 
      L_0010: bne.un L_001b
      L_0015: ldloc.0 
      L_0016: br L_001c
      L_001b: ldloc.1 
      L_001c: stloc.2 


if (c1 != null) c1; else (c2 : C1)
      L_0042: ldloc.0 
      L_0043: ldnull 
      L_0044: ceq 
      L_0046: ldc.i4.0 
      L_0047: ceq 
      L_0049: ldc.i4.1 
      L_004a: bne.un L_0055
      L_004f: ldloc.0 
      L_0050: br L_005b
      L_0055: ldloc.1 
      L_0056: call C1 C2::op_Implicit(C2)
      L_005b: stloc.s c4

ie>    // с наллаблами:
ie>    public int? GetValueN()
ie>    {
ie>        return надоВернутьЗначение ? 10 : (int?)null;
ie>    }

ie>        int? zn = GetValueN();
ie>        if (zn != null)
ie>            // do something
ie>

using System.Console;

module P
{
  public GetValueWithDefault[T](value : option[T], default : T) : T
  {
      match (value)
      {
          | Some(x) => x
          | None    => default
      }
  }
}

def a = Some(1) : option[int];
def b = None() : option[int];

WriteLine(P.GetValueWithDefault(a, 0));
WriteLine(P.GetValueWithDefault(b, 0));

using System.Console;

module P
{
  public GetValueWithDefault[T](value : T?, default : T) : T
        where T: struct
  {
    if (value.HasValue) value.Value else default;
  }
}

def a = 1 : int?;
def b = null : int?;

WriteLine(P.GetValueWithDefault(a, 0));
WriteLine(P.GetValueWithDefault(b, 0));

using System;

class P
{
    static T GetValueWithDefault<T>(T? value, T def)
        where T: struct

    {
        return value.HasValue ? value.Value : def;
    }

    static void Main(string[] args)
    {
        int? a = 1;
        int? b = null;

        Console.WriteLine(GetValueWithDefault(a, 0));
        Console.WriteLine(GetValueWithDefault(b, 0));
    }
}

    class A {}
    class B
    public static @:(_ : B) : A
        A()
    def a = A()
    def b = B()
    // expected B-, got A in computation branch:
    def c = if (a==null) b else a

def p = (10 : int?) :> int; 
// это был пример с наллаблами, но проблема распростроняется и на все другие типы, например:
class Y['t]
  mutable _t : 't
  public this(t : 't)
    _t = t
  public static @:> (y : Y['t]) : 't
    y._t
  
def y = Y.[int](10)
def x = y :> int

tv 't.836 defined in Y and accessed from _N_AutoModule

using Nemerle;
using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;
using Nemerle.Compiler.Typedtree;
using Nemerle.Text;

namespace Nemerle.Core
{
  macro @?? (exprA, exprB) 
  {
    def refEq = System.Type.ReferenceEquals;
    def ref3Eq = (t1,t2,t3) => refEq(t1, t2) || refEq(t1, t3);
    def tnullable = typeof (System.Nullable[_]);
    def toptNone = typeof (Nemerle.Core.option[_].None);
    def toptSome = typeof (Nemerle.Core.option[_].Some);

    def typer = Macros.ImplicitCTX ();
    def hA = typer.TypeExpr (exprA).Type.Hint;
    def hB = typer.TypeExpr (exprB).Type.Hint;
    def tx = (hA, hB);

    match (tx) {
      | (Some (Class (tiA, _)), Some (Class (tiB, _))) 
        when tiA.IsValueType && refEq (tiA.SystemType, tnullable)
                && !refEq (tiB.SystemType, tnullable)
             || ref3Eq (tiA.SystemType, toptNone, toptSome)
                && !ref3Eq (tiB.SystemType, toptNone, toptSome) =>

          <[ if ($exprA.HasValue) $exprA.Value else $exprB ]>;

      | (Some (Class (tiA, _)), Some (Class (tiB, _))) 
        when tiA.IsValueType && refEq (tiA.SystemType, tnullable)
                && refEq (tiB.SystemType, tnullable) =>

          <[ if ($exprA != null) $exprA else $exprB ]>;

      | (Some (Class (tiA, _)), Some (Class (tiB, _))) 
        when ref3Eq (tiA.SystemType, toptNone, toptSome)
                && ref3Eq (tiB.SystemType, toptNone, toptSome) =>

          <[ if ($exprA.IsSome) $exprA else $exprB ]>;

      | (Some (Class (tiA, _)), Some (Class (_, _))) 
        when tiA.IsValueType =>

          Message.FatalError (exprA.Location, 
                              $"`$tiA' is not a reference or nullable type "
                              "as required by the `??' operator");

      | _ => 
          <[ if ($exprA != null) $exprA else $exprB ]>;
    }
  }
}

using System.Console;



def GetExprType['t] (_ : 't)
{
  typeof ('t)
}



def rn = null;
def r1 = "str1";
def r2 = "str2";

assert (rn ?? r2 == "str2");
assert (GetExprType(rn ?? r2).Equals (typeof (string)));
WriteLine($"$(rn ?? r2)");

assert (r1 ?? r2 == "str1");
assert (GetExprType(r1 ?? r2).Equals (typeof (string)));
WriteLine($"$(r1 ?? r2)");



def dn : double? = null;
def d1 : double? = 0.1;
def d2 : double? = 0.2;

assert ((dn ?? d2).Value == 0.2);
assert (GetExprType(dn ?? d2).Equals (typeof (double?)));
WriteLine($"$(dn ?? d2)");

assert ((d1 ?? d2).Value == 0.1);
assert (GetExprType(d1 ?? d2).Equals (typeof (double?)));
WriteLine($"$(d1 ?? d2)");

assert (dn ?? 0.3 == 0.3);
assert (GetExprType(dn ?? 0.3).Equals (typeof (double)));
WriteLine($"$(dn ?? 0.3)");

assert (d1 ?? 0.3 == 0.1);
assert (GetExprType(d1 ?? 0.3).Equals (typeof (double)));
WriteLine($"$(d1 ?? 0.3)");



def on = None();
def on2 = None();
def o1 = Some(1);
def o2 = Some(2);

assert ((on ?? o2).IsSome);
assert ((on ?? o2).Value == 2);
assert (GetExprType(on ?? o2).Equals (typeof (option[int])));
WriteLine($"$(on ?? o2)");

assert ((o1 ?? o2).Value == 1);
assert (GetExprType(o1 ?? o2).Equals (typeof (option[int].Some)));
WriteLine($"$(o1 ?? o2)");

assert (on ?? 3 == 3);
assert (GetExprType(on ?? 3).Equals (typeof (int)));
WriteLine($"$(on ?? 3)");

assert (o1 ?? 3 == 1);
assert (GetExprType(o1 ?? 3).Equals (typeof (int)));
WriteLine($"$(o1 ?? 3)");

assert ((on ?? on2).IsNone);
assert (GetExprType(on ?? on2).Equals (typeof (option[int].None)));
WriteLine($"$(on ?? on2)");

ie>    def tnullable = typeof (System.Nullable[_]);
ie>    def toptNone = typeof (Nemerle.Core.option[_].None);
ie>    def toptSome = typeof (Nemerle.Core.option[_].Some);
ie>

          <[ if ($exprA.IsSome) $exprA else $exprB ]>;

          <[ match ($exprA) { | Some(x) => x | _ => $exprB ]>;

assert (GetExprType(on ?? o2).Equals (typeof (option[int])));

assert (GetExprType(on ?? o2).Equals (typeof (int)));

IT>Теперь пора заняться '??='

  macro @??= (exprA, exprB) 
  {
    <[ {$exprA = $exprA ?? $exprB; $exprA} ]>
  }

IT>Теперь пора заняться '??='

def i : int? = 10;
def j = i ?? 2;

mutable a;
def b = a ?? { a = c; a };

int? p = null;
int? q = null;
if (p ?? q == 0); // тут мне 0 нафиг не нужен

IT>mutable a;
IT>def b = a ?? { a = c; a };
IT>

mutable a : int? = null;
def b = a ?? 5; // тут тип int, а если тупо выражать ??= через ??, то получим бредовые ошибки.

Error 1 expected option[int-]-, got int in assigned value: common super type of types [option[int-], int] is just `System.Object', please upcast one of the types to `System.Object' if this is desired E:\Ivan\Projects\MyOwn Projects\Nemerle Projects\Macro\Cns.MacroLibrary.Test\Main.n 78 9 Cns.MacroLibrary.Test
Error 2 there is no member named `HasValue' in System.Object- with type ? E:\Ivan\Projects\MyOwn Projects\Nemerle Projects\Macro\Cns.MacroLibrary.Test\Main.n 78 9 Cns.MacroLibrary.Test
Error 3 there is no member named `Value' in System.Object- with type ? E:\Ivan\Projects\MyOwn Projects\Nemerle Projects\Macro\Cns.MacroLibrary.Test\Main.n 78 9 Cns.MacroLibrary.Test

`5' should have type `option[int]'.

def b = {when (a == null) a = 6; a};

def x : int? = null;
def x ::= 2;

def x : int? = null;
def x = x ?? 2;

ie>int? p = null;
ie>int? q = null;
ie>if (p ?? q == 0); // тут мне 0 нафиг не нужен
ie>

using System;

class Program
{
    static void Main(string[] args)
    {
        int? a1 = null;
        int a2 = a1 ?? 2;
        Console.WriteLine(a2);
        Console.WriteLine((a1 ?? 2) == 2);
        Console.WriteLine((a1 ?? 2).GetType().FullName);
        a1 = 4;
        Console.WriteLine((a1 ?? 2) == 2);
        Console.WriteLine((a1 ?? 2).GetType().FullName);
    }
}

2
True
System.Int32
False
System.Int32

ie>>int? p = null;
ie>>int? q = null;
ie>>if (p ?? q == 0); // тут мне 0 нафиг не нужен
ie>>

The type of the expression a ?? b depends on which implicit conversions are available between the types
of the operands. In order of preference, the type of a ?? b is A0, A, or B, where A is the type of a, B is the
type of b, and A0 is the type that results from removing the trailing ? modifier, if any, from A. Specifically,
a ?? b is processed as follows:
• If A is not a nullable type or a reference type, a compile-time error occurs.
• If A is a nullable type and an implicit conversion exists from b to A0, the result type is A0. At run-time, a
is first evaluated. If a is not null, a is unwrapped to type A0, and this becomes the result. Otherwise, b is
evaluated and converted to type A0, and this becomes the result.
• Otherwise, if an implicit conversion exists from b to A, the result type is A. At run-time, a is first
evaluated. If a is not null, a becomes the result. Otherwise, b is evaluated and converted to type A, and
this becomes the result.
• Otherwise, if an implicit conversion exists from A0 to B, the result type is B. At run-time, a is first
evaluated. If a is not null, a is unwrapped to type A0 (unless A and A0 are the same type) and converted
to type B, and this becomes the result. Otherwise, b is evaluated and becomes the result.
Otherwise, a and b are incompatible, and a compile-time error occurs.

VD>        int? a1 = null;
VD>        int a2 = a1 ?? 2;
VD>        Console.WriteLine(a2);
VD>        Console.WriteLine((a1 ?? 2) == 2);
VD>        Console.WriteLine((a1 ?? 2).GetType().FullName);
VD>        a1 = 4;
VD>        Console.WriteLine((a1 ?? 2) == 2);
VD>        Console.WriteLine((a1 ?? 2).GetType().FullName);
VD>}
VD>

VD>2
VD>True
VD>System.Int32
VD>False
VD>System.Int32
VD>

VD>Что-то мне не веритися, что в МС реализовали эту фичу не по спецификации.

IT>>mutable a;
IT>>def b = a ?? { a = c; a };
IT>>

VD>Ты хоть сам то понял что написал? Я — нет.

private NemerleSource _source;
public  NemerleSource  Source
{
    get
    {
        if (_source == null)
            _source = (NemerleSource)_service.GetSource(TextLines);
        return _source;
    }
}

protected internal VSLangProj.VSProject VSProject
{
    get
    {
        if (_vsProject == null)
            _vsProject = new OAVSProject(this);
        return _vsProject;
    }
}

private NemerleSource _source;
public  NemerleSource  Source
{
    get { return _source ??= (NemerleSource)_service.GetSource(TextLines); }
}

protected internal VSLangProj.VSProject VSProject
{
    get { _vsProject ??= new OAVSProject(this); }
}

IT>private NemerleSource _source;
IT>public  NemerleSource  Source
IT>{
IT>    get { return _source ??= (NemerleSource)_service.GetSource(TextLines); }
IT>}
IT>

IT>protected internal VSLangProj.VSProject VSProject
IT>{
IT>    get { _vsProject ??= new OAVSProject(this); }
IT>}
IT>

AutoInit[T](var : ref T, creator : void) : T
    where T: class
{
    when (var == null)
        var = creator();
    
    var;
}

def GetValue(p) : int?
{
    // возвращаем зависимое от p значение
}
...
...
foreach (i in $[1..20])
  res = res ?? GetValue(i); // мож сделать оператор '=??' в догонку к '??' и '??=' ?  :)))

ie>def GetValue(p) : int?
ie>{
ie>    // возвращаем зависимое от p значение
ie>}
ie>...
ie>...
ie>foreach (i in $[1..20])
ie>  res = res ?? GetValue(i); // мож сделать оператор '=??' в догонку к '??' и '??=' ?  :))) 
ie>

<[ mattch ($value1) { Some| (x) => x | None() => $defValue } ]>

ie>>def GetValue(p) : int?
ie>>{
ie>>    // возвращаем зависимое от p значение
ie>>}
ie>>...
ie>>...
ie>>foreach (i in $[1..20])
ie>>  res = res ?? GetValue(i); // мож сделать оператор '=??' в догонку к '??' и '??=' ?  :))) 
ie>>

VD><[ mattch ($value1) { Some| (x) => x | None() => $defValue } ]>
VD>

def x = Some (1);
def y = Some (2);
def z = x ?? y ?? 3; // у 'z' будет тип 'int'

int? n = 0;
n &= 1;

ie>>def x = Some (1);
ie>>def y = Some (2);
ie>>def z = x ?? y ?? 3; // у 'z' будет тип 'int'
ie>>

assert (on ?? o1 ?? o2 ?? 3 == 1);
assert (GetExprType(on ?? o1 ?? o2 ?? 3).Equals (typeof (int)));
WriteLine($"$(on ?? o1 ?? o2 ?? 3)");

assert (on ?? on ?? on ?? 3 == 3);
assert (GetExprType(on ?? on ?? on ?? 3).Equals (typeof (int)));
WriteLine($"$(on ?? on ?? on ?? 3)");

ie>assert (on ?? o1 ?? o2 ?? 3 == 1);
ie>assert (GetExprType(on ?? o1 ?? o2 ?? 3).Equals (typeof (int)));
ie>WriteLine($"$(on ?? o1 ?? o2 ?? 3)");

ie>assert (on ?? on ?? on ?? 3 == 3);
ie>assert (GetExprType(on ?? on ?? on ?? 3).Equals (typeof (int)));
ie>WriteLine($"$(on ?? on ?? on ?? 3)");
ie>

def a : option[int] = None();
def b : int = a ?? 2;
assert((a ?? 2).GetType().FullName == "System.Int32");
assert(a ?? 2 == 2);

def a : option[int] = Some(1);
def b : int = a ?? 2;
assert((a ?? 2).GetType().FullName == "System.Int32");
assert(a ?? 2 == 1);

VD>def a : option[int] = None();
VD>def b : int = a ?? 2;
VD>assert((a ?? 2).GetType().FullName == "System.Int32");
VD>assert(a ?? 2 == 2);

VD>def a : option[int] = Some(1);
VD>def b : int = a ?? 2;
VD>assert((a ?? 2).GetType().FullName == "System.Int32");
VD>assert(a ?? 2 == 1);
VD>

option['t] ?? 't -> 't
option['t] ?? option['t] -> option['t]