Typdefinition: Generics in Generics gehen nicht?

[Der schöne Günther]

Ich glaube der Covfefe ☕ war zu schwach und ich stehe auf dem Schlauch.

Warum geht folgendes nicht, bzw. was muss ich tun damit es geht?

Delphi-Quellcode:

uses
   System.SysUtils;

type
   Nullable<T> = record
      value: T;
      hasValue: Boolean;
   end;

   TStruct = record
      someFloat: Nullable<Single>;
   end;

   TMyObject = class(TObject) // E2564 Undefinierter Typ 'Nullable<T>'
      myStruct: Nullable<TStruct>;
   end;

Der Compiler nimmt die Definition für mein TMyObject nicht an.



Im Docwiki finde ich:

Zitat:

Generic types are instantiated by providing type arguments. In Delphi, you can use any type as a type argument except for the following: a static array, a short string, or a record type that (recursively) contains a field of one or more of these two types.

[Neutral General]

Okay das verstehe ich auch nicht.
Man kann aber ansonsten als globale/lokale Variable ohne Probleme ein Nullable<TStruct> deklarieren.
Es scheint aus irgendeinem Grund nur in Klassen/Records nicht zu gehen.

Delphi-Quellcode:

var
  Form1: TForm1;
  y: TNullable<TStruct>; // Geht

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
var x: TNullable<TStruct>;  // Geht
begin

end;

Macht in meinen Augen keinen Sinn. Aber mal abwarten was Uwe dazu sagt

[Uwe Raabe]

Zitat von Neutral General:

Aber mal abwarten was Uwe dazu sagt

Mit einem zusätzlichen Type funktioniert es - zumindest unter 10.3.3:

Delphi-Quellcode:

type
   Nullable<T> = record
      value: T;
      hasValue: Boolean;
   end;

   TStruct = record
      someFloat: Nullable<Single>;
   end;

type
   TMyObject = class(TObject)
      myStruct: Nullable<TStruct>;
   end;

[Der schöne Günther]

wtf (⊙_⊙)？

Tatsächlich. Auch unter 10.0 Seattle. Was für eine merkwürdige Welt.

[himitsu]

Wollte ich auch grade vorschlagen.

Delphi führt ein "type" als Gruppe aus, darum kann man dort auch mit Forward-Deklarationen von Klassen-Typen arbeiten,
nur wird ja der Generic hier erst im Anschluß "richtig" erzeugt und ist somit noch nicht vorhanden.

hier darf kein TYPE zwischen den beiden A= sein

Delphi-Quellcode:

type 
  A = class;

  R = record
    a: A;
  end;

  A = class()
    ...
  end;

Gut, der Compiler könnte für Generics nochmal in die aktuelle Verarbeitungsliste schauen und wenn der Generic-Name dort zu finden ist, dann eine "verständlichere" Fehlermeldung ausgeben.

[Der schöne Günther]

Faszinierend, das wusste ich nicht. Schwer zu merken, aber das bekomme ich hoffentlich noch hin. Danke euch beiden!

[himitsu]

Das braucht man zu Beispiel, wenn sich zwei Klassen gegenseitig referenzieren, also in der Definition der Klasse A brauchst du B und in B willst du auch A haben.

Delphi-Quellcode:

type
  TA = class;

  TB = class
    A: TA;
  end;

  TA = class
    B: TB;
  end;

Im TB ist schon bekannt wie groß der Zeiger (Variable) auf TA ist, drum kann auch ohne Kenntis des genauen Aufbaus von TA, das TB bereits zusammengebaut werden.
Deshalb geht es auch nur für Klassen und nicht z.B. für Records.

Wenn TB nur in der Implementation auf den Typen TA zugreift, dann wäre das nicht nötig.

[Der schöne Günther]

Zitat von himitsu:

Das braucht man zu Beispiel wenn sich zwei Klassen gegenseitig referenzieren

Ich glaube so etwas unanständiges habe ich noch nie gemacht 😎

[Redeemer]

Zitat von himitsu:

Das braucht man zu Beispiel, wenn sich zwei Klassen gegenseitig referenzieren

Der Vollständigkeit halber: Wenn hingegen Records sich selber referenzieren (was natürlich nur für Methodenparameter und Funktionswerte geht) muss man zu Record-Helpern greifen. Wie unanständig ist das, Schöner Günther?

Helper gehen aber allgemein nicht für Generics, daher ist das eigentlich schon OT.

[freimatz]

Records sich selber referenzieren geht auch ohne Methoden. Schönes Beispiel von vor 30 Jahren bei Prof. Dr. Rudolf Herschel gelernt waren doppelt verkettete Listen.