Dependency-style generic haskell

Löh, Andres; ClarkeDave,; JeuringJohan,

doi:10.1145/944746.944719

Cited by 9 publications

(10 citation statements)

References 23 publications

(20 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…User-defined type classes cannot take advantage of deriving. To address this limitation, there have been a number of proposals for experimental libraries and extensions to Haskell, such as Polytypic Programming (PolyP) [18], Generic Haskell [3,24], Derivable type classes [11], the Typeable type class (with the "Scrap your Boilerplate Library" [21,22,23]), preprocessors such as DrIFT [6] and Template Haskell [30], and various encodings of representation types [39,5,13]. These proposals each have their benefits, but none has emerged as a clearly better solution.…”

Section: Deriving Type-indexed Operationsmentioning

confidence: 99%

RepLib

Weirich

2006

Proceedings of the 2006 ACM SIGPLAN Workshop on Haskell

View full text Add to dashboard Cite

Some type class instances can be automatically derived from the structure of types. As a result, the Haskell language includes the "deriving" mechanism to automatic generates such instances for a small number of built-in type classes. In this paper, we present RepLib, a GHC library that enables a similar mechanism for arbitrary type classes. Users of RepLib can define the relationship between the structure of a datatype and the associated instance declaration by a normal Haskell functions that pattern-matches a representation type. Furthermore, operations defined in this manner are extensible-instances for specific types not defined by type structure may also be incorporated. Finally, this library also supports the definition of operations defined by parameterized types.In Section 7, we compare the capabilities of this proposal to existing work. For example, there are a number of ways to generically represent the structure of datatypes, and, more broadly, there are a number of ways to define type-indexed operations that do not rely on representation types. However, our view is that the success of any proposal relies on ease of adoption. Therefore, we have worked hard to identify a small set of mechanisms, implementable within the language of an existing Haskell compiler, that are, in our subjective view, useful for common situations and provide a programming model familiar to functional programmers.An initial release of RepLib is available for download 1 and is compilable with the Glasgow Haskell Compiler (GHC), version 6.4. This library is not portable. It requires many of the advanced features of GHC that are not found in Haskell 98: Higher-rank polymorphism [29], lexically-scoped type variables [31], Generalized Algebraic Datatypes (GADTs) [28], and undecidable instance declarations. Furthermore, Template Haskell [30] automates the definition of representations for new datatypes. However, all of these extensions are useful in their own respect.

show abstract

Section: Deriving Type-indexed Operationsmentioning

confidence: 99%

RepLib

Weirich

2006

Proceedings of the 2006 ACM SIGPLAN Workshop on Haskell

View full text Add to dashboard Cite

show abstract

“…We specify the traversal operation using the polytypic programming extension of Haskell: Generic Haskell [14]. Every type, except certain predefined/basic types as Int, has a generic representation using only sums, products, and units.…”

Section: Polytypic Traversalsmentioning

confidence: 99%

“…Polytypic examples use Generic Haskell [14], the generic programming extension for Haskell. The code can be downloaded from http://www.cs.ru.nl/A.vanWeelden/bi-arrows/.…”

Section: Introductionmentioning

confidence: 99%

There and back again

Alimarine

Smetsers

Weelden

et al. 2005

Proceedings of the 2005 ACM SIGPLAN Workshop on Haskell

View full text Add to dashboard Cite

Invertible programming occurs in the area of data conversion where it is required that the conversion in one direction is the inverse of the other. For that purpose, we introduce bidirectional arrows (biarrows). The bi-arrow class is an extension of Haskell's arrow class with an extra combinator that changes the direction of computation.The advantage of the use of bi-arrows for invertible programming is the preservation of invertibility properties using the biarrow combinators. Programming with bi-arrows in a polytypic or generic way exploits this the most. Besides bidirectional polytypic examples, including invertible serialization, we give the definition of a monadic bi-arrow transformer, which we use to construct a bidirectional parser/pretty printer.

show abstract

“…(empty (emptyT rb))) Inr r → PlusCase (Pair (empty (emptyT ra)) (single rb r v))) prod ra rb = Single (prod (emptyT ra) (emptyT rb)) (λi v → case i of Prod x y → ProdCase (single ra x (single rb y v))) data ra iso iso2 = Single (data (emptyT ra) iso iso2) (λi v → to iso2 (single ra (from iso i) v)) The idea of dependencies is motivated by Dependency-Style Generic Haskell [26,27]. In this version of Generic Haskell, the type system reflects the uses of generic functions in the definitions by keeping track of constraints that identify such uses.…”

Section: Triesmentioning

confidence: 99%

“…Furthermore, Generic Haskell features generic types and generic function customisation (which were not present in PolyP). Dependency-Style Generic Haskell [26,27] introduces a rather complex type system that keeps track of dependencies on generic function calls. The need for this sophisticated type system is a consequence of a model for generic programming that allows generic function customisation.…”

Section: Related Workmentioning

confidence: 99%

TypeCase

Oliveira

Gibbons

2005

Proceedings of the 2005 ACM SIGPLAN Workshop on Haskell

View full text Add to dashboard Cite

A type-indexed function is a function that is defined for each member of some family of types. Haskell's type class mechanism provides collections of open type-indexed functions, in which the indexing family can be extended by defining a new type class instance but the collection of functions is fixed. The purpose of this paper is to present TypeCase: a design pattern that allows the definition of closed type-indexed functions, in which the index family is fixed but the collection of functions is extensible. It is inspired by Cheney and Hinze's work on lightweight approaches to generic programming. We generalise their techniques as a design pattern. Furthermore, we show that type-indexed functions with typeindexed types, and consequently generic functions with generic types, can also be encoded in a lightweight manner, thereby overcoming one of the main limitations of the lightweight approaches.

show abstract

Dependency-style generic haskell

Cited by 9 publications

References 23 publications

RepLib

RepLib

There and back again

TypeCase

Contact Info

Product

Resources

About