Language and Compiler Features Since Delphi 7

Delphi allows certain functions, or operators, to be overloaded within record declarations

TMyClass = class
    class operator Add(a, b: TMyClass): TMyClass; // Addition of two operands of type TMyClass
    class operator Subtract(a, b: TMyClass): TMyclass; // Subtraction of type TMyClass
    class operator Implicit(a: Integer): TMyClass; // Implicit conversion of an Integer to type TMyClass
    class operator Implicit(a: TMyClass): Integer; // Implicit conversion of TMyClass to Integer
    class operator Explicit(a: Double): TMyClass; // Explicit conversion of a Double to TMyClass
end;

// Example implementation of Add class operator 
TMyClass.Add(a, b: TMyClass): TMyClass;
begin
  ...
end;

var
x, y: TMyClassbegin
  x := 12; // Implicit conversion from an Integer 
  y := x + x; // Calls TMyClass.Add(a, b: TMyClass): TMyClass 
  b := b + 100; // Calls TMyClass.Add(b, TMyClass.Implicit(100)) 
end;

A class helper is a type that - when associated with another class - introduces additional method names and properties which may be used in the context of the associated class (or its descendants). Class helpers are a way to extend a class without using inheritance. A class helper simply introduces a wider scope for the compiler to use when resolving identifiers. When you declare a class helper, you state the helper name, and the name of the class you are going to extend with the helper. You can use the class helper any place where you can legally use the extended class. The compiler's resolution scope then becomes the original class, plus the class helper. Class helpers provide a way to extend a class, but they should not be viewed as a design tool to be used when developing new code. They should be used solely for their intended purpose, which is language and platform RTL binding.

type
  TMyClass = class

    procedure MyProc;
	function  MyFunc: Integer;
  end;

   ...

   procedure TMyClass.MyProc;
   var
	 X: Integer;
   begin
	  X := MyFunc;
   end;

   function TMyClass.MyFunc: Integer;
   begin
	   ...
   end;

...

type
   TMyClassHelper = class helper for TMyClass
	 procedure HelloWorld;
	 function MyFunc: Integer;
   end;

   ...

   procedure TMyClassHelper.HelloWorld;
   begin
	 WriteLn(Self.ClassName); // Self refers to TMyClass type, not TMyClassHelper

   end;

   function TMyClassHelper.MyFunc: Integer;
   begin
	 ...
   end;
...

var
  X: TMyClass;
begin
  X := TMyClass.Create;
  X.MyProc;    // Calls TMyClass.MyProc
  X.HelloWorld; // Calls TMyClassHelper.HelloWorld
  X.MyFunc; // Calls TMyClassHelper.MyFunc

end;

In addition to fields, records now may have properties and methods (including constructors), class properties, class methods, class fields, and nested types. 

type
  TMyRecord = record
    type
      TInnerColorType = Integer;
    var
      Red: Integer;
    class var
      Blue: Integer;
    procedure printRed();
    constructor Create(val: Integer);
    property RedProperty: TInnerColorType read Red write Red;
    class property BlueProp: TInnerColorType read Blue write Blue;
  end;

constructor TMyRecord.Create(val: Integer);
begin
  Red := val;
end;

procedure TMyRecord.printRed;
begin
  writeln('Red: ', Red);
end;

Classes, and not just methods, can be declared as abstract.

type
  TAbstractClass = class abstract
    procedure SomeProcedure;
end;

type
  TAbstractClass = class sealed
    procedure SomeProcedure;
end;

type
  TClassWithConstant = class
    public 
      const SomeConst = 'This is a class constant';
  end;
			

procedure TForm1.FormCreate(Sender: TObject);
begin
  ShowMessage(TClassWithConstant.SomeConst);
end;

type
  TClassWithClassType = class
  private
	type
	  TRecordWithinAClass = record
	  SomeField: string;
	end;
  public

	    class var
	  RecordWithinAClass: TRecordWithinAClass;
  end;
  ...
procedure TForm1.FormCreate(Sender: TObject);
begin
  TClassWithClassType.RecordWithinAClass.SomeField := 'This is a field of a class type declaration';
  ShowMessage(TClassWithClassType.RecordWithinAClass.SomeField);
end;

type
  TOuterClass = class
  strict private
	MyField: Integer;
  public
	type
      TInnerClass = class
	  public
        MyInnerField: Integer;
		procedure InnerProc;
      end;
      procedure OuterProc;
  end;

procedure TOuterClass.TInnerClass.InnerProc;
begin
  ...
end;

TAbstractClass = classabstract
  public
    procedure Bar; virtual;
  end;

  TSealedClass = classsealed(TAbstractClass)
  public
    procedure Bar; override;
  end;

  TFinalMethodClass = class(TAbstractClass)
  public
    procedure Bar; override; final;
  end;

type
  TMyClass = class
    strict private
      class var
        FX: Integer;
    strict protected  

    // Note: accessors for class properties must be declared class static.

      class function GetX: Integer; static;
	  class procedure SetX(val: Integer); static;
    public
      class property X: Integer read GetX write SetX;
	  class procedure StatProc(s: String); static;
  end;

TMyClass.X := 17;
TMyClass.StatProc('Hello');

  for Element in ArrayExpr do Stmt;
  for Element in StringExpr do Stmt;
  for Element in SetExpr do Stmt;
  for Element in CollectionExpr do Stmt;