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;