Generics for the masses

Hinze, Ralf

doi:10.1017/s0956796806006022

Cited by 44 publications

(24 citation statements)

References 34 publications

(31 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Modular interpretations are also possible in Haskell via a variant of Church encodings that uses type classes. The original technique is due to Hinze [9] and was shown to be 10:12 modular and extensible by Oliveira, Hinze and Löh [16]. It has since been popularized under the name Finally Tagless [2] in the context of embedded DSLs.…”

Section: Modular Interpretations In Haskellmentioning

confidence: 99%

Shallow EDSLs and Object-Oriented Programming: Beyond Simple Compositionality

Zhang

Oliveira

2019

Programming

View full text Add to dashboard Cite

Context. Embedded Domain-Specific Languages (EDSLs) are a common and widely used approach to DSLs in various languages, including Haskell and Scala. There are two main implementation techniques for EDSLs: shallow embeddings and deep embeddings.Inquiry. Shallow embeddings are quite simple, but they have been criticized in the past for being quite limited in terms of modularity and reuse. In particular, it is often argued that supporting multiple DSL interpretations in shallow embeddings is difficult.Approach. This paper argues that shallow EDSLs and Object-Oriented Programming (OOP) are closely related. Gibbons and Wu already discussed the relationship between shallow EDSLs and procedural abstraction, while Cook discussed the connection between procedural abstraction and OOP. We make the transitive step in this paper by connecting shallow EDSLs directly to OOP via procedural abstraction. The knowledge about this relationship enables us to improve on implementation techniques for EDSLs.Knowledge. This paper argues that common OOP mechanisms (including inheritance, subtyping, and typerefinement) increase the modularity and reuse of shallow EDSLs when compared to classical procedural abstraction by enabling a simple way to express multiple, possibly dependent, interpretations.Grounding. We make our arguments by using Gibbons and Wu's examples, where procedural abstraction is used in Haskell to model a simple shallow EDSL. We recode that EDSL in Scala and with an improved OO-inspired Haskell encoding. We further illustrate our approach with a case study on refactoring a deep external SQL query processor to make it more modular, shallow, and embedded.Importance. This work is important for two reasons. Firstly, from an intellectual point of view, this work establishes the connection between shallow embeddings and OOP, which enables a better understanding of both concepts. Secondly, this work illustrates programming techniques that can be used to improve the modularity and reuse of shallow EDSLs. ACM CCS 2012Software and its engineering → Language features; Domain specific languages;

show abstract

Section: Modular Interpretations In Haskellmentioning

confidence: 99%

Shallow EDSLs and Object-Oriented Programming: Beyond Simple Compositionality

Zhang

Oliveira

2019

Programming

View full text Add to dashboard Cite

show abstract

“…This is a sum-of-products representation similar to that proposed by Hinze [2006]. Algebraic data types can be uniformly viewed in this way: choice between constructor variants is encoded as (potentially nested) binary sums (:+:).…”

Section: Generic Programmingmentioning

confidence: 99%

“…Magalhães [2014] considered multiple parameters, but has a different solution to ours and is less flexible. Our method is to use the generic structure of data, which was prominently investigated by Hinze [2006], and has led to an implementation in GHC that allows generic type classes to be derived [Magalhães et al 2010]. GHC.Generics was intended to be a low-level way for library authors to implement generic programming libraries.…”

Section: Related Workmentioning

confidence: 99%

Generic deriving of generic traversals

Kiss

Pickering

2018

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Functional programmers have an established tradition of using traversals as a design pattern to work with recursive data structures. The technique is so prolific that a whole host of libraries have been designed to help in the task of automatically providing traversals by analysing the generic structure of data types. More recently, lenses have entered the functional scene and have proved themselves to be a simple and versatile mechanism for working with product types. They make it easy to focus on the salient parts of a data structure in a composable and reusable manner.In this paper, we use the combination of lenses and traversals to give rise to an expressive and flexible library for querying and modifying complex data structures. Furthermore, since our lenses and traversals are based on the generic shape of data, we are able to use this information to produce code that is as efficient as hand-written versions. The technique leverages the structure of data to produce generic abstractions that are then eliminated by the standard workhorses of modern functional compilers: inlining and specialisation.

show abstract

“…Hinze [14] describes a library for generic programming in Haskell with a type class that corresponds quite closely to the TYPE signature of §2, except that the types described are Haskell's, not the types of a foreign language. There is a close connection between Haskell's type classes and ML's modules, and so Karvonen's implementation of Hinze's approach in ML [15] corresponds even more directly to this aspect of Cmeleon's design.…”

Section: Influences and Related Workmentioning

confidence: 99%

A modular foreign function interface

Yallop

Sheets

Madhavapeddy

2018

Science of Computer Programming

View full text Add to dashboard Cite

Foreign function interfaces (FFIs) between high-level languages and system libraries typically intertwine the actions of describing the interface of a system library and selecting a binding strategy for linking to it. This tight coupling makes it difficult for programmers to switch between different binding strategies, and discourages the development of new approaches to binding, since more exotic approaches are unlikely to attract sufficient users to justify the cost of development.We present Cmeleon, a replacement for the standard OCaml FFI that exposes typed constructors that correspond to the operations of the type algebra of C, and binding strategies that interpret this type structure as separate program stages. Cmeleon parameterises external calls across binding strategies, isolating interface descriptions from choices relating to call construction (code generation vs dynamic call frames), concurrency style (blocking, cooperatively or preemptively threaded), and separation (in-process, address space or a network connection).This flexibility enables significant code reuse of bindings in many different contexts, from rapid interactive development in a REPL to production deployments with generated code and privilege separation. Cmeleon has been used for the past two years to bind to a broad variety of real-world OCaml libraries, and entirely supplants the need for the low-level C FFI for the vast majority of applications.

show abstract

Generics for the masses

Cited by 44 publications

References 34 publications

Shallow EDSLs and Object-Oriented Programming: Beyond Simple Compositionality

Shallow EDSLs and Object-Oriented Programming: Beyond Simple Compositionality

Generic deriving of generic traversals

A modular foreign function interface

Contact Info

Product

Resources

About