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); // мож сделать оператор '=??' в догонку к '??' и '??=' ?  :)))