struct ClanId {
    public int Value { get {
        if(HasValue)
            return value_;
        throw ...
    }}

    public bool HasValue { get { return Value != 0; }}
}

ClanInfo GetClanInfo(int clan_id) {}

class PlayerInfo {
    ClanId clanId;
    ...
}

...
PlayerInfo pi = ...
ClanInfo ci;

if(pi.clanId.HasValue)
    ci = GetClanInfo(pi.clanId.Value);

type ClanId = Optional<int> where NotSet = 0;

void UpdateXXX(PlayerPDU pdu) {
   if(pdu.clanId.HasValue) {
      player.clanId = pdu.clanId.Value;
      player.clanInfo = GetClanInfo(player.clanId);
   }
   ...
}

class ClanInfo {...}

ClanInfo GetClanInfo(ClanId clanId) {
    if(!clanId.HasValue)
        return null;

    return RetrieveClanInfoFromCacheOrServer(clanId.Value);
}

interface INullable<T> {
    bool HasValue { get; }
    T Value { get; }
}

struct ClanId : INullable<int> {...}

void SerializeHeader(T nullable, Formatter<bool> f) where T : INullable<T>
{
    f.Write(nullable.HasValue);
}

void SerializeBody(T nullable, Formatter<T> f) where T : INullable<T>
{
    if(nullable.HasValue)
        f.write(nullable.Value);
}

void foo(void *) { std::cout << "void*" << std::endl;  }
void foo(int) { std::cout << "int" << std::endl; }

foo(NULL);
foo(nullptr);

opt.ifPresent( x -> System.out.println("found " + x));

public T ValueOr(T alternative) => hasValue ? value : alternative;

public T ValueOr(Func<T> alternativeFactory) ...

public void MatchSome(Action<T> some) {
    if (hasValue)
        some(value);
}

public Option<TResult> Map<TResult>(Func<T, TResult> mapping) ...

Единственное нормальное решение в ООП — через колбэк. Но, боюсь, индустрия как такому "нормальному решению" может оказаться не готовой, ы-ы-ы.

Grammar     KB/sec
XML         45,993
Java        24,972
JSON        17,696
DOT         16,152
Lua          5,698
C            4,238
Verilog2001  1,994
Erlang       751

Some of these grammars yield reasonable but much slower parse times compared to Java and XML but demonstrate that
programmers can convert a language specification to ANTLR’s meta-syntax and get a working grammar without major modiGrammar

fications. (In our experience, grammar specifications are rarely tuned to a particular tool or parsing strategy and are often ambiguous.)
Later, programmers can use ANTLR’s profiling and diagnostics to improve performance, as with any programming
task. For example, the C11 specification grammar is LL not SLL because of rule declarationSpecifiers, which we altered
to be SLL in our C grammar (getting a 7x speed boost).

Parsers that ignore the parser call stack for prediction are called Strong LL (SLL) parsers. The recursive-descent parsers
programmers build by hand are in the SLL class. By convention, the literature refers to SLL as LL but we distinguish the
terms since “real” LL is needed to handle all grammars. The above grammar is LL(2) but not SLL(k) for any k, though
duplicating A for each call site renders the grammar SLL(2).

Creating a different lookahead DFA for each possible parser call stack is not feasible since the number of stack permutations
is exponential in the stack depth. Instead, we take advantage of the fact that most decisions are not stack-sensitive and build
lookahead DFA ignoring the parser call stack. If SLL ATN simulation finds a prediction conflict (Section 5.3), it cannot be
sure if the lookahead phrase is ambiguous or stack-sensitive.
In this case, adaptivePredict must re-examine the lookahead using the parser stack γ0. This hybrid or optimized LL mode
improves performance by caching stack-insensitive prediction results in lookahead DFA when possible while retaining full
stack-sensitive prediction power. Optimized LL mode applies on a per-decision basis, but two-stage parsing, described next,
can often avoid LL simulation completely. (We henceforth use SLL to indicate stack-insensitive parsing and LL to indicate
stack-sensitive.)

V>>opt.ifPresent( x -> System.out.println("found " + x));
V>>

VD>Как же так? По твоей же теории в не функциональном языке без вариантов такое невозможно!

Поэтому, в ООП стиле "окончательно правильно" можно только так:

Optional<MyType> optional = getValueFromSomewhere();
optional.tryExtract(extractedValue => { /* callback */ });

V>>public T ValueOr(T alternative) => hasValue ? value : alternative;
V>>

Даже взять извлечение дефолтного значения, вот это правильный код (option[T]):

    public WithDefault (val : T) : T
    {
      match (this) {
        | Some (v) => v
        | None => val
      }
    }

А вот за это руки поотрывать и отлучать от программирования на веки вечные (ValueOption[T]):

public GetValueOrDefault() : T { _value }

    public Value : T
    {
      get
      {
        if (HasValue) _value 
        else assert(false, "try use Value when it not set");
      }
    }

[ExtensionPattern(VSome(value) = ValueOption where(HasValue=true, Value=value))]
[ExtensionPattern(VNone()      = ValueOption where(HasValue=false))]
public struct ValueOption[T]

def Plus(x : optin[int], y : optin[int])
{
  | (Some(x), None)    => x
  | (None,    Some(y)) => y
  | (Some(x), Some(y)) => x + y
}

Например, в ФП языках некий Т был value-тип (ну вот так компилятор решил), а после заворачивания F(T) всегда получаем ссылочный тип. Итого, храним лишнюю ссылку вместо значения.

    [DllImport("user32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool GetCursorPos(out POINT point);
    public static POINT? GetCursorPos() => GetCursorPos(out var point) ? (POINT?)point : null;

    [DllImport("user32.dll")]
    public static extern IntPtr WindowFromPoint(POINT point);

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
    public static RECT? GetWindowRect(IntPtr hWnd)=> GetWindowRect(hWnd, out var rect) ? (RECT?)rect : null;

    [StructLayout(LayoutKind.Sequential)]
    public struct POINT
    {
      public int X;
      public int Y;

      public POINT(int x, int y)
      {
        X = x;
        Y = y;
      }

      public POINT(Point     p) : this(     p.X,      p.Y) { }
      public POINT(Wpf.Point p) : this((int)p.X, (int)p.Y) { }

      public static implicit operator Point    (POINT p) => new Point    (p.X,      p.Y);
      public static implicit operator POINT    (Point p) => new POINT    (p.X,      p.Y);
      public static implicit operator Wpf.Point(POINT p) => new Wpf.Point(p.X,      p.Y);
      public static implicit operator POINT(Wpf.Point p) => new POINT    (p);

      public override string ToString()
      {
        return $"POINT {{ X={X} Y={Y} }}";
      }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct RECT
    {
      public int Left;        // x position of upper-left corner
      public int Top;         // y position of upper-left corner
      public int Right;       // x position of lower-right corner
      public int Bottom;      // y position of lower-right corner

      public RECT(int left, int top, int right, int bottom)
      {
        Left   = left;
        Top    = top;
        Right  = right;
        Bottom = bottom;
      }

      public Size      Size    => new Size     (Right - Left, Bottom - Top);
      public Wpf.Size  WpfSize => new Wpf.Size (this.Size.Width, this.Size.Height);
      public Point     Pos     => new Point    (Left, Top);
      public Wpf.Point WpfPos  => new Wpf.Point(Left, Top);
      public Rectangle Rect    => new Rectangle(this.Pos, this.Size);
      public Wpf.Rect  WpfRect => new Wpf.Rect(this.WpfPos, this.WpfSize);

      public static implicit operator Rectangle(RECT p) => p.Rect;
      public static implicit operator RECT(Rectangle p) => new RECT(left:p.Left, top:p.Top, right:p.Right, bottom:p.Bottom);
      public static implicit operator Wpf.Rect(RECT p) => p.WpfRect;
      public static implicit operator RECT(Wpf.Rect p) => new RECT(left: (int)p.Left, top: (int)p.Top, right: (int)p.Right, bottom: (int)p.Bottom);

      public override string ToString()
      {
        return $"RECT {{Left={Left} Top={Top} Right={Right} Bottom={Bottom} Size={Size} }}";
      }
    }

    [DllImport("user32.dll", SetLastError = true)]
    public static extern IntPtr GetDC(IntPtr hWnd);

    [DllImport("user32.dll")]
    public static extern bool ReleaseDC(IntPtr hWnd, IntPtr hDC);

    [DllImport("gdi32.dll", EntryPoint = "CreateSolidBrush", SetLastError = true)]
    public static extern IntPtr CreateSolidBrush(int crColor);

    [DllImport("user32.dll")]
    static extern int FillRect(IntPtr hDC, [In] ref RECT rect, IntPtr hbr);

    public static void FillRect(RECT rect)
    {
      IntPtr desktop = GetDC(IntPtr.Zero);
      var blueBrush = CreateSolidBrush(0x0000FF);
      FillRect(desktop, ref rect, blueBrush);
      ReleaseDC(IntPtr.Zero, desktop);
    }