Hi,

if I define 2 types like:

type
  MyA = type string;
  MyB = type string;

are MyA and MyB considered as the same type ?
Should it be allowed to assign a variable of type MyA to a variable of type MyB ?
IIRC, the use of = type <some type> creates a new type. Or am I wrong ?

Marc

No, you are explicitly marking them as a new type. This is a very cool feature of Pascal you wont find in many other languages.

(For instance, you could use it to create a new integer-type for little- and big-endian numbers, ensuring that you _never_ directly assign a little-endian number to a big-endian one, or vice versa)

Should it be allowed to assign a variable of type MyA to a variable of type MyB ?

No.

IIRC, the use of = type <some type> creates a new type.

That's right.

OK, thanks for confirming my thoughts.
In an attempt to make some use of it, I tried the following, and it compiles without a problem (also tried with Integer).

From this it seems that for FPC it doesn't matter if it is "typed" or not.

Marc

program TypeTest;
{$mode objfpc}{$h+}
type
  TMyA = type String;
  TMyB = type String;
var
  A: TMyA;
  B: TMyB;
  S: String;
begin
  S := 'Some value';
  A := S;
  B := S;
  S := A;
  S := B;
  A := B;
  B := A;
end.

Well, assign works, but if you use them as var Parameters it works not! It's also nice if you have got overloaded functions.

-Ivo

For the compiler the types are not equal anymore, but they are still compatible for implicit type conversion. This has mainly impact on overload choosing and parameter passing. Normal assignments using ':=' are not affected because of the still available implicit type conversion.

I came to this when I wanted to do operator overloading on them. The compiler complained that you cannot overload for equal types.

So I wanted first to know if it are equal types or not.

Next question: Should operator overloading be possible on such types ?

Marc

one trick if you wan't to keep a type but redefine the operators on it is to wrap it in a single element record.

Next question: Should operator overloading be possible on such types ?

Yes.

Florian Klaempfl wrote

Marc Weustink schrieb: > Next question: Should operator overloading be possible on such types ? Yes.

Then I think I found a bug, see 7610

Marc

I really feel there should be a way to make two types completely incompatible.

How exactly does the compiler figure out the rules for implicit conversion?

In the case of wrapper integers in records, are 4-byte records handled as efficiently by the compiler as 4-byte integers? I suspect it's some radically different code that handles it.

Only by making it a record. Conversion of atomic types (string,integer,etc) are always handled internally by the compiler.

Peter

In the case of wrapper integers in records, are 4-byte records handled as efficiently by the compiler as 4-byte integers? I suspect it's some radically different code that handles it.

test it?

That would require me to actually do something and not just talk about it... ;-)

(but yes, I am going to test it :)