Academia.eduAcademia.edu

Outline

Title
Abstract
FAQs
Introduction
Related Work
Lexically Scoped Models and Overlapping
Conclusion
References
All Topics
Computer Science
Software

Essential language support for generic programming

Profile image of Andrew LumsdaineAndrew Lumsdaine

2005, ACM SIGPLAN Notices

https://doi.org/10.1145/1064978.1065021
visibility

…

description

12 pages

link

1 file

Abstract

Concepts are an essential language feature for generic programming in the large. Concepts allow for succinct expression of constraints on type parameters of generic algorithms, enable systematic organization of problem domain abstractions, and make generic algorithms easier to use. In this paper we present the design of a type system and semantics for concepts that is suitable for non-type-inferencing languages. Our design shares much in common with the type classes of Haskell, though our primary influence is from best practices in the C++ community, where concepts are used to document type requirements for templates in generic libraries. Concepts include a novel combination of associated types and same-type constraints that do not appear in type classes, but that are similar to nested types and type sharing in ML.

FAQs

sparkles

AI

What distinguishes concepts from traditional type classes in programming languages?add

The paper finds concepts allow multiple models with the same member name, unlike type classes, enhancing modularity. This distinction is crucial for languages without Haskell's type inference.

How does F G improve language support for generic programming?add

In F G, concepts and models provide first-class support for expressing admissible type sets. This captures the essence of generic programming better than subtype bounds or type classes.

What limitations exist in current programming languages supporting generic programming?add

The evaluation revealed current languages inadequately represent essential generic programming features like concepts, leading to issues with modularity and encapsulation. For example, associated types often introduce cumbersome clutter in interface definitions.

What methodology did the authors use to evaluate existing language features?add

The study implemented a generic graph library in four different programming paradigms, assessing their support for generic programming. This hands-on evaluation highlighted strengths and weaknesses in each approach.

What are the potential future improvements discussed for F G?add

The authors mention enhancements such as nested requirements, implicit instantiation rules, and static overload resolution to alleviate the clutter in model member access. Additionally, future work will address algorithm specialization and function overloading.

Related papers

Less Is More: Generic Programming Theory and Practice
José Pedro

2012

In Haskell, there is a clear distinction between values, types, and kinds. Values are built with constructors, such as True, which we colour in blue; we do not colour numerals, characters, or strings: Just 3, (Right 'p' Left "abc"). Datatypes, type synonyms, type variables, indexed families, and type classes are coloured in orange: Bool, Show α ⇒ Show [ α ], type family PF α. Kinds and kind variables are coloured in green: , → , Constraint. For simplicity we do not colour the arrow operator, as it can appear at different levels. Agda code The distinction between values and types is less clear in Agda. Our convention is to use blue for constructors (e.g. refl), orange for identifiers of type Set (e.g. _≡_), and green for identifiers of type Set 1 or (for simplicity) higher (e.g. Set). 2.2.3 Isomorphisms We have mentioned that some types are equivalent to others without formally defining this equivalence. When we say two types are equivalent we mean that they are isomorphic. The concept of isomorphism can be succinctly summarised as an Agda record type:

View PDFchevron_right
A Generic Framework for Genericity
Etienne Duris, Didier Parigot

Recently, generic programming becomes of a major interest in several programming paradigms. A recurrent idea to achieve genericity is to specify algorithms on their convenient data structure, and to allow these specifications to be instantiated onto a large number of neighboring data structures. Polytypic programming, shapely types and generic attribute grammars are generic programming methods related to this approach. A framework for generic programming is proposed to embed these methods. It consists in tools for automatic generation of morphisms between data structures, and for program composition. Thanks to this compositional approach, the complete specialization of generic programs could be advantageously delegated to a general and powerful mechanism of "symbolic composition", which performs deforestation and partial evaluation. 1 Introduction In several programming paradigms, generic programming is being emerging. Although this concept is not new, genericity currently...

View PDFchevron_right
A language for generic programming
Andrew Lumsdaine

2005

for carefully editing and catching the many many times when I accidentally skipped over the important stuff. Thanks to Jaakko and Jeremiah for hours of stimulating discussions and arguments concerning separate compilation and concept-based overloading. Thanks to David Abrahams for countless hours spent debating the merits of one design over another while jogging through the hinterlands of Norway. Thanks to Alexander Stepanov and David Musser for getting all this started, and thank you for the encouragement over the years. Thanks to Matthew Austern, his book Generic Programming in the STL was both an inspiration and an invaluable reference. Thanks to Beman Dawes and everyone involved with the Boost libraries. The collective experience from Boost was vital in the creation of this thesis. Thanks to Vincent Cremet and Martin Odersky for answering questions about Scala and virtual types.

View PDFchevron_right
A comparative study of language support for generic programming
Andrew Lumsdaine

ACM SIGPLAN Notices, 2003

Many modern programming languages support basic generic programming, sufficient to implement type-safe polymorphic containers. Some languages have moved beyond this basic support to a broader, more powerful interpretation of generic programming, and their extensions have proven valuable in practice. This paper reports on a comprehensive comparison of generics in six programming languages: C ++ , Standard ML, Haskell, Eiffel, Java (with its proposed generics extension), and Generic C#. By implementing a substantial example in each of these languages, we identify eight language features that support this broader view of generic programming. We find these features are necessary to avoid awkward designs, poor maintainability, unnecessary run-time checks, and painfully verbose code. As languages increasingly support generics, it is important that language designers understand the features necessary to provide powerful generics and that their absence causes serious difficulties for programmers.

View PDFchevron_right
Concepts (linguistic support for generic programming in C++)
Gabriel Menegatti Reis

Proceedings of the 21st Annual Acm Sigplan Conference, 2006

Generic programming has emerged as an important technique for the development of highly reusable and efficient software libraries. In C++, generic programming is enabled by the flexibility of templates, the C++ type parametrization mechanism. However, the power of templates comes with a price: generic (template) libraries can be more difficult to use and develop than non-template libraries and their misuse results in notoriously confusing error messages. As currently defined in C++98, templates are unconstrained, and type-checking of templates is performed late in the compilation process, i.e., after the use of a template has been combined with its definition. To improve the support for generic programming in C++, we introduce concepts to express the syntactic and semantic behavior of types and to constrain the type parameters in a C++ template. Using concepts, type-checking of template definitions is separated from their uses, thereby making templates easier to use and easier to compile. These improvements are achieved without limiting the flexibility of templates or decreasing their performance-in fact their expressive power is increased. This paper describes the language extensions supporting concepts, their use in the expression of the C++ Standard Template Library, and their implementation in the ConceptGCC compiler. Concepts are candidates for inclusion in the upcoming revision of the ISO C++ standard, C++0x.

View PDFchevron_right
A language for generic programming in the large
Andrew Lumsdaine

Science of Computer Programming, 2011

Generic programming is an effective methodology for developing reusable software libraries. Many programming languages provide generics and have features for describing interfaces, but none completely support the idioms used in generic programming. To address this need we developed the language G. The central feature of G is the concept, a mechanism for organizing constraints on generics that is inspired by

View PDFchevron_right
Fundamentals of Generic Programming
Alexander Stepanov

Lecture Notes in Computer Science, 2000

programming depends on the decomposition of programs into components which may be developed separately and combined arbitrarily, subject only to well-defined interfaces. Among the interfaces of interest, indeed the most pervasively and unconsciously used, are the fundamental operators common to all C++ built-in types, as extended to user-defined types, e.g. copy constructors, assignment, and equality. We investigate the relations which must hold among these operators to preserve consistency with their semantics for the built-in types and with the expectations of programmers.

View PDFchevron_right
Discussion: The Rôle of Types in Generic Programming
Johan Jeuring

Generic Programming, 2003

View PDFchevron_right
Genericity through Constrained Types
Vijay Saraswat

Modern object-oriented languages such as X10 require a rich framework for types capable of expressing valuedependency, type-dependency and supporting pluggable, application-specific extensions. In earlier work, we presented the framework of constrained types for concurrent, object-oriented languages, parametrized by an underlying constraint system C. Constraint systems are a very expressive framework for partial information. Types are viewed as formulas C{c} where C is the name of a class or an interface and c is a constraint in C on the immutable instance state of C (the properties). Many (value-)dependent type systems for object-oriented languages can be viewed as constrained types. This paper extends the constrained types approach to handle type-dependency ("genericity"). The key idea is to extend the constraint system to include predicates over types such as X is a subtype of T. Generic types are supported by introducing parameters and properties that range over types and permitting the user program to impose constraints on such variables. Type-valued properties are required to have a run-time representation-the run-time semantics is not defined through erasure. Run-time casts are permitted through dynamic code generation. To illustrate the underlying theory, we develop a formal family FX(C) of programming languages with a common set of sound type-checking rules. By varying C and extending the type system, we obtain languages with the power of FJ, FGJ, dependent types, and new object-oriented languages that uniformly support value-and type-dependency. Concretely, we illustrate with the design and implementation of the type system for X10. The type system integrates and extends the features of nominal types, virtual types, and path-dependent types.

View PDFchevron_right
Generic Programming with Dependent Types
Conor McBride

Lecture Notes in Computer Science, 2007

View PDFchevron_right

References (66)

  1. Ada 95 Reference Manual, 1997.
  2. J.-D. Boissonnat, F. Cazals, F. Da, O. Devillers, S. Pion, F. Rebufat, M. Teillaud, and M. Yvinec. Programming with CGAL: the example of triangulations. In Proceedings of the fifteenth annual symposium on Computational geometry, pages 421-422. ACM Press, 1999.
  3. Boost. Boost C++ Libraries. http://www.boost.org/.
  4. G. Bracha, N. Cohen, C. Kemper, S. Marx, et al. JSR 14: Add Generic Types to the Java Programming Language, April 2001. http://www.jcp.org/en/jsr/detail?id=014.
  5. K. B. Bruce, A. Schuett, and R. van Gent. PolyTOIL: A type- safe polymorphic object-oriented language. In W. Olthoff, editor, Proceedings of ECOOP '95, number 952 in Lecture Notes in Computer Science, pages 27-51. Springer-Verlag, 1995.
  6. P. Canning, W. Cook, W. Hill, W. Olthoff, and J. C. Mitchell. F-bounded polymorphism for object-oriented programming. In Proceedings of the fourth international conference on functional programming languages and computer architecture, 1989.
  7. L. Cardelli and P. Wegner. On understanding types, data abstraction, and polymorphism. ACM Computing Surveys, 17(4):471-522, 1985.
  8. M. Chakravarty, G. Keller, S. P. Jones, and S. Marlow. Associated types with class. In Proceedings of the 32nd ACM-SIGACT Symposium on Principles of Programming Languages, POPL 2005, Long Beach, California, pages 1-13. ACM, Jan. 2005.
  9. K. Chen, P. Hudak, and M. Odersky. Parametric type classes. In LISP and Functional Programming, pages 170-181, 1992.
  10. G. J. Ditchfield. Contextual polymorphism, 1994.
  11. G. J. Ditchfield. Cforall reference manual and rationale, 1997.
  12. E. Ernst. gbeta -a Language with Virtual Attributes, Block Structure, and Propagating, Dynamic Inheritance. PhD thesis, Department of Computer Science, University of Aarhus, Århus, Denmark, 1999.
  13. E. Ernst. Family polymorphism. In ECOOP, volume 2072 of Lecture Notes in Computer Science, pages 303-326. Springer, June 2001.
  14. R. Garcia, J. Järvi, A. Lumsdaine, J. Siek, and J. Willcock. A comparative study of language support for generic programming. In Proceedings of the 18th ACM SIGPLAN conference on Object- oriented programing, systems, languages, and applications, pages 115-134. ACM Press, Oct. 2003.
  15. J.-Y. Girard. Interprtation Fonctionnelle et Élimination des Coupures de l'Arithmtique d'Ordre Suprieur. Thse de doctorat d'tat, Universit Paris VII, Paris, France, 1972.
  16. J. A. Goguen, T. Winker, J. Meseguer, K. Futatsugi, and J.- P. Jouannaud. Introducing OBJ. In Applications of Algebraic Specification using OBJ. Cambridge University Press, 1992.
  17. C. V. Hall, K. Hammond, S. L. P. Jones, and P. L. Wadler. Type classes in Haskell. ACM Trans. Program. Lang. Syst., 18(2):109-138, 1996.
  18. International Standardization Organization (ISO). ANSI/ISO Standard 14882, Programming Language C++. 1 rue de Varembé, Case postale 56, CH-1211 Genève 20, Switzerland, 1998.
  19. J. Järvi, A. Lumsdaine, J. Siek, and J. Willcock. An analysis of constrained polymorphism for generic programming. In K. Davis and J. Striegnitz, editors, Multiparadigm Programming in Object- Oriented Languages Workshop (MPOOL) at OOPSLA, Anaheim, CA, Oct. 2003.
  20. J. Järvi, J. Willcock, and A. Lumsdaine. Algorithm specialization and concept constrained genericity. In Concepts: a Linguistic Foundation of Generic Programming. Adobe Systems, Apr. 2004.
  21. M. P. Jones. Type classes with functional dependencies. In European PLDI'05, 11 2005/4/19
  22. Symposium on Programming, number 1782 in LNCS, pages 230-244.
  23. W. Kahl and J. Scheffczyk. Named instances for Haskell type classes. In R. Hinze, editor, Proc. Haskell Workshop 2001, volume 59 of ENTCS, 2001. See also: http://ist.unibw-muenchen.de/ Haskell/NamedInstances/.
  24. D. Kapur and D. Musser. Tecton: a framework for specifying and verifying generic system components. Technical Report RPI-92-20, Department of Computer Science, Rensselaer Polytechnic Institute, Troy, New York 12180, July 1992.
  25. D. Kapur, D. R. Musser, and X. Nie. An overview of the tecton proof system. Theoretical Computer Science, 133:307-339, Oct. 1994.
  26. D. Kapur, D. R. Musser, and A. Stepanov. Operators and algebraic structures. In Proc. of the Conference on Functional Programming Languages and Computer Architecture, Portsmouth, New Hampshire. ACM, 1981.
  27. D. Katiyar, D. Luckham, and J. Mitchell. A type system for prototyping languages. In Conference Record of POPL '94: 21st ACM SIGPLAN-SIGACT Symposium of Principles of Programming Languages, Portland, Oregon, pages 138-150, 1994.
  28. A. Kennedy and D. Syme. Design and implementation of generics for the .NET Common Language Runtime. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), pages 1-12, Snowbird, Utah, June 2001.
  29. A. Kershenbaum, D. Musser, and A. Stepanov. Higher order imperative programming. Technical Report 88-10, Rensselaer Polytechnic Institute, 1988.
  30. U. Köthe. Handbook on Computer Vision and Applications, volume 3, chapter Reusable Software in Computer Vision. Acadamic Press, 1999.
  31. D. Le Botlan and D. Rémy. MLF: Raising ML to the power of System- F. In Proceedings of the International Conference on Functional Programming (ICFP 2003), Uppsala, Sweden, pages 27-38. ACM Press, aug 2003.
  32. X. Leroy, D. Doligez, J. Garrigue, D. Remy, and J. Vouillon. The Object Caml Documentation and User's Manual, September 2003.
  33. B. Liskov, R. Atkinson, T. Bloom, E. Moss, C. Schaffert, B. Scheifler, and A. Snyder. CLU reference manual. Technical Report LCS-TR- 225, Cambridge, MA, USA, October 1979.
  34. B. Liskov and J. Guttag. Abstraction and specification in program development. MIT Press, Cambridge, MA, USA, 1986.
  35. D. MacQueen. An implementation of Standard ML modules. In Proceedings of the 1988 ACM Conference on LISP and Functional Programming, Snowbird, UT, pages 212-223, New NY, 1988. ACM.
  36. B. Meyer. Eiffel: the Language. Prentice Hall, New York, NY, first edition, 1992.
  37. Microsoft Corporation. Generics in C#, September 2002. Part of the Gyro distribution of generics for .NET available at http: //research.microsoft.com/projects/clrgen/.
  38. R. Milner, M. Tofte, and R. Harper. The Definition of Standard ML. MIT Press, 1990.
  39. J. C. Mitchell. Polymorphic type inference and containment. Information and Computation, 76(2-3):211-249, 1988.
  40. D. R. Musser and A. Stepanov. Generic programming. In ISSAC: Proceedings of the ACM SIGSAM International Symposium on Symbolic and Algebraic Computation, 1988.
  41. D. R. Musser and A. A. Stepanov. A library of generic algorithms in Ada. In Using Ada (1987 International Ada Conference), pages 216-225, New York, NY, Dec. 1987. ACM SIGAda.
  42. G. Nelson and D. C. Oppen. Fast decision procedures based on congruence closure. J. ACM, 27(2):356-364, 1980.
  43. T. Nipkow. Structured Proofs in Isar/HOL. In H. Geuvers and F. Wiedijk, editors, Types for Proofs and Programs (TYPES 2002), volume 2646, pages 259-278, 2003.
  44. T. Nipkow, L. C. Paulson, and M. Wenzel. Isabelle/HOL -A Proof Assistant for Higher-Order Logic, volume 2283 of LNCS. Springer, 2002.
  45. M. Odersky and al. An overview of the scala programming language. Technical Report IC/2004/64, EPFL Lausanne, Switzerland, 2004.
  46. M. Odersky, V. Cremet, C. Röckl, and M. Zenger. A nominal theory of objects with dependent types. In Proc. ECOOP'03, Springer LNCS, 2003.
  47. M. Odersky and K. Läufer. Putting type annotations to work. In Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages, pages 54-67. ACM Press, 1996.
  48. B. C. Pierce. Intersection types and bounded polymorphism. Mathematical Structures in Computer Science, 11, 1996.
  49. B. C. Pierce. Types and Programming Languages. MIT Press, 2002.
  50. W. R. Pitt, M. A. Williams, M. Steven, B. Sweeney, A. J. Bleasby, and D. S. Moss. The bioinformatics template library: generic components for biocomputing. Bioinformatics, 17(8):729-737, 2001.
  51. E. Poll and S. Thompson. The Type System of Aldor. Technical Re- port 11-99, Computing Laboratory, University of Kent at Canterbury, Kent CT2 7NF, UK, July 1999.
  52. D. Rémy and J. Vouillon. Objective ML: An effective object-oriented extension to ML. Theory And Practice of Object Systems, 4(1):27-50, 1998. A preliminary version appeared in the proceedings of the 24th ACM Conference on Principles of Programming Languages, 1997.
  53. J. C. Reynolds. Towards a theory of type structure. In B. Robinet, editor, Programming Symposium, volume 19 of Lecture Notes in Computer Science, pages 408-425, Berlin, 1974. Springer-Verlag.
  54. J. Siek, L.-Q. Lee, and A. Lumsdaine. The generic graph component library. In Proceedings of the 1999 ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications, pages 399-414. ACM Press, 1999.
  55. J. Siek, L.-Q. Lee, and A. Lumsdaine. The Boost Graph Library: User Guide and Reference Manual. Addison-Wesley, 2002.
  56. J. Siek and A. Lumsdaine. Essential language support for generic programming: Formalization part 1. Technical Report 605, Indiana University, December 2004.
  57. J. G. Siek and A. Lumsdaine. Advances in Software Tools for Scientific Computing, chapter A Modern Framework for Portable High Performance Numerical Linear Algebra. Springer, 2000.
  58. Silicon Graphics, Inc. SGI Implementation of the Standard Template Library, 2004. http://www.sgi.com/tech/stl/.
  59. A. Stepanov. gclib. http://www.stepanovpapers.com, 1987.
  60. A. A. Stepanov and M. Lee. The Standard Template Library. Technical Report X3J16/94-0095, WG21/N0482, ISO Programming Language C++ Project, May 1994.
  61. B. Stroustrup. Parameterized types for C++. In USENIX C++ Conference, October 1988.
  62. J. Tiuryn and P. Urzyczyn. The subtyping problem for second-order types is undecidable. Information and Computation, 179(1):1-18, 2002.
  63. M. Troyer, S. Todo, S. Trebst, and A. F. and. ALPS: Algorithms and Libraries for Physics Simulations. http://alps.comp-phys. org/.
  64. P. Wadler and S. Blott. How to make ad-hoc polymorphism less ad- hoc. In ACM Symposium on Principles of Programming Languages, pages 60-76. ACM, Jan. 1989.
  65. J. Walter and M. Koch. uBLAS. Boost. http://www.boost.org/ libs/numeric/ublas/doc/index.htm.
  66. J. Willcock, J. Järvi, A. Lumsdaine, and D. Musser. A formalization of concepts for generic programming. In Concepts: a Linguistic Foundation of Generic Programming at Adobe Tech Summit. Adobe Systems, Apr. 2004.

Related papers

Essential Language Support for Generic Programming: Formalization Part 1 Technical Report 605
Andrew Lumsdaine

2004

Concepts are an essential language feature for generic programming in the large. Concepts allow for succinct expression of constraints on type parameters of generic algorithms, enable systematic organization of problem domain abstractions, and make generic algorithms easier to use. In this paper we present the design of a type system and semantics for concepts that is suitable for non-typeinferencing languages. Our design shares much in common with the type classes of Haskell, though our primary influence is from best practices in the C ++ community, where concepts are used to document type requirements for templates in generic libraries. Concepts include a novel combination of associated types and sametype constraints that do not appear in type classes, but that are similar to nested types and type sharing in ML.

View PDFchevron_right
An extended comparative study of language support for generic programming
Andrew Lumsdaine

Journal of Functional Programming, 2006

Many modern programming languages support basic generics, sufficient to implement type-safe polymorphic containers. Some languages have moved beyond this basic support, and in doing so have enabled a broader, more powerful form of generic programming. This paper reports on a comprehensive comparison of facilities for generic programming in eight programming languages: C++, Standard ML, Objective Caml, Haskell, Eiffel, Java, C# (with its proposed generics extension), and Cecil. By implementing a substantial example in each of these languages, we illustrate how the basic roles of generic programming can be represented in each language. We also identify eight language properties that support this broader view of generic programming: support for multi-type concepts, multiple constraints on type parameters, convenient associated type access, constraints on associated types, retroactive modeling, type aliases, separate compilation of algorithms and data structures, and implicit argument t...

View PDFchevron_right
An analysis of constrained polymorphism for generic programming
Andrew Lumsdaine

2003

Support for object-oriented programming has become an integral part of mainstream languages, and more recently generic programming has gained widespread acceptance. A natural question is how these two paradigms, and their underlying language mechanisms, should interact. One particular design option, that of using subtyping to constrain the type parameters of generic functions, has been chosen for the generics extensions to Java and C#. The leading alternative to subtype-based constraints is to use type classes, as they are called in Haskell, or concepts, as they are called in the C++ generic programming community. In this paper we argue that while object-oriented interfaces and concepts are similar in many ways, they also have subtle but important differences that make concepts more suitable for constraining polymorphism in generic programming.

View PDFchevron_right
A formalization of concepts for generic programming
Andrew Lumsdaine

Concepts: a Linguistic Foundation …

Abstract. Generic programming is a paradigm for systematic design and clas-sification of software components for optimal reuse. It has been the guiding methodology behind the design of the C++ Standard Template Library and nu-merous other C++ libraries. Generic ...

View PDFchevron_right
Towards a categorical foundation for generic programming
Nicolas Wu

2011

Abstract Generic Haskell is an extension of Haskell that supports datatype generic programming. The central idea of Generic Haskell is to interpret a type by a function, the so-called instance of a generic function at that type. Since types in Haskell include parametric types such as' list of', Generic Haskell represents types by terms of the simply-typed lambda calculus.

View PDFchevron_right

Related topics

  • Computer Science
  • Type System
  • Standard Ml
  • Contents

    • Cited by

    The implicit calculus: a new foundation for generic programming
    Wonchan Lee

    Sigplan Notices

    Generic programming (GP) is an increasingly important trend in programming languages. Well-known GP mechanisms, such as type classes and the C++0x concepts proposal, usually combine two features: 1) a special type of interfaces; and 2) implicit instantiation of implementations of those interfaces.

    View PDFchevron_right
    580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved