into Record?

[himitsu]

Ich hab da mal bissl rumgespielt.

Einmal hätte ich ja das Problem, dass der Record sich unterschiedlich verhalten soll,
jenachdem von wo er kommt -> Property oder Variable.

Und wenn ich zwei Records habe, dass sie aber dennoch zuweisungskompatibel sind.
Kein Problem mit den ClassOperatoren, aber mit den Generics hatte ich sowas noch nie mit sich selbst probiert.

Versuch 1 (Idee siehe vorheriger Post) lief schief, da ich von SELF keinen Typ bekomme (falls der überhaupt sich unterscheiden hätte, was ich kaum glaube).
Dabei wäre Dieses die einfachste/übersichtlichste Lösung geworden.

Delphi-Quellcode:

uses
  TypInfo;

type
  TFuu = record
    procedure Test;
  end;

  TBar = type TFuu;

procedure TForm11.FormCreate(Sender: TObject);
var
  A: TBar;
begin
  A.Test;
end;

procedure TFuu.Test;
begin
  ShowMessage(PTypeInfo(TypeInfo(Self)).Name);  // geht nicht
end;

Versuch 2 klappte dann erstmal.
Zwar wieder kein Typ von Self, aber dafür von <T>.
Aber dennoch nicht funktional, da diese Typen sich nicht einander zuweisen lassen.

Delphi-Quellcode:

uses
  TypInfo;

type
  TFuu<T> = record
    procedure Test;
  end;

  TFuu = TFuu<Byte>;
  TBar = TFuu<Word>;

procedure TForm11.FormCreate(Sender: TObject);
var
  A: TBar;
begin
  A.Test;
end;

procedure TFuu<T>.Test;
begin
  //ShowMessage(PTypeInfo(TypeInfo(Self)).Name);  // geht auch nicht
  ShowMessage(PTypeInfo(TypeInfo(T)).Name);
end;

Versuch 3 ... naja

Delphi-Quellcode:

type
  TFuu<X> = record
    procedure Test;

    class operator Implicit(const A: TFuu<Word>): TFuu<Byte>;
    class operator Implicit(const A: TFuu<Byte>): TFuu<Word>;
  end;

[dcc32 Fehler] E2521 Operator 'Implicit' muss einen 'TFuu<X>'-Typ im Parameter oder Ergebnistyp übernehmen

Delphi-Quellcode:

type
  TFuu<X> = record
    procedure Test;

    class operator Implicit(const A: TFuu<X>): TFuu<Byte>;
    class operator Implicit(const A: TFuu<X>): TFuu<Word>;
    class operator Implicit(const A: TFuu<Word>): TFuu<X>;
    class operator Implicit(const A: TFuu<Byte>): TFuu<X>;
  end;

Also genau was der Compiler nun wollte, aber dennoch mag er es nun nicht, wegen der Nicht-Eindeutigkeit.
Erstes und Letztes sind identisch und verweisen auch noch jeweils auf sich selber.

Delphi-Quellcode:

    // z.B. X = Byte
    class operator Implicit(const A: TFuu<Byte>): TFuu<Byte>;
    class operator Implicit(const A: TFuu<Byte>): TFuu<Word>;
    class operator Implicit(const A: TFuu<Word>): TFuu<Byte>;
    class operator Implicit(const A: TFuu<Byte>): TFuu<Byte>;

Dann, bei der 4, wurde es kompliziert und fast unübersichtlich (hatte mehrmals 'nen Knoten im Hirn und dachte es sei andersrum),
ABER es scheint zu gehn.

Delphi-Quellcode:

uses
  TypInfo;

type
  TFuu<X,Y> = record
    Value: string;
    procedure Test;

    class operator Implicit(const A: TFuu<X,Y>): TFuu<Y,X>;
    class operator Implicit(const A: TFuu<Y,X>): TFuu<X,Y>;
    class operator Initialize(out Dest: TFuu<X,Y>);
    class operator Finalize  (var Dest: TFuu<X,Y>);
    class operator Assign    (var Dest: TFuu<X,Y>; const [ref] Src: TFuu<X,Y>);
  end;

  TFuu = TFuu<Byte,Word>;
  TBar = TFuu<Word,Byte>;

procedure TForm11.FormCreate(Sender: TObject);
var
  F: TFuu;
  Q: TFuu;
  B: TBar;
begin                         // create TFuu(F), create TFuu(Q), create TBar(B)
  F.Test;                     // test TFuu(F)
  B.Test;                     // test TBar(B)

  F.Value := 'Test';          // -setValue TFuu(F)-
  Q := F;                     // assign TFuu(F)->TFuu(Q)
  B := F;                     // create TBar(Temp), toMe TFuu(F)->TBar(Temp), assign TBar(Temp)->TBar(B), free TBar(Temp)
  if B.Value = 'Test' then ;  // -getValue TFuu(B)-
end;                          // free TBar(B), free TFuu(Q), free TFuu(F)

procedure TFuu<X,Y>.Test;
begin
  //ShowMessage(PTypeInfo(TypeInfo(X)).Name + ' ' + PTypeInfo(TypeInfo(Y)).Name);
  if TypeInfo(X) = TypeInfo(Byte) then
    ShowMessage('test TFuu')
  else
    ShowMessage('test TBar');
end;

class operator TFuu<X,Y>.Assign(var Dest: TFuu<X,Y>; const [ref] Src: TFuu<X,Y>);
begin
  if TypeInfo(X) = TypeInfo(Byte) then
    ShowMessage('assign TFuu->TFuu')
  else
    ShowMessage('assign TBar->TBar');
  Dest.Value := Src.Value;
end;

class operator TFuu<X,Y>.Finalize(var Dest: TFuu<X,Y>);
begin
  if TypeInfo(X) = TypeInfo(Byte) then
    ShowMessage('free TFuu')
  else
    ShowMessage('free TBar');
  Dest.Value := '';
end;

class operator TFuu<X,Y>.Initialize(out Dest: TFuu<X,Y>);
begin
  if TypeInfo(X) = TypeInfo(Byte) then
    ShowMessage('create TFuu')
  else
    ShowMessage('create TBar');
  Dest.Value := 'empty';
end;

class operator TFuu<X,Y>.Implicit(const A: TFuu<Y,X>): TFuu<X,Y>;
begin
  //ShowMessage(PTypeInfo(TypeInfo(Y)).Name + ' ' + PTypeInfo(TypeInfo(X)).Name
  //  + ' -> ' + PTypeInfo(TypeInfo(X)).Name + ' ' + PTypeInfo(TypeInfo(Y)).Name);
  if TypeInfo(X) = TypeInfo(Byte) then
    ShowMessage('toMe TBar->TFuu')
  else
    ShowMessage('toMe TFuu->TBar');

  //Result := TFuu<X,Y>(A);
  Result.Value := A.Value;
end;

class operator TFuu<X,Y>.Implicit(const A: TFuu<X,Y>): TFuu<Y,X>;
begin
  //ShowMessage(PTypeInfo(TypeInfo(X)).Name + ' ' + PTypeInfo(TypeInfo(Y)).Name
  //  + ' -> ' + PTypeInfo(TypeInfo(Y)).Name + ' ' + PTypeInfo(TypeInfo(X)).Name);
  if TypeInfo(X) = TypeInfo(Byte) then
    ShowMessage('fromMe TFuu->TBar')
  else
    ShowMessage('fromMe TBar->TFuu');

  //TFuu<X,Y>(Result) := A;  // [dcc32 Fehler] E2064 Der linken Seite kann nichts zugewiesen werden
  //Result := TFuu<Y,X>(A);
  Result.Value := A.Value;
end;

Früher war mir so, als wenn Temp-Variablen für Zwischenergebnisse als lokale Funktionsvariablen (von begin bis end) erstellt würden.
Jetzt scheint das wirklich nur dort zu sein, wo es ist ... vielleicht haben sie nun die neuen inline-Variablen hier selbst benutzt.

[mytbo]

Zitat von himitsu:

Früher war mir so, als wenn Temp-Variablen für Zwischenergebnisse als lokale Funktionsvariablen (von begin bis end) erstellt würden.

Wenn ich dich richtig verstanden habe, meinst du das: Delphi 10.4 / Delphi 11 Alexandria Breaking Changes

Bis bald...
Thomas

[himitsu]

Jo, also doch richtig gesehn.

Ist ja blöd, denn das alte Verhalten hatte in einem Fall einen Vorteil.
Für einfache Logging-Funktionen, also zu Beginn ein Interface erstellen und bei Funktionsende wird es freigegeben, also auch nochmal das Ende automatisch loggen können.

[Uwe Raabe]

Zitat von himitsu:

Für einfache Logging-Funktionen, also zu Beginn ein Interface erstellen und bei Funktionsende wird es freigegeben, also auch nochmal das Ende automatisch loggen können.

Wenn du das direkt nach dem begin machst, dann ist der Scope aber immer noch die gesamte Methode. Da hat sich nichts geändert.

In dem verlinkten Beispiel wird das Interface aber im Scope eines inneren begin-end erstellt. Das funktioniert jetzt anders als vorher.

[himitsu]

ahhh OK.
jetzt noch probieren, ob es auch in einem IF-THEN funktioniert, aber theoretisch wäre das doch auch in einem anderen Scope.

Nja, ansonsten wäre noch die Überlegung für eine Attribut an Variable oder an einem Function-Result, so wie bei [Weak] und Co.


Aktuell haben wir für Logging und Exception-Beahndlung am Ende eine Kennung ... die reicht, um in der bis nach oben durchgewanderten Exception noch paar Infos mit anzuzeigen,
aber will man mittendrin mit Try-Except das abfangen und die Exception anzeigen, dann fehlt das natürlich. Drum wäre es besser das schon zu Beginn anf 'nen Stack zu schieben und am Ende automatisch entfernen zu lassen.

[Uwe Raabe]

Zitat von himitsu:

Nja, ansonsten wäre noch die Überlegung für eine Attribut an Variable oder an einem Function-Result, so wie bei [Weak] und Co.

In dem Fall täte es auch eine simple lokale (nicht inline) Variable um das Interface bis zum Methodenende zu halten. Hätte auch den Charme von Abwärtskompatibilität.

[himitsu]

Mal schnell getestet und natürlich zuerst ein kleines Fehlerchen, mit blöder Auswirkung. (nur die lokalen Variablen wurden freigegeben)

Delphi-Quellcode:

type
  TTest = class(TInterfacedObject, ITest)
    Name: string;
    constructor Create(Name: string);
    destructor Destroy; override;
  end;

Delphi-Quellcode:

type
  ITest = interface
  end;

  TTest = class(TInterfacedObject, ITest)
    Name: string;
    constructor Create(Name: string);
    destructor Destroy; override;
  end;

class function TTest.Create(Name: string): ITest;
begin
  Result := inherited Create;
  (Result as TTest).Name := Name;
  ShowMessage('Start ' + Name);
end;

destructor TTest.Destroy;
begin
  ShowMessage('Stop ' + Name);
  inherited;
end;

procedure TForm11.FormCreate(Sender: TObject);
var
  Var1, Var2, Var3, Var4: ITest;
begin
  Var1 := TTest.Create('Var1');               // Start Var1
  var Inline1 := TTest.Create('Inline1');     // Start Inline1
  TTest.Create('Temp1');                      // Start Temp1
  Beep;
  if Tag = 0 then
    Var2 := TTest.Create('Var2');             // Start Var2
  if Tag = 0 then
    var Inline2 := TTest.Create('Inline2');   // Start/Stop Inline2
  if Tag = 0 then
    TTest.Create('Temp2');                    // Start/Stop Temp2
  Beep;
  if Tag = 0 then begin
    Var3 := TTest.Create('Var3');             // Start Var3
    var Inline3 := TTest.Create('Inline3');   // Start Inline3
    TTest.Create('Temp3');                    // Start Temp3
  end;                                        // Stop Temp3/Inline3
  Beep;
  if Tag = 0 then begin
    Var4 := TTest.Create('Var4');             // Start Var4
    var Inline4 := TTest.Create('Inline4');   // Start Inline4
    TTest.Create('Temp4');                    // Start Temp4
    Beep;
    begin
      TTest.Create('Temp5');                  // Start Temp5
    end;                                      // Stop Temp5
    Beep;
    begin
      TTest.Create('Temp6');                  // Start Temp6
      Beep;
      TTest.Create('Temp7');                  // Start Temp7
      Beep;
    end;                                      // Stop Temp7/Temp6
    Beep;
    begin
      var Temp8 := TTest.Create('Temp8');     // Start Temp8
      Beep;
      Temp8 := TTest.Create('Temp9');         // Stop Temp8 / Start Temp9
      Beep;
    end;                                      // Stop Temp9
    Beep;
    ShowMessage('Show');                      // Show
    Beep;
  end;                                        // Stop Temp4/Inline4
  Beep;
end;                                          // Stop Temp1/Inline1/Var4/Var3/Var2/Var1

Delphi-Quellcode:

class function TTest.Create(Name: string): ITest;
begin
  ShowMessage('Start ' + Name);
  Result := inherited Create;
  (Result as TTest).Name := Name;
end;

    begin
      var Temp8 := TTest.Create('Temp8');     // Start Temp8
      Beep;
      Temp8 := TTest.Create('Temp9');         // Start Temp9 / Stop Temp8
      Beep;
    end;                                      // Stop Temp9

Jo, egal ob mit Begin/End oder nicht ... IF reagiert gleich einheitlich.

[Dennis07]

Kleine Info am Rande:
SmartPascal bzw. DWScript untrstützt sowas in der Art. Das wäre sicher auch eine schöne Sache für Delphianer:

Delphi-Quellcode:

TMy = class
  FInner: TMyInner;
  property Prop read (FInner.Value);
end;

Theoretisch kann man hier mit ( und ) jeden beliebigen Code aufrufen, der einen Wert des Typen TMyInner zurückgibt (oder der implizit dorthin konvertierbar wäre). Das ist schon manchmal ganz geil, weil das haufenweise unnötige Getter bzw. Setter einspart. Gerade bei indizierten Eigenschaften, die ja nunmal gar kein Feldzugriff so in-line erlauben...