Delphi Nullable with Custom Managed Records

Published with special permission from Embarcadero - this post writes about pre-release Delphi version where everything is subject to change until finally released.

Nullables are a rather simple concept. All you need is a value, and some flag that will tell you whether or not the value has been explicitly set or not.

type
  TNullable<T> = record
  private
    FHasValue: boolean;
    FValue: T;
    function GetValue: T;
    procedure SetValue(AValue: T);
  public
    property HasValue: boolean read FHasValue;
    property Value: T read GetValue write SetValue;
  end;

function TNullable<T>.GetValue: T;
begin
  if FHasValue then
    Result := FValue
  else
    raise Exception.Create('Invalid operation, Nullable type has no value');
end;

procedure TNullable<T>.SetValue(AValue: T);
begin
  FHasValue := True;
  FValue := AValue;
end;

Plain and simple. But then you have the fact that records are not automatically initialized and that your FHasValue boolean can hold a random value. Of course, you can always add some initialization procedure that will set FHasValue to False before you start using the record variable but this is error-prone. Sooner or later, you will forget to call the initialization procedure, and the whole thing will fall apart. What is worse, it might not break immediately so you can fix the problem, but it may fail randomly at runtime and you will end up chasing random bugs you cannot exactly figure out.

In Delphi, managed types (like strings and interfaces) when put in record will be automatically initialized even when such a record is declared as local variable. Following that fact, instead of using a boolean as a flag you can use an interface. How to do that and how to optimize such a record (interfaces introduce speed penalty and locking) by using "fake" interfaces, you can read in Allen Bauer's excellent post A "Nullable" Post

With the upcoming Delphi 10.4 Sydney and the introduction of custom managed records, our initial nullable implementation with the boolean flag has got another chance.

Since all we need is automatic initialization, the additional code will be quite simple, just have to add an Initialize operator and that is it.

type
  TNullable<T> = record
  private
    FHasValue: boolean;
    FValue: T;
    function GetValue: T;
    procedure SetValue(AValue: T);
  public

    class operator Initialize(out Dest: TNullable<T>);
    
    property HasValue: boolean read FHasValue;
    property Value: T read GetValue write SetValue;
  end;

class operator TNullable<T>.Initialize(out Dest: TNullable<T>);
begin
  Dest.FHasValue := False;
end;

Not only is this Nullable implementation much simpler and more understandable code than the interface-based Nullable implementation, but it is also much faster (approximately 8 times).

More details about custom managed records you can find at Custom Managed Records Coming to Delphi 10.4l