Generics/ko: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		The first thing someone who knows thie stuff needs to do is explain what a generic is so we understand what the issue is.
2	2
3	3		## FPC에서 제너릭
4	4
5	5		Generic classes are already implemented in the 2.3.1 version of FPC. 제너릭 클래스들은 이미 FPC 2.3.1 버전안에 구현되어져 있습니다.
6	6
7	7		See the [FPC reference](http://www.freepascal.org/docs-html/ref/ref.html). 여기를 보세요 [FPC reference](http://www.freepascal.org/docs-html/ref/ref.html).
8	8
9	9		This page contains proposals and ideas, which lead to the current implementation and for further features. 이 문서는 앞으로의 모습과 성취물을 안내하는, 제안과 아이디어를 포함하고 있습니다.
10	10
11	11		## 왜?
12	12
13	13		- 형 안정성 !
14	14		- 속도
15	15		- 재미있게 읽을수 있음
16	16
17	17		See "Already existing stuff" for possible but lacking ways right now. 당장 약간 모자라지만, 가능하면 "이미 존재하는 것"을 읽어보세요
18	18
19	19		## 관심을 갖은 사람들
20	20
21	21		\- Almindor - dannym - fpk - giantm - oliebol - plugwash - Synopsis - tom - PublicJoke - neli - dr_evil
22	22
23	23		## 사용 례 (분류안됨)
24	24
25	25		TODO: combine the below stuff into one example using the \<\> syntax TODO: \<\> 문법을 사용하는 예제와 아래의 것을 결합합니다
26	26
27	27		(tom 의 제안)
28	28
29	29		` type`\
30	30		` // explicit addition of "generic" keyword. Maybe something like "uses generic <...>" `\
31	31		` // better use the <>-brackets because otherwise it may cause confusion with arrays `\
32	32		` // in the actual instantiation`\
33	33		` // "generic"키워드를 명시합니다. 실제 인스턴스에서 배열들과 함께 혼동을 일으킬 것이므로, `\
34	34		` // <>괄호를 쓰는 것보다 "generic <...>" 을 쓰는 것이 나을것입니다`\
35	35		` abc = class(..) generic <a, b>`\
36	36		` end;`\
37	37		` var`\
38	38		` // because they're still unused ;)`\
39	39		` // 왜냐면 그것들은 아직 사용되지 않았습니다 ;)`\
40	40		` xyz : abc<String, Integer>;`\
41	41		` xyz2 : abc<AObj1, AObj2>;`\
42	42		` begin`\
43	43		` // don't repeat generics in instance creation (if not necessary)`\
44	44		` // 인스턴스의 초기화에 제너릭을 반복하지 마십시요(필요하지 않다면)`\
45	45		` xyz := abc.Create;`\
46	46		` xyz2 := abc<descendant_of_Aobj1, descendant_of_Aobj2>.Create;`\
47	47		` end.`
48	48
49	49		(dannym 의 새로운 제안)
50	50
51	51		` type`\
52	52		` GList = generic class of T`\
53	53		` public`\
54	54		` procedure Add(const stuff: T);`\
55	55		` end;`
56	56
57	57		` procedure GList.Add(const stuff: T); // note that here no 'of T' //'of T'가 없음을 유의하세요`\
58	58		` begin`\
59	59		` ...`\
60	60		` end;`
61	61
62	62		` var`\
63	63		` intlist: GList of Integer;`\
64	64		` begin`\
65	65		` intlist := GList.Create; // note that here the detail type is missing and `\
66	66		` // needs to be deducted from the var declaration`\
67	67		` // 여기에 자세한 선언형이 없으며, var 선언으로 (선언형이)빠져야만 한다는 것을 알아두세요`
68	68
69	69		` //or intlist := typeof(intlist).Create;`\
70	70		` //intlist := GList of Integer.Create; <-- this is unclear if that works <-- 이 것이 실제 구현된 것이라면, 명확하지 않습니다`\
71	71		` end;`
72	72
73	73		(dannym 의 옛 제안)
74	74
75	75		` type`\
76	76		` GList<T> = class`\
77	77		` public`\
78	78		` procedure Add(const stuff: T);`\
79	79		` end;`
80	80
81	81		` procedure GList<T>.Add(const stuff: T);`\
82	82		` begin`\
83	83		` ...`\
84	84		` end;`
85	85
86	86		` var`\
87	87		` intlist: GList<Integer>;`\
88	88		` begin`\
89	89		` intlist := GList<Integer>.Create;`\
90	90		` end;`
91	91
92	92		plugwash 의 것:
93	93
94	94		` tmycollection=template(tobject)[x]`\
95	95		` tintegercollection=tmycollection[integer]`
96	96
97	97		oliebol 의 것:
98	98
99	99		` template blaat<t:integer>(a:t);`\
100	100		` var x : t;`\
101	101		` begin`\
102	102		` do something with a, and use t with it`\
103	103		` end;`
104	104
105	105		note that we should have a generics section (like interface and implementation sections) containing the generics: 우리는 (interface와 implementation 섹션들처럼) 제너릭들을 포함하는, generics 섹션을 가져야한다는것을 알립니다
106	106
107	107		` unit xyz;`\
108	108		` generics`\
109	109		` type`\
110	110		` GList......`\
111	111		` procedure GList.Add(const value: T);`\
112	112		` ....`\
113	113		` end.`
114	114
115	115		(eiffel의 것)
116	116
117	117		<http://paste.lisp.org/display/6236>
118	118
119	119		(PublicJoke 의 제안)
120	120
121	121		` unit Unit1(TMathType);`\
122	122		` `\
123	123		` interface`\
124	124		` `\
125	125		` type`\
126	126		` TMathClass = class`\
127	127		` public`\
128	128		` class function Add(a1, a2: TMathType): TMathType;`\
129	129		` end;`\
130	130		` `\
131	131		` implementation`\
132	132		` `\
133	133		` class function TMathClass.Add(a1, a2: TMathType): TMathType;`\
134	134		` begin`\
135	135		` Result:=a1+a2;`\
136	136		` end;`\
137	137		` `\
138	138		` end.`
139	139
140	140		` unit Unit2;`\
141	141		` `\
142	142		` type`\
143	143		` TMathType = Longword;`\
144	144		` `\
145	145		` interface`\
146	146		` `\
147	147		` implementation`\
148	148		` `\
149	149		` end.`
150	150
151	151		` program prog;`\
152	152		` `\
153	153		` uses`\
154	154		` Unit2, `\
155	155		` Unit1(Byte) as ByteMath in 'Unit1.pas',`\
156	156		` Unit1(TMathType) as PolyMath in 'Unit1.pas';`\
157	157		` `\
158	158		` type`\
159	159		` TByteMathClass = ByteMath.TMathClass;`\
160	160		` TPolyMathClass = PolyMath.TMathClass;`\
161	161		` `\
162	162		` var`\
163	163		` b: Byte;`\
164	164		` p: TMathType;`\
165	165		` `\
166	166		` begin`\
167	167		` b:=TByteMathClass.Add(1, 2);`\
168	168		` p:=TPolyMathClass.Add(3, 4);`\
169	169		` end.`
170	170
171	171		(Gadnio 의 제안) I personally think the C++ way of doing this is clear enough AND will be the easiest to parse/understand: 저는 개인적으로 C++의 방법이 이것을 충분히 명확하게 하고, 해석과 이해가 쉬워질꺼라고 생각합니다
172	172
173	173		` template <T>`\
174	174		` TGenericObject< T > = record`\
175	175		` Data : T;`\
176	176		` OtherStuff : Pointer;`\
177	177		` end;{TGenericObject}`\
178	178		` template <TKey, TData = TGenericObject< boolean > >`\
179	179		` TGenericList = class( TWhee< TKey > )`\
180	180		` public`\
181	181		` function Lookup( const Key : TKey ): TData;`\
182	182		` template <THihi>`\
183	183		` class function DataToHihi( Data : TData ): THihi;`\
184	184		` end;{TGenericList}`
185	185
186	186		Also, note that template specialization is a very, very important thing (for me especially). In C++ they've got vector\< bool \> that behaves different than the standard vector\< T \>. An example: 또한, template의 특수함은 매우, 매우 중요한 것임을 알아야 합니다(특히 나에게는). C++에서는 표준 vector\< T \>와는 다른 동작을 하는 vector\< bool \>을 가지고 있습니다. 한 예로..
187	187
188	188		` template <T, TT>`\
189	189		` TSame = class`\
190	190		` class function Same: Boolean;`\
191	191		` end;{TSame}`\
192	192		` template <T>`\
193	193		` TSame = class`\
194	194		` class function Same: Boolean;`\
195	195		` end;{TSame}`
196	196
197	197		` template <T, TT>`\
198	198		` class function TSame.Same: Boolean;`\
199	199		` begin`\
200	200		` Result := false;`\
201	201		` end;{TSame<T, TT>.Same}`\
202	202		` template <T>`\
203	203		` class function TSame.Same: Boolean;`\
204	204		` begin`\
205	205		` Result := true;`\
206	206		` end;{TSame<T>.Same}`
207	207
208	208		This allows to make a compile-time check for same types that are not TObject, e.g. 이 것은 TObject가 아닌, 같은 선언형에 대해서 compile-time 검사를 할수 있게 합니다. 예로 들면..
209	209
210	210		` TFoo = class;`\
211	211		` TBar = class( TFoo );`\
212	212		` var`\
213	213		` S : Boolean;`\
214	214		` begin`\
215	215		` S := TSame< String, Integer >.Same; //s = false`\
216	216		` S := TSame< Int64, Integer >.Same; //s = false`\
217	217		` S := TSame< String, String >.Same; //s = true`\
218	218		` S := TSame< TBar, TFoo >.Same;//s = false (not the same as "var x: TFoo; begin x := TBar.Create; end;" )`\
219	219		` // "var x: TFoo; begin x := TBar.Create; end;" 가 같지 않듯이)`\
220	220		` end;`
221	221
222	222		Another thing to note: It would be very good if something like this (c++ syntax) would be implemented: 다른 한가지를 적자면, 만약 이 런것이(C++ 문법) 시행되어진다면, 매우 좋아질 겁니다
223	223
224	224		` template <bool b>`\
225	225		` class h`\
226	226		` {`\
227	227		` public:`\
228	228		` static const int i = 0;`\
229	229		` };//h`
230	230
231	231		` template <>`\
232	232		` class h< true >`\
233	233		` {`\
234	234		` public:`\
235	235		` static const int i = 1;`\
236	236		` };`
237	237
238	238		` template <>`\
239	239		` class h< false >`\
240	240		` {`\
241	241		` public:`\
242	242		` static const int i = 2;`\
243	243		` };`
244	244
245	245		Here 여기는 항상
246	246
247	247		` h<false>.i = 2`\
248	248		` h<true>.i = 1 `
249	249
250	250		ALWAYS. 이렇게 됩니다
251	251
252	252		## 사용 례
253	253
254	254		If you add more syntax examples, please add equivalent to both. 만약 좀더 문법예제를 추가한다면, 두가지에 상응하는 것을 추가해 주세요. Two main syntaxes seem to be popular, "\<\>" which looks more or less like C++, c#, etc.. and adding a "generic" keyword which is more along the Pascal style of code. Go to [[Generics Vote]] to vote for one or the other syntax. 두 가지 기본 문법들은 인기있어질 것으로 보이는데, 어느 정도 C++, C# 등의 것으로 보이는 "\<\>"과 코드의 방식이 좀더 Pascal스러운, 추가된 "generic" 낱말입니다.
255	255
256	256		### 괄호 사용하기: \<\>
257	257
258	258		` type`\
259	259		` TGenericCollection<T: TCollectionItem> = class(TComponent)`\
260	260		` ...implement TCollection and use T`\
261	261		` end;`
262	262
263	263		` TCollection = TGenericCollection<TCollectionItem>;`\
264	264		` TFieldDefs = TGenericCollection<TFieldDef>; `
265	265
266	266		` TGenericList<T: PtrInt> = class(TObject)`\
267	267		` ...implement TList and use PtrInt size for code generation`\
268	268		` end;`
269	269
270	270		` TList = TGenericList<Pointer>;`
271	271
272	272		Implementation of TGenericCollection can be compiled as if (T: TCollectionItem) were used. TGenericCollection의 구현은 마치 (T: TCollectionItem)이 사용된 것처럼 컴파일 되어질 것입니다
273	273
274	274		Would this solve the circular dependency ? It seems so to me, because one knows at least as much as in current implementation of these classes, but I'm no compiler engineer. 여기서 순환참조를 해결할 수 있을까요? 저는 컴파일러 엔지니어가 아니지만, 적어도 하나가 현재 이 클래스들의 구현만큼 알기 때문에 가능하다고 봅니다
275	275
276	276		For procedures: procedure 로써:
277	277
278	278		` function MyFunc<T: TTreeItem>(A: T): T;`\
279	279		` begin`\
280	280		` // do something with the tree item`\
281	281		` // tree 아이템과 함께 무언가를 합니다`\
282	282		` end; `
283	283
284	284		` function Max<T>(A, B: T): T;`\
285	285		` begin`\
286	286		` if A < B then`\
287	287		` Result := B`\
288	288		` else`\
289	289		` Result := A;`\
290	290		` end; `
291	291
292	292		My restrictions won't allow implementing generic Max and Min, I guess. That really needs macro-alike stuff (for the compiler implementation). 제가 생각하기로, 저의 제한은 Max, Min제너릭 구현을 허용할것 같지 않습니다. 그 것은 매크로 비슷한 것이 정말 필요해집니다(컴파일러 구현으로서)
293	293
294	294		Another example for linked lists: (ripped from mail to fpc-devel of dannym, but modified a bit) 링크드 리스트로 다른 예제가 있습니다(메일로 온 dannym의 fpc-devel에서 가져왔지만, 조금만 고쳤습니다)
295	295
296	296		` type`\
297	297		` TListItem<T> = record`\
298	298		` Data: T;`\
299	299		` Next: TListItem;`\
300	300		` end;`\
301	301		` PListItem = ^TListItem;`\
302		-	\
	302	+
303	303		` TList<T> = class`\
304	304		` private`\
305	305		` fHead: PListItem<T>;`\
306	306		` fTail: PListItem<T>;`\
307	307		` published`\
308	308		` procedure Add(Item: T);`\
309	309		` end;`\
310		-	\
	310	+
311	311		` procedure TList<T>.Add(Item: T);`\
312	312		` var`\
313	313		` node: PListItem<T>;`\
314	314		` begin`\
315	315		` New(node);`\
316	316		` node^.Data := Item;`\
317	317		` node^.Next := nil;`\
318	318		` `\
319	319		` if Assigned(fTail) then begin`\
320	320		` fTail^.Next := node;`\
321	321		` end else begin`\
322	322		` fHead := node;`\
323	323		` end;`\
324	324		` `\
325	325		` fTail := node;`\
326	326		` end;`\
327	327		` `\
328	328		` type`\
329	329		` TApple = class`\
330	330		` end;`\
331	331		` TOrange = class`\
332	332		` end;`\
333	333		` `\
334	334		` TAppleList = TList<TApple>;`\
335	335		` `\
336	336		` var`\
337	337		` apples: TAppleList;`\
338	338		` apple: TApple;`\
339	339		` begin`\
340	340		` apples.Add(TApple.Create); // works //잘 됨.`\
341	341		` apples.Add(TOrange.Create); // compile error //컴파일 에러.`\
342	342		` `\
343	343		` apple := apples[0]; // works //잘 됨.`\
344	344		` apple := apples[1]; // not applicable //적용되지 않음`\
345	345		` apple := apples[0] as TApple; // works, but unneccessary //필요하지 않지만, 잘 됨.`\
346	346		` apple := apples[1] as TApple; // not applicable //적용되지 않음`\
347	347		` end;`
348	348
349	349		### "generic" 낱말을 사용하기
350	350
351	351		` type`\
352	352		` TGenericCollection = generic(T: TCollectionItem) class(TComponent)`\
353	353		` ...implement TCollection and use T`\
354	354		` end;`
355	355
356	356		` TCollection = specialize TGenericCollection(TCollectionItem);`\
357	357		` TFieldDefs = specialize TGenericCollection(TFieldDef); `
358	358
359	359		` TGenericList = generic(T: PtrInt) class(TObject)`\
360	360		` ...implement TList and use PtrInt size for code generation`\
361	361		` end;`
362	362
363	363		` TList = specialize TGenericList(Pointer);`
364	364
365	365		procedure 로써:
366	366
367	367		` function generic(T: TTreeItem) MyFunc(A: T): T;`\
368	368		` begin`\
369	369		` // do something with the tree item`\
370	370		` // tree 아이템 과 함께 무언가를 합니다`\
371	371		` end; `
372	372
373	373		` function generic(T) Max(A, B: T): T;`\
374	374		` begin`\
375	375		` if A < B then`\
376	376		` Result := B`\
377	377		` else`\
378	378		` Result := A;`\
379	379		` end; `
380	380
381	381		Another example for linked lists: (ripped from mail to fpc-devel of dannym, but modified a bit) 링크드 리스트로 다른 예제가 있습니다(메일로 온 dannym의 fpc-devel에서 가져왔지만, 조금만 고쳤습니다)
382	382
383	383		` type`\
384	384		` TListItem = generic(T) record`\
385	385		` Data: T;`\
386	386		` Next: TListItem;`\
387	387		` end;`\
388	388		` PListItem = ^TListItem;`\
389		-	\
	389	+
390	390		` TList = generic(T) class`\
391	391		` private`\
392	392		` fHead: specialize PListItem(T);`\
393	393		` fTail: specialize PListItem(T);`\
394	394		` published`\
395	395		` procedure Add(Item: T);`\
396	396		` end;`\
397		-	\
	397	+
398	398		` procedure generic(T) TList.Add(Item: T);`\
399	399		` var`\
400	400		` node: specialize PListItem(T);`\
401	401		` begin`\
402	402		` New(node);`\
403	403		` node^.Data := Item;`\
404	404		` node^.Next := nil;`\
405	405		` `\
406	406		` if Assigned(fTail) then begin`\
407	407		` fTail^.Next := node;`\
408	408		` end else begin`\
409	409		` fHead := node;`\
410	410		` end;`\
411	411		` `\
412	412		` fTail := node;`\
413	413		` end;`\
414	414		` `\
415	415		` type`\
416	416		` TApple = class`\
417	417		` end;`\
418	418		` TOrange = class`\
419	419		` end;`\
420	420		` `\
421	421		` TAppleList = specialize TList(TApple);`\
422	422		` `\
423	423		` var`\
424	424		` apples: TAppleList;`\
425	425		` apple: TApple;`\
426	426		` begin`\
427	427		` apples.Add(TApple.Create); // works //잘 됨.`\
428	428		` apples.Add(TOrange.Create); // compile error //컴파일 에러`\
429	429		` `\
430	430		` apple := apples[0]; // works //잘 됨.`\
431	431		` apple := apples[1]; // not applicable //적용 안됨`\
432	432		` apple := apples[0] as TApple; // works, but unneccessary //필요하지 않지만, 잘 됨.`\
433	433		` apple := apples[1] as TApple; // not applicable //적용 안됨`\
434	434		` end;`
435	435
436	436		Ugly things in need to be resolved: 해결이 필요한, 안좋은 점들:
437	437
438	438		` { a generic type "TPointer" which is a pointer to type instantiated with }`\
439	439		` { 포인터로 생성된 "TPointer" 제너릭 선언 }`\
440	440		` type TPointer = generic(Type) ^Type;`\
441	441		` { a generic type that instantiates all the enums for Type }`\
442	442		` { 선언형의 모든 열거를 생성하는 제너릭 선언 }`\
443	443		` type TAllEnums = generic(Type)(low(Type),high(Type));`
444	444
445	445		So, before a keyword can be real "nice" the following things need addressing: 그래서, keyword가 진짜 "멋져"지는것 보다 먼저, 아래의 목록들이 주소를 필요합니다
446	446
447	447		1. Double brackets ()(), looks C-ish again
448	448		2. 다시 C같이 보여지는 두 개의 괄호 () ()
449	449		3. In math, one usually defines functions with the parameters on the left of the equal sign, not on the right
450	450		4. 수학에서, 보통 equal 기호의 왼쪽에(오른 쪽이 아닌) 인자들과 함께 함수들을 선언합니다.
451	451
452	452		#### 제안 2
453	453
454	454		Inspired by idea from oliebol in combination with ugly examples, in list of const, var, type sections, add "template" section: 안좋은 예제들의 결합 속에서 oliebol의 생각으로부터 영감을 얻어, const와 var, type 섹션들의 목록안에 "template" 섹션을 추가합니다
455	455
456	456		` const`\
457	457		` ThisIsAConst = 1;`\
458	458		` `\
459	459		` type`\
460	460		` TMyEnum = (ab, ac);`\
461	461		` `\
462	462		` template(T: TCollectionItem)`\
463	463		` TGenericCollection = class(TComponent)`\
464	464		` ...implement TCollection and use T`\
465	465		` end;`\
466	466		` `\
467	467		` type`\
468	468		` TCollection = specialize TGenericCollection(TCollectionItem);`\
469	469		` TFieldDefs = specialize TGenericCollection(TFieldDef); `\
470	470		` `\
471	471		` template(T: PtrInt)`\
472	472		` TGenericList = class(TObject)`\
473	473		` ...implement TList and use PtrInt size for code generation`\
474	474		` end;`\
475	475		` `\
476	476		` type`\
477	477		` TList = specialize TGenericList(Pointer);`
478	478
479	479		For procedures: procedure 로써:
480	480
481	481		` function generic(T: TTreeItem) MyFunc(A: T): T;`\
482	482		` begin`\
483	483		` // do something with the tree item`\
484	484		` // tree 아이템과 함께 무언가를 합니다`\
485	485		` end; `
486	486
487	487		` function generic(T) Max(A, B: T): T;`\
488	488		` begin`\
489	489		` if A < B then`\
490	490		` Result := B`\
491	491		` else`\
492	492		` Result := A;`\
493	493		` end; `
494	494
495	495		Another example for linked lists: (ripped from mail to fpc-devel of dannym, but modified a bit) 링크드 리스트로 다른 예제가 있습니다(메일로 온 dannym의 fpc-devel에서 가져왔지만, 조금만 고쳤습니다)
496	496
497	497		` template(T)`\
498	498		` TListItem = record`\
499	499		` Data: T;`\
500	500		` Next: TListItem;`\
501	501		` end;`\
502	502		` PListItem = ^specialize TListItem(T);`\
503		-	\
	503	+
504	504		` TList = class`\
505	505		` type`\
506	506		` PItem = specialize PListItem(T);`\
507	507		` private`\
508	508		` fHead: PItem;`\
509	509		` fTail: PItem;`\
510	510		` published`\
511	511		` procedure Add(Item: T);`\
512	512		` end;`\
513		-	\
	513	+
514	514		` ...implementation...`\
515	515		` `\
516	516		` procedure generic(T) TList.Add(Item: T);`\
517	517		` var`\
518	518		` node: PItem;`\
519	519		` begin`\
520	520		` New(node);`\
521	521		` node^.Data := Item;`\
522	522		` node^.Next := nil;`\
523	523		` `\
524	524		` if Assigned(fTail) then begin`\
525	525		` fTail^.Next := node;`\
526	526		` end else begin`\
527	527		` fHead := node;`\
528	528		` end;`\
529	529		` `\
530	530		` fTail := node;`\
531	531		` end;`\
532	532		` `\
533	533		` type`\
534	534		` TApple = class`\
535	535		` end;`\
536	536		` TOrange = class`\
537	537		` end;`\
538	538		` `\
539	539		` TAppleList = specialize TList(TApple);`\
540	540		` `\
541	541		` var`\
542	542		` apples: TAppleList;`\
543	543		` apple: TApple;`\
544	544		` begin`\
545	545		` apples.Add(TApple.Create); // works //잘 됨.`\
546	546		` apples.Add(TOrange.Create); // compile error //컴파일 에러`\
547	547		` `\
548	548		` apple := apples[0]; // works //잘 됨`\
549	549		` apple := apples[1]; // not applicable //적용 안 됨`\
550	550		` apple := apples[0] as TApple; // works, but unneccessary //필요하지 않지만, 잘 됨`\
551	551		` apple := apples[1] as TApple; // not applicable //적용 안 됨`\
552	552		` end;`
553	553
554	554		#### 제안 3
555	555
556	556		` { Chu Jetcheng, 2008-07-24 }`
557	557
558	558		` program Generics;`
559	559
560	560		` type`\
561	561		` { The compiler should maintain a global table storing each specialized type for each generic. The `\
562	562		`` `of' operator is used to create a specialization for a specified generic type. Specialized types ``\
563	563		`` of the same `type layout' (no other words) point to the same entry in the table of specializations ``\
564	564		` of the specialized generic type, and thus are compatible. Generic objects and records should also `\
565	565		` be allowed. }`\
566	566		`` { 컴파일러는 각 제너릭들을 위해 특별화된 선언형을 저장하는 전역 테이블을 유지해야만 합니다. `of' 연산자는 열거된 제너릭 선언들을 위해 ``\
567	567		`` 특별하게 생성하려 사용되어졌습니다. 같은 `type layout'(다른 단어)의 특별화된 선언형들이 특별화된 제너릭 선언형의 테이블 안에 같은 ``\
568	568		` entry를 가리키므로, 호환될 수 있습니다. 또한 제너릭 객체들과 레코드들은 허용해야 합니다}`
569	569
570	570		` TGeneric = generic class(TAncestorClass) of T1, T2`\
571	571		` private`\
572	572		` FData1: T1;`\
573	573		` FData2: T2;`\
574	574		` public`\
575	575		` property Data1: T1 read FData1 write FData1;`\
576	576		` property Data2: T2 read FData2 write FData2;`\
577	577		` constructor Create(const A: T1; const B: T2);`\
578	578		` procedure WriteData; virtual;`\
579	579		` end;`
580	580
581	581		` TGenericDescendent = generic class(TGeneric of Integer, T3) of T3`\
582	582		` private`\
583	583		` FData3: T3;`\
584	584		` FObjectOfSameType: TGenericDescendent of T3;`\
585	585		` public`\
586	586		` property Data3: T3 read FData3 write FData3;`\
587	587		` property ObjectOfSameType: TGenericDescendent of T3 read FObjectOfSameType write FObjectOfSameType;`\
588	588		` constructor Create(const C: T3);`\
589	589		` procedure WriteData; override;`\
590	590		` end;`
591	591
592	592		` TGenericIR = TGeneric of Integer, Real;`\
593	593		` TGenericIRClass = class of TGenericIR;`
594	594
595	595		` TGenericISClass = class of (TGeneric of Integer, string);`
596	596
597	597		` PGenericObj = generic ^TGenericObj; `\
598	598		` TGenericObj = generic object of T `\
599	599		` MyField: T;`\
600	600		` procedure WriteData;`\
601	601		` end;`
602	602
603	603		` { TGeneric }`
604	604
605	605		` { Use the same syntax for method implementations as with immediate classes. }`\
606	606		` { 직접 클래스들과 함께로써 method 구현들을 위해 똑같은 문법을 사용합니다 }`
607	607
608	608		` constructor TGeneric.Create(const A: T1; const B: T2);`\
609	609		` begin`\
610	610		` FData1 := A;`\
611	611		` FData2 := B;`\
612	612		` end;`
613	613
614	614		` procedure TGeneric.WriteData;`\
615	615		` begin`\
616	616		` Writeln(FData1);`\
617	617		` Writeln(FData2);`\
618	618		` end;`
619	619
620	620		` { TGenericDescendent }`
621	621
622	622		` constructor TGenericDescendent.Create(const C: T3);`\
623	623		` begin`\
624	624		` inherited Create(16, C);`\
625	625		` FData3 := C;`\
626	626		` end;`
627	627
628	628		` procedure TGenericDescendent.WriteData;`\
629	629		` begin`\
630	630		` inherited;`\
631	631		` Writeln(FData3);`\
632	632		` if Assigned(FObjectOfSameType) then FObjectOfSameType.WriteData;`\
633	633		` end;`
634	634
635	635		` { TGenericObj }`
636	636
637	637		` procedure TGenericObj.WriteData;`\
638	638		` begin`\
639	639		` Writeln(MyField);`\
640	640		` end;`
641	641
642	642		` var `\
643	643		` Obj1: TGeneric of Integer, Real;`\
644	644		` Obj2, Obj3: TGenericDescendent of string;`\
645	645		` OldStyleObj: TGenericObj of Integer;`\
646	646		` OldStyleObjPtr: PGenericObj of Integer;`
647	647
648	648		` begin`\
649	649		` Obj1 := TGeneric.Create(32, 3.14);`\
650	650		` Obj1.WriteData;`\
651	651		` Writeln(#9, Obj1 is TGenericIR);`\
652	652		` Writeln(#9, Obj1 is TGenericIS);`
653	653
654	654		` Obj2 := TGenericDescendent.Create('Generic test.');`\
655	655		` Obj2.WriteData;`\
656	656		` Writeln(#9, Obj2 is TGenericIR);`\
657	657		` Writeln(#9, Obj2 is TGenericIS);`
658	658
659	659		` Obj3 := TGenericDescendent.Create('Another generic test.');`\
660	660		` Obj3.ObjectOfSameType := Obj2;`\
661	661		` Obj3.WriteData;`
662	662
663	663		` Obj3.Free;`\
664	664		` Obj2.Free;`\
665	665		` Obj1.Free;`
666	666
667	667		` OldStyleObj.MyField := 100;`\
668	668		` OldStyleObj.WriteData;`
669	669
670	670		` OldStyleObjPtr := New(PGenericObj of Integer);`\
671	671		` with OldStyleObjPtr^ do begin`\
672	672		` MyField := 202;`\
673	673		` WriteData;`\
674	674		` end;`\
675	675		` Dispose(ObjStyleObjPtr);`\
676	676		` end.`
677	677
678	678		## Terms
679	679
680	680		type user:
681	681
682	682		- the function in the compiler that defines a variable or return type and thus 'uses a (already defined) type'.
683	683
684	684		immediate type:
685	685
686	686		- not generic and not specialized, i.e. 'normal type'
687	687
688	688		generic type:
689	689
690	690		- template for a class with some unspecified types, never to be filled in into this class type. Only by specialisation.
691	691
692	692		specialization:
693	693
694	694		- copy generic type class to new specialized type class
695	695
696	696		type parameters:
697	697
698	698		- T and Q, the unknown types for the generic TSomeGeneric\<T,Q\>
699	699
700	700		specialized type:
701	701
702	702		- a generic type with all type parameters know, written into a real class type (tree) and reused if possible
703	703
704	704		## 변화들
705	705
706	706		### class/record선언 표현 의 변화들
707	707
708	708		Each class definition representation has added fields for:
709	709
710	710		` - class instantiation mode`\
711	711		` 0 immediate type`\
712	712		` 1 generic type, no instantiation, just generate specialized type`\
713	713		` 2 specialized type`
714	714
715	715		` - when mode 2:`\
716	716		` generic type uplink (XXXX, what, unitname, typename?)`\
717	717		` when mode 1:`\
718	718		` list of specialized types known so far (and where),`\
719	719		` XXXX list items`\
720	720		` when mode 0: `\
721	721		` nothing`
722	722
723	723		### Changes in 'type user' compilation (for class/record types only)
724	724
725	725		Each class type user will have to check mode of the class type.
726	726
727	727		For the used class type, If mode is immediate
728	728
729	729		` - proceed as always till now.`
730	730
731	731		If mode is specialized
732	732
733	733		` - proceed as always till now `\
734	734		` - keep in mind the generic type for some checks later (and debugging).`
735	735
736	736		If mode is generic, this:
737	737
738	738		` - check 'list of specialized types' for the type parameter to use.`\
739	739		` If there is already a specialized type, use that.`\
740	740		` (given that it is compatible with 'compile parameters' XXXX)`
741	741
742	742		` - If not available, clone the generic type in the tree, and fill in the`\
743	743		` type params with the actual types to use.`\
744	744		` Generate machine code as normal.`\
745	745		` Remember the new specialized type for later in the list by the `\
746	746		` generic type and type params used.`
747	747
748	748		(the generic type is best written to some ppu as parse tree so that it can be refetched for cloning somewhen. To keep it easy, initially it should be limited to having its .pas file around when wanting to use a generic)
749	749
750	750		### type params
751	751
752	752		Generics store a list of the type params (names).
753	753
754	754		` ('T', 'Q')`
755	755
756	756		And Specializations store a list of type mappings from the real types to the type params, in the way of
757	757
758	758		` type`\
759	759		` T = Integer;`\
760	760		` Q = Boolean;`
761	761
762	762		of course these are local to this class/record specialization.
763	763
764	764		## Other things to note (for later)
765	765
766	766		### What if a method implementation depends on the type used to know how the implementation should look like ?
767	767
768	768		` procedure GList<T is TObject>.Add(const value: T);`\
769	769		` procedure GList<T is Integer>.Add(const value: T);`\
770	770		` ?`
771	771
772	772		or more cryptic like
773	773
774	774		` procedure GList<TObject>.Add(const value: T);`\
775	775		` procedure GList<Integer>.Add(const value: T);`\
776	776		` ?`
777	777
778	778		or like
779	779
780	780		` procedure GList<T>.Add(const value: Integer);`\
781	781		` procedure GList<T>.Add(const value: TObject);`
782	782
783	783		the latter would need extra compiler support but would be nicer, overall. Potentially clashing with normal overloads though.
784	784
785	785		### How to do internal storage classes
786	786
787	787		` type`\
788	788		` PNode<T> = ^TNode<T>;`\
789	789		` TNode<T> = record`\
790	790		` prev,next: PNode<T>;`\
791	791		` data: T;`\
792	792		` end;`
793	793
794	794		` type`\
795	795		` GList<T> = class`\
796	796		` private`\
797	797		` head, tail: PNode<T>;`\
798	798		` cnt: Integer;`\
799	799		` public`\
800	800		` procedure Add(const stuff: T);`\
801	801		` end;`\
802	802		` ?`
803	803
804	804		This implies that generics are best implemented both for records and for classes alike! Also implies that pointer types need to support generic too.
805	805
806	806		Also one specialization should chain other specializations (probably also when deriving from a generic).
807	807
808	808		### How to derive from the generic type
809	809
810	810		It would be good if generic types could be derived from.
811	811
812	812		` type`\
813	813		` TGenericEventyList<T> = class(TGenericList<T>)`\
814	814		` public`\
815	815		` procedure Add(value: T); override;`\
816	816		` end;`\
817	817		` ...`
818	818
819	819		### Interfaces should support generics too
820	820
821	821		` type`\
822	822		` IBa<T> = interface`\
823	823		` procedure Add(value: T);`\
824	824		` end;`\
825	825		` TBa<T> = class(...,IBla<T>,IInterface)`\
826	826		` end;`
827	827
828	828		(what to do about the guids of the specializations? probably just generate whatever, they dont have any real meaning after all)
829	829
830	830		Of course this has limitations to check, like
831	831
832	832		- the generic interface cannot be used, just its specializations
833	833		- the specialized interface cannot be used in a generic class interface list
834	834		- (the generic interface can be used in a generic class interface list)
835	835		- the generic interface itself is invalid to use anywhere (just as generic classes are) except for specializing and deriving from
836	836		- normal interfaces cannot derive from generic interfaces
837	837		- (generic interfaces can derive from generic interfaces) - given the type params are the same
838	838		- specialized interfaces cannot be derived from
839	839
840	840		### Limitation of possible specialisations
841	841
842	842		` type`\
843	843		` TGenericList<T: TObject or Integer> = ...`\
844	844		` end;`
845	845
846	846		Probably useful...
847	847
848	848		### What to do with class functions
849	849
850	850		I dont know a whole lot of how class functions are stored internally. What happens to class functions in generics?
851	851
852	852		### 'class of'
853	853
854	854		\<Almindor\> don't forget class of, we need class of compatibility for dynamic class factories
855	855
856	856		\<Almindor\> There are possible problems with 'class of'
857	857
858	858		## Implementation details
859	859
860	860		### Sanity checks
861	861
862	862		- Generic types cannot be instantiated from
863	863		- (Generic types can be derived from)
864	864		- Specialized types cannot be derived from
865	865		- Normal types cannot use generic types in its definition
866	866		- (Normal types can use specialized types in its definition)
867	867		- There are no half specialized types (one type param specified, the other not)
868	868		- prevent loops while 'unpacking' specializations (loop counter field in every specialization)
869	869
870	870		### Things to note and not forgot
871	871
872	872		- class와 record 제너릭은 그 선언 안에서 그 자신을 선언형으로 사용할 수 있습니다
873	873
874	874		예:
875	875
876	876		` type`\
877	877		` TBla<T> = class`\
878	878		` parent: TBla<T>;`\
879	879		` end;`
880	880
881	881		- class와 record 제너릭은 그 선언 안에서 다른 제너릭을 선언형으로 사용할 수 있습니다
882	882
883	883		` type`\
884	884		` TBla<T> = class`\
885	885		` parent: TBlo<T>;`\
886	886		` end;`
887	887
888	888		## Implementation steps
889	889
890	890		### Extend parser to support '\<T\>' and '\<T: bla or bla or bla\>' and '\<T,Q\>' notation
891	891
892	892		Easy to do. Done.
893	893
894	894		## Different ways to do it, one excluding the other
895	895
896	896		### Way 1
897	897
898	898		#### Change class/record/object/pointertype/interface parser to mark if it is a generic, a specialization or normal
899	899
900	900		Mediate to do. Have done it for class/object and pointertype. Needs all kinds of clone functions for the defs and syms. fpk says he has patches. waiting.
901	901
902	902		#### insert dummy symbols (typesym + typedef) for the type params in the generic
903	903
904	904		Cannot be inserted into the object because parsing of types within objects has been disabled to make that possible:
905	905
906	906		` type`\
907	907		` Row = Cardinal;`\
908	908		` TBla = class `\
909	909		` Row: Integer;`\
910	910		` end;`
911	911
912	912		weird.. (function searchsym_type, is not possible to have type definitions in records, objects, parameters)
913	913
914	914		#### parse implementation section methods for the generic
915	915
916	916		Is harder than it sounds, because the class/object the method is member of has to be searched for the type symbol for the type params (and these not derefed but just used as is).
917	917
918	918		#### when parsing generics, use a dummy type in place of the type params
919	919
920	920		For that, defer the type checking of the compiler in that case to 'as late as possible' or 'never for the generic' \<--- TODO... hard...
921	921
922	922		#### Change derivation handlers to do the sanity checks
923	923
924	924		Should pose no problems other than finding all the places.
925	925
926	926		#### Add error messages for it
927	927
928	928		#### Change pexpr (tnode creating)
929	929
930	930		\<Synopsis+\> see the do_resulttypepass() calls in pexpr.pas But the compiler needs to known for example if it allows a . after the type
931	931
932	932		- add a new tnode type for postfix operators (instead of resolving the operators into the fields/methods they reference) and defer type checking until later (just before binary generation - which is not done for the generic type).
933	933
934	934		Examples for postfix operators are:
935	935
936	936		- '\[\]' array member access (normal array, class default array property?)
937	937
938	938		- '.' record/class member method/variable access
939	939
940	940		- '^' pointer dereference
941	941
942	942		- (automatic pointer dereference)
943	943
944	944		\<Synopsis\> grep for m_auto and you'll find the places where it is used \<Synopsis\> only in pexpr.pas
945	945
946	946		#### Change ppu streaming routines to save the tree of generics to the ppu
947	947
948	948		#### Change type user to instantiate specialized types for generics when used
949	949
950	950		Somewhat hard to do. (main work here :))
951	951
952	952		For the instantiation
953	953
954	954		- there is a dummy type sym needed (ok),
955	955		- a new objectdef
956	956		- clone of all the syms and defs (at least proc and property) of the original class/object
957	957		- and replacing all the type params by the correct types.
958	958		- Store that into the module as def (not on disk).
959	959		- (\<Synopsis+\> an additional symtable shall be added to tmodule: tempsymtable; all temporary tdef's shall be stored in that symtable)
960	960		- Then resume compiling for the class/object.
961	961
962	962		### Way 2
963	963
964	964		just keep the source code of the generic around and do blind replacing of the type params and then compile a specialization from that as 'source'
965	965
966	966		#### Notes
967	967
968	968		\<Synopsis+\> but the code to generate the specialization at runtime can be generated at the time the specialization is created. It doesn't need to be stored in ppu. all information is available to generate the tree at that time.
969	969
970	970		\<Synopsis+\> In the 2.1.x development series a rewrite of the ppu loading is planned to make it more clean and more maintainable. Currently it is risky to fix bugs without introducing new bugs
971	971
972	972		\<plugwash-\> It needs to be stored in some form so that the specialisations can be generated from it. \<Synopsis+\> but you can't store them in the ppu. Or with the same limitations as inlining. No references to the implementation symtable.
973	973
974	974		fpk has patches to make cloning defs possible.
975	975
976	976		01:28:24 \<Synopsis+\> users will complain; things like:
977	977
978	978		` interface`\
979	979		` generictype declar`\
980	980		` implementation`\
981	981		` procedure helper;`\
982	982		` begin`\
983	983		` end`\
984	984		` constructor generictype.create`\
985	985		` begin`\
986	986		` helper`\
987	987		` end`\
988	988		` end.`
989	989
990	990		Will not be allowed.
991	991
992	992		Another problem:
993	993
994	994		` unit a;`\
995	995		` interface`\
996	996		` generictypeA`\
997	997		` implementation`\
998	998		` uses B`\
999	999		` end.`
1000	1000
1001	1001		` unit b;`\
1002	1002		` interface`\
1003	1003		` uses a`\
1004	1004		` implemenation`\
1005	1005		` begin`\
1006	1006		` generictypeA<integer>.craete`\
1007	1007		` end.`
1008	1008
1009	1009		At the time that the implementation of B is parsed it needs already the code of generictypeA. but that is not yet parsed! The compiler doesn't know anything yet. It only knows that generictypeA exists.
1010	1010
1011	1011		\<fpk-\> dannym, Synopsis: we can simply forbid such code in generics which cause the problem
1012	1012
1013	1013		\<fpk-\> i.e. everything used by generics must be already included in the interface uses clause ... or forbid references to units used only in the implementation section :)
1014	1014
1015	1015		\<Synopsis+\> fpk had a good idea that can solve some of the issues: unit bla; interface ... generics ... implementation ... initialisation ... finalizatrion end.
1016	1016
1017	1017		\<Synopsis+\> The generics delcarations shall be put in a separate section before implementation is parsed
1018	1018
1019	1019		\<dannym\> at 'procedure TTest.Add(x: T);', T needs to be known. but it doesnt seem that the object symtable is searched for the class method parameters. correct ?
1020	1020
1021	1021		\<Synopsis+\> dannym: correct, object symtables can not contain types, because that created problems. there is special code for that: remove the objectsymtable before parsing type declarations.
1022	1022
1023	1023		` { for records, don't search the recordsymtable for the symbols of the types }`\
1024	1024		` oldsymtablestack:=symtablestack;`\
1025	1025		` symtablestack:=symtablestack.next;`
1026	1026
1027	1027		Because you can have a field with the same name as a type
1028	1028
1029	1029		` type`\
1030	1030		` Wrd = Word;`\
1031	1031		` R = Record`\
1032	1032		` Wrd : Wrd;`\
1033	1033		` end`
1034	1034
1035	1035		this is allowed. To support this the record or object symtable is remvoed from the symtablestack when the type is parsed.
1036	1036
1037	1037		## 이미 존재하는 것
1038	1038
1039	1039		### 메타 클래스
1040	1040
1041	1041		` type`\
1042	1042		` TObjectClass = class of TObject;`\
1043	1043		` TTypedList = class`\
1044	1044		` private`\
1045	1045		` Fwanttype: TObjectClass;`\
1046	1046		` ...`\
1047	1047		` public`\
1048	1048		` constructor Create(itemtype: TObjectClass);`\
1049	1049		` procedure Add(item: TObject);`\
1050	1050		` ...`\
1051	1051		` end;`\
1052	1052		` constructor TTypedList.Create(itemtype: TObjectClass);`\
1053	1053		` begin`\
1054	1054		` Fwanttype := itemtype;`\
1055	1055		` ...`\
1056	1056		` end;`\
1057	1057		` procedure TTypedList.Add(item: TObject);`\
1058	1058		` begin`\
1059	1059		` assert(item.Class = Fwanttype);`\
1060	1060		` ...`\
1061	1061		` end;`
1062	1062
1063	1063		` ...`\
1064	1064		` TSomeStuff = class`\
1065	1065		` end;`\
1066	1066		` ...`\
1067	1067		` Flist := TTypedList.Create(TSomeStuff);`
1068	1068
1069	1069		장점
1070	1070
1071	1071		- 이미 구현되어 있음
1072	1072
1073	1073		단점
1074	1074
1075	1075		- runtime 때 느림
1076	1076		- 간단한 선언형을 만들 수 없음.
1077	1077		- 지원되는 선언형들에서도 모든 time에 변환(type-casting)이 필요합니다(다시말하면, 읽을때에도)
1078	1078
1079	1079		## 여기서 부터 통합됩니다
1080	1080
1081	1081		### 채팅 내용
1082	1082
1083	1083		\<Synopsis\> <http://www.eleforum.com/cgi-bin/eleweb_lift?action=3&script=wall&num=18&reversesort=true&type=today&starttime=00:00&endtime=23:59&startdate=01-02-05&enddate=01-02-05> \<Synopsis\> or \<Synopsis\> <http://neli.hopto.org:3980/~micha/irc-fpc/2005/01/%23fpc.20050102.log>
1084	1084
1085	1085		---
1086	1086		From the Free Pascal wiki, page "Generics/ko", as it stood on 2010-09-03 after a change by Hwiorn, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history