Stepanov–Musser and other generic programming paradigms
Generic programming is defined in as follows, The "generic programming" paradigm is an approach to software decomposition whereby fundamental requirements on types are abstracted from across concrete examples of algorithms and data structures and formalized as concepts, analogously to the abstraction of algebraic theories infind, sort etc., a direct approach would implement each algorithm specifically for each data structure, giving combinations to implement. However, in the generic programming approach, each data structure returns a model of an iterator concept (a simple value type that can be dereferenced to retrieve the current value, or changed to point to another value in the sequence) and each algorithm is instead written generically with arguments of such iterators, e.g. a pair of iterators pointing to the beginning and end of the subsequence or ''range'' to process. Thus, only data structure-algorithm combinations need be implemented. Several iterator concepts are specified in the STL, each a refinement of more restrictive concepts e.g. forward iterators only provide movement to the next value in a sequence (e.g. suitable for a singly linked list or a stream of input data), whereas a random-access iterator also provides direct constant-time access to any element of the sequence (e.g. suitable for a vector). An important point is that a data structure will return a model of the most general concept that can be implemented efficiently— computational complexity requirements are explicitly part of the concept definition. This limits the data structures a given algorithm can be applied to and such complexity requirements are a major determinant of data structure choice. Generic programming similarly has been applied in other domains, e.g. graph algorithms.
Note that although this approach often utilizes language features of compile-time genericity/templates, it is in fact independent of particular language-technical details. Generic programming pioneer Alexander Stepanov wrote,
Bjarne Stroustrup noted,
Other programming paradigms that have been described as generic programming include ''Datatype generic programming'' as described in "Generic Programming – an Introduction". The approach is a lightweight generic programming approach for Haskell.
In this article we distinguish the high-level Programming language support for genericity
Genericity facilities have existed in high-level languages since at least the 1970s in languages such as ML,In object-oriented languages
When creating container classes in statically typed languages, it is inconvenient to write specific implementations for each datatype contained, especially if the code for each datatype is virtually identical. For example, in C++, this duplication of code can be circumvented by defining a class template:T is a placeholder for whatever type is specified when the list is created. These "containers-of-type-T", commonly called templates, allow a class to be reused with different datatypes as long as certain contracts such as Moving_Object containing objects of type Animal and Car. Templates can also be used for type-independent functions as in the Swap example below:
template construct used above is widely cited as the genericity construct that popularized the notion among programmers and language designers and supports many generic programming idioms. The D programming language also offers fully generic-capable templates based on the C++ precedent but with a simplified syntax. The Java programming language has provided genericity facilities syntactically based on C++'s since the introduction of Generics in Ada
Ada has had generics since it was first designed in 1977–1980. The standard library uses generics to provide many services. Ada 2005 adds a comprehensive generic container library to the standard library, which was inspired by C++'s=Example
= The specification of a generic package:=Advantages and limitations
= The language syntax allows precise specification of constraints on generic formal parameters. For example, it is possible to specify that a generic formal type will only accept a modular type as the actual. It is also possible to express constraints ''between'' generic formal parameters; for example:Templates in C++
C++ uses templates to enable generic programming techniques. The C++ Standard Library includes the=Technical overview
= There are many kinds of templates, the most common being function templates and class templates. A ''function template'' is a pattern for creating ordinary functions based upon the parameterizing types supplied when instantiated. For example, the C++ Standard Template Library contains the function templatemax(x, y) that creates functions that return either ''x'' or ''y,'' whichever is larger. max() could be defined like this:
max and determines that this is a call to max(int, int). It then instantiates a version of the function where the parameterizing type T is int, making the equivalent of the following function:
x and y are integers, strings, or any other type for which the expression x < y is sensible, or more specifically, for any type for which operator< is defined. Common inheritance is not needed for the set of types that can be used, and so it is very similar to duck typing. A program defining a custom data type can use operator overloading to define the meaning of < for that type, thus allowing its use with the max() function template. While this may seem a minor benefit in this isolated example, in the context of a comprehensive library like the STL it allows the programmer to get extensive functionality for a new data type, just by defining a few operators for it. Merely defining < allows a type to be used with the standard sort(), stable_sort(), and binary_search() algorithms or to be put inside data structures such as sets, complex does not define the < operator, because there is no strict order on max(x, y) will fail with a compile error, if ''x'' and ''y'' are complex values. Likewise, other templates that rely on < cannot be applied to complex data unless a comparison (in the form of a functor or function) is provided. E.g.: A complex cannot be used as key for a map unless a comparison is provided. Unfortunately, compilers historically generate somewhat esoteric, long, and unhelpful error messages for this sort of error. Ensuring that a certain object adheres to a method protocol can alleviate this issue. Languages which use compare instead of < can also use complex values as keys.
Another kind of template, a ''class template,'' extends the same concept to classes. A class template specialization is a class. Class templates are often used to make generic containers. For example, the STL has a list<int>. A list of strings is denoted list<string>. A list has a set of standard functions associated with it, that work for any compatible parameterizing types.
=Template specialization
= A powerful feature of C++'s templates is ''template specialization''. This allows alternative implementations to be provided based on certain characteristics of the parameterized type that is being instantiated. Template specialization has two purposes: to allow certain forms of optimization, and to reduce code bloat. For example, consider asort() template function. One of the primary activities that such a function does is to swap or exchange the values in two of the container's positions. If the values are large (in terms of the number of bytes it takes to store each of them), then it is often quicker to first build a separate list of pointers to the objects, sort those pointers, and then build the final sorted sequence. If the values are quite small however it is usually fastest to just swap the values in-place as needed. Furthermore, if the parameterized type is already of some pointer-type, then there is no need to build a separate pointer array. Template specialization allows the template creator to write different implementations and to specify the characteristics that the parameterized type(s) must have for each implementation to be used.
Unlike function templates, class templates can be partially specialized. That means that an alternate version of the class template code can be provided when some of the template parameters are known, while leaving other template parameters generic. This can be used, for example, to create a default implementation (the ''primary specialization'') that assumes that copying a parameterizing type is expensive and then create partial specializations for types that are cheap to copy, thus increasing overall efficiency. Clients of such a class template just use specializations of it without needing to know whether the compiler used the primary specialization or some partial specialization in each case. Class templates can also be ''fully specialized,'' which means that an alternate implementation can be provided when all of the parameterizing types are known.
=Advantages and disadvantages
= Some uses of templates, such as themax() function, were previously filled by function-like preprocessor macros (a legacy of the Templates in D
The D programming language supports templates based in design on C++. Most C++ template idioms will carry over to D without alteration, but D adds some additional functionality: * Template parameters in D are not restricted to just types and primitive values (as it was in C++ before C++20), but also allow arbitrary compile-time values (such as strings and struct literals), and aliases to arbitrary identifiers, including other templates or template instantiations. * Template constraints and thestatic if statement provide an alternative to respectively C++'s C++ concepts and if constexpr.
* The is(...) expression allows speculative instantiation to verify an object's traits at compile time.
* The auto keyword and the typeof expression allow type inference for variable declarations and function return values, which in turn allows "Voldemort types" (types that do not have a global name).
Templates in D use a different syntax than in C++: whereas in C++ template parameters are wrapped in angular brackets (Template),
D uses an exclamation sign and parentheses: Template!(param1, param2).
This avoids the C++ parsing difficulties due to ambiguity with comparison operators.
If there is only one parameter, the parentheses can be omitted.
Conventionally, D combines the above features to provide compile-time polymorphism using trait-based generic programming.
For example, an input range is defined as any type that satisfies the checks performed by isInputRange, which is defined as follows:
=Code generation
= In addition to template metaprogramming, D also provides several features to enable compile-time code generation: * Theimport expression allows reading a file from disk and using its contents as a string expression.
* Compile-time reflection allows enumerating and inspecting declarations and their members during compilation.
* User-defined attributes allow users to attach arbitrary identifiers to declarations, which can then be enumerated using compile-time reflection.
* Compile-Time Function Execution (CTFE) allows a subset of D (restricted to safe operations) to be interpreted during compilation.
* String mixins allow evaluating and compiling the contents of a string expression as D code that becomes part of the program.
Combining the above allows generating code based on existing declarations.
For example, D serialization frameworks can enumerate a type's members and generate specialized functions for each serialized type
to perform serialization and deserialization.
User-defined attributes could further indicate serialization rules.
The import expression and compile-time function execution also allow efficiently implementing domain-specific languages.
For example, given a function that takes a string containing an HTML template and returns equivalent D source code, it is possible to use it in the following way:
Genericity in Eiffel
Generic classes have been a part of Eiffel since the original method and language design. The foundation publications of Eiffel, use the term ''genericity'' to describe the creation and use of generic classes.=Basic/Unconstrained genericity
= Generic classes are declared with their class name and a list of one or more ''formal generic parameters''. In the following code, classLIST has one formal generic parameter G
ACCOUNT and DEPOSIT are other class names. ACCOUNT and DEPOSIT are considered ''actual generic parameters'' as they provide real class names to substitute for G in actual use.
LIST /code> is considered a class, it is not considered a type. However, a generic derivation of LIST /code> such as LIST CCOUNT/code> is considered a type.
=Constrained genericity
=
For the list class shown above, an actual generic parameter substituting for G can be any other available class. To constrain the set of classes from which valid actual generic parameters can be chosen, a ''generic constraint'' can be specified. In the declaration of class SORTED_LIST below, the generic constraint dictates that any valid actual generic parameter will be a class that inherits from class COMPARABLE. The generic constraint ensures that elements of a SORTED_LIST can in fact be sorted.
class
SORTED_LIST -> COMPARABLE
Generics in Java
Support for the ''generics'', or "containers-of-type-T" was added to the Java programming language
Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible. It is a general-purpose programming language intended to let programmers ''write once, run an ...
in 2004 as part of J2SE 5.0. In Java, generics are only checked at compile time for type correctness. The generic type information is then removed via a process called type erasure, to maintain compatibility with old JVM implementations, making it unavailable at runtime. For example, a List<String> is converted to the raw type List. The compiler inserts type casts to convert the elements to the String type when they are retrieved from the list, reducing performance compared to other implementations such as C++ templates.
Genericity in .NET #, VB.NET/h3>
Generics were added as part of .NET Framework 2.0
Microsoft started development on the .NET Framework in the late 1990s originally under the name of Next Generation Windows Services (NGWS). By late 2001 the first beta versions of .NET 1.0 were released. The first version of .NET Framework was ...
in November 2005, based on a research prototype from Microsoft Research started in 1999. Although similar to generics in Java, .NET generics do not apply type erasure, but implement generics as a first class mechanism in the runtime using reification
Reification may refer to:
Science and technology
* Reification (computer science), the creation of a data model
* Reification (knowledge representation), the representation of facts and/or assertions
* Reification (statistics), the use of an id ...
. This design choice provides additional functionality, such as allowing reflection with preservation of generic types, as well as alleviating some of the limitations of erasure (such as being unable to create generic arrays). This also means that there is no performance hit from runtime casts
Cast may refer to:
Music
* Cast (band), an English alternative rock band
* Cast (Mexican band), a progressive Mexican rock band
* The Cast, a Scottish musical duo: Mairi Campbell and Dave Francis
* ''Cast'', a 2012 album by Trespassers William
...
and normally expensive boxing conversions. When primitive and value types are used as generic arguments, they get specialized implementations, allowing for efficient generic collections and methods. As in C++ and Java, nested generic types such as Dictionary> are valid types, however are advised against for member signatures in code analysis design rules.
.NET allows six varieties of generic type constraints using the where keyword including restricting generic types to be value types, to be classes, to have constructors, and to implement interfaces. Below is an example with an interface constraint:
using System;
class Sample
The MakeAtLeast() method allows operation on arrays, with elements of generic type T. The method's type constraint indicates that the method is applicable to any type T that implements the generic IComparable<T> interface. This ensures a compile time error, if the method is called if the type does not support comparison. The interface provides the generic method CompareTo(T).
The above method could also be written without generic types, simply using the non-generic Array type. However, since arrays are contravariant, the casting would not be type safe
In computer science, type safety and type soundness are the extent to which a programming language discourages or prevents type errors. Type safety is sometimes alternatively considered to be a property of facilities of a computer language; that ...
, and the compiler would be unable to find certain possible errors that would otherwise be caught when using generic types. In addition, the method would need to access the array items as objects instead, and would require casting to compare two elements. (For value types like types such as int this requires a boxing
Boxing (also known as "Western boxing" or "pugilism") is a combat sport in which two people, usually wearing protective gloves and other protective equipment such as hand wraps and mouthguards, throw punches at each other for a predetermine ...
conversion, although this can be worked around using the Comparer<T> class, as is done in the standard collection classes.)
A notable behavior of static members in a generic .NET class is static member instantiation per run-time type (see example below).
//A generic class
public class GenTest
//a class
public class CountedInstances
//main code entry point
//at the end of execution, CountedInstances.Counter = 2
GenTest g1 = new GenTest(1);
GenTest g11 = new GenTest(11);
GenTest g111 = new GenTest(111);
GenTest g2 = new GenTest(1.0);
Genericity in Delphi
Delphi's Object Pascal dialect acquired generics in the Delphi 2007 release, initially only with the (now discontinued) .NET compiler before being added to the native code in the Delphi 2009 release. The semantics and capabilities of Delphi generics are largely modelled on those had by generics in .NET 2.0, though the implementation is by necessity quite different. Here's a more or less direct translation of the first C# example shown above:
program Sample;
uses
Generics.Defaults; //for IComparer<>
type
TUtils = class
class procedure MakeAtLeast(Arr: TArray; const Lowest: T;
Comparer: IComparer); overload;
class procedure MakeAtLeast(Arr: TArray; const Lowest: T); overload;
end;
class procedure TUtils.MakeAtLeast(Arr: TArray; const Lowest: T;
Comparer: IComparer);
var
I: Integer;
begin
if Comparer = nil then Comparer := TComparer.Default;
for I := Low(Arr) to High(Arr) do
if Comparer.Compare(Arr Lowest) < 0 then
Arr := Lowest;
end;
class procedure TUtils.MakeAtLeast(Arr: TArray; const Lowest: T);
begin
MakeAtLeast(Arr, Lowest, nil);
end;
var
Ints: TArray;
Value: Integer;
begin
Ints := TArray.Create(0, 1, 2, 3);
TUtils.MakeAtLeast(Ints, 2);
for Value in Ints do
WriteLn(Value);
ReadLn;
end.
As with C#, methods as well as whole types can have one or more type parameters. In the example, TArray is a generic type (defined by the language) and MakeAtLeast a generic method. The available constraints are very similar to the available constraints in C#: any value type, any class, a specific class or interface, and a class with a parameterless constructor. Multiple constraints act as an additive union.
Genericity in Free Pascal
Free Pascal implemented generics before Delphi, and with different syntax and semantics. However, since FPC version 2.6.0, the Delphi-style syntax is available when using the language mode. Thus, Free Pascal programmers are able to use generics in whichever style they prefer.
Delphi and Free Pascal example:
// Delphi style
unit A;
interface
type
TGenericClass = class
function Foo(const AValue: T): T;
end;
implementation
function TGenericClass.Foo(const AValue: T): T;
begin
Result := AValue + AValue;
end;
end.
// Free Pascal's ObjFPC style
unit B;
interface
type
generic TGenericClass = class
function Foo(const AValue: T): T;
end;
implementation
function TGenericClass.Foo(const AValue: T): T;
begin
Result := AValue + AValue;
end;
end.
// example usage, Delphi style
program TestGenDelphi;
uses
A,B;
var
GC1: A.TGenericClass;
GC2: B.TGenericClass;
begin
GC1 := A.TGenericClass.Create;
GC2 := B.TGenericClass.Create;
WriteLn(GC1.Foo(100)); // 200
WriteLn(GC2.Foo('hello')); // hellohello
GC1.Free;
GC2.Free;
end.
// example usage, ObjFPC style
program TestGenDelphi;
uses
A,B;
// required in ObjFPC
type
TAGenericClassInt = specialize A.TGenericClass;
TBGenericClassString = specialize B.TGenericClass;
var
GC1: TAGenericClassInt;
GC2: TBGenericClassString;
begin
GC1 := TAGenericClassInt.Create;
GC2 := TBGenericClassString.Create;
WriteLn(GC1.Foo(100)); // 200
WriteLn(GC2.Foo('hello')); // hellohello
GC1.Free;
GC2.Free;
end.
Functional languages
Genericity in Haskell
The type class mechanism of Haskell supports generic programming.
Six of the predefined type classes in Haskell (including Eq, the types that can be compared for equality, and Show, the types whose values can be rendered as strings) have the special property of supporting ''derived instances.'' This means that a programmer defining a new type can state that this type is to be an instance of one of these special type classes, without providing implementations of the class methods as is usually necessary when declaring class instances. All the necessary methods will be "derived" – that is, constructed automatically – based on the structure of the type.
For instance, the following declaration of a type of binary trees states that it is to be an instance of the classes Eq and Show:
data BinTree a = Leaf a , Node (BinTree a) a (BinTree a)
deriving (Eq, Show)
This results in an equality function (show) being automatically defined for any type of the form BinTree T provided that T itself supports those operations.
The support for derived instances of Eq and Show makes their methods show generic in a qualitatively different way from parametrically polymorphic functions: these "functions" (more accurately, type-indexed families of functions) can be applied to values of various types, and although they behave differently for every argument type, little work is needed to add support for a new type. Ralf Hinze (2004) has shown that a similar effect can be achieved for user-defined type classes by certain programming techniques. Other researchers have proposed approaches to this and other kinds of genericity in the context of Haskell and extensions to Haskell (discussed below).
= PolyP
=
PolyP was the first generic programming language extension to Haskell. In PolyP, generic functions are called ''polytypic''. The language introduces a special construct in which such polytypic functions can be defined via structural induction over the structure of the pattern functor of a regular datatype. Regular datatypes in PolyP are a subset of Haskell datatypes. A regular datatype t must be of kind ''* → *'', and if ''a'' is the formal type argument in the definition, then all recursive calls to ''t'' must have the form ''t a''. These restrictions rule out higher-kinded datatypes as well as nested datatypes, where the recursive calls are of a different form.
The flatten function in PolyP is here provided as an example:
flatten :: Regular d => d a -> flatten = cata fl
polytypic fl :: f a -> case f of
g+h -> either fl fl
g*h -> \(x,y) -> fl x ++ fl y
() -> \x -> []
Par -> \x -> [x]
Rec -> \x -> x
d@g -> concat . flatten . pmap fl
Con t -> \x -> []
cata :: Regular d => (FunctorOf d a b -> b) -> d a -> b
=Generic Haskell
=
Generic Haskell is another extension to Haskell, developed at Utrecht University in the Netherlands
)
, anthem = ( en, "William of Nassau")
, image_map =
, map_caption =
, subdivision_type = Sovereign state
, subdivision_name = Kingdom of the Netherlands
, established_title = Before independence
, established_date = Spanish Netherl ...
. The extensions it provides are:
*''Type-indexed values'' are defined as a value indexed over the various Haskell type constructors (unit, primitive types, sums, products, and user-defined type constructors). In addition, we can also specify the behaviour of a type-indexed values for a specific constructor using ''constructor cases'', and reuse one generic definition in another using ''default cases''.
The resulting type-indexed value can be specialized to any type.
*''Kind-indexed types'' are types indexed over kinds, defined by giving a case for both ''*'' and ''k → k. Instances are obtained by applying the kind-indexed type to a kind.
*Generic definitions can be used by applying them to a type or kind. This is called ''generic application''. The result is a type or value, depending on which sort of generic definition is applied.
*''Generic abstraction'' enables generic definitions be defined by abstracting a type parameter (of a given kind).
*''Type-indexed types'' are types that are indexed over the type constructors. These can be used to give types to more involved generic values. The resulting type-indexed types can be specialized to any type.
As an example, the equality function in Generic Haskell:
type Eq t1 t2 = t1 -> t2 -> Bool
type Eq t1 t2 = forall u1 u2. Eq u1 u2 -> Eq (t1 u1) (t2 u2)
eq :: Eq t t
eq _ _ = True
eq eqA eqB (Inl a1) (Inl a2) = eqA a1 a2
eq eqA eqB (Inr b1) (Inr b2) = eqB b1 b2
eq eqA eqB _ _ = False
eq eqA eqB (a1 :*: b1) (a2 :*: b2) = eqA a1 a2 && eqB b1 b2
eq = ()
eq = ()
eq = ()
Clean
Clean offers generic programming based and the as supported by the GHC ≥ 6.0. It parametrizes by kind as those but offers overloading.
Other languages
Languages in the ML family support generic programming through parametric polymorphism and generic modules called ''functors.'' Both Standard ML and OCaml provide functors, which are similar to class templates and to Ada's generic packages. Scheme syntactic abstractions also have a connection to genericity – these are in fact a superset of C++ templates.
A Verilog module may take one or more parameters, to which their actual values are assigned upon the instantiation of the module. One example is a generic register array where the array width is given via a parameter. Such an array, combined with a generic wire vector, can make a generic buffer or memory module with an arbitrary bit width out of a single module implementation.
VHDL, being derived from Ada, also has generic capabilities. https://www.ics.uci.edu/~jmoorkan/vhdlref/generics.html VHDL Reference
C supports "type-generic expressions" using the keyword:WG14 N1516 Committee Draft — October 4, 2010
/ref>
#define cbrt(x) _Generic((x), long double: cbrtl, \
default: cbrt, \
float: cbrtf)(x)
See also
* Concept (generic programming)
* Partial evaluation
* Template metaprogramming
* Type polymorphism
References
Sources
*
*
*
Further reading
* Gabriel Dos Reis and Jaakko Järvi,
What is Generic Programming?
'
LCSD 2005
.
*
*
External links
generic-programming.org
* Alexander A. Stepanov
Collected Papers of Alexander A. Stepanov
(creator of the STL STL may refer to:
Communications
* Standard telegraph level
*Studio/transmitter link
International law
*Special Tribunal for Lebanon
The Special Tribunal for Lebanon (STL), also referred to as the Lebanon Tribunal or the Hariri Tribunal, is a ...
)
;C++/D
* Walter Bright,
Templates Revisited
''
* David Vandevoorde, Nicolai M Josuttis, ''C++ Templates: The Complete Guide'', 2003 Addison-Wesley.
;C#/.NET
* Jason Clark,
Introducing Generics in the Microsoft CLR
" September 2003, ''MSDN Magazine'', Microsoft.
* Jason Clark,
More on Generics in the Microsoft CLR
" October 2003, ''MSDN Magazine'', Microsoft.
* M. Aamir Maniar
Generics.Net
An open source generics library for C#.
;Delphi/Object Pascal
* Nick Hodges,
Delphi 2009 Reviewers Guide
" October 2008, ''Embarcadero Developer Network'', Embarcadero.
* Craig Stuntz,
Delphi 2009 Generics and Type Constraints
" October 2008
* Dr. Bob,
* Free Pascal
Free Pascal Reference guide Chapter 8: Generics
Michaël Van Canneyt, 2007
* Delphi for Win32
Generics with Delphi 2009 Win32
Sébastien DOERAENE, 2008
* Delphi for .NET
Felix COLIBRI, 2008
;Eiffel
;Haskell
* Johan Jeuring, Sean Leather, José Pedro Magalhães, and Alexey Rodriguez Yakushev
''Libraries for Generic Programming in Haskell''
Utrecht University.
* Dæv Clarke, Johan Jeuring and Andres Löh
The Generic Haskell user's guide
* Ralf Hinze,
Generics for the Masses
" In ''Proceedings of the ACM
ACM or A.C.M. may refer to:
Aviation
* AGM-129 ACM, 1990–2012 USAF cruise missile
* Air chief marshal
* Air combat manoeuvring or dogfighting
* Air cycle machine
* Arica Airport (Colombia) (IATA: ACM), in Arica, Amazonas, Colombia
Computing
* ...
SIGPLAN International Conference on Functional Programming (ICFP),'' 2004.
* Simon Peyton Jones, editor,
The Haskell 98 Language Report
'' Revised 2002.
* Ralf Lämmel and Simon Peyton Jones, "Scrap Your Boilerplate: A Practical Design Pattern for Generic Programming," In ''Proceedings of the ACM
ACM or A.C.M. may refer to:
Aviation
* AGM-129 ACM, 1990–2012 USAF cruise missile
* Air chief marshal
* Air combat manoeuvring or dogfighting
* Air cycle machine
* Arica Airport (Colombia) (IATA: ACM), in Arica, Amazonas, Colombia
Computing
* ...
SIGPLAN International Workshop on Types in Language Design and Implementation (TLDI'03),'' 2003. (Also see the websit
devoted to this research
* Andres Löh,
Exploring Generic Haskell
'' PhD thesis, 2004 Utrecht University.
Generic Haskell: a language for generic programming
;Java
* Gilad Bracha,
Generics in the Java Programming Language
'' 2004.
* Maurice Naftalin and Philip Wadler, ''Java Generics and Collections,'' 2006, O'Reilly Media, Inc.
* Peter Sestoft, ''Java Precisely, Second Edition,'' 2005 MIT Press.
* , 2004 Sun Microsystems, Inc.
* Angelika Langer
{{Authority control
Articles with example C Sharp code