Mutually dependent records in Delphi

Question

I am using the operator overloading for records in Delphi 2006. (Please don't answer this question by telling me not to.)

I have two record types with the implicit operator overloaded. They are both only in the implementation of the module, not exposed through the interface.

My problem is, now that they are mutally dependent, I don't know how to forward declare the second type to the compiler. I know how to do this with functions, procedure and classes, but not with records.

Here is a simplified example of what I am trying to do:

implementation

type
  TMyRec1 = record
    Field1 : Integer;
    class operator Implicit(a: TMyRec2): TMyRec1;  // <---- Undeclared Identifier here.
  end;

  TMyRec2 = record
    Field2: Integer;
    class operator Implicit(a: TMyRec1): TMyRec2;
  end;

class operator TMyRec1.Implicit(a:TMyRec2): TMyRec1;
begin
  Result.Field1 := a.Field2;
end;

class operator TMyRec2.Implicit(a:TMyRec2): TMyRec2;
begin
  Result.Field2 := a.Field1;
end;

Answer 1

You can't have forward declarations for record types. Define both Implicit operators in the second type:

type
  TMyRec1 = record
    Field1 : Integer;
  end;

  TMyRec2 = record
    Field2: Integer;
    class operator Implicit(a: TMyRec2): TMyRec1;
    class operator Implicit(a: TMyRec1): TMyRec2;
  end;

Quoting from the help:

Implicit conversions should be provided only where absolutely necessary, and reflexivity should be avoided. It is best to let type B implicitly convert itself to type A, and let type A have no knowledge of type B (or vice versa).

Answer 2

How to SOLVE this problem:

unit myMath;

interface


type

  myInteger=record
    Value:string;
    class operator Implicit(s:string):myInteger; overload;
    class operator Implicit(i:integer):myInteger; overload;
  end;

  myFraction=record
    Nominator,Denominator:myinteger;
    class operator Implicit(m:myInteger):myFraction;
    class operator Divide(n,d:myInteger):myFraction;
  end;


implementation

class operator myInteger.Implicit(s:string):myInteger;
begin
  Result.Value:=s;
end;

class operator myInteger.Implicit(i:integer):myInteger;
begin
  str(i,Result.Value);
end;



class operator myFraction.Implicit(m:myInteger):myFraction;
begin
  Result.Nominator:=m;
  Result.Denominator:=1;
end;

class operator myFraction.Divide(n,d:myInteger):myFraction;
begin
  Result.Nominator:=n;
  Result.Denominator:=d;
end;


end.