Well, I think you can improve a bit if you are using Records. You can try to use Record and do some operator overloads. And you can do some "mapping" containing several operations with each type that exists in Delphi and custom types. I'm already doing something with this idea. Excerpt and link below.

https://github.com/lotexiu/HelperLibrary

[AutoDestroy.pas]
...
  RAD<T> = record
  private
    FValue: TAutoDestroy<T>;
    FRtti: TRttiType;
    FContext: IAD<TRttiContext>;
    function getRtti: TRttiType;
  public
  ...
  {Operations}
  class operator Add(a: RAD<T>; b: RAD<T>): Double;
  class operator Subtract(a: RAD<T>; b: RAD<T>) : Double;
  class operator Multiply(a: RAD<T>; b: RAD<T>) : Double;
  class operator Divide(a: RAD<T>; b: RAD<T>) : Double;
  
  class operator Negative(a: RAD<T>): RAD<T>;
  class operator Positive(a: RAD<T>): RAD<T>;
  class operator Inc(a: RAD<T>): RAD<T>;
  class operator Dec(a: RAD<T>): RAD<T>;
  class operator LogicalNot(a: RAD<T>): Boolean;
  class operator Modulus(a, b: RAD<T>): RAD<T>;
  ...

[UTOperation.pas]
...
TTOperation<T> = class(TInterfacedObject,
  IAdd<T>,        ISubtract<T>,
  IMultiply<T>,   IDivide<T>,
  INegative<T>,   IPositive<T>,
  IInc<T>,        IDec<T>,
  ILogicalNot<T>, IModulus<T>
)
private
  FFAdd:        TFunc2P<T,Double>;
  FFSubtract:   TFunc2P<T,Double>;
  FFMultiply:   TFunc2P<T,Double>;
  FFDivide:     TFunc2P<T,Double>;
  FFIntDivide:  TFunc2P<T,Integer>;
  FFNegative:   TFunc1P<T,T>;
  FFPositive:   TFunc1P<T,T>;
  FFInc:        TFunc1P<T,T>;
  FFDec:        TFunc1P<T,T>;
  FFLogicalNot: TFunc1P<T,Boolean>;
  FFModulus:    TFunc2P<T,T>;
public
  constructor Create;
  property FuncAdd:        TFunc2P<T,Double > read FFAdd        write FFAdd;
  property FuncSubtract:   TFunc2P<T,Double > read FFSubtract   write FFSubtract;
  property FuncMultiply:   TFunc2P<T,Double > read FFMultiply   write FFMultiply;
  property FuncDivide:     TFunc2P<T,Double > read FFDivide     write FFDivide;
  property FuncIntDivide:  TFunc2P<T,Integer> read FFIntDivide  write FFIntDivide;
  property FuncNegative:   TFunc1P<T,T>       read FFNegative   write FFNegative;
  property FuncPositive:   TFunc1P<T,T>       read FFPositive   write FFPositive;
  property FuncInc:        TFunc1P<T,T>       read FFInc        write FFInc;
  property FuncDec:        TFunc1P<T,T>       read FFDec        write FFDec;
  property FuncLogicalNot: TFunc1P<T,Boolean> read FFLogicalNot write FFLogicalNot;
  property FuncModulus:    TFunc2P<T,T>       read FFModulus    write FFModulus;

  function Add       (const A, B: T): Double ;
  function Subtract  (const A, B: T): Double ;
  function Multiply  (const A, B: T): Double ;
  function Divide    (const A, B: T): Double ;
  function IntDivide (const A, B: T): Integer;
  function Negative  (const A: T):    T      ;
  function Positive  (const A: T):    T      ;
  function Inc       (const A: T):    T      ;
  function Dec       (const A: T):    T      ;
  function LogicalNot(const A: T):    Boolean;
  function Modulus   (const A, B: T): T      ;
end;
...

procedure DefaultOperations;
var
  LObjOp: TTOperation<TObject>;
  LIntOp: TTOperation<Integer>;
  LDblOp: TTOperation<Double>;
  LStrOp: TTOperation<String>;
begin
  LStrOp := TTOperation<String>.Create;
  with LStrOp do
  begin { TODO - Try to convert first to Number }
    FuncAdd      := function(A,B: String): Double begin Result := Length(A) + Length(B) end;
    FuncSubtract := function(A,B: String): Double begin Result := Length(A) - Length(B) end;
    FuncMultiply := function(A,B: String): Double begin Result := Length(A) * Length(B) end;
    FuncDivide   := function(A,B: String): Double begin Result := Length(A) / Length(B) end;
    FuncIntDivide:= function(A,B: String): Integer begin Result := Length(A) div Length(B) end;
  end;

  LObjOp := TTOperation<TObject>.Create;
  with LObjOp do
  begin
    FuncAdd      := function(A,B: TObject): Double begin Result := NativeInt(A) + NativeInt(B) end;
    FuncSubtract := function(A,B: TObject): Double begin Result := NativeInt(A) - NativeInt(B) end;
    FuncMultiply := function(A,B: TObject): Double begin Result := NativeInt(A) * NativeInt(B) end;
    FuncDivide   := function(A,B: TObject): Double begin Result := NativeInt(A) / NativeInt(B) end;
  end;

  LIntOp := TTOperation<Integer>.Create;
  with LIntOp do
  begin
    FuncAdd         := function(A,B: Integer):  Double begin Result := A + B      end;
    FuncSubtract    := function(A,B: Integer):  Double begin Result := A - B      end;
    FuncMultiply    := function(A,B: Integer):  Double begin Result := A * B      end;
    FuncDivide      := function(A,B: Integer):  Double begin Result := A / B      end;
    FuncIntDivide   := function(A,B: Integer): Integer begin Result := A div B    end;
    FuncNegative    := function(A: Integer):   Integer begin Result := -A;        end;
    FuncPositive    := function(A: Integer):   Integer begin Result := Abs(A);    end;
    FuncInc         := function(A: Integer):   Integer begin Result := A + 1;     end;
    FuncDec         := function(A: Integer):   Integer begin Result := A - 1;     end;
    FuncLogicalNot  := function(A: Integer):   Boolean begin Result := A = 0;     end;
    FuncModulus     := function(A, B: Integer): Integer begin Result := A mod B;  end;
  end;

  LDblOp := TTOperation<Double>.Create;
  with LDblOp do
  begin
    FuncAdd         := function(A,B: Double): Double begin Result := A + B        end;
    FuncSubtract    := function(A,B: Double): Double begin Result := A - B        end;
    FuncMultiply    := function(A,B: Double): Double begin Result := A * B        end;
    FuncDivide      := function(A,B: Double): Double begin Result := A / B        end;
    FuncNegative    := function(A: Double):   Double begin Result := -A;          end;
    FuncPositive    := function(A: Double):   Double begin Result := Abs(A);      end;
    FuncInc         := function(A: Double):   Double begin Result := A + 1;       end;
    FuncDec         := function(A: Double):   Double begin Result := A - 1;       end;
    FuncLogicalNot  := function(A: Double):   Boolean begin Result := A = 0;      end;
    FuncModulus     := function(A, B: Double): Double begin Result := A - (Int(A/B) * B); end;
  end;

  TOperations.new<TObject>('Default',LObjOp);
  TOperations.new<Integer>('Default',LIntOp);
  TOperations.new<Double> ('Default',LDblOp);
  TOperations.new<String> ('Default',LStrOp);
end;

initialization
  TOperations.Operations := TGenericDictionary.Create;
  DefaultOperations;

finalization
  TOperations.Operations.FreeValuesOnDestroy := True;
  TGenU.freeAndNil(TOperations.Operations);