Generic programming - Knowledge (XXG)

2250:

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.

897: 2261:) 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 5586:

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

4590:

As with C#, methods and 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

2382:

Also, the implementation source code for the template must be completely available (e.g. included in a header) to the translation unit (source file) using it. Templates, including much of the Standard Library, if not included in header files, cannot be compiled. (This is in contrast to non-templated

291:

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

860:

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

512:

can be viewed as predefined generic types. Every usage of an array or struct type instantiates a new concrete type, or reuses a previous instantiated type. Array element types and struct element types are parameterized types, which are used to instantiate the corresponding generic type. All this is

5462:

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,

2727:

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

2309:

However, templates are generally considered an improvement over macros for these purposes. Templates are type-safe. Templates avoid some of the common errors found in code that makes heavy use of function-like macros, such as evaluating parameters with side effects twice. Perhaps most importantly,

311:

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.

2355:

So, can derivation be used to reduce the problem of code replicated because templates are used? This would involve deriving a template from an ordinary class. This technique proved successful in curbing code bloat in real use. People who do not use a technique like this have found that replicated

3880:

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

2378:

The extra instantiations generated by templates can also cause some debuggers to have difficulty working gracefully with templates. For example, setting a debug breakpoint within a template from a source file may either miss setting the breakpoint in the actual instantiation desired or may set a

532:

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

306:

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

5587:

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).

2249:

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

2325:

Templates in C++ lack many features, which makes implementing them and using them in a straightforward way often impossible. Instead programmers have to rely on complicated tricks which leads to bloated, hard to understand and hard to maintain code. Current developments in the C++ standards

1027:

is a value, a variable, a constant, a type, a subprogram, or even an instance of another, designated, generic unit. For generic formal types, the syntax distinguishes between discrete, floating-point, fixed-point, access (pointer) types, etc. Some formal parameters can have default values.

5603:. 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 2399:

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

307:

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—

2110:

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

2347:

of the templated class or function for every type parameters used with it. (This is necessary because types in C++ are not all the same size, and the sizes of data fields are important to how classes work.) So the indiscriminate use of templates can lead to

5935:

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

4602:

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 {$ mode Delphi} language mode. Thus, Free Pascal code supports generics in either style.

2242:. 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. 2383:

code, which may be compiled to binary, providing only a declarations header file for code using it.) This may be a disadvantage by exposing the implementing code, which removes some abstractions, and could restrict its use in closed-source projects.

2257:. 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 1688:

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

1004:

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

234:

Generic programming centers around the idea of abstracting from concrete, efficient algorithms to obtain generic algorithms that can be combined with different data representations to produce a wide variety of useful

6557:

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.

245:

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

7925: 3110:

and methods. As in C++ and Java, nested generic types such as Dictionary<string, List<int>> are valid types, however are advised against for member signatures in code analysis design rules.

2190:

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

2329:

Many compilers historically had poor support for templates, thus the use of templates could have made code somewhat less portable. Support may also be poor when a C++ compiler is being used with a

486:

by default as both passing values to functions and value assignment are type-indifferent and such behavior is often used for abstraction or code terseness, however this is not typically labeled

3098:

with preservation of generic types, and alleviating some of the limits of erasure (such as being unable to create generic arrays). This also means that there is no performance hit from runtime

327:

and not from type theory. Its goal is the incremental construction of systematic catalogs of useful, efficient and abstract algorithms and data structures. Such an undertaking is still a dream.

363:

Following Stepanov, we can define generic programming without mentioning language features: Lift algorithms and data structures from concrete examples to their most general and abstract form.

5622:. These restrictions rule out higher-kinded datatypes and nested datatypes, where the recursive calls are of a different form. The flatten function in PolyP is here provided as an example: 1769:

In this example, Array_Type is constrained by both Index_Type and Element_Type. When instantiating the unit, the programmer must pass an actual array type that satisfies these constraints.

3488:, 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 1854:

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 template

206:

in a more specific sense than the above, to describe a programming paradigm in which fundamental requirements on data types are abstracted from across concrete examples of algorithms and

462:

Genericity is implemented and supported differently in various programming languages; the term "generic" has also been used differently in various programming contexts. For example, in

5982:

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.

7831: 3118:

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:

2340:

Compilers can produce confusing, long, and sometimes unhelpful error messages when errors are detected in code that uses SFINAE. This can make templates difficult to develop with.

7895: 6820:

Matthew H. Austern: Generic programming and the STL: using and extending the C++ Standard Template Library. Addison-Wesley Longman Publishing Co., Inc. Boston, MA, USA 1998

7844: 7680: 3039:

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

3481: 2214:

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

1805:

all instances of a generic being exactly the same, it is easier to review and understand programs written by others; there are no "special cases" to take into account.

1787:: the object code for a generic unit can be shared between all instances (unless the programmer requests inlining of subprograms, of course). As further consequences: 502:

where types are always parametric and the actual code on those types is generic. These uses still serve a similar purpose of code-saving and rendering an abstraction.

2739:. 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: 2352:, resulting in excessively large executables. However, judicious use of template specialization and derivation can dramatically reduce such code bloat in some cases: 2908:

The formal generic parameters are placeholders for arbitrary class names that will be supplied when a declaration of the generic class is made, as shown in the two

1772:

The disadvantage of this fine-grained control is a complicated syntax, but, because all generic formal parameters are completely defined in the specification, the

7994: 524:

A broad survey of genericity mechanisms in programming languages follows. For a specific survey comparing suitability of mechanisms for generic programming, see.

7929: 1779:

Unlike C++, Ada does not allow specialised generic instances, and requires that all generics be instantiated explicitly. These rules have several consequences:

482:

capacities that, however, are not referred to as such in most Forth texts. Similarly, dynamically typed languages, especially interpreted ones, usually offer

6992:

R. Garcia; J. Ja ̈rvi; A. Lumsdaine; J. Siek; J. Willcock (2005). "An extended comparative study of language support for generic programming (preprint)".

3086:

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

7824: 8793: 8058: 9164: 8798: 8408: 8270: 6553:

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

8788: 8783: 8414: 7436:. Spring School on Datatype-Generic Programming 2006. Lecture Notes in Computer Science. Vol. 4719. Heidelberg: Springer. pp. 1–71. 7817: 7627: 7343: 7286: 7237: 7069: 6745: 6644: 2313:

There are four primary drawbacks to the use of templates: supported features, compiler support, poor error messages (usually with pre C++20

319:

genericity and templates, it is independent of particular language-technical details. Generic programming pioneer Alexander Stepanov wrote,

8771: 8672: 8599: 8347: 918: 2395:

language supports templates based in design on C++. Most C++ template idioms work in D without alteration, but D adds some functionality:

2326:

exacerbate this problem by making heavy use of these tricks and building a lot of new features for templates on them or with them in mind.

7711: 7674: 7150: 1797: 1039:

parameters for each formal. The generic instance then behaves just like any other unit. It is possible to instantiate generic units at

8067: 7305: 1835: 1040: 3106:. When primitive and value types are used as generic arguments, they get specialized implementations, allowing for efficient generic 7792: 7778: 7742: 7536: 7391: 6688: 2439:

for variable declarations and function return values, which in turn allows "Voldemort types" (types that do not have a global name).

988: 7596: 3511:

A notable behavior of static members in a generic .NET class is static member instantiation per run-time type (see example below).

6968: 969: 8439: 8119: 8063: 1793:

it is possible to instantiate generics at run-time, and at compile time, since no new object code is required for a new instance.

49: 941: 861:

syntax. The Java programming language has provided genericity facilities syntactically based on C++'s since the introduction of

8922: 8299: 8172: 8103: 8038: 7961: 2717: 2254: 1830:

or STL that provides a framework of templates for common data structures and algorithms. Templates in C++ may also be used for

862: 624: 509: 292:

generically with arguments of such iterators, e.g. a pair of iterators pointing to the beginning and end of the subsequence or

3881:

implementation is by necessity quite different. Here's a more or less direct translation of the first C# example shown above:

2991:

can be any other available class. To constrain the set of classes from which valid actual generic parameters can be chosen, a

9039: 8844: 8776: 8738: 8477: 8240: 7870: 7471: 6829:

Jeremy G. Siek, Lie-Quan Lee, Andrew Lumsdaine: The Boost Graph Library: User Guide and Reference Manual. Addison-Wesley 2001

6811:

Alexander Stepanov and Meng Lee: The Standard Template Library. HP Laboratories Technical Report 95-11(R.1), 14 November 1995

6788: 3091: 1808:

all instantiations being explicit, there are no hidden instantiations that might make it difficult to understand the program.

922: 872: 868: 134: 122: 83:, generic programming became part of the repertoire of professional library design. The techniques were further improved and 2723:

String mixins allow evaluating and compiling the contents of a string expression as D code that becomes part of the program.

1811:

Ada does not permit arbitrary computation at compile time, because operations on generic arguments are performed at runtime.

7662: 7217: 948: 8255: 8245: 8023: 7728: 6598: 6543: 3063:

type when they are retrieved from the list, reducing performance compared to other implementations such as C++ templates.

2815: 452: 444: 247: 211: 146: 130: 2302:, before compiling proper; templates are actual real functions. Macros are always expanded inline; templates can also be 254:. Early examples of this programming approach were implemented in Scheme and Ada, although the best known example is the 9215: 8939: 8869: 8717: 8639: 8619: 8549: 8492: 8454: 8444: 8404: 8329: 8265: 8235: 8162: 8151: 8048: 8028: 8003: 7966: 7173: 6499: 2999:

below, the generic constraint dictates that any valid actual generic parameter will be a class that inherits from class

2714:

allow users to attach arbitrary identifiers to declarations, which can then be enumerated using compile-time reflection.

2463: 610:

is a placeholder for whatever type is specified when the list is created. These "containers-of-type-T", commonly called

463: 184: 180: 158: 2443:

Templates in D use a different syntax than in C++: whereas in C++ template parameters are wrapped in angular brackets (

1796:

actual objects corresponding to a generic formal object are always considered to be non-static inside the generic; see

9194: 8594: 8357: 8324: 8219: 8195: 8157: 8137: 8033: 7942: 7920: 7905: 2192: 448: 432: 323:

Generic programming is about abstracting and classifying algorithms and data structures. It gets its inspiration from

154: 138: 57: 2374:

of the template class which would require rewriting of an entire class for a specific template parameters used by it.

955: 907: 5463:

constructed automatically – based on the structure of the type. For example, the following declaration of a type of

8949: 8817: 8541: 8527: 8434: 8394: 8319: 8225: 8205: 8072: 7951: 7885: 6660:

Milner, R.; Morris, L.; Newey, M. (1975). "A Logic for Computable Functions with Reflexive and Polymorphic Types".

2334: 1001: 420: 416: 142: 118: 72: 3469:

error, if the method is called if the type does not support comparison. The interface provides the generic method

2696:

In addition to template metaprogramming, D also provides several features to enable compile-time code generation:

1790:

there is no possibility of code bloat (code bloat is common in C++ and requires special care, as explained below).

926: 911: 9127: 9079: 8991: 8969: 8964: 8892: 8758: 8634: 8399: 8309: 8289: 8275: 7505: 6519: 3501: 3103: 3036: 2459: 2094:

is defined. Common inheritance is not needed for the set of types that can be used, and so it is very similar to

1827: 1006: 412: 255: 176: 150: 53: 7797: 937: 9001: 8665: 8614: 8574: 8517: 8449: 8187: 8018: 7720: 6942: 6608: 6567: 2736: 2392: 2285: 2281: 1831: 440: 107: 7761: 490:

as it's a direct consequence of the dynamic typing system employed by the language. The term has been used in

7013: 6546:

syntactic abstractions also have a connection to genericity – these are in fact a superset of C++ templates.

2265:

which means that an alternate implementation can be provided when all of the parameterizing types are known.

1955:

of this function template, instantiations with specific types, can be called just like an ordinary function:

9154: 9069: 8624: 8604: 8545: 8532: 8512: 8339: 8076: 7980: 7938: 6523: 2455:

due to ambiguity with comparison operators. If there is only one parameter, the parentheses can be omitted.

171: 61: 218:

implemented in terms of these concepts, typically using language genericity mechanisms as described above.

8897: 8753: 8712: 8707: 8584: 8559: 8553: 8497: 8459: 8147: 8142: 8094: 7989: 7890: 7862: 7853: 7437: 6993: 6766: 3095: 2707:

Compile-time reflection allows enumerating and inspecting declarations and their members during compiling.

611: 518: 499: 491: 308: 7640: 7418: 7410: 411:

Genericity facilities have existed in high-level languages since at least the 1970s in languages such as

8887: 8862: 8486: 8482: 8424: 8376: 7946: 4591:

interface, and a class with a parameterless constructor. Multiple constraints act as an additive union.

2711: 2230:

has a set of standard functions associated with it, that work for any compatible parameterizing types.

7456:

Conference proceedings on Object-oriented programming systems, languages and applications - OOPSLA '86

8689: 8629: 8609: 8569: 8371: 8230: 8099: 8086: 7840: 7379: 7057: 2099: 388: 30: 7442: 6771: 2633:

A function that accepts only input ranges can then use the above template in a template constraint:

281:

etc., a direct approach would implement each algorithm specifically for each data structure, giving

102: 9159: 9064: 8917: 8909: 8829: 8658: 8564: 8314: 8294: 8280: 8012: 7880: 7875: 6998: 6918: 6527: 2818:

since the original method and language design. The foundation publications of Eiffel, use the term

1850:

There are many kinds of templates, the most common being function templates and class templates. A

1826:

C++ uses templates to enable generic programming techniques. The C++ Standard Library includes the

191:. (Haskell terminology also uses the term "generic" for a related but somewhat different concept.) 97: 20: 7804: 9142: 9122: 9074: 9049: 8834: 8803: 8381: 8334: 8304: 8250: 8109: 8008: 7900: 7809: 7734: 7705: 7701: 7688: 7477: 7319: 6938: 6880: 6794: 6603: 5921: 5604: 2330: 2132: 962: 339: 203: 2720:(CTFE) allows a subset of D (restricted to safe operations) to be interpreted during compiling. 9029: 8959: 8934: 8748: 8743: 8537: 8429: 8284: 8260: 8200: 8167: 8129: 8114: 8053: 7788: 7774: 7738: 7571: 7532: 7467: 7387: 7353: 7339: 7301: 7282: 7233: 7065: 7049: 6784: 6741: 6684: 6640: 6613: 6554: 3874: 2361: 2136: 876: 356: 166: 126: 7668: 7260: 7086: 5458:, the types whose values can be rendered as strings) have the special property of supporting 2452: 1821: 76: 9174: 9059: 8857: 8419: 8351: 8215: 7956: 7459: 7331: 6914: 6872: 6776: 6634: 3107: 3026: 380: 251: 215: 6761:

Musser, David R.; Stepanov, Alexander A. (1987). "A library of generic algorithms in Ada".

3476:

The above method could also be written without generic types, simply using the non-generic

614:, allow a class to be reused with different datatypes as long as certain contracts such as 9179: 9044: 8996: 8929: 8469: 8343: 8209: 7910: 7422: 7323: 7248: 7206: 5970:. The result is a type or value, depending on which sort of generic definition is applied. 3493: 3099: 3056: 2303: 1839: 505: 428: 89: 7653: 7520: 7357: 7195: 5976:

enables generic definitions be defined by abstracting a type parameter (of a given kind).

2704:

expression allows reading a file from disk and using its contents as a string expression.

2422:

expression allows speculative instantiation to verify an object's traits at compile time.

7620: 7383: 7061: 7037: 6510:

as supported by the GHC ≥ 6.0. It parametrizes by kind as those but offers overloading.

2408: 262:

that is used to decouple sequence data structures and the algorithms operating on them.

9132: 8954: 8944: 8852: 8521: 8177: 8043: 7613: 7560: 7549: 7451: 7429: 6975: 5450:

supports generic programming. Six of the predefined type classes in Haskell (including

3083: 2436: 2155: 880: 619: 207: 65: 6763:

Proceedings of the 1987 annual ACM SIGAda international conference on Ada - SIGAda '87

6542:

provide functors, which are similar to class templates and to Ada's generic packages.

9209: 9054: 8507: 7372: 7038:

Stroustrup, Dos Reis (2003): Concepts - Design choices for template argument checking

6899: 6677: 3877: 2971:

is considered a class, it is not considered a type. However, a generic derivation of

2182:

data unless a comparison (in the form of a functor or function) is provided. E.g.: A

6840: 373:

Other programming paradigms that have been described as generic programming include

64:

that differ only in the set of types on which they operate when used, thus reducing

9011: 8986: 7708:, "Scrap Your Boilerplate: A Practical Design Pattern for Generic Programming," In 7315: 6884: 6863: 5966:

Generic definitions can be used by applying them to a type or kind. This is called

3466: 3457:. The method's type constraint indicates that the method is applicable to any type 3087: 3040: 2735:

expression and compile-time function execution also allow efficiently implementing

2299: 2278: 424: 343: 338:

I believe that iterator theories are as central to Computer Science as theories of

324: 316: 199: 7652:

Johan Jeuring, Sean Leather, José Pedro Magalhães, and Alexey Rodriguez Yakushev.

7481: 6798: 9189: 9184: 9034: 8981: 8808: 8389: 7717:

International Workshop on Types in Language Design and Implementation (TLDI'03),

7609: 7603: 6535: 5925: 5464: 4599: 2215: 2095: 1834:, which is a way of pre-evaluating some of the code at compile-time rather than 896: 879:

2005 have constructs that exploit the support for generics present in Microsoft

456: 403:). For further discussion and comparison of generic programming paradigms, see. 2003:. It then instantiates a version of the function where the parameterizing type 368:

Bjarne Stroustrup, Evolving a language in and for the real world: C++ 1991-2006

9094: 9089: 9006: 8974: 8879: 8822: 7693: 5443: 2349: 2318: 2310:

templates were designed to be applicable to much larger problems than macros.

162: 7184: 2987:

For the list class shown above, an actual generic parameter substituting for

2830:

Generic classes are declared with their class name and a list of one or more

9169: 9147: 9104: 9099: 8766: 8722: 8681: 7585: 7335: 6943:"Scrap Your Boilerplate: A Practical Design Pattern for Generic Programming" 6876: 3485: 2143: 629: 615: 38: 34: 5614:

is the formal type argument in the definition, then all recursive calls to

2343:

Finally, the use of templates requires the compiler to generate a separate

632:

usage of exchangeable sub-classes: for instance, a list of objects of type

6780: 9084: 6717: 3094:. This design choice provides additional functionality, such as allowing 3090:, but implement generics as a first class mechanism in the runtime using 2288:

language). For example, here is a possible implementation of such macro:

1773: 514: 467: 259: 7463: 7714: 7677: 6550: 5917: 5596: 5447: 495: 188: 7495: 7328:

Symbolic and Algebraic Computation: International symposium ISSAC 1988

7174:

C#: Yesterday, Today, and Tomorrow: An Interview with Anders Hejlsberg

644:. Templates can also be used for type-independent functions as in the 7370:

Gamma, Erich; Helm, Richard; Johnson, Ralph; Vlissides, John (1994).

6675:

Gamma, Erich; Helm, Richard; Johnson, Ralph; Vlissides, John (1994).

5963:. Instances are obtained by applying the kind-indexed type to a kind. 2431: 2356:

code can cost megabytes of code space even in moderate size programs.

2314: 1776:

can instantiate generics without looking at the body of the generic.

7330:. Lecture Notes in Computer Science. Vol. 358. pp. 13–25. 7196:

Code Analysis CA1006: Do not nest generic types in member signatures

2744:// Import the contents of example.htt as a string manifest constant. 384:

approach is a lightweight generic programming approach for Haskell.

269:

sequence data structures, e.g. singly linked list, vector etc., and

7747: 7432:(2007). Backhouse, R.; Gibbons, J.; Hinze, R.; Jeuring, J. (eds.). 1506:-- Allows the user to jump between recorded locations in a document 436: 80: 7501: 6539: 3540:// A static variable - will be created for each type on reflection 3047:

implementations, making it unavailable at runtime. For example, a

2333:

that is not C++-aware, or when attempting to use templates across

2086:

are integers, strings, or any other type for which the expression

478:

that expose the compiler behaviour and therefore naturally offers

103:

Modern C++ Design: Generic Programming and Design Patterns Applied

5948:

The resulting type-indexed value can be specialized to any type.

3453:

method allows operation on arrays, with elements of generic type

8702: 6561: 5955:

are types indexed over kinds, defined by giving a case for both

3114:.NET allows six varieties of generic type constraints using the 622:

are kept. This genericity mechanism should not be confused with

400: 8654: 7813: 6662:

Proceedings of the Conference on Proving and Improving Programs

474:

and new implementations for those words on the fly. It has few

8697: 7374:

Design Patterns: Elements of Reusable Object-Oriented Software

5595:

PolyP was the first generic programming language extension to

3636://Static variable - this will be incremented once per instance 3044: 2466:

is defined as any type that satisfies the checks performed by

890: 377:

as described in "Generic Programming – an Introduction". The

8650: 7415: 3496:

to compare two elements. (For value types like types such as

2462:

using trait-based generic programming. For example, an input

240:

Musser, David R.; Stepanov, Alexander A., Generic Programming

7359:

Evolving a language in and for the real world: C++ 1991-2006

7056:. Reading, Massachusetts: Addison-Wesley. pp. 346–348. 6865:

Evolving a language in and for the real world: C++ 1991-2006

710:// is defined in the standard library header <utility> 517:

and the syntax differs from other generic constructs. Some

2090:

is sensible, or more specifically, for any type for which

250:, analogously to the abstraction of algebraic theories in 71:

Generic programming was introduced to the mainstream with

5986:

As an example, the equality function in Generic Haskell:

3504:

conversion, although this can be worked around using the

2458:

Conventionally, D combines the above features to provide

2218:

container. To make a linked list of integers, one writes

1468:-- records a location in the text document we are editing 6639:. Springer Science & Business Media. pp. 9–10. 3696:// at the end of execution, CountedInstances.Counter = 2 2379:

breakpoint in every place the template is instantiated.

707:// A similar, but safer and potentially faster function 470:

can execute code while compiling and one can create new

7249:

https://www.ics.uci.edu/~jmoorkan/vhdlref/generics.html

5559:) being automatically defined for any type of the form 3508:

class, as is done in the standard collection classes.)

2407:

statement provide an alternative to respectively C++'s

2146:

at compile time. As a demonstration, the standard type

2127:

algorithms or to be put inside data structures such as

315:

Although this approach often uses language features of

222:

Stepanov–Musser and other generic programming paradigms

7115:

Object-Oriented Software Construction, second edition,

6564:, being derived from Ada, also has generic abilities. 521:

try to unify built-in and user defined generic types.

7207:

Constraints on Type Parameters (C# Programming Guide)

3669://increase counter by one during object instantiation 2293:#define max(a,b) ((a) < (b) ? (b) : (a)) 1669:-- Now, open the file Document_Name and read it in... 1089:-- a generic formal type; accepts any nonlimited type 56:

programming language in 1973, permits writing common

6913:

Backhouse, Roland; Jansson, Patrik; Jeuring, Johan;

5940:, and reuse one generic definition in another using 3003:. The generic constraint ensures that elements of a 1016:

is a package or a subprogram that takes one or more

9113: 9022: 8908: 8878: 8843: 8731: 8688: 8583: 8468: 8370: 8186: 8128: 8085: 7988: 7979: 7919: 7861: 7852: 7748:

Generic Haskell: a language for generic programming

7151:.NET/C# Generics History: Some Photos From Feb 1999 6581:#define cbrt(x) _Generic((x), long double: cbrtl, \ 6571: 5467:states that it is to be an instance of the classes 5454:, the types that can be compared for equality, and 2932:as they provide real class names to substitute for 2011:, making the equivalent of the following function: 1838:. Using template specialization, C++ Templates are 395:, above, from the lower-level programming language 7681:International Conference on Functional Programming 7371: 6676: 6636:Programming Languages: An Active Learning Approach 2277:function, were previously filled by function-like 2253:Unlike function templates, class templates can be 6969:"What is Generic Programming? (preprint LCSD'05)" 6857: 6855: 6736:Alexander Stepanov; Paul McJones (19 June 2009). 1995:The compiler examines the arguments used to call 351:Alexander Stepanov, An Interview with A. Stepanov 7141:, p. 126, §Item 28: Prefer lists to arrays. 2822:to describe creating and using generic classes. 2098:. A program defining a custom data type can use 7614:Free Pascal Reference guide Chapter 8: Generics 2447:), D uses an exclamation sign and parentheses: 2353: 2174:values. Likewise, other templates that rely on 361: 336: 321: 232: 6703: 6570:supports "type-generic expressions" using the 2995:can be specified. In the declaration of class 2967:Within the Eiffel type system, although class 2370:Templated classes or functions may require an 2195:can alleviate this issue. Languages which use 2154:operator, because there is no strict order on 2106:for that type, thus allowing its use with the 387:In this article we distinguish the high-level 227: 8666: 7825: 3035:, or "containers-of-type-T" was added to the 2792:// Paste the contents of htmlDCode as D code. 1800:in the Wikibook for details and consequences. 87:were introduced in the influential 1994 book 8: 7655:Libraries for Generic Programming in Haskell 7298:"Effective Java: Programming Language Guide" 7261:WG14 N1516 Committee Draft — October 4, 2010 2900:-- Add `new_item' at the end of the list 7232:. Blaine C. Readler, Full Arc Press, 2011. 6967:Dos Reis, Gabriel; Ja ̈rvi, Jaakko (2005). 6522:family support generic programming through 2115:allows a type to be used with the standard 925:. Unsourced material may be challenged and 407:Programming language support for genericity 401:Programming language support for genericity 48:when needed for specific types provided as 8673: 8659: 8651: 7985: 7858: 7832: 7818: 7810: 7661:Dæv Clarke, Johan Jeuring and Andres Löh, 7052:(1994). "15.5 Avoiding Code Replication". 2870:-- The item currently pointed to by cursor 1858:that creates functions that return either 7896:Programming in the large and in the small 7762:Generics in the Java Programming Language 7597:Delphi 2009 Generics and Type Constraints 7574:. An open source generics library for C#. 7550:Introducing Generics in the Microsoft CLR 7502:Collected Papers of Alexander A. Stepanov 7454:(1986). "Genericity versus inheritance". 7441: 6997: 6770: 6716:Musser, David R.; Stepanov, Alexander A. 5599:. In PolyP, generic functions are called 2768:// Transpile the HTML template to D code. 2298:Macros are expanded (copy pasted) by the 2238:A powerful feature of C++'s templates is 989:Learn how and when to remove this message 7161: 5916:Generic Haskell is another extension to 5555:) and a string representation function ( 2306:when the compiler deems it appropriate. 1693:generic formal parameters; for example: 1511:Using an instance of a generic package: 1051:The specification of a generic package: 653:// "&" denotes a reference 423:, and were subsequently adopted by many 332:Alexander Stepanov, Short History of STL 7527:David Vandevoorde, Nicolai M Josuttis, 6625: 2364:, The Design and Evolution of C++, 1994 851:// Output is "Hello, World!". 7641:Eiffel ISO/ECMA specification document 7111:Object-Oriented Software Construction, 5551:This results in an equality function ( 1999:and determines that this is a call to 1035:a generic unit, the programmer passes 7561:More on Generics in the Microsoft CLR 7138: 6920:Generic Programming – an Introduction 5570:The support for derived instances of 3043:, to maintain compatibility with old 1624:-- Initialise the stack of bookmarks: 7: 7769:Maurice Naftalin and Philip Wadler, 6507: 2814:Generic classes have been a part of 2273:Some uses of templates, such as the 923:adding citations to reliable sources 273:algorithms to operate on them, e.g. 113:Such software entities are known as 7408:Gabriel Dos Reis and Jaakko Järvi, 2162:will fail with a compile error, if 1445:Instantiating the generic package: 258:(STL), which developed a theory of 7322:(1989). "Generic programming". In 7300:(third ed.). Addison-Wesley. 5928:. The extensions it provides are: 5567:itself supports those operations. 226:Generic programming is defined in 96:New techniques were introduced by 52:. This approach, pioneered by the 14: 7529:C++ Templates: The Complete Guide 6633:Lee, Kent D. (15 December 2008). 6502:offers generic programming based 4776:// Free Pascal's ObjFPC style 3219:// Change array to { 2, 2, 2, 3 } 2838:has one formal generic parameter 2622:// can get the front of the range 2078:This works whether the arguments 8440:Partitioned global address space 7663:The Generic Haskell user's guide 7218:The Generic Haskell User's Guide 4606:Delphi and Free Pascal example: 3480:type. However, since arrays are 895: 519:extensible programming languages 7785:Java Precisely, Second Edition, 7621:Generics with Delphi 2009 Win32 7054:The Design and Evolution of C++ 6900:"An Interview with A. Stepanov" 6740:. Addison-Wesley Professional. 3082:Generics were added as part of 3059:to convert the elements to the 2834:. In the following code, class 2826:Basic, unconstrained genericity 2718:Compile-time function execution 2470:, which is defined as follows: 2222:. A list of strings is denoted 863:Java Platform, Standard Edition 7771:Java Generics and Collections, 7694:The Haskell 98 Language Report 5178:// example usage, ObjFPC style 4938:// example usage, Delphi style 2445:Template<param1, param2> 1: 8739:Arbitrary-precision or bignum 7800:, 2004 Sun Microsystems, Inc. 7590:Embarcadero Developer Network 7185:Generics in C#, Java, and C++ 6599:Concept (generic programming) 3492:s instead, and would require 3051:is converted to the raw type 3004: 3000: 2996: 2988: 2976: 2972: 2968: 2933: 2925: 2921: 2917: 2913: 2839: 2835: 2403:Template constraints and the 2142:C++ templates are completely 1731:-- can be any nonlimited type 1043:, for example inside a loop. 498:-like languages, which use a 16:Style of computer programming 7967:Uniform Function Call Syntax 7719:2003. (Also see the website 7434:Datatype-generic programming 7411:What is Generic Programming? 7281:(First ed.). O'Reilly. 7228:Verilog by Example, Section 3461:that implements the generic 2559:// can define a range object 2269:Advantages and disadvantages 2210:Another kind of template, a 2186:cannot be used as key for a 1870:could be defined like this: 528:In object-oriented languages 399:used to implement them (see 375:Datatype generic programming 228:Musser & Stepanov (1989) 110:implemented the same ideas. 8435:Parallel programming models 8409:Concurrent constraint logic 7798:Generic Programming in Java 7773:2006, O'Reilly Media, Inc. 7616:, Michaël Van Canneyt, 2007 7586:Delphi 2009 Reviewers Guide 3484:, the casting would not be 1783:the compiler can implement 636:containing objects of type 346:are central to Mathematics. 9234: 8528:Metalinguistic abstraction 8395:Automatic mutual exclusion 7623:, Sébastien DOERAENE, 2008 6704:Musser & Stepanov 1989 6503: 3465:interface. This ensures a 3024: 1819: 1713:-- must be a discrete type 18: 9080:Strongly typed identifier 8400:Choreographic programming 7729:Exploring Generic Haskell 7277:Albahari, Joseph (2022). 7113:Prentice Hall, 1988, and 4595:Genericity in Free Pascal 3037:Java programming language 2930:actual generic parameters 2832:formal generic parameters 2737:domain-specific languages 2460:compile-time polymorphism 2449:Template!(param1, param2) 2102:to define the meaning of 1828:Standard Template Library 1071:-- a generic formal value 1018:generic formal parameters 1007:standard template library 256:Standard Template Library 198:was originally coined by 8450:Relativistic programming 7721:devoted to this research 6609:Template metaprogramming 6578: 5988: 5624: 5477: 4608: 3883: 3693:// main code entry point 3513: 3120: 3009: 2938: 2843: 2741: 2635: 2598:// can invoke popFront() 2472: 2453:C++ parsing difficulties 2290: 2245:For example, consider a 2013: 1957: 1872: 1832:template metaprogramming 1695: 1513: 1447: 1053: 1025:generic formal parameter 650: 535: 513:usually built-in in the 309:computational complexity 37:are written in terms of 19:Not to be confused with 9155:Parametric polymorphism 7669:Generics for the Masses 7531:, 2003 Addison-Wesley. 7500:Alexander A. Stepanov, 7496:generic-programming.org 7336:10.1007/3-540-51084-2_2 6877:10.1145/1238844.1238848 6738:Elements of Programming 6524:parametric polymorphism 3913://for IComparer<> 3102:and normally expensive 3055:. The compiler inserts 3007:can in fact be sorted. 2920:are other class names. 2762:"example.htt" 2372:explicit specialization 2240:template specialization 2234:Template specialization 296:to process. Thus, only 172:parametric polymorphism 8460:Structured concurrency 7845:Comparison by language 7421:28 August 2019 at the 7296:Bloch, Joshua (2018). 7230:The Rest for Reference 7087:"Voldemort Types in D" 2983:Constrained genericity 2979:is considered a type. 2367: 2259:primary specialization 1866:whichever is larger. 1798:Generic formal objects 875:(formerly Chrome) and 625:inclusion polymorphism 500:structural type system 492:functional programming 371: 354: 335: 243: 8425:Multitier programming 8241:Interface description 7841:Programming paradigms 7658:. Utrecht University. 7630:, Felix COLIBRI, 2008 7579:Delphi, Object Pascal 7127:Eiffel: The Language, 6839:Stepanov, Alexander. 6781:10.1145/317500.317529 5438:Genericity in Haskell 5214:// required in ObjFPC 3579:// simple constructor 2728:serialization rules. 2583:// can test for empty 2255:partially specialized 2178:cannot be applied to 1684:Advantages and limits 938:"Generic programming" 431:languages, including 397:genericity mechanisms 389:programming paradigms 42:to-be-specified-later 7604:Delphi 2009 Generics 7458:. pp. 391–405. 7129:Prentice Hall, 1991. 7117:Prentice Hall, 1997. 6981:on 25 December 2005. 6898:Lo Russo, Graziano. 6862:Stroustrup, Bjarne. 6842:Short History of STL 6765:. pp. 216–225. 5578:makes their methods 5433:Functional languages 5328:TBGenericClassString 5295:TBGenericClassString 5247:TBGenericClassString 3870:Genericity in Delphi 3654://simple constructor 3463:IComparable<T> 2810:Genericity in Eiffel 2150:does not define the 2100:operator overloading 919:improve this section 169:. They are known as 31:computer programming 9216:Generic programming 9160:Primitive data type 9065:Recursive data type 8918:Algebraic data type 8794:Quadruple precision 8565:Self-modifying code 8173:Probabilistic logic 8104:Functional reactive 8059:Expression-oriented 8013:Partial application 7710:Proceedings of the 7673:Proceedings of the 7552:," September 2003, 7521:Templates Revisited 7464:10.1145/28697.28738 7384:1995dper.book.....G 7279:C# 10 in a Nutshell 7062:1994dec..book.....S 6939:Peyton Jones, Simon 6719:Generic Programming 5974:Generic abstraction 5968:generic application 5933:Type-indexed values 5618:must have the form 3895:{$ APPTYPE CONSOLE} 3067:Genericity in .NET 2910:generic derivations 883:since version 2.0. 791:"Hello, " 393:generic programming 265:For example, given 196:generic programming 98:Andrei Alexandrescu 85:parameterized types 27:Generic programming 21:Genetic programming 9123:Abstract data type 8804:Extended precision 8763:Reduced precision 8478:Attribute-oriented 8251:List comprehension 8196:Algebraic modeling 8009:Anonymous function 7901:Design by contract 7871:Jackson structures 7805:Java Generics FAQs 7735:Utrecht University 7706:Simon Peyton Jones 7689:Simon Peyton Jones 7619:Delphi for Win32: 7378:. Addison-Wesley. 7354:Stroustrup, Bjarne 7050:Stroustrup, Bjarne 6683:. Addison-Wesley. 6604:Partial evaluation 5980:Type-indexed types 5953:Kind-indexed types 5922:Utrecht University 5460:derived instances. 3516:// A generic class 3104:boxing conversions 3084:.NET Framework 2.0 3049:List<String> 2993:generic constraint 2451:. This avoids the 2263:fully specialized, 2224:list<string> 2137:associative arrays 1846:Technical overview 770:"World!" 562:// Class contents. 494:, specifically in 210:and formalized as 204:Alexander Stepanov 9203: 9202: 8935:Associative array 8799:Octuple precision 8648: 8647: 8538:Program synthesis 8430:Organic computing 8366: 8365: 8271:Non-English-based 8246:Language-oriented 8024:Purely functional 7975: 7974: 7803:Angelika Langer, 7733:PhD thesis, 2004 7626:Delphi for .NET: 7588:," October 2008, 7570:M. Aamir Maniar, 7563:," October 2003, 7345:978-3-540-51084-0 7288:978-1-098-12195-2 7238:978-0-9834973-0-1 7071:978-81-317-1608-3 6915:Meertens, Lambert 6747:978-0-321-63537-2 6646:978-0-387-79422-8 6614:Type polymorphism 6518:Languages in the 5938:constructor cases 5310:TAGenericClassInt 5283:TAGenericClassInt 5220:TAGenericClassInt 3506:Comparer<T> 3261:// Print results. 2879:-- Element change 2435:expression allow 2362:Bjarne Stroustrup 2284:(a legacy of the 1852:function template 999: 998: 991: 973: 877:Visual Basic .NET 472:compiler keywords 357:Bjarne Stroustrup 216:generic functions 167:Visual Basic .NET 100:in his 2001 book 9223: 9175:Type constructor 9060:Opaque data type 8992:Record or Struct 8789:Double precision 8784:Single precision 8675: 8668: 8661: 8652: 8550:by demonstration 8455:Service-oriented 8445:Process-oriented 8420:Macroprogramming 8405:Concurrent logic 8276:Page description 8266:Natural language 8236:Grammar-oriented 8163:Nondeterministic 8152:Constraint logic 8054:Point-free style 8049:Functional logic 7986: 7957:Immutable object 7876:Block-structured 7859: 7834: 7827: 7820: 7811: 7787:2005 MIT Press. 7504:(creator of the 7485: 7447: 7445: 7397: 7377: 7366: 7365:. ACM HOPL 2007. 7364: 7349: 7311: 7292: 7263: 7258: 7252: 7246: 7240: 7226: 7220: 7215: 7209: 7204: 7198: 7193: 7187: 7182: 7176: 7171: 7165: 7159: 7153: 7148: 7142: 7136: 7130: 7124: 7118: 7108: 7102: 7101: 7099: 7097: 7085:Bright, Walter. 7082: 7076: 7075: 7046: 7040: 7035: 7029: 7028: 7026: 7024: 7010: 7004: 7003: 7001: 6989: 6983: 6982: 6980: 6974:. Archived from 6973: 6964: 6958: 6957: 6955: 6953: 6947: 6941:(January 2003). 6934: 6928: 6927: 6925: 6910: 6904: 6903: 6895: 6889: 6888: 6870: 6859: 6850: 6849: 6847: 6836: 6830: 6827: 6821: 6818: 6812: 6809: 6803: 6802: 6774: 6758: 6752: 6751: 6733: 6727: 6726: 6724: 6713: 6707: 6701: 6695: 6694: 6682: 6672: 6666: 6665: 6657: 6651: 6650: 6630: 6588: 6587:float: cbrtf)(x) 6585: 6584:default: cbrt, \ 6582: 6575: 6574: 6490: 6487: 6484: 6481: 6478: 6475: 6472: 6469: 6466: 6463: 6460: 6457: 6454: 6451: 6448: 6445: 6442: 6439: 6436: 6433: 6430: 6427: 6424: 6421: 6418: 6415: 6412: 6409: 6406: 6403: 6400: 6397: 6394: 6391: 6388: 6385: 6382: 6379: 6376: 6373: 6370: 6367: 6364: 6361: 6358: 6355: 6352: 6349: 6346: 6343: 6340: 6337: 6334: 6331: 6328: 6325: 6322: 6319: 6316: 6313: 6310: 6307: 6304: 6301: 6298: 6295: 6292: 6289: 6286: 6283: 6280: 6277: 6274: 6271: 6268: 6265: 6262: 6259: 6256: 6253: 6250: 6247: 6244: 6241: 6238: 6235: 6232: 6229: 6226: 6223: 6220: 6217: 6214: 6211: 6208: 6205: 6202: 6199: 6196: 6193: 6190: 6187: 6184: 6181: 6178: 6175: 6172: 6169: 6166: 6163: 6160: 6157: 6154: 6151: 6148: 6145: 6142: 6139: 6136: 6133: 6130: 6127: 6124: 6121: 6118: 6115: 6112: 6109: 6106: 6103: 6100: 6097: 6094: 6091: 6088: 6085: 6082: 6079: 6076: 6073: 6070: 6067: 6064: 6061: 6058: 6055: 6052: 6049: 6046: 6043: 6040: 6037: 6034: 6031: 6028: 6025: 6022: 6019: 6016: 6013: 6010: 6007: 6004: 6001: 5998: 5995: 5992: 5907: 5904: 5901: 5898: 5895: 5892: 5889: 5886: 5883: 5880: 5877: 5874: 5871: 5868: 5865: 5862: 5859: 5856: 5853: 5850: 5847: 5844: 5841: 5838: 5835: 5832: 5829: 5826: 5823: 5820: 5817: 5814: 5811: 5808: 5805: 5802: 5799: 5796: 5793: 5790: 5787: 5784: 5781: 5778: 5775: 5772: 5769: 5766: 5763: 5760: 5757: 5754: 5751: 5748: 5745: 5742: 5739: 5736: 5733: 5730: 5727: 5724: 5721: 5718: 5715: 5712: 5709: 5706: 5703: 5700: 5697: 5694: 5691: 5688: 5685: 5682: 5679: 5676: 5673: 5670: 5667: 5664: 5661: 5658: 5655: 5652: 5649: 5646: 5643: 5640: 5637: 5634: 5631: 5628: 5585: 5581: 5577: 5573: 5566: 5562: 5558: 5554: 5547: 5544: 5541: 5538: 5535: 5532: 5529: 5526: 5523: 5520: 5517: 5514: 5511: 5508: 5505: 5502: 5499: 5496: 5493: 5490: 5487: 5484: 5481: 5474: 5470: 5457: 5453: 5428: 5425: 5422: 5419: 5416: 5413: 5410: 5407: 5404: 5401: 5398: 5395: 5392: 5389: 5386: 5383: 5380: 5377: 5374: 5371: 5368: 5365: 5362: 5359: 5356: 5353: 5350: 5347: 5344: 5341: 5338: 5335: 5332: 5329: 5326: 5323: 5320: 5317: 5314: 5311: 5308: 5305: 5302: 5299: 5296: 5293: 5290: 5287: 5284: 5281: 5278: 5275: 5272: 5269: 5266: 5263: 5260: 5257: 5254: 5251: 5248: 5245: 5242: 5239: 5236: 5233: 5230: 5227: 5224: 5221: 5218: 5215: 5212: 5209: 5206: 5203: 5200: 5197: 5194: 5191: 5188: 5185: 5182: 5179: 5176: 5173: 5170: 5167: 5164: 5161: 5158: 5155: 5152: 5149: 5146: 5143: 5140: 5137: 5134: 5131: 5128: 5125: 5122: 5119: 5116: 5113: 5110: 5107: 5104: 5101: 5098: 5095: 5092: 5089: 5086: 5083: 5080: 5077: 5074: 5071: 5068: 5065: 5062: 5059: 5056: 5053: 5050: 5047: 5044: 5041: 5038: 5035: 5032: 5029: 5026: 5023: 5020: 5017: 5014: 5011: 5008: 5005: 5002: 4999: 4996: 4993: 4990: 4987: 4984: 4981: 4978: 4975: 4972: 4969: 4966: 4963: 4960: 4957: 4954: 4951: 4948: 4945: 4942: 4939: 4936: 4933: 4930: 4927: 4924: 4921: 4918: 4915: 4912: 4909: 4906: 4903: 4900: 4897: 4894: 4891: 4888: 4885: 4882: 4879: 4876: 4873: 4870: 4867: 4864: 4861: 4858: 4855: 4852: 4849: 4846: 4843: 4840: 4837: 4834: 4831: 4828: 4825: 4822: 4819: 4816: 4813: 4810: 4807: 4804: 4801: 4798: 4795: 4792: 4789: 4786: 4783: 4780: 4777: 4774: 4771: 4768: 4765: 4762: 4759: 4756: 4753: 4750: 4747: 4744: 4741: 4738: 4735: 4732: 4729: 4726: 4723: 4720: 4717: 4714: 4711: 4708: 4705: 4702: 4699: 4696: 4693: 4690: 4687: 4684: 4681: 4678: 4675: 4672: 4669: 4666: 4663: 4660: 4657: 4654: 4651: 4648: 4645: 4642: 4639: 4636: 4633: 4630: 4627: 4624: 4621: 4618: 4615: 4612: 4586: 4583: 4580: 4577: 4574: 4571: 4568: 4565: 4562: 4559: 4556: 4553: 4550: 4547: 4544: 4541: 4538: 4535: 4532: 4529: 4526: 4523: 4520: 4517: 4514: 4511: 4508: 4505: 4502: 4499: 4496: 4493: 4490: 4487: 4484: 4481: 4478: 4475: 4472: 4469: 4466: 4463: 4460: 4457: 4454: 4451: 4448: 4445: 4442: 4439: 4436: 4433: 4430: 4427: 4424: 4421: 4418: 4415: 4412: 4409: 4406: 4403: 4400: 4397: 4394: 4391: 4388: 4385: 4382: 4379: 4376: 4373: 4370: 4367: 4364: 4361: 4358: 4355: 4352: 4349: 4346: 4343: 4340: 4337: 4334: 4331: 4328: 4325: 4322: 4319: 4316: 4313: 4310: 4307: 4304: 4301: 4298: 4295: 4292: 4289: 4286: 4283: 4280: 4277: 4274: 4271: 4268: 4265: 4262: 4259: 4256: 4253: 4250: 4247: 4244: 4241: 4238: 4235: 4232: 4229: 4226: 4223: 4220: 4217: 4214: 4211: 4208: 4205: 4202: 4199: 4196: 4193: 4190: 4187: 4184: 4181: 4178: 4175: 4172: 4169: 4166: 4163: 4160: 4157: 4154: 4151: 4148: 4145: 4142: 4139: 4136: 4133: 4130: 4127: 4124: 4121: 4118: 4115: 4112: 4109: 4106: 4103: 4100: 4097: 4094: 4091: 4088: 4085: 4082: 4079: 4076: 4073: 4070: 4067: 4064: 4061: 4058: 4055: 4052: 4049: 4046: 4043: 4040: 4037: 4034: 4031: 4028: 4025: 4022: 4019: 4016: 4013: 4010: 4007: 4004: 4001: 3998: 3995: 3992: 3989: 3986: 3983: 3980: 3977: 3974: 3971: 3968: 3965: 3962: 3959: 3956: 3953: 3950: 3947: 3944: 3941: 3938: 3935: 3932: 3929: 3926: 3923: 3920: 3917: 3914: 3911: 3908: 3905: 3902: 3899: 3896: 3893: 3890: 3887: 3865: 3862: 3859: 3856: 3853: 3850: 3847: 3844: 3841: 3838: 3835: 3832: 3829: 3826: 3823: 3820: 3817: 3814: 3811: 3808: 3805: 3802: 3799: 3796: 3793: 3790: 3787: 3784: 3781: 3778: 3775: 3772: 3769: 3766: 3763: 3760: 3757: 3754: 3751: 3748: 3745: 3742: 3739: 3736: 3733: 3730: 3727: 3724: 3721: 3718: 3715: 3712: 3709: 3706: 3703: 3700: 3697: 3694: 3691: 3688: 3685: 3682: 3679: 3676: 3673: 3672:CountedInstances 3670: 3667: 3664: 3661: 3660:CountedInstances 3658: 3655: 3652: 3649: 3646: 3643: 3640: 3637: 3634: 3631: 3630:CountedInstances 3628: 3625: 3622: 3619: 3616: 3613: 3610: 3607: 3604: 3601: 3598: 3595: 3592: 3589: 3586: 3583: 3580: 3577: 3574: 3571: 3568: 3565: 3564:// a data member 3562: 3559: 3558:CountedInstances 3556: 3553: 3550: 3547: 3546:CountedInstances 3544: 3541: 3538: 3535: 3532: 3529: 3526: 3523: 3520: 3517: 3507: 3500:this requires a 3499: 3491: 3479: 3472: 3464: 3460: 3456: 3452: 3445: 3442: 3439: 3436: 3433: 3430: 3427: 3424: 3421: 3418: 3415: 3412: 3409: 3406: 3403: 3400: 3397: 3394: 3391: 3388: 3385: 3382: 3379: 3376: 3373: 3370: 3367: 3364: 3361: 3358: 3355: 3352: 3349: 3346: 3343: 3340: 3337: 3334: 3331: 3328: 3325: 3322: 3319: 3316: 3313: 3310: 3307: 3304: 3301: 3298: 3295: 3292: 3289: 3286: 3283: 3280: 3277: 3274: 3271: 3268: 3265: 3262: 3259: 3256: 3253: 3250: 3247: 3244: 3241: 3238: 3235: 3232: 3229: 3226: 3223: 3220: 3217: 3214: 3211: 3208: 3205: 3202: 3199: 3196: 3193: 3190: 3187: 3184: 3181: 3178: 3175: 3172: 3169: 3166: 3163: 3160: 3157: 3154: 3151: 3148: 3145: 3142: 3139: 3136: 3133: 3130: 3127: 3124: 3117: 3079: 3078: 3074: 3062: 3054: 3050: 3031:Support for the 3027:Generics in Java 3021:Generics in Java 3016: 3013: 3006: 3002: 2998: 2990: 2978: 2974: 2970: 2963: 2960: 2957: 2954: 2953:list_of_deposits 2951: 2948: 2945: 2942: 2941:list_of_accounts 2935: 2927: 2923: 2919: 2915: 2904: 2901: 2898: 2895: 2892: 2889: 2886: 2883: 2880: 2877: 2874: 2871: 2868: 2865: 2862: 2859: 2856: 2853: 2850: 2847: 2841: 2837: 2805: 2802: 2799: 2796: 2793: 2790: 2787: 2784: 2781: 2778: 2775: 2772: 2769: 2766: 2763: 2760: 2757: 2754: 2751: 2748: 2745: 2734: 2703: 2687: 2684: 2681: 2678: 2675: 2672: 2669: 2666: 2663: 2660: 2657: 2654: 2651: 2648: 2645: 2642: 2639: 2629: 2626: 2623: 2620: 2617: 2614: 2611: 2608: 2605: 2602: 2599: 2596: 2593: 2590: 2587: 2584: 2581: 2578: 2575: 2572: 2569: 2566: 2563: 2560: 2557: 2554: 2551: 2548: 2545: 2542: 2539: 2536: 2533: 2530: 2527: 2524: 2521: 2518: 2515: 2512: 2509: 2506: 2503: 2500: 2497: 2494: 2491: 2488: 2485: 2482: 2479: 2476: 2469: 2450: 2446: 2434: 2429:keyword and the 2428: 2421: 2414: 2406: 2365: 2304:inline functions 2294: 2276: 2248: 2229: 2225: 2221: 2207:values as keys. 2206: 2202: 2198: 2189: 2185: 2181: 2177: 2173: 2161: 2153: 2149: 2130: 2126: 2122: 2118: 2114: 2109: 2105: 2093: 2089: 2085: 2081: 2074: 2071: 2068: 2065: 2062: 2059: 2056: 2053: 2050: 2047: 2044: 2041: 2038: 2035: 2032: 2029: 2026: 2023: 2020: 2017: 2010: 2006: 2002: 1998: 1991: 1988: 1985: 1982: 1979: 1976: 1973: 1970: 1967: 1964: 1961: 1948: 1945: 1942: 1939: 1936: 1933: 1930: 1927: 1924: 1921: 1918: 1915: 1912: 1909: 1906: 1903: 1900: 1897: 1894: 1891: 1888: 1885: 1882: 1879: 1876: 1869: 1857: 1816:Templates in C++ 1765: 1762: 1759: 1756: 1753: 1750: 1747: 1744: 1741: 1738: 1735: 1732: 1729: 1726: 1723: 1720: 1717: 1714: 1711: 1708: 1705: 1702: 1699: 1679: 1676: 1673: 1670: 1667: 1664: 1661: 1658: 1655: 1652: 1649: 1646: 1643: 1640: 1637: 1634: 1631: 1628: 1625: 1622: 1619: 1616: 1613: 1610: 1607: 1604: 1601: 1598: 1595: 1592: 1589: 1586: 1583: 1580: 1577: 1574: 1571: 1568: 1565: 1562: 1559: 1556: 1553: 1552:Unbounded_String 1550: 1547: 1544: 1541: 1538: 1535: 1532: 1529: 1526: 1523: 1520: 1517: 1507: 1504: 1500: 1497: 1494: 1490: 1487: 1484: 1481: 1478: 1475: 1472: 1469: 1466: 1463: 1460: 1457: 1454: 1451: 1441: 1438: 1435: 1432: 1429: 1426: 1423: 1420: 1417: 1414: 1411: 1408: 1405: 1402: 1399: 1396: 1393: 1390: 1387: 1384: 1381: 1378: 1375: 1372: 1369: 1366: 1363: 1360: 1357: 1354: 1351: 1348: 1345: 1342: 1339: 1336: 1333: 1330: 1327: 1324: 1321: 1318: 1315: 1312: 1309: 1306: 1303: 1300: 1297: 1294: 1291: 1288: 1285: 1282: 1279: 1276: 1273: 1270: 1267: 1264: 1261: 1258: 1255: 1252: 1249: 1246: 1243: 1240: 1237: 1234: 1231: 1228: 1225: 1222: 1219: 1216: 1213: 1210: 1207: 1204: 1201: 1198: 1195: 1192: 1189: 1186: 1183: 1180: 1177: 1174: 1171: 1168: 1165: 1162: 1159: 1156: 1153: 1150: 1147: 1144: 1141: 1138: 1135: 1132: 1129: 1126: 1123: 1120: 1117: 1114: 1111: 1108: 1105: 1102: 1099: 1096: 1093: 1090: 1087: 1084: 1081: 1078: 1075: 1072: 1069: 1066: 1063: 1060: 1057: 994: 987: 983: 980: 974: 972: 931: 899: 891: 859: 852: 849: 846: 843: 840: 837: 834: 831: 828: 825: 822: 819: 816: 813: 810: 807: 804: 801: 798: 795: 792: 789: 786: 783: 780: 777: 774: 771: 768: 765: 762: 759: 756: 753: 750: 747: 744: 741: 738: 735: 732: 729: 726: 723: 720: 717: 714: 711: 708: 705: 702: 699: 696: 693: 690: 687: 684: 681: 678: 675: 672: 669: 666: 663: 660: 657: 654: 647: 643: 639: 635: 609: 602: 599: 596: 593: 590: 587: 584: 581: 578: 575: 572: 569: 566: 563: 560: 557: 554: 551: 548: 545: 542: 539: 369: 352: 333: 305: 290: 280: 276: 252:abstract algebra 241: 106:. Subsequently, 9233: 9232: 9226: 9225: 9224: 9222: 9221: 9220: 9206: 9205: 9204: 9199: 9180:Type conversion 9115: 9109: 9045:Enumerated type 9018: 8904: 8898:null-terminated 8874: 8839: 8727: 8684: 8679: 8649: 8644: 8586: 8579: 8470:Metaprogramming 8464: 8380: 8375: 8362: 8344:Graph rewriting 8182: 8158:Inductive logic 8138:Abductive logic 8124: 8081: 8044:Dependent types 7992: 7971: 7943:Prototype-based 7923: 7921:Object-oriented 7915: 7911:Nested function 7906:Invariant-based 7848: 7838: 7783:Peter Sestoft, 7628:Delphi Generics 7599:," October 2008 7595:Craig Stuntz, " 7518:Walter Bright, 7492: 7474: 7452:Meyer, Bertrand 7450: 7443:10.1.1.159.1228 7430:Gibbons, Jeremy 7428: 7423:Wayback Machine 7405: 7403:Further reading 7400: 7394: 7369: 7362: 7352: 7346: 7320:Stepanov, A. A. 7314: 7308: 7295: 7289: 7276: 7272: 7267: 7266: 7259: 7255: 7247: 7243: 7227: 7223: 7216: 7212: 7205: 7201: 7194: 7190: 7183: 7179: 7172: 7168: 7160: 7156: 7149: 7145: 7137: 7133: 7125: 7121: 7109: 7105: 7095: 7093: 7084: 7083: 7079: 7072: 7048: 7047: 7043: 7036: 7032: 7022: 7020: 7014:"Generic Units" 7012: 7011: 7007: 6991: 6990: 6986: 6978: 6971: 6966: 6965: 6961: 6951: 6949: 6945: 6936: 6935: 6931: 6923: 6912: 6911: 6907: 6897: 6896: 6892: 6868: 6861: 6860: 6853: 6845: 6838: 6837: 6833: 6828: 6824: 6819: 6815: 6810: 6806: 6791: 6772:10.1.1.588.7431 6760: 6759: 6755: 6748: 6735: 6734: 6730: 6722: 6715: 6714: 6710: 6702: 6698: 6691: 6679:Design Patterns 6674: 6673: 6669: 6659: 6658: 6654: 6647: 6632: 6631: 6627: 6622: 6595: 6590: 6589: 6586: 6583: 6580: 6572: 6516: 6514:Other languages 6508:Generic Haskell 6497: 6492: 6491: 6488: 6485: 6482: 6479: 6476: 6473: 6470: 6467: 6464: 6461: 6458: 6455: 6452: 6449: 6446: 6443: 6440: 6437: 6434: 6431: 6428: 6425: 6422: 6419: 6416: 6413: 6410: 6407: 6404: 6401: 6398: 6395: 6392: 6389: 6386: 6383: 6380: 6377: 6374: 6371: 6368: 6365: 6362: 6359: 6356: 6353: 6350: 6347: 6344: 6341: 6338: 6335: 6332: 6329: 6326: 6323: 6320: 6317: 6314: 6311: 6308: 6305: 6302: 6299: 6296: 6293: 6290: 6287: 6284: 6281: 6278: 6275: 6272: 6269: 6266: 6263: 6260: 6257: 6254: 6251: 6248: 6245: 6242: 6239: 6236: 6233: 6230: 6227: 6224: 6221: 6218: 6215: 6212: 6209: 6206: 6203: 6200: 6197: 6194: 6191: 6188: 6185: 6182: 6179: 6176: 6173: 6170: 6167: 6164: 6161: 6158: 6155: 6152: 6149: 6146: 6143: 6140: 6137: 6134: 6131: 6128: 6125: 6122: 6119: 6116: 6113: 6110: 6107: 6104: 6101: 6098: 6095: 6092: 6089: 6086: 6083: 6080: 6077: 6074: 6071: 6068: 6065: 6062: 6059: 6056: 6053: 6050: 6047: 6044: 6041: 6038: 6035: 6032: 6029: 6026: 6023: 6020: 6017: 6014: 6011: 6008: 6005: 6002: 5999: 5996: 5993: 5990: 5920:, developed at 5914: 5912:Generic Haskell 5909: 5908: 5905: 5902: 5899: 5896: 5893: 5890: 5887: 5884: 5881: 5878: 5875: 5872: 5869: 5866: 5863: 5860: 5857: 5854: 5851: 5848: 5845: 5842: 5839: 5836: 5833: 5830: 5827: 5824: 5821: 5818: 5815: 5812: 5809: 5806: 5803: 5800: 5797: 5794: 5791: 5788: 5785: 5782: 5779: 5776: 5773: 5770: 5767: 5764: 5761: 5758: 5755: 5752: 5749: 5746: 5743: 5740: 5737: 5734: 5731: 5728: 5725: 5722: 5719: 5716: 5713: 5710: 5707: 5704: 5701: 5698: 5695: 5692: 5689: 5686: 5683: 5680: 5677: 5674: 5671: 5668: 5665: 5662: 5659: 5656: 5653: 5650: 5647: 5644: 5641: 5638: 5635: 5632: 5629: 5626: 5593: 5583: 5579: 5575: 5571: 5564: 5560: 5556: 5552: 5549: 5548: 5545: 5542: 5539: 5536: 5533: 5530: 5527: 5524: 5521: 5518: 5515: 5512: 5509: 5506: 5503: 5500: 5497: 5494: 5491: 5488: 5485: 5482: 5479: 5472: 5468: 5455: 5451: 5440: 5435: 5430: 5429: 5426: 5423: 5420: 5417: 5414: 5411: 5408: 5405: 5402: 5399: 5396: 5393: 5390: 5388:'hello' 5387: 5384: 5381: 5378: 5375: 5372: 5369: 5366: 5363: 5360: 5357: 5354: 5351: 5348: 5345: 5342: 5339: 5336: 5333: 5330: 5327: 5324: 5321: 5318: 5315: 5312: 5309: 5306: 5303: 5300: 5297: 5294: 5291: 5288: 5285: 5282: 5279: 5276: 5273: 5270: 5267: 5264: 5261: 5258: 5255: 5252: 5249: 5246: 5243: 5240: 5237: 5234: 5231: 5228: 5225: 5222: 5219: 5216: 5213: 5210: 5207: 5204: 5201: 5198: 5195: 5193:{$ mode objfpc} 5192: 5189: 5186: 5183: 5180: 5177: 5174: 5171: 5168: 5165: 5162: 5159: 5156: 5153: 5150: 5147: 5144: 5141: 5138: 5136:'hello' 5135: 5132: 5129: 5126: 5123: 5120: 5117: 5114: 5111: 5108: 5105: 5102: 5099: 5096: 5093: 5090: 5087: 5084: 5081: 5078: 5075: 5072: 5069: 5066: 5063: 5060: 5057: 5054: 5051: 5048: 5045: 5042: 5039: 5036: 5033: 5030: 5027: 5024: 5021: 5018: 5015: 5012: 5009: 5006: 5003: 5000: 4997: 4994: 4991: 4988: 4985: 4982: 4979: 4976: 4973: 4970: 4967: 4964: 4961: 4958: 4955: 4953:{$ mode delphi} 4952: 4949: 4946: 4943: 4940: 4937: 4934: 4931: 4928: 4925: 4922: 4919: 4916: 4913: 4910: 4907: 4904: 4901: 4898: 4895: 4892: 4889: 4886: 4883: 4880: 4877: 4874: 4871: 4868: 4865: 4862: 4859: 4856: 4853: 4850: 4847: 4844: 4841: 4838: 4835: 4832: 4829: 4826: 4823: 4820: 4817: 4814: 4811: 4808: 4805: 4802: 4799: 4796: 4793: 4791:{$ mode objfpc} 4790: 4787: 4784: 4781: 4778: 4775: 4772: 4769: 4766: 4763: 4760: 4757: 4754: 4751: 4748: 4745: 4742: 4739: 4736: 4733: 4730: 4727: 4724: 4721: 4718: 4715: 4712: 4709: 4706: 4703: 4700: 4697: 4694: 4691: 4688: 4685: 4682: 4679: 4676: 4673: 4670: 4667: 4664: 4661: 4658: 4655: 4652: 4649: 4646: 4643: 4640: 4637: 4634: 4631: 4628: 4626:{$ mode delphi} 4625: 4622: 4619: 4616: 4613: 4611:// Delphi style 4610: 4597: 4588: 4587: 4584: 4581: 4578: 4575: 4572: 4569: 4566: 4563: 4560: 4557: 4554: 4551: 4548: 4545: 4542: 4539: 4536: 4533: 4530: 4527: 4524: 4521: 4518: 4515: 4512: 4509: 4506: 4503: 4500: 4497: 4494: 4491: 4488: 4485: 4482: 4479: 4476: 4473: 4470: 4467: 4464: 4461: 4458: 4455: 4452: 4449: 4446: 4443: 4440: 4437: 4434: 4431: 4428: 4425: 4422: 4419: 4416: 4413: 4410: 4407: 4404: 4401: 4398: 4395: 4392: 4389: 4386: 4383: 4380: 4377: 4374: 4371: 4368: 4365: 4362: 4359: 4356: 4353: 4350: 4347: 4344: 4341: 4338: 4335: 4332: 4329: 4326: 4323: 4320: 4317: 4314: 4311: 4308: 4305: 4302: 4299: 4296: 4293: 4290: 4287: 4284: 4281: 4278: 4275: 4272: 4269: 4266: 4263: 4260: 4257: 4254: 4251: 4248: 4245: 4242: 4239: 4236: 4233: 4230: 4227: 4224: 4221: 4218: 4215: 4212: 4209: 4206: 4203: 4200: 4197: 4194: 4191: 4188: 4185: 4182: 4179: 4176: 4173: 4170: 4167: 4164: 4161: 4158: 4155: 4152: 4149: 4146: 4143: 4140: 4137: 4134: 4131: 4128: 4125: 4122: 4119: 4116: 4113: 4110: 4107: 4104: 4101: 4098: 4095: 4092: 4089: 4086: 4083: 4080: 4077: 4074: 4071: 4068: 4065: 4062: 4059: 4056: 4053: 4050: 4047: 4044: 4041: 4038: 4035: 4032: 4029: 4026: 4023: 4020: 4017: 4014: 4011: 4008: 4005: 4002: 3999: 3996: 3993: 3990: 3987: 3984: 3981: 3978: 3975: 3972: 3969: 3966: 3963: 3960: 3957: 3954: 3951: 3948: 3945: 3942: 3939: 3936: 3933: 3930: 3927: 3924: 3921: 3918: 3915: 3912: 3909: 3906: 3903: 3900: 3897: 3894: 3891: 3888: 3885: 3872: 3867: 3866: 3863: 3860: 3857: 3854: 3851: 3848: 3845: 3842: 3839: 3836: 3833: 3830: 3827: 3824: 3821: 3818: 3815: 3812: 3809: 3806: 3803: 3800: 3797: 3794: 3791: 3788: 3785: 3782: 3779: 3776: 3773: 3770: 3767: 3764: 3761: 3758: 3755: 3752: 3749: 3746: 3743: 3740: 3737: 3734: 3731: 3728: 3725: 3722: 3719: 3716: 3713: 3710: 3707: 3704: 3701: 3698: 3695: 3692: 3689: 3686: 3683: 3680: 3677: 3674: 3671: 3668: 3665: 3662: 3659: 3656: 3653: 3650: 3647: 3644: 3641: 3638: 3635: 3632: 3629: 3626: 3623: 3620: 3617: 3614: 3611: 3608: 3605: 3602: 3599: 3596: 3593: 3590: 3587: 3584: 3581: 3578: 3575: 3572: 3569: 3566: 3563: 3560: 3557: 3554: 3551: 3548: 3545: 3542: 3539: 3536: 3533: 3530: 3527: 3524: 3521: 3518: 3515: 3505: 3497: 3489: 3477: 3470: 3462: 3458: 3454: 3450: 3447: 3446: 3443: 3440: 3437: 3434: 3431: 3428: 3425: 3422: 3419: 3416: 3413: 3410: 3407: 3404: 3401: 3398: 3395: 3392: 3389: 3386: 3383: 3380: 3377: 3374: 3371: 3368: 3365: 3362: 3359: 3356: 3353: 3350: 3347: 3344: 3341: 3338: 3335: 3332: 3329: 3326: 3323: 3320: 3317: 3314: 3311: 3308: 3305: 3302: 3299: 3296: 3293: 3290: 3287: 3284: 3281: 3278: 3275: 3272: 3269: 3266: 3263: 3260: 3257: 3254: 3251: 3248: 3245: 3242: 3239: 3236: 3233: 3230: 3227: 3224: 3221: 3218: 3215: 3212: 3209: 3206: 3203: 3200: 3197: 3194: 3191: 3188: 3185: 3182: 3179: 3176: 3173: 3170: 3167: 3164: 3161: 3158: 3155: 3152: 3149: 3146: 3143: 3140: 3137: 3134: 3131: 3128: 3125: 3122: 3115: 3080: 3076: 3072: 3070: 3069: 3060: 3052: 3048: 3029: 3023: 3018: 3017: 3014: 3011: 2985: 2965: 2964: 2962:-- Deposit list 2961: 2958: 2955: 2952: 2950:-- Account list 2949: 2946: 2943: 2940: 2936:in actual use. 2928:are considered 2906: 2905: 2902: 2899: 2896: 2893: 2890: 2887: 2884: 2881: 2878: 2875: 2872: 2869: 2866: 2863: 2860: 2857: 2854: 2851: 2848: 2845: 2828: 2812: 2807: 2806: 2803: 2800: 2797: 2794: 2791: 2788: 2785: 2782: 2780:htmlTemplateToD 2779: 2776: 2773: 2770: 2767: 2764: 2761: 2758: 2755: 2752: 2749: 2746: 2743: 2732: 2701: 2694: 2692:Code generation 2689: 2688: 2685: 2682: 2679: 2676: 2673: 2670: 2667: 2664: 2661: 2658: 2655: 2652: 2649: 2646: 2643: 2640: 2637: 2631: 2630: 2627: 2624: 2621: 2618: 2615: 2612: 2609: 2606: 2603: 2600: 2597: 2594: 2591: 2588: 2585: 2582: 2579: 2576: 2573: 2570: 2567: 2564: 2561: 2558: 2555: 2552: 2549: 2546: 2543: 2540: 2537: 2534: 2531: 2528: 2525: 2522: 2519: 2516: 2513: 2510: 2507: 2504: 2501: 2498: 2495: 2492: 2489: 2486: 2483: 2480: 2477: 2474: 2467: 2448: 2444: 2430: 2426: 2419: 2412: 2404: 2400:instantiations. 2389: 2366: 2360: 2296: 2295: 2292: 2274: 2271: 2246: 2236: 2227: 2223: 2220:list<int> 2219: 2212:class template, 2204: 2200: 2196: 2193:method protocol 2187: 2183: 2179: 2175: 2171: 2159: 2156:complex numbers 2151: 2147: 2128: 2125:binary_search() 2124: 2120: 2116: 2112: 2107: 2103: 2091: 2087: 2083: 2079: 2076: 2075: 2072: 2069: 2066: 2063: 2060: 2057: 2054: 2051: 2048: 2045: 2042: 2039: 2036: 2033: 2030: 2027: 2024: 2021: 2018: 2015: 2008: 2004: 2000: 1996: 1993: 1992: 1989: 1986: 1983: 1980: 1977: 1974: 1971: 1968: 1965: 1962: 1959: 1953:Specializations 1950: 1949: 1946: 1943: 1940: 1937: 1934: 1931: 1928: 1925: 1922: 1919: 1916: 1913: 1910: 1907: 1904: 1901: 1898: 1895: 1892: 1889: 1886: 1883: 1880: 1877: 1874: 1867: 1855: 1848: 1840:Turing complete 1824: 1818: 1785:shared generics 1767: 1766: 1763: 1760: 1757: 1754: 1751: 1748: 1745: 1742: 1739: 1736: 1733: 1730: 1727: 1724: 1721: 1718: 1715: 1712: 1709: 1706: 1703: 1700: 1697: 1686: 1681: 1680: 1677: 1674: 1671: 1668: 1665: 1662: 1659: 1656: 1653: 1650: 1647: 1644: 1641: 1638: 1635: 1632: 1629: 1627:Bookmark_Stacks 1626: 1623: 1620: 1617: 1614: 1611: 1608: 1605: 1602: 1599: 1596: 1593: 1590: 1587: 1584: 1581: 1578: 1575: 1572: 1569: 1566: 1564:Bookmark_Stacks 1563: 1560: 1557: 1554: 1551: 1548: 1545: 1542: 1539: 1536: 1533: 1530: 1527: 1524: 1521: 1518: 1515: 1509: 1508: 1505: 1502: 1498: 1495: 1492: 1488: 1485: 1482: 1479: 1476: 1474:Bookmark_Stacks 1473: 1470: 1467: 1464: 1461: 1458: 1455: 1452: 1449: 1443: 1442: 1439: 1436: 1433: 1430: 1427: 1424: 1421: 1418: 1415: 1412: 1409: 1406: 1403: 1400: 1397: 1394: 1391: 1388: 1385: 1382: 1379: 1376: 1373: 1370: 1367: 1364: 1361: 1358: 1355: 1352: 1349: 1346: 1343: 1340: 1337: 1334: 1331: 1328: 1325: 1322: 1319: 1316: 1313: 1310: 1307: 1304: 1301: 1298: 1295: 1292: 1289: 1286: 1283: 1280: 1277: 1274: 1271: 1268: 1265: 1262: 1259: 1256: 1253: 1250: 1247: 1244: 1241: 1238: 1235: 1232: 1229: 1226: 1223: 1220: 1217: 1214: 1211: 1208: 1205: 1202: 1199: 1196: 1193: 1190: 1187: 1184: 1181: 1178: 1175: 1172: 1169: 1166: 1163: 1160: 1157: 1154: 1151: 1148: 1145: 1142: 1139: 1136: 1133: 1130: 1127: 1124: 1121: 1118: 1115: 1112: 1109: 1106: 1103: 1100: 1097: 1094: 1091: 1088: 1085: 1082: 1079: 1076: 1073: 1070: 1067: 1064: 1061: 1058: 1055: 1049: 995: 984: 978: 975: 932: 930: 916: 900: 889: 887:Generics in Ada 857: 854: 853: 850: 847: 844: 841: 838: 835: 832: 829: 826: 823: 820: 817: 814: 811: 808: 805: 802: 799: 796: 793: 790: 787: 784: 781: 778: 775: 772: 769: 766: 763: 760: 757: 754: 751: 748: 745: 742: 739: 736: 733: 730: 727: 724: 721: 718: 715: 712: 709: 706: 703: 700: 697: 694: 691: 688: 685: 682: 679: 676: 673: 670: 667: 664: 661: 658: 655: 652: 648:example below: 645: 641: 637: 633: 628:, which is the 607: 604: 603: 600: 597: 594: 591: 588: 585: 582: 580:list_of_animals 579: 576: 573: 570: 567: 564: 561: 558: 555: 552: 549: 546: 543: 540: 537: 530: 455:'s now defunct 429:object-oriented 409: 370: 367: 353: 350: 334: 331: 297: 282: 278: 274: 242: 239: 224: 208:data structures 90:Design Patterns 24: 17: 12: 11: 5: 9231: 9230: 9227: 9219: 9218: 9208: 9207: 9201: 9200: 9198: 9197: 9192: 9187: 9182: 9177: 9172: 9167: 9162: 9157: 9152: 9151: 9150: 9140: 9135: 9133:Data structure 9130: 9125: 9119: 9117: 9111: 9110: 9108: 9107: 9102: 9097: 9092: 9087: 9082: 9077: 9072: 9067: 9062: 9057: 9052: 9047: 9042: 9037: 9032: 9026: 9024: 9020: 9019: 9017: 9016: 9015: 9014: 9004: 8999: 8994: 8989: 8984: 8979: 8978: 8977: 8967: 8962: 8957: 8952: 8947: 8942: 8937: 8932: 8927: 8926: 8925: 8914: 8912: 8906: 8905: 8903: 8902: 8901: 8900: 8890: 8884: 8882: 8876: 8875: 8873: 8872: 8867: 8866: 8865: 8860: 8849: 8847: 8841: 8840: 8838: 8837: 8832: 8827: 8826: 8825: 8815: 8814: 8813: 8812: 8811: 8801: 8796: 8791: 8786: 8781: 8780: 8779: 8774: 8772:Half precision 8769: 8759:Floating point 8756: 8751: 8746: 8741: 8735: 8733: 8729: 8728: 8726: 8725: 8720: 8715: 8710: 8705: 8700: 8694: 8692: 8686: 8685: 8680: 8678: 8677: 8670: 8663: 8655: 8646: 8645: 8643: 8642: 8637: 8632: 8627: 8622: 8617: 8612: 8607: 8602: 8597: 8591: 8589: 8581: 8580: 8578: 8577: 8572: 8567: 8562: 8557: 8535: 8530: 8525: 8515: 8510: 8505: 8500: 8495: 8490: 8480: 8474: 8472: 8466: 8465: 8463: 8462: 8457: 8452: 8447: 8442: 8437: 8432: 8427: 8422: 8417: 8412: 8402: 8397: 8392: 8386: 8384: 8368: 8367: 8364: 8363: 8361: 8360: 8355: 8340:Transformation 8337: 8332: 8327: 8322: 8317: 8312: 8307: 8302: 8297: 8292: 8287: 8278: 8273: 8268: 8263: 8258: 8253: 8248: 8243: 8238: 8233: 8228: 8226:Differentiable 8223: 8213: 8206:Automata-based 8203: 8198: 8192: 8190: 8184: 8183: 8181: 8180: 8175: 8170: 8165: 8160: 8155: 8145: 8140: 8134: 8132: 8126: 8125: 8123: 8122: 8117: 8112: 8107: 8097: 8091: 8089: 8083: 8082: 8080: 8079: 8073:Function-level 8070: 8061: 8056: 8051: 8046: 8041: 8036: 8031: 8026: 8021: 8016: 8006: 8000: 7998: 7983: 7977: 7976: 7973: 7972: 7970: 7969: 7964: 7959: 7954: 7949: 7935: 7933: 7917: 7916: 7914: 7913: 7908: 7903: 7898: 7893: 7888: 7886:Non-structured 7883: 7878: 7873: 7867: 7865: 7856: 7850: 7849: 7839: 7837: 7836: 7829: 7822: 7814: 7808: 7807: 7801: 7795: 7781: 7767: 7759:Gilad Bracha, 7756: 7755: 7751: 7750: 7745: 7724: 7699: 7686: 7665: 7659: 7649: 7648: 7644: 7643: 7637: 7636: 7632: 7631: 7624: 7617: 7607: 7600: 7593: 7592:, Embarcadero. 7584:Nick Hodges, " 7581: 7580: 7576: 7575: 7568: 7559:Jason Clark, " 7557: 7548:Jason Clark, " 7545: 7544: 7540: 7539: 7525: 7515: 7514: 7510: 7509: 7498: 7491: 7490:External links 7488: 7487: 7486: 7472: 7448: 7426: 7404: 7401: 7399: 7398: 7392: 7367: 7350: 7344: 7312: 7307:978-0134685991 7306: 7293: 7287: 7273: 7271: 7268: 7265: 7264: 7253: 7251:VHDL Reference 7241: 7221: 7210: 7199: 7188: 7177: 7166: 7154: 7143: 7131: 7119: 7103: 7077: 7070: 7041: 7030: 7005: 6999:10.1.1.110.122 6984: 6959: 6937:Lämmel, Ralf; 6929: 6905: 6890: 6851: 6831: 6822: 6813: 6804: 6789: 6753: 6746: 6728: 6708: 6696: 6689: 6667: 6652: 6645: 6624: 6623: 6621: 6618: 6617: 6616: 6611: 6606: 6601: 6594: 6591: 6579: 6515: 6512: 6496: 6493: 5989: 5984: 5983: 5977: 5971: 5964: 5946: 5945: 5913: 5910: 5625: 5592: 5589: 5563:provided that 5478: 5439: 5436: 5434: 5431: 4863:implementation 4695:implementation 4609: 4596: 4593: 3884: 3871: 3868: 3514: 3121: 3068: 3065: 3025:Main article: 3022: 3019: 3010: 2984: 2981: 2939: 2844: 2827: 2824: 2811: 2808: 2742: 2725: 2724: 2721: 2715: 2708: 2705: 2693: 2690: 2636: 2473: 2441: 2440: 2437:type inference 2423: 2416: 2401: 2388: 2387:Templates in D 2385: 2376: 2375: 2368: 2358: 2341: 2338: 2335:shared library 2327: 2291: 2270: 2267: 2235: 2232: 2014: 1958: 1873: 1847: 1844: 1822:Template (C++) 1820:Main article: 1817: 1814: 1813: 1812: 1809: 1806: 1803: 1802: 1801: 1794: 1791: 1696: 1685: 1682: 1514: 1448: 1422:Allocated_Size 1368:Allocated_Size 1054: 1048: 1045: 997: 996: 903: 901: 894: 888: 885: 881:.NET Framework 651: 536: 529: 526: 408: 405: 383: 365: 348: 329: 237: 223: 220: 75:in 1977. With 66:duplicate code 44:that are then 29:is a style of 15: 13: 10: 9: 6: 4: 3: 2: 9229: 9228: 9217: 9214: 9213: 9211: 9196: 9193: 9191: 9188: 9186: 9183: 9181: 9178: 9176: 9173: 9171: 9168: 9166: 9163: 9161: 9158: 9156: 9153: 9149: 9146: 9145: 9144: 9141: 9139: 9136: 9134: 9131: 9129: 9126: 9124: 9121: 9120: 9118: 9112: 9106: 9103: 9101: 9098: 9096: 9093: 9091: 9088: 9086: 9083: 9081: 9078: 9076: 9073: 9071: 9068: 9066: 9063: 9061: 9058: 9056: 9055:Function type 9053: 9051: 9048: 9046: 9043: 9041: 9038: 9036: 9033: 9031: 9028: 9027: 9025: 9021: 9013: 9010: 9009: 9008: 9005: 9003: 9000: 8998: 8995: 8993: 8990: 8988: 8985: 8983: 8980: 8976: 8973: 8972: 8971: 8968: 8966: 8963: 8961: 8958: 8956: 8953: 8951: 8948: 8946: 8943: 8941: 8938: 8936: 8933: 8931: 8928: 8924: 8921: 8920: 8919: 8916: 8915: 8913: 8911: 8907: 8899: 8896: 8895: 8894: 8891: 8889: 8886: 8885: 8883: 8881: 8877: 8871: 8868: 8864: 8861: 8859: 8856: 8855: 8854: 8851: 8850: 8848: 8846: 8842: 8836: 8833: 8831: 8828: 8824: 8821: 8820: 8819: 8816: 8810: 8807: 8806: 8805: 8802: 8800: 8797: 8795: 8792: 8790: 8787: 8785: 8782: 8778: 8775: 8773: 8770: 8768: 8765: 8764: 8762: 8761: 8760: 8757: 8755: 8752: 8750: 8747: 8745: 8742: 8740: 8737: 8736: 8734: 8730: 8724: 8721: 8719: 8716: 8714: 8711: 8709: 8706: 8704: 8701: 8699: 8696: 8695: 8693: 8691: 8690:Uninterpreted 8687: 8683: 8676: 8671: 8669: 8664: 8662: 8657: 8656: 8653: 8641: 8638: 8636: 8633: 8631: 8628: 8626: 8623: 8621: 8618: 8616: 8613: 8611: 8610:Data-oriented 8608: 8606: 8603: 8601: 8598: 8596: 8593: 8592: 8590: 8588: 8582: 8576: 8573: 8571: 8568: 8566: 8563: 8561: 8558: 8555: 8551: 8547: 8543: 8539: 8536: 8534: 8531: 8529: 8526: 8523: 8519: 8516: 8514: 8511: 8509: 8508:Homoiconicity 8506: 8504: 8501: 8499: 8496: 8494: 8491: 8488: 8484: 8481: 8479: 8476: 8475: 8473: 8471: 8467: 8461: 8458: 8456: 8453: 8451: 8448: 8446: 8443: 8441: 8438: 8436: 8433: 8431: 8428: 8426: 8423: 8421: 8418: 8416: 8415:Concurrent OO 8413: 8410: 8406: 8403: 8401: 8398: 8396: 8393: 8391: 8388: 8387: 8385: 8383: 8378: 8373: 8369: 8359: 8356: 8353: 8349: 8345: 8341: 8338: 8336: 8333: 8331: 8328: 8326: 8323: 8321: 8318: 8316: 8313: 8311: 8310:Set-theoretic 8308: 8306: 8303: 8301: 8298: 8296: 8293: 8291: 8290:Probabilistic 8288: 8286: 8282: 8279: 8277: 8274: 8272: 8269: 8267: 8264: 8262: 8259: 8257: 8254: 8252: 8249: 8247: 8244: 8242: 8239: 8237: 8234: 8232: 8229: 8227: 8224: 8221: 8217: 8214: 8211: 8207: 8204: 8202: 8199: 8197: 8194: 8193: 8191: 8189: 8185: 8179: 8176: 8174: 8171: 8169: 8166: 8164: 8161: 8159: 8156: 8153: 8149: 8146: 8144: 8141: 8139: 8136: 8135: 8133: 8131: 8127: 8121: 8118: 8116: 8113: 8111: 8108: 8105: 8101: 8098: 8096: 8093: 8092: 8090: 8088: 8084: 8078: 8074: 8071: 8069: 8068:Concatenative 8065: 8062: 8060: 8057: 8055: 8052: 8050: 8047: 8045: 8042: 8040: 8037: 8035: 8032: 8030: 8027: 8025: 8022: 8020: 8017: 8014: 8010: 8007: 8005: 8002: 8001: 7999: 7996: 7991: 7987: 7984: 7982: 7978: 7968: 7965: 7963: 7960: 7958: 7955: 7953: 7950: 7948: 7944: 7940: 7937: 7936: 7934: 7931: 7927: 7922: 7918: 7912: 7909: 7907: 7904: 7902: 7899: 7897: 7894: 7892: 7889: 7887: 7884: 7882: 7879: 7877: 7874: 7872: 7869: 7868: 7866: 7864: 7860: 7857: 7855: 7851: 7846: 7842: 7835: 7830: 7828: 7823: 7821: 7816: 7815: 7812: 7806: 7802: 7799: 7796: 7794: 7793:0-262-69325-9 7790: 7786: 7782: 7780: 7779:0-596-52775-6 7776: 7772: 7768: 7765: 7763: 7758: 7757: 7753: 7752: 7749: 7746: 7744: 7743:90-393-3765-9 7740: 7736: 7732: 7730: 7725: 7722: 7718: 7716: 7713: 7707: 7703: 7700: 7698:Revised 2002. 7697: 7695: 7690: 7687: 7684: 7682: 7679: 7676: 7670: 7667:Ralf Hinze, " 7666: 7664: 7660: 7657: 7656: 7651: 7650: 7646: 7645: 7642: 7639: 7638: 7634: 7633: 7629: 7625: 7622: 7618: 7615: 7611: 7608: 7605: 7601: 7598: 7594: 7591: 7587: 7583: 7582: 7578: 7577: 7573: 7569: 7566: 7565:MSDN Magazine 7562: 7558: 7555: 7554:MSDN Magazine 7551: 7547: 7546: 7542: 7541: 7538: 7537:0-201-73484-2 7534: 7530: 7526: 7524: 7522: 7517: 7516: 7512: 7511: 7507: 7503: 7499: 7497: 7494: 7493: 7489: 7483: 7479: 7475: 7469: 7465: 7461: 7457: 7453: 7449: 7444: 7439: 7435: 7431: 7427: 7424: 7420: 7417: 7414: 7412: 7407: 7406: 7402: 7395: 7393:0-201-63361-2 7389: 7385: 7381: 7376: 7375: 7368: 7361: 7360: 7355: 7351: 7347: 7341: 7337: 7333: 7329: 7325: 7321: 7317: 7316:Musser, D. R. 7313: 7309: 7303: 7299: 7294: 7290: 7284: 7280: 7275: 7274: 7269: 7262: 7257: 7254: 7250: 7245: 7242: 7239: 7235: 7231: 7225: 7222: 7219: 7214: 7211: 7208: 7203: 7200: 7197: 7192: 7189: 7186: 7181: 7178: 7175: 7170: 7167: 7163: 7162:Albahari 2022 7158: 7155: 7152: 7147: 7144: 7140: 7135: 7132: 7128: 7123: 7120: 7116: 7112: 7107: 7104: 7092: 7088: 7081: 7078: 7073: 7067: 7063: 7059: 7055: 7051: 7045: 7042: 7039: 7034: 7031: 7019: 7018:www.adaic.org 7015: 7009: 7006: 7000: 6995: 6988: 6985: 6977: 6970: 6963: 6960: 6944: 6940: 6933: 6930: 6922: 6921: 6916: 6909: 6906: 6901: 6894: 6891: 6886: 6882: 6878: 6874: 6867: 6866: 6858: 6856: 6852: 6844: 6843: 6835: 6832: 6826: 6823: 6817: 6814: 6808: 6805: 6800: 6796: 6792: 6786: 6782: 6778: 6773: 6768: 6764: 6757: 6754: 6749: 6743: 6739: 6732: 6729: 6721: 6720: 6712: 6709: 6705: 6700: 6697: 6692: 6690:0-201-63361-2 6686: 6681: 6680: 6671: 6668: 6663: 6656: 6653: 6648: 6642: 6638: 6637: 6629: 6626: 6619: 6615: 6612: 6610: 6607: 6605: 6602: 6600: 6597: 6596: 6592: 6577: 6569: 6565: 6563: 6559: 6556: 6552: 6547: 6545: 6541: 6537: 6533: 6529: 6525: 6521: 6513: 6511: 6509: 6505: 6501: 6494: 5987: 5981: 5978: 5975: 5972: 5969: 5965: 5962: 5958: 5954: 5951: 5950: 5949: 5943: 5942:default cases 5939: 5934: 5931: 5930: 5929: 5927: 5923: 5919: 5911: 5623: 5621: 5617: 5613: 5609: 5606: 5602: 5598: 5590: 5588: 5568: 5476: 5466: 5461: 5449: 5446:mechanism of 5445: 5437: 5432: 5397:// hellohello 5262:TGenericClass 5235:TGenericClass 5190:{$ ifdef fpc} 5184:TestGenDelphi 5145:// hellohello 5070:TGenericClass 5040:TGenericClass 5013:TGenericClass 4989:TGenericClass 4950:{$ ifdef fpc} 4944:TestGenDelphi 4869:TGenericClass 4806:TGenericClass 4788:{$ ifdef fpc} 4701:TGenericClass 4638:TGenericClass 4623:{$ ifdef fpc} 4607: 4604: 4601: 4594: 4592: 3882: 3879: 3878:Object Pascal 3876: 3869: 3512: 3509: 3503: 3495: 3487: 3483: 3482:contravariant 3474: 3468: 3451:MakeAtLeast() 3119: 3112: 3109: 3105: 3101: 3097: 3093: 3089: 3085: 3075: 3066: 3064: 3058: 3046: 3042: 3038: 3034: 3028: 3020: 3008: 2994: 2982: 2980: 2937: 2931: 2912:below, where 2911: 2842: 2833: 2825: 2823: 2821: 2817: 2809: 2740: 2738: 2729: 2722: 2719: 2716: 2713: 2710:User-defined 2709: 2706: 2699: 2698: 2697: 2691: 2634: 2471: 2465: 2461: 2456: 2454: 2438: 2433: 2424: 2417: 2410: 2402: 2398: 2397: 2396: 2394: 2386: 2384: 2380: 2373: 2369: 2363: 2357: 2351: 2346: 2342: 2339: 2336: 2332: 2328: 2324: 2323: 2322: 2320: 2316: 2311: 2307: 2305: 2301: 2289: 2287: 2283: 2280: 2268: 2266: 2264: 2260: 2256: 2251: 2243: 2241: 2233: 2231: 2217: 2213: 2208: 2203:can also use 2194: 2169: 2165: 2158:. Therefore, 2157: 2145: 2140: 2138: 2134: 2121:stable_sort() 2101: 2097: 2012: 2001:max(int, int) 1990:// Outputs 7. 1956: 1954: 1871: 1865: 1861: 1853: 1845: 1843: 1841: 1837: 1833: 1829: 1823: 1815: 1810: 1807: 1804: 1799: 1795: 1792: 1789: 1788: 1786: 1782: 1781: 1780: 1777: 1775: 1770: 1694: 1692: 1683: 1615:Document_Type 1591:Document_Name 1519:Document_Type 1512: 1501:Bookmark_Type 1453:Bookmark_Type 1446: 1052: 1046: 1044: 1042: 1038: 1034: 1029: 1026: 1021: 1019: 1015: 1010: 1008: 1003: 993: 990: 982: 971: 968: 964: 961: 957: 954: 950: 947: 943: 940: – 939: 935: 934:Find sources: 928: 924: 920: 914: 913: 909: 904:This section 902: 898: 893: 892: 886: 884: 882: 878: 874: 870: 866: 864: 649: 634:Moving_Object 631: 627: 626: 621: 617: 613: 534: 527: 525: 522: 520: 516: 511: 507: 503: 501: 497: 493: 489: 485: 481: 477: 473: 469: 465: 460: 458: 454: 450: 446: 442: 438: 434: 430: 426: 422: 418: 414: 406: 404: 402: 398: 394: 390: 385: 382: 378: 376: 364: 360: 358: 347: 345: 344:Banach spaces 341: 328: 326: 320: 318: 313: 310: 304: 300: 295: 289: 285: 272: 268: 263: 261: 257: 253: 249: 236: 231: 229: 221: 219: 217: 213: 209: 205: 201: 197: 192: 190: 186: 182: 178: 174: 173: 168: 164: 160: 156: 152: 148: 144: 140: 136: 132: 128: 124: 120: 116: 111: 109: 105: 104: 99: 94: 92: 91: 86: 82: 78: 74: 69: 67: 63: 59: 55: 51: 47: 43: 40: 36: 32: 28: 22: 9137: 8960:Intersection 8615:Event-driven 8502: 8019:Higher-order 7947:Object-based 7784: 7770: 7760: 7727: 7726:Andres Löh, 7709: 7692: 7672: 7654: 7589: 7572:Generics.Net 7567:, Microsoft. 7564: 7556:, Microsoft. 7553: 7528: 7519: 7455: 7433: 7409: 7373: 7358: 7327: 7297: 7278: 7256: 7244: 7229: 7224: 7213: 7202: 7191: 7180: 7169: 7157: 7146: 7134: 7126: 7122: 7114: 7110: 7106: 7094:. Retrieved 7090: 7080: 7053: 7044: 7033: 7021:. Retrieved 7017: 7008: 6987: 6976:the original 6962: 6950:. Retrieved 6932: 6919: 6908: 6893: 6864: 6841: 6834: 6825: 6816: 6807: 6762: 6756: 6737: 6731: 6718: 6711: 6699: 6678: 6670: 6661: 6655: 6635: 6628: 6566: 6560: 6548: 6531: 6526:and generic 6517: 6498: 5985: 5979: 5973: 5967: 5960: 5956: 5952: 5947: 5941: 5937: 5932: 5915: 5619: 5615: 5611: 5607: 5600: 5594: 5569: 5550: 5465:binary trees 5459: 5441: 4605: 4598: 4589: 3873: 3510: 3475: 3471:CompareTo(T) 3467:compile time 3448: 3113: 3088:type erasure 3081: 3041:type erasure 3032: 3030: 2992: 2986: 2966: 2929: 2909: 2907: 2831: 2829: 2819: 2813: 2786:htmlTemplate 2750:htmlTemplate 2730: 2726: 2695: 2668:isInputRange 2632: 2499:isInputRange 2478:isInputRange 2468:isInputRange 2457: 2442: 2413:if constexpr 2409:C++ concepts 2390: 2381: 2377: 2371: 2354: 2344: 2312: 2308: 2300:preprocessor 2297: 2279:preprocessor 2272: 2262: 2258: 2252: 2244: 2239: 2237: 2211: 2209: 2167: 2163: 2141: 2092:operator< 2077: 1994: 1952: 1951: 1863: 1859: 1851: 1849: 1825: 1784: 1778: 1771: 1768: 1761:Element_Type 1719:Element_Type 1690: 1687: 1657:Initial_Size 1510: 1496:Element_Type 1444: 1353:Element_Type 1266:Element_Type 1224:Element_Type 1167:Initial_Size 1077:Element_Type 1050: 1036: 1032: 1030: 1024: 1022: 1017: 1014:generic unit 1013: 1011: 1000: 985: 979:January 2024 976: 966: 959: 952: 945: 933: 917:Please help 905: 867: 865:(J2SE) 5.0. 855: 623: 605: 598:list_of_cars 531: 523: 504: 487: 483: 479: 475: 471: 461: 425:object-based 410: 396: 392: 386: 374: 372: 362: 355: 337: 322: 317:compile-time 314: 302: 298: 293: 287: 283: 270: 266: 264: 244: 233: 230:as follows, 225: 200:David Musser 195: 193: 170: 114: 112: 101: 95: 88: 84: 70: 46:instantiated 45: 41: 26: 25: 9190:Type theory 9185:Type system 9035:Bottom type 8982:Option type 8923:generalized 8809:Long double 8754:Fixed point 8625:Intentional 8605:Data-driven 8587:of concerns 8546:Inferential 8533:Multi-stage 8513:Interactive 8390:Actor-based 8377:distributed 8320:Stack-based 8120:Synchronous 8077:Value-level 8064:Applicative 7981:Declarative 7939:Class-based 7702:Ralf Lämmel 7610:Free Pascal 6948:. Microsoft 6536:Standard ML 5926:Netherlands 4600:Free Pascal 4516:MakeAtLeast 4381:MakeAtLeast 4327:MakeAtLeast 4093:MakeAtLeast 4018:MakeAtLeast 3934:MakeAtLeast 3333:IComparable 3291:MakeAtLeast 3192:MakeAtLeast 3108:collections 3092:reification 3015:SORTED_LIST 3005:SORTED_LIST 2997:SORTED_LIST 2337:boundaries. 2216:linked list 2199:instead of 2096:duck typing 1710:(<>); 1033:instantiate 873:Oxygene 1.5 630:algorithmic 457:Trellis-Owl 381:boilerplate 379:Scrap your 9095:Empty type 9090:Type class 9040:Collection 8997:Refinement 8975:metaobject 8823:signedness 8682:Data types 8600:Components 8585:Separation 8560:Reflective 8554:by example 8498:Extensible 8372:Concurrent 8348:Production 8335:Templating 8315:Simulation 8300:Scientific 8220:Spacecraft 8148:Constraint 8143:Answer set 8095:Flow-based 7995:comparison 7990:Functional 7962:Persistent 7926:comparison 7891:Procedural 7863:Structured 7854:Imperative 7691:, editor, 7602:Dr. Bob, " 7473:0897912047 7139:Bloch 2018 6952:16 October 6790:0897912438 6620:References 6390:&& 5444:type class 5253:specialize 5226:specialize 3621:// a class 3549:OnePerType 3096:reflection 3057:type casts 3001:COMPARABLE 2820:genericity 2712:attributes 2350:code bloat 2319:code bloat 1749:Index_Type 1737:Array_Type 1704:Index_Type 1576:end record 1428:end record 1398:Index_Type 1341:Index_Type 1302:Index_Type 949:newspapers 533:template: 488:genericity 484:genericity 480:genericity 163:TypeScript 50:parameters 39:data types 35:algorithms 9170:Subtyping 9165:Interface 9148:metaclass 9100:Unit type 9070:Semaphore 9050:Exception 8955:Inductive 8945:Dependent 8910:Composite 8888:Character 8870:Reference 8767:Minifloat 8723:Bit array 8487:Inductive 8483:Automatic 8305:Scripting 8004:Recursive 7438:CiteSeerX 7416:LCSD 2005 7324:P. Gianni 7091:Dr. Dobbs 6994:CiteSeerX 6767:CiteSeerX 6576:keyword: 6532:functors. 5873:FunctorOf 5663:polytypic 5610:, and if 5601:polytypic 5561:BinTree T 5196:{$ endif} 4956:{$ endif} 4797:interface 4794:{$ endif} 4632:interface 4629:{$ endif} 4318:procedure 4204:TComparer 4147:IComparer 4084:procedure 4015:procedure 3988:IComparer 3931:procedure 3486:type safe 3408:CompareTo 3249:WriteLine 2858:-- Access 2801:htmlDCode 2774:htmlDCode 2405:static if 2160:max(x, y) 2144:type safe 1856:max(x, y) 1755:<>) 1651:Bookmarks 1582:procedure 1558:Bookmarks 1546:Unbounded 1374:Size_Type 1347:<>) 1308:Size_Type 1290:exception 1284:Underflow 1278:exception 1230:procedure 1188:procedure 1176:Size_Type 1143:procedure 1104:Size_Type 906:does not 620:signature 612:templates 260:iterators 235:software. 194:The term 77:templates 58:functions 33:in which 9210:Category 9195:Variable 9085:Top type 8950:Equality 8858:physical 8835:Rational 8830:Interval 8777:bfloat16 8640:Subjects 8630:Literate 8620:Features 8575:Template 8570:Symbolic 8542:Bayesian 8522:Hygienic 8382:parallel 8261:Modeling 8256:Low-code 8231:End-user 8168:Ontology 8100:Reactive 8087:Dataflow 7543:C#, .NET 7419:Archived 7356:(2007). 7023:25 April 6917:(1999). 6593:See also 6573:_Generic 6555:register 6506:and the 5531:deriving 4866:function 4824:function 4698:function 4656:function 4264:Comparer 4198:Comparer 4186:Comparer 4141:Comparer 4069:overload 4006:overload 3982:Comparer 3907:Defaults 3901:Generics 3875:Delphi's 3033:generics 2975:such as 2888:new_item 2592:popFront 2475:template 2359:— 2345:instance 2088:x < y 1969:<< 1881:typename 1875:template 1836:run-time 1774:compiler 1645:Document 1609:Document 1528:Contents 1486:Max_Size 1320:Max_Size 1272:Overflow 1182:Max_Size 1119:Max_Size 1059:Max_Size 1041:run-time 858:template 856:The C++ 836:<< 830:<< 824:<< 662:typename 656:template 616:subtypes 544:typename 538:template 515:compiler 468:compiler 366:— 349:— 330:— 248:concepts 238:— 212:concepts 115:generics 9138:Generic 9114:Related 9030:Boolean 8987:Product 8863:virtual 8853:Address 8845:Pointer 8818:Integer 8749:Decimal 8744:Complex 8732:Numeric 8595:Aspects 8503:Generic 8493:Dynamic 8352:Pattern 8330:Tactile 8295:Quantum 8285:filters 8216:Command 8115:Streams 8110:Signals 7881:Modular 7715:SIGPLAN 7683:(ICFP), 7678:SIGPLAN 7647:Haskell 7380:Bibcode 7326:(ed.). 7270:Sources 7058:Bibcode 6885:7518369 6551:Verilog 6530:called 6528:modules 5924:in the 5918:Haskell 5861:Regular 5825:flatten 5651:flatten 5633:Regular 5627:flatten 5597:Haskell 5522:BinTree 5507:BinTree 5483:BinTree 5448:Haskell 5370:WriteLn 5340:WriteLn 5241:Integer 5181:program 5118:WriteLn 5088:WriteLn 5046:Integer 4995:Integer 4941:program 4803:generic 4561:WriteLn 4522:Integer 4471:Integer 4450:Integer 4438:Integer 4270:Compare 4216:Default 4174:Integer 3886:program 3846:GenTest 3825:GenTest 3804:GenTest 3783:GenTest 3762:GenTest 3741:GenTest 3720:GenTest 3699:GenTest 3678:Counter 3648:Counter 3585:GenTest 3567:private 3525:GenTest 3494:casting 3270:ReadKey 3264:Console 3243:Console 3222:foreach 2926:DEPOSIT 2922:ACCOUNT 2918:DEPOSIT 2914:ACCOUNT 2876:feature 2855:feature 2420:is(...) 2317:), and 2205:complex 2197:compare 2184:complex 2180:complex 2172:complex 2148:complex 1725:private 1698:generic 1691:between 1540:Strings 1471:package 1462:Natural 1404:Storage 1299:subtype 1296:private 1257:Element 1215:Element 1137:private 1134:limited 1092:package 1083:private 1065:Natural 1056:generic 1047:Example 963:scholar 927:removed 912:sources 606:Above, 510:structs 496:Haskell 359:noted, 214:, with 189:Haskell 9128:Boxing 9116:topics 9075:Stream 9012:tagged 8970:Object 8893:String 8358:Visual 8325:System 8210:Action 8034:Strict 7791: 7777: 7741: 7671:," In 7635:Eiffel 7535: 7513:C++, D 7482:285030 7480: 7470: 7440: 7390: 7342: 7304: 7285: 7236: 7096:3 June 7068: 6996: 6883: 6799:795406 6797: 6787: 6769: 6744: 6687: 6643: 6544:Scheme 6042:forall 5961:k → k' 5819:concat 5702:either 5367:// 200 5334:Create 5316:Create 5268:String 5115:// 200 5082:Create 5076:String 5052:Create 5019:String 4920:AValue 4914:AValue 4908:Result 4884:AValue 4836:AValue 4758:AValue 4752:AValue 4746:Result 4722:AValue 4668:AValue 4576:ReadLn 4510:TUtils 4477:Create 4465:TArray 4432:TArray 4402:Lowest 4363:Lowest 4348:TArray 4321:TUtils 4303:Lowest 4282:Lowest 4129:Lowest 4114:TArray 4087:TUtils 4054:Lowest 4039:TArray 3970:Lowest 3955:TArray 3919:TUtils 3889:Sample 3852:double 3831:double 3657:public 3642:static 3639:public 3624:public 3582:public 3543:static 3519:public 3502:boxing 3490:object 3435:lowest 3414:lowest 3381:Length 3318:lowest 3285:static 3141:static 3135:Sample 3126:System 3071:": --> 3061:String 2816:Eiffel 2756:import 2733:import 2702:import 2683:// ... 2511:typeof 2432:typeof 2331:linker 2315:SFINAE 2282:macros 2247:sort() 2135:, and 2123:, and 2117:sort() 2046:return 1920:return 1633:Create 1600:String 1525:record 1480:Stacks 1477:is new 1437:Stacks 1410:Vector 1389:record 1329:Vector 1146:Create 1095:Stacks 1037:actual 965: 958: 951: 944: 936: 782:string 761:string 638:Animal 574:Animal 506:Arrays 451:, and 445:Eiffel 187:, and 165:, and 147:Python 131:Eiffel 127:Delphi 9023:Other 9007:Union 8940:Class 8930:Array 8713:Tryte 8635:Roles 8518:Macro 8281:Pipes 8201:Array 8178:Query 8130:Logic 8039:GADTs 8029:Total 7952:Agent 7766:2004. 7685:2004. 7478:S2CID 7363:(PDF) 6979:(PDF) 6972:(PDF) 6946:(PDF) 6924:(PDF) 6881:S2CID 6869:(PDF) 6846:(PDF) 6795:S2CID 6723:(PDF) 6540:OCaml 6534:Both 6504:PolyP 6500:Clean 6495:Clean 6321:False 6066:-> 6018:-> 6012:-> 5903:-> 5894:-> 5885:-> 5867:=> 5852:-> 5843:-> 5816:-> 5801:-> 5792:-> 5786:-> 5777:-> 5771:-> 5762:-> 5741:-> 5720:-> 5699:-> 5678:-> 5648:-> 5639:=> 5608:* → * 5591:PolyP 5301:begin 5271:>; 5244:>; 5079:>. 5049:>. 5025:begin 5022:>; 4998:>; 4905:begin 4881:const 4833:const 4821:class 4743:begin 4719:const 4710:>. 4665:const 4653:class 4567:Value 4549:Value 4474:>. 4456:begin 4444:Value 4441:>; 4378:begin 4360:const 4357:>; 4315:class 4213:>. 4180:begin 4126:const 4123:>; 4081:class 4051:const 4048:>; 4012:class 3967:const 3964:>; 3928:class 3925:class 3627:class 3522:class 3478:Array 3324:where 3237:array 3207:array 3159:array 3132:class 3123:using 3116:where 3100:casts 3012:class 2977:LIST 2973:LIST 2969:LIST 2846:class 2795:mixin 2674:Range 2656:range 2653:Range 2647:Range 2616:front 2574:empty 2520:inout 2464:range 2275:max() 2133:heaps 2108:max() 1868:max() 1752:range 1743:array 1660:=> 1642:=> 1621:begin 1570:Stack 1499:=> 1489:=> 1362:Stack 1344:range 1335:array 1311:range 1251:Stack 1209:Stack 1161:Stack 1128:Stack 1110:range 970:JSTOR 956:books 871:2.0, 833:hello 827:world 809:hello 803:world 785:hello 764:world 695:& 683:& 553:class 476:words 464:Forth 340:rings 325:Knuth 294:range 185:Julia 181:Scala 159:Swift 62:types 9143:Kind 9105:Void 8965:List 8880:Text 8718:Word 8708:Trit 8703:Byte 8283:and 7930:list 7789:ISBN 7775:ISBN 7754:Java 7739:ISBN 7704:and 7533:ISBN 7468:ISBN 7388:ISBN 7340:ISBN 7302:ISBN 7283:ISBN 7234:ISBN 7098:2015 7066:ISBN 7025:2024 6954:2016 6785:ISBN 6742:ISBN 6685:ISBN 6641:ISBN 6562:VHDL 6538:and 6471:Bool 6441:Char 6165:True 6147:Unit 6024:type 6021:Bool 5991:type 5959:and 5855:cata 5831:pmap 5681:case 5657:cata 5605:kind 5584:show 5582:and 5576:Show 5574:and 5557:show 5543:Show 5501:Node 5492:Leaf 5480:data 5473:Show 5471:and 5456:Show 5442:The 5418:Free 5406:Free 5265:< 5238:< 5217:type 5199:uses 5166:Free 5154:Free 5073:< 5043:< 5016:< 4992:< 4959:uses 4815:> 4809:< 4800:type 4779:unit 4704:< 4647:> 4641:< 4635:type 4614:unit 4555:Ints 4531:Ints 4525:> 4519:< 4468:< 4459:Ints 4435:< 4426:Ints 4390:> 4384:< 4351:< 4336:> 4330:< 4294:then 4288:< 4246:High 4207:< 4195:then 4156:> 4150:< 4117:< 4102:> 4096:< 4042:< 4027:> 4021:< 3997:> 3991:< 3958:< 3943:> 3937:< 3916:type 3898:uses 3855:> 3849:< 3834:> 3828:< 3813:> 3807:< 3795:g111 3792:> 3786:< 3771:> 3765:< 3750:> 3744:< 3729:> 3723:< 3708:> 3702:< 3534:> 3528:< 3449:The 3429:list 3420:< 3402:list 3375:list 3372:< 3342:> 3336:< 3309:list 3300:> 3294:< 3288:void 3276:true 3201:> 3195:< 3147:Main 3144:void 3073:edit 3053:List 2959:LIST 2947:LIST 2924:and 2916:and 2861:item 2849:LIST 2836:LIST 2771:enum 2747:enum 2731:The 2700:The 2638:auto 2625:})); 2601:auto 2553:init 2496:bool 2493:enum 2427:auto 2425:The 2418:The 2411:and 2391:The 2228:list 2226:. A 2201:< 2176:< 2170:are 2166:and 2152:< 2113:< 2104:< 2082:and 2052:< 1966:cout 1926:< 1887:> 1878:< 1734:type 1716:type 1701:type 1675:Edit 1585:Edit 1516:type 1450:type 1359:type 1326:type 1239:From 1197:Into 1191:Push 1125:type 1101:type 1074:type 942:news 910:any 908:cite 821:cout 797:Swap 746:temp 716:temp 674:Swap 671:void 668:> 659:< 646:Swap 640:and 618:and 595:> 589:< 586:List 577:> 571:< 568:List 556:List 550:> 541:< 508:and 466:the 449:Java 433:BETA 427:and 419:and 279:sort 275:find 202:and 155:Rust 139:Java 9002:Set 8698:Bit 8188:DSL 7712:ACM 7675:ACM 7506:STL 7460:doi 7332:doi 6873:doi 6777:doi 6411:Int 6393:eqB 6381:eqA 6369::*: 6354::*: 6345:eqB 6342:eqA 6333::*: 6309:eqB 6306:eqA 6297::+: 6279:eqB 6267:Inr 6255:Inr 6249:eqB 6246:eqA 6237::+: 6219:eqA 6207:Inl 6195:Inl 6189:eqB 6186:eqA 6177::+: 5837:Con 5789:Rec 5774:Par 5620:t a 5424:end 5412:GC2 5400:GC1 5382:Foo 5376:GC2 5358:100 5352:Foo 5346:GC1 5322:GC2 5304:GC1 5289:GC2 5277:GC1 5274:var 5172:end 5160:GC2 5148:GC1 5130:Foo 5124:GC2 5106:100 5100:Foo 5094:GC1 5058:GC2 5028:GC1 5001:GC2 4977:GC1 4974:var 4932:end 4926:end 4875:Foo 4857:end 4827:Foo 4770:end 4764:end 4713:Foo 4689:end 4659:Foo 4582:end 4546:for 4423:var 4417:end 4408:nil 4396:Arr 4342:Arr 4309:end 4297:Arr 4276:Arr 4252:Arr 4237:Arr 4231:Low 4222:for 4192:nil 4165:var 4108:Arr 4075:end 4033:Arr 3949:Arr 3861:1.0 3843:new 3819:111 3810:int 3801:new 3789:int 3768:int 3759:new 3753:g11 3747:int 3726:int 3717:new 3705:int 3645:int 3561:(); 3555:new 3498:int 3354:int 3348:for 3228:int 3198:int 3156:int 3045:JVM 2903:... 2882:put 2873:... 2852:... 2641:fun 2595:(); 2523:int 2188:map 2131:s, 2129:set 2034:int 2025:int 2019:max 2016:int 2009:int 2007:is 1997:max 1972:max 1960:std 1893:max 1862:or 1672:end 1534:Ada 1459:new 1434:end 1392:Top 1263:out 1248:out 1233:Pop 1206:out 1158:out 1031:To 1002:Ada 921:by 815:std 776:std 755:std 642:Car 592:Car 453:DEC 437:C++ 421:Ada 417:CLU 391:of 342:or 175:in 143:Nim 119:Ada 117:in 81:C++ 79:in 73:Ada 60:or 9212:: 8552:, 8548:, 8544:, 8350:, 8346:, 8075:, 8066:, 7945:, 7941:, 7928:, 7737:. 7612:: 7476:. 7466:. 7386:. 7338:. 7318:; 7089:. 7064:. 7016:. 6879:. 6871:. 6854:^ 6793:. 6783:. 6775:. 6549:A 6520:ML 6486:== 6462:eq 6456:== 6432:eq 6426:== 6402:eq 6399:b2 6396:b1 6387:a2 6384:a1 6372:b2 6366:a2 6357:b1 6351:a1 6324:eq 6288:eq 6285:b2 6282:b1 6270:b2 6258:b1 6228:eq 6225:a2 6222:a1 6210:a2 6198:a1 6168:eq 6138:eq 6129:{} 6126:Eq 6123::: 6111::: 6099:eq 6093:u2 6090:t2 6081:u1 6078:t1 6072:{} 6069:Eq 6063:u2 6060:u1 6057:{} 6054:Eq 6048:u2 6045:u1 6036:t2 6033:t1 6030:{} 6027:Eq 6015:t2 6009:t1 6003:t2 6000:t1 5997:{} 5994:Eq 5858::: 5834:fl 5759:() 5753:fl 5750:++ 5744:fl 5708:fl 5705:fl 5687:of 5669::: 5666:fl 5660:fl 5630::: 5580:== 5572:Eq 5553:== 5537:Eq 5475:: 5469:Eq 5452:Eq 5391:)) 5361:)) 5325::= 5307::= 5139:)) 5109:)) 5061::= 5031::= 4911::= 4749::= 4558:do 4552:in 4462::= 4300::= 4261:if 4258:do 4243:to 4228::= 4201::= 4183:if 3864:); 3837:g2 3822:); 3780:); 3777:11 3738:); 3711:g1 3681:++ 3663:() 3603:_t 3573:_t 3473:. 3396:if 3390:++ 3279:); 3258:); 3234:in 3216:); 3189:}; 3150:() 2804:); 2789:); 2765:); 2662:if 2650:)( 2580:{} 2562:if 2505:is 2321:: 2139:. 2119:, 1987:); 1963::: 1864:y, 1842:. 1758:of 1740:is 1722:is 1707:is 1666:); 1663:10 1606:is 1597:in 1594:: 1522:is 1503:); 1491:20 1456:is 1425:); 1419:.. 1386:is 1377::= 1371:: 1350:of 1332:is 1317:.. 1305:is 1269:); 1260:: 1245:in 1242:: 1227:); 1221:in 1218:: 1203:in 1200:: 1185:); 1179::= 1173:in 1170:: 1155:: 1131:is 1116:.. 1107:is 1098:is 1080:is 1023:A 1020:. 1012:A 1009:. 869:C# 839:‘\ 818::: 812:); 779::: 758::: 565:}; 459:. 447:, 443:, 439:, 435:, 415:, 413:ML 301:+ 286:× 277:, 183:, 179:, 177:ML 161:, 157:, 153:, 151:Go 149:, 145:, 141:, 137:, 135:F# 133:, 129:, 125:, 123:C# 121:, 93:. 68:. 54:ML 8674:e 8667:t 8660:v 8556:) 8540:( 8524:) 8520:( 8489:) 8485:( 8411:) 8407:( 8379:, 8374:, 8354:) 8342:( 8222:) 8218:( 8212:) 8208:( 8154:) 8150:( 8106:) 8102:( 8015:) 8011:( 7997:) 7993:( 7932:) 7924:( 7847:) 7843:( 7833:e 7826:t 7819:v 7764:, 7731:, 7723:) 7696:, 7606:" 7523:. 7508:) 7484:. 7462:: 7446:. 7425:. 7413:, 7396:. 7382:: 7348:. 7334:: 7310:. 7291:. 7164:. 7100:. 7074:. 7060:: 7027:. 7002:. 6956:. 6926:. 6902:. 6887:. 6875:: 6848:. 6801:. 6779:: 6750:. 6725:. 6706:. 6693:. 6664:. 6649:. 6568:C 6489:) 6483:( 6480:= 6477:} 6474:| 6468:| 6465:{ 6459:) 6453:( 6450:= 6447:} 6444:| 6438:| 6435:{ 6429:) 6423:( 6420:= 6417:} 6414:| 6408:| 6405:{ 6378:= 6375:) 6363:( 6360:) 6348:( 6339:} 6336:| 6330:| 6327:{ 6318:= 6315:_ 6312:_ 6303:} 6300:| 6294:| 6291:{ 6276:= 6273:) 6264:( 6261:) 6252:( 6243:} 6240:| 6234:| 6231:{ 6216:= 6213:) 6204:( 6201:) 6192:( 6183:} 6180:| 6174:| 6171:{ 6162:= 6159:_ 6156:_ 6153:} 6150:| 6144:| 6141:{ 6135:t 6132:t 6120:} 6117:| 6114:k 6108:t 6105:| 6102:{ 6096:) 6087:( 6084:) 6075:( 6051:. 6039:= 6006:= 5957:* 5944:. 5906:b 5900:a 5897:d 5891:) 5888:b 5882:b 5879:a 5876:d 5870:( 5864:d 5849:x 5846:\ 5840:t 5828:. 5822:. 5813:g 5810:@ 5807:d 5804:x 5798:x 5795:\ 5783:x 5780:\ 5768:x 5765:\ 5756:y 5747:x 5738:) 5735:y 5732:, 5729:x 5726:( 5723:\ 5717:h 5714:* 5711:g 5696:h 5693:+ 5690:g 5684:f 5675:a 5672:f 5654:= 5645:a 5642:d 5636:d 5616:t 5612:a 5565:T 5546:) 5540:, 5534:( 5528:) 5525:a 5519:( 5516:a 5513:) 5510:a 5504:( 5498:| 5495:a 5489:= 5486:a 5427:. 5421:; 5415:. 5409:; 5403:. 5394:; 5385:( 5379:. 5373:( 5364:; 5355:( 5349:. 5343:( 5337:; 5331:. 5319:; 5313:. 5298:; 5292:: 5286:; 5280:: 5259:. 5256:B 5250:= 5232:. 5229:A 5223:= 5211:; 5208:B 5205:, 5202:A 5187:; 5175:. 5169:; 5163:. 5157:; 5151:. 5142:; 5133:( 5127:. 5121:( 5112:; 5103:( 5097:. 5091:( 5085:; 5067:. 5064:B 5055:; 5037:. 5034:A 5010:. 5007:B 5004:: 4986:. 4983:A 4980:: 4971:; 4968:B 4965:, 4962:A 4947:; 4935:. 4929:; 4923:; 4917:+ 4902:; 4899:T 4896:: 4893:) 4890:T 4887:: 4878:( 4872:. 4860:; 4854:; 4851:T 4848:: 4845:) 4842:T 4839:: 4830:( 4818:= 4812:T 4785:; 4782:B 4773:. 4767:; 4761:; 4755:+ 4740:; 4737:T 4734:: 4731:) 4728:T 4725:: 4716:( 4707:T 4692:; 4686:; 4683:T 4680:: 4677:) 4674:T 4671:: 4662:( 4650:= 4644:T 4620:; 4617:A 4585:. 4579:; 4573:; 4570:) 4564:( 4543:; 4540:) 4537:2 4534:, 4528:( 4513:. 4507:; 4504:) 4501:3 4498:, 4495:2 4492:, 4489:1 4486:, 4483:0 4480:( 4453:; 4447:: 4429:: 4420:; 4414:; 4411:) 4405:, 4399:, 4393:( 4387:T 4375:; 4372:) 4369:T 4366:: 4354:T 4345:: 4339:( 4333:T 4324:. 4312:; 4306:; 4291:0 4285:) 4279:, 4273:( 4267:. 4255:) 4249:( 4240:) 4234:( 4225:I 4219:; 4210:T 4189:= 4177:; 4171:: 4168:I 4162:; 4159:) 4153:T 4144:: 4138:; 4135:T 4132:: 4120:T 4111:: 4105:( 4099:T 4090:. 4078:; 4072:; 4066:; 4063:) 4060:T 4057:: 4045:T 4036:: 4030:( 4024:T 4009:; 4003:; 4000:) 3994:T 3985:: 3979:; 3976:T 3973:: 3961:T 3952:: 3946:( 3940:T 3922:= 3910:; 3904:. 3892:; 3858:( 3840:= 3816:( 3798:= 3774:( 3756:= 3735:1 3732:( 3714:= 3690:} 3687:} 3684:; 3675:. 3666:{ 3651:; 3633:{ 3618:} 3615:} 3612:; 3609:t 3606:= 3600:{ 3597:) 3594:t 3591:T 3588:( 3576:; 3570:T 3552:= 3537:{ 3531:T 3459:T 3455:T 3444:} 3441:} 3438:; 3432:= 3426:) 3423:0 3417:) 3411:( 3405:. 3399:( 3393:) 3387:i 3384:; 3378:. 3369:i 3366:; 3363:0 3360:= 3357:i 3351:( 3345:{ 3339:T 3330:: 3327:T 3321:) 3315:T 3312:, 3306:T 3303:( 3297:T 3282:} 3273:( 3267:. 3255:i 3252:( 3246:. 3240:) 3231:i 3225:( 3213:2 3210:, 3204:( 3186:3 3183:, 3180:2 3177:, 3174:1 3171:, 3168:0 3165:{ 3162:= 3153:{ 3138:{ 3129:; 3077:] 2989:G 2956:: 2944:: 2934:G 2897:) 2894:G 2891:: 2885:( 2867:G 2864:: 2840:G 2798:( 2783:( 2777:= 2759:( 2753:= 2686:} 2680:{ 2677:) 2671:! 2665:( 2659:) 2644:( 2628:} 2619:; 2613:. 2610:r 2607:= 2604:h 2589:. 2586:r 2577:) 2571:. 2568:r 2565:( 2556:; 2550:. 2547:R 2544:= 2541:r 2538:R 2535:{ 2532:) 2529:0 2526:= 2517:( 2514:( 2508:( 2502:= 2490:{ 2487:) 2484:R 2481:( 2415:. 2393:D 2286:C 2168:y 2164:x 2084:y 2080:x 2073:} 2070:; 2067:x 2064:: 2061:y 2058:? 2055:y 2049:x 2043:{ 2040:) 2037:y 2031:, 2028:x 2022:( 2005:T 1984:7 1981:, 1978:3 1975:( 1947:} 1944:; 1941:x 1938:: 1935:y 1932:? 1929:y 1923:x 1917:{ 1914:) 1911:y 1908:T 1905:, 1902:x 1899:T 1896:( 1890:T 1884:T 1860:x 1764:; 1746:( 1728:; 1678:; 1654:, 1648:. 1639:S 1636:( 1630:. 1618:; 1612:: 1603:) 1588:( 1579:; 1573:; 1567:. 1561:: 1555:; 1549:. 1543:. 1537:. 1531:: 1493:, 1483:( 1465:; 1440:; 1431:; 1416:1 1413:( 1407:: 1401:; 1395:: 1383:) 1380:0 1365:( 1356:; 1338:( 1323:; 1314:1 1293:; 1287:: 1281:; 1275:: 1254:; 1236:( 1212:; 1194:( 1164:; 1152:S 1149:( 1140:; 1122:; 1113:0 1086:; 1068:; 1062:: 992:) 986:( 981:) 977:( 967:· 960:· 953:· 946:· 929:. 915:. 848:; 845:’ 842:n 806:, 800:( 794:; 788:= 773:; 767:= 752:} 749:; 743:= 740:a 737:; 734:a 731:= 728:b 725:; 722:b 719:= 713:T 704:{ 701:) 698:b 692:T 689:, 686:a 680:T 677:( 665:T 608:T 601:; 583:; 559:{ 547:T 441:D 303:M 299:N 288:M 284:N 271:M 267:N 108:D 23:.

Text is available under the Creative Commons Attribution-ShareAlike License. Additional terms may apply.