Delphi does indeed so some type inference as Primoz found out below. It has been doing this for a long time, improved over time, but has a long road ahead.
One odd thing is that generics (and the majority of inference support) were introduced in Delphi 2009 ([WayBack] Generics with Delphi 2009 Win32), but the inference was already documented in Delphi 2007: [WayBack] Delphi 2007 – Declaring Generics: Parameterized Types
This is a reminder to myself to write some more example code on what kinds of inference work and which do not, especially because of the comments from David Heffernan, Marco Cantu and Stefan Glienke, especially since the improvement over time has been small. I am curious to see how the promised “working on it” by now lives up to reality.
David Heffernan
This is a rare piece of code where type inference actually works. Mostly it does not which is very frustrating.It’s a little ironic that you ask why you don’t need to include
<T>. Normally people ask about the much more frequent instances where you do need to include <T> because the compiler’s type inference is so weak.David Heffernan
+Marco Cantù Much more commonly there are times when you want the compiler to infer the type, but it won’t. It would really make a difference to us if the compiler was better at this.Marco Cantù
+David Heffernan I tend to agree the compiler should be much better at type inference. Working on it!Stefan Glienke
Infering the generic argument from a constructed generic type would be great.GuessTheType<T>(const x: TArray<T>); var a: TArray<Integer>; begin GuessTheType(a);does not work although the compiler could infer the parameter for
GuessTheTypefrom itsxparameter but currently it does not know that a originally was aTArray<T>(yes, I knowarray of Tas signature works but that is a different thing).P.S. +Marco Cantù btw how hard can it be to finally implement generic standalone routines without that ugly static type? Probably one of the highest voted feature requests: https://quality.embarcadero.com/browse/RSP-13724)
Source: [WayBack] Anybody here knows since when we don’t have to write when calling generic ProcSomething(param: T)? It was brought to my attention today that the… – Primož Gabrijelčič – Google+
–jeroen
A quick look into the generated assembler code proves that the type is indeed resolved correctly:
Project17.dpr.26: TGeneric.GuessTheType<Exception>(x);
0041C530 8B151C484200 mov edx,[$0042481c]
0041C536 A1F4974100 mov eax,[$004197f4]
0041C53B E84CD3FFFF call TGeneric.GuessTheType<System.SysUtils.Exception>
Project17.dpr.27: TGeneric.GuessTheType(x);
0041C540 8B151C484200 mov edx,[$0042481c]
0041C546 A1F4974100 mov eax,[$004197f4]
0041C54B E83CD3FFFF call TGeneric.GuessTheType<System.SysUtils.Exception>
Project17.dpr.28: TGeneric.GuessTheType(s);
0041C550 8B1520484200 mov edx,[$00424820]
0041C556 A1F4974100 mov eax,[$004197f4]
0041C55B E83CD3FFFF call TGeneric.GuessTheType<System.SysUtils.TSimpleRWSync>
Source: https://plus.google.com/+Primo%C5%BEGabrijel%C4%8Di%C4%8D/posts/edE3YWtwY3B
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| program Project17; | |
| {$APPTYPE CONSOLE} | |
| {$R *.res} | |
| uses | |
| System.SysUtils; | |
| type | |
| TGeneric = class | |
| class procedure GuessTheType<T>(const value: T); | |
| end; | |
| var | |
| x: Exception; | |
| s: TSimpleRWSync; | |
| { TGeneric<T> } | |
| class procedure TGeneric.GuessTheType<T>(const value: T); | |
| begin | |
| end; | |
| begin | |
| TGeneric.GuessTheType<Exception>(x); | |
| TGeneric.GuessTheType(x); | |
| TGeneric.GuessTheType(s); | |
| end. | |
The Wiert Corner - irregular stream of stuff 