Hello,

If my memory is not misleading me, there was once a TLinkedList class under Classes unit, but I can't find any documentation on it. I found an include file that contains it, but it is not meant for the interface part.

Is there a reason for this ? Should I use records instead ?

Thanks,
Ido

I don't remember having that since 2.X.X... there was always TList, however. And that's what I was using (I use generics for all my containers use now).

leledumbo wrote

I don't remember having that since 2.X.X... there was always TList, however. And that's what I was using (I use generics for all my containers use now).

Thanks. Personally I dislike are not that readable imho. Even though FPC's implementation is one of the most readable ways I have ever seen.

Ido

I believe generics makes faster code due to having no need to test types during runtime... i maybe wrong.

2012/2/11 ik :

2012/2/11, Jorge Aldo G. de F. Junior :

I believe generics makes faster code due to having no need to test types during runtime... i maybe wrong.

It is true only if you use the type-safe "as" casting. Normal casting does not check does make the code more readable. Like:

  MyVar := MyList[i];

compared to

  MyVar := TMyType(MyList[i]);

Also, you get compile time type-checking, just like arrays had from day 1. The code is safer, more readable and self-documenting.

I hope there will be a good and comprehensive generics container library. Now the containers are scattered around and are competing with each other.
Java serves as a good example here. It has a consistent generics container library. Classes are easy to find and use.

Juha

doesn't generics more or less duplicate the class every time you use it with different type, and if so would this not cause alot of bloating ?

‎That's one of the things that I'm afraid of actually.

Carver413 wrote

doesn't generics more or less duplicate the class every time you use it with different type, and if so would this not cause alot of bloating ?

Yes it does. So for embedded systems "use with care" ;)

Regards,
Sven

2012/2/14, Sven Barth :

Oh, that is bad!

C++ templates generate lots of duplicate code.

Java's generics do not because it is just "syntactic sugar" allowing the compiler to check types which IMO is enough for most purposes. You don't need ugly type-casts but code-generation is not affected. Perfect.

I know Delphi's and FPC's generics are different but I believed the compiler is clever enough to use the same class when possible. For example, in all cases where objects inherited from TObject are stored in a container, the same container could be used.

This indirectly answered another question I had in mind: Does a generics container for a char or integer use the minimum needed amount of memory?
I guess it does when a new instance of the container class is generated.

Juha

Such logic unnecessarily complicates the compiler. Generics are already troublesome enough.

This indirectly answered another question I had in mind: Does a generics container for a char or integer use the minimum needed amount of memory?

If the container uses thinks like "SizeOf(T)" (where T is the generic type parameter) and such then it does use the least amount of memory. A specialization is basically a reparsing of the generic as if T was the specialization type all along.

I guess it does when a new instance of the container class is generated.

Sorry, but I don't understand what you mean here.

As long as one knows of the disadvantages of generics there is no problem in enjoying their advantages.

Regards,
Sven

As long as one knows of the disadvantages of generics there is no problem in enjoying their advantages.

the disadvantage will come in the useing. over time more and more units will contain these because they are easy. so you will end up with a lot of redundant code. doesn't matter if they know better or not. they will choose the easy path and let someone else worry about it. just like many of the half ported code that is out there, people port what they need to get there code working then contribute it hoping someone else will finish.

In our previous episode, Sven Barth said:

> in a container, the same container could be used. Such logic unnecessarily complicates the compiler. Generics are already troublesome enough.

Afaik it was the main reason to implement generic constraints in Delphi (like .NET)?

It won't really matter to you whether some unit you got from somewhere in the internet contains a specialization of a generic TList or whether the list was implemented especially for that type.

Free Pascal is a native language. There aren't much alternatives to code duplication.

Regards,
Sven

Constraints allow the compiler to infer further information on the given types to improve e.g. type checking when parsing the generic, but they won't magically allow the compiler to not duplicate code (in theory it would be possible to do something like Java's generics for cases where the constraints are for descendants of TObject or IInterface, but in my opinion the tradeoffs (increased compiler complexity) are not worth it).

Regards,
Sven

In our previous episode, Sven Barth said:

Exactly. You e.g. know that the unspecialized generic is already meant for reference types, from line one.

Yeah, that is typical. If it is not used inside the compiler it is unoptimized :-)

Maybe redo cclasses with generics?

i once read a textbook about generics (C++ generics) showing how C++ code can end up being FASTER than C equivalent due to lack of type checks...

it uses a quick sort routing as example.

on C you end up having to check the type of storage to get a similar result, while on C++ you check was something along that lines.

the point being made was that object orientation is not necessarely "bloat" but leads to better written code. (not always true, but...)

2012/2/14 Marco van de Voort :

2012/2/15, Jorge Aldo G. de F. Junior :

i once read a textbook about generics (C++ generics) showing how C++

C++ does not have generics, it has templates. Templates syntax is complex, you can do actual programming with it. IMO, using all its capacity leads to over-engineered and unreadable code. I read about a plan to add Java style generics syntax to C++, in addition to templates. I guess it will not happen. C++ has enough syntax already.

Code can still be fast even if it is bloated in size. Object orientation helps in writing readable and maintainable code but that is yet another issue.
The code duplication we discussed here has no advantage for speed. It is quite useless duplication.

From Sven Barth: Free Pascal is a native language. There aren't much alternatives to code duplication.

Yes there is. The same container code can be reused (when possible), just like Java does.
Free Pascal is native, Java generates byte-code, but that is irrelevant here.

I was planning to use generics in many places in Lazarus code but now I must rethink...
Lazarus executable is quite big already.

Juha

You really do not understand the state of mind of C++ :) C++ is like a big pot on a camp fire.
They just throw everything inside, and hope you choose only the food you like to eat, but usually ends up eating fast food instead (Qt, Boost etc...)

That wouldn't change that much... the performance of specialized generics isn't that different from "normal" code. Also I've not yet seen anyone complain about the size of the compiler executable, only it's speed...

Let's first implement everything that we need to have full Delphi compatibilty (generic methods, constraints, inline specializations in more complicated expressions) and then we can think of optimizing the generic implementation for cases like class or interface based specializations...

Regards,
Sven

I tested that. It's about 10% slower.

Michael.

In our previous episode, Sven Barth said:

Note that I mostly reacted to the sentiment it wouldn't be directly agree it is not the highest prio in the generics implementation.

I saw you recently fixed some of my bugs, I'll do a new run.

Am 15.02.2012 14:09, schrieb

Compile time or runtime?

Regards,
Sven

Yes, do that please. And don't dare to find new bugs! :P :P :P

Regards,
Sven

Runtime.

Michael.

Am 15.02.2012 15:09, schrieb

Then this might be because the current generic classes are written in a rather generic way (no pun intended). This might improve once constraints are implemented and generics for specific subtypes (e.g. the TFPGObjectList) can be implemented more efficiently.

Regards,
Sven

In our previous episode, Sven Barth said:

What does

baseimagegen.pas(130,4) Error: Global Generic template references static
symtable

Mean?

(it is at the end of a method)

You are accessing a symbol that's defined in the static symtable (implementation section of the unit). Does that code compile with Delphi? If so then please report a bug...

Regards,
Sven

http://theory.stanford.edu/~amitp/rants/c++-vs-c/

found the thing... its not a book and C++ has no generics but templates (for me both are the same, im no C++ programmer).

Now reading it again... The thing is that a quicksort in C can be fast only if used for one single type (at least the comparision function) while in C++ the template specialization makes the comparision function work for a greater number of types, simplifying resulting code...

2012/2/15 Juha Manninen :

In our previous episode, Sven Barth said:

I was still isolating at the end of the working day, so that will be later. tomorrow, I'm maybe not in the office, so that will be friday.

The static symtable bit might be simple constant values. The structure is more or less

type
      TgenImage<T>=Class(TBaseImage) // tbaseimage is not generic
                     type
                       reft = ^T;
                     private
                       allocptr : reft;
                     public
	               procedure alloc; override; // is virtual abstract in baseimage
                     end;
implementation
const alignvalue =16;  // must be power of two
      alignmask  =alignvalue-1;
procedure tgenimage<t>.alloc;
var localptr : reft;
begin
  (ptrint(allocptr) and alignmask)];
end;

(to align an allocation to a certain boundery for SSE use, code from memory, it is the pattern, not an exact formula to do that)

While isolating, the error seemed to randomly disappear and popup. But that could also be several "inline" methods, which have now been removed for isolation purposes.