def x : option[int] = None();
def y = x.WithDefault(10); // y == 10

H>def y = x.WithDefault(10); // y == 10
H>

public static WithDefault (this o : T, val : T) : T
  where T : class
{
  if(o == null)
    val
  else
    o
}

def y = x.WithDefault(10); // y == 10

      match (x) {
        | Some => ...
        | _ => ...

P>очень хорошая возможность, но при этом было бы логично запретить использование, передачу в качестве параметра и возврат из метода значения null, причём на уровне рантайма (утопия ) и тем более для Some.

P>def y = x.WithDefault(10); // y == 10
P>

P>      match (x) {
P>        | Some => ...
P>        | _ => ...
P>

P>что было бы эквивалентно проверке на null, только больше писанины.

match (x)
{
  | Some(y) => y...
  | _ => ...
}

    def result = Some(LibraryFunctionFromAnotherAssembly()); // неприятно будет

H>def x : option[int] = None();
H>def y = x.WithDefault(10); // y == 10

    class Foocator
    {
         public Id : int { get; private set; }
         public MyBar : BarInfo { get; private set; } // может ли MyBar быть null?
    }

/** или **/

    class Foocator
    {
         public Id : int { get; private set; }
         public MyBar : option[BarInfo] { get; private set; } // явно указано, что MyBar опционален
    }

  macro @?? (exprA, exprB) 
  {
    def typer = Macros.ImplicitCTX ();      
    def tnullable = typer.InternalType.Generic_Nullable_tc;
    def toption = typer.InternalType.Nemerle_option_tc;

    def isNullable = tnullable.Equals(_);
    def isOption (t)
    {
      toption.Equals (t) 
      || (t.BaseType != null && toption.Equals (t.BaseType))
    }

    def tExprA = typer.TypeExpr(exprA);
    def tExprB = typer.TypeExpr(exprB);
    def tR = typer.FreshTypeVar(); // result type

    def resolve (check, lastTry)
    {
      match (tExprB.Type.Hint)
      {
        | Some (Class (tiB, _)) =>
            def v = if (check(tiB)) <[ $exprA ]> else <[ $exprA.Value ]>;
            Some(<[ match ($exprA.HasValue) { | true => $v | _ => $exprB } ]>)
        | None => 
            when (lastTry)
              Message.Error(exprB.Location, $"Can't infer type of right operand ($exprB) of the `??' operator");
            None()
        | _ => Some(<[ if ($exprA != null) $exprA else $exprB ]>)
      }
    }

    def checkTypes(lastTry)
    {
      match (tExprA.Type.Hint)
      {
        | None when !lastTry => None()
        | None  =>
            Message.Error(exprA.Location, $"Can't infer type of left operand ($exprA) of the `??' operator");
            None()

        | Some (Class (tiA, _)) when tiA.IsValueType && !isNullable(tiA) =>
            Message.Error(exprA.Location, $"Left operand ($exprA) of the `??' operator should be reference or nullable type ");
            None()

        | Some (Class (tiA, _))   when isNullable(tiA) => resolve(isNullable, lastTry)
        | Some (Class (tiA, [_])) when isOption(tiA)   => resolve(isOption,   lastTry)
        | _ => Some(<[ if ($exprA != null) $exprA else $exprB ]>)
      }
    }

    typer.DelayMacro(checkTypes, tR);
  }