[fpc-devel] Re: Templates / Generics Syntax

[Thomas Schatzl]

> Op Thu, 3 Nov 2005, schreef Mattias Gaertner:
> 
> 
>>Here is a proposal of the syntax:
>>
>>type
>>  TGenericClass<T,F> = class
>>  public
>>    procedure Add(Item: T; Flag: F);
>>  end;
> 
> 
> This syntax is almost impossible to implement since in one of your other 
> mails the symbols to mark the parameters appear in regular source code:
> 
> begin
>   generictypeA<integer>.create
> end.
> 
> It will be very hard for the parser to see the difference in advance 
> between:
> 
>   variable<integer(another_var)
>   generic_type<integer
> 
> Only when the > symbol is parsed the result is known.

No, already after the second token after the opening "<". It must either 
be a ",", or the closing bracket.

Assuming that you disallow something like generic_type<generic_type2<...

Even that limitation can be overcome by disallowing directly nested 
generic use specification. Something like

type
	TGeneric2 = generic_type2<...>;

generic_type<TGeneric2 ...

could be allowed however.

> Maybe the parser may be able lookup the type first and make a decision 
> based on that, but it would be in the middle of a recursive expression 
> parse designed for infix operators.

Simply use a second, third, ... lookahead token for the < case.

> 
> Also in C++ this sometimes causes trouble where you need to change your 
> code notation so the compiler eats it. I don't know if this proposal 
> suffers from this mess, but we should avoid at all cost to import it into 
> Pascal.
> 

From: Mattias Gaertner <nc-gaertnma at netcologne.de>
> On Thu, 3 Nov 2005 19:59:40 +0100 (CET)
> Daniël Mantione <daniel.mantione at freepascal.org> wrote:
> Right. I didn't think of that.
> 
> What about edged brackets?
> 
> type
>   TGenericClass[T,F] = class
>   public
>     procedure Add(Item: T; Flag: F);
>   end;
> 
> procedure TGenericClass.Add(Item: T; Flag: F);
> // Note: No redundant [T,F] after TGenericClass.
> begin
> end;
> 
> type TListOfComponent = TGenericList[TComponent];
> 
> Analog:
> type TGenericListClass[T] = class of TGenericList[T];
> type PGenericRecord[T] = ^TGenericRecord[T];
> 
> procedure GenericProc[T](Param: T);
> begin
> end;

I think this has a similar problem to the other one. Consider this:

my_procedure[...

where my_procedure isn't an instantiation of a method using the generic 
but a function returing an array of something.

Not completely sure whether this is a problem though... depends on the 
implementation.

Regards,
   Thomas