## Generic programming with fixed points for mutually (2008)

### Cached

### Download Links

Citations: | 24 - 13 self |

### BibTeX

@MISC{Rodriguez08genericprogramming,

author = {Alexey Rodriguez and Stefan Holdermans and Andres Löh and Johan Jeuring},

title = {Generic programming with fixed points for mutually },

year = {2008}

}

### OpenURL

### Abstract

### Citations

298 | Functional programming with bananas, lenses, envelopes and barbed wire
- Meijer, Fokkinga, et al.
- 1991
(Show Context)
Citation Context ...matically adapt to a changing datatype. Generic programming grew out of category theory, in which datatypes are represented as initial algebras or fixed points of functors (Hagino 1987; Malcolm 1990; =-=Meijer et al. 1991-=-). A functor is a datatype of kind ∗ → ∗ together with a map function. Fixed points are represented by an instance of the Fix datatype: {alexey,stefan,andres,johanj}@cs.uu.nl data Fix f = In (f (Fix f... |

174 | PolyP – a polytypic programming language extension
- Jansson, Jeuring
- 1997
(Show Context)
Citation Context ...means of Fix is limited, and does not include mutually recursive datatypes and nested datatypes (Bird and Meertens 1998). Early generic programming systems based on a fixed-point view, such as PolyP (=-=Jansson and Jeuring 1997-=-), inherit these restrictions. The lack of support for mutually recursive datatypes is particularly limiting, because most larger systems are described by several datatypes with complex dependencies. ... |

172 | Template meta-programming for Haskell - Sheard, Jones - 2002 |

167 | Towards a Practical Programming Language Based on Dependent Type Theory - Norell - 2007 |

157 | Simple unification-based type inference for GADTs
- Jones, Vytiniotis, et al.
- 2006
(Show Context)
Citation Context ...s: • We show how to represent a system of (arbitrarily many) mutually recursive datatypes using a fixed-point view in Haskell, using extensions to the Haskell language, most prominently GADTs (Peyton =-=Jones et al. 2006-=-), type families (Chakravarty et al. 2005) and rank-2 types. Despite these extensions, the technique is easy to use for the programmer, and does not require more effort than other approaches to generi... |

135 | Scrap your boilerplate: a practical design pattern for generic programming - Lämmel, Jones - 2003 |

112 | A fold for all seasons
- Sheard, Fegaras
- 1993
(Show Context)
Citation Context ...e datatypes in Haskell suitable for implementing generic programs. Several authors discuss how to generate folds and other recursive schemes on mutually recursive datatypes (Böhm and Berarducci 1985; =-=Sheard and Fegaras 1993-=-; Swierstra et al. 1999; Lämmel et al. 2000). The definitions in these papers cannot be directly translated to Haskell because they require (type level) induction on the number of datatypes involved. ... |

107 | Polytypic values possess polykinded types
- Hinze
- 2000
(Show Context)
Citation Context ... are described by several datatypes with complex dependencies. Partially to overcome such limitations, several other approaches to generic programming have been developed, among them Generic Haskell (=-=Hinze 2000-=-; Löh 2004; Löh et al. 2008) and Scrap Your Boilerplate (Lämmel and Peyton Jones 2003). These approaches do not use fixed points to represent datatypes, and can handle mutually recursive types, and ma... |

105 |
Data structures and program transformation
- Malcolm
- 1990
(Show Context)
Citation Context ...ions that automatically adapt to a changing datatype. Generic programming grew out of category theory, in which datatypes are represented as initial algebras or fixed points of functors (Hagino 1987; =-=Malcolm 1990-=-; Meijer et al. 1991). A functor is a datatype of kind ∗ → ∗ together with a map function. Fixed points are represented by an instance of the Fix datatype: {alexey,stefan,andres,johanj}@cs.uu.nl data ... |

94 | A new approach to generic functional programming - Hinze - 2000 |

92 | The zipper
- Huet
- 1997
(Show Context)
Citation Context ...g functions (Jansson and Jeuring 2000), functions for selecting subexpressions (Steenbergen et al. 2008), pattern matching (Jeuring 1995), design patterns (Gibbons 2006), the Zipper and its variants (=-=Huet 1997-=-; McBride 2001; Hinze et al. 2004; Morris et al. 2006; McBride 2008), etc. The recursive structure of datatypes also plays an important role when transforming programs or proving properties about prog... |

79 | Nested datatypes
- BIRD, MEERTENS
- 1998
(Show Context)
Citation Context ...sing a limited set of datatypes for sums and products. The set of datatypes that can be represented by means of Fix is limited, and does not include mutually recursive datatypes and nested datatypes (=-=Bird and Meertens 1998-=-). Early generic programming systems based on a fixed-point view, such as PolyP (Jansson and Jeuring 1997), inherit these restrictions. The lack of support for mutually recursive datatypes is particul... |

75 |
Associated type synonyms
- Chakravarty, Keller, et al.
- 2005
(Show Context)
Citation Context ...tem of (arbitrarily many) mutually recursive datatypes using a fixed-point view in Haskell, using extensions to the Haskell language, most prominently GADTs (Peyton Jones et al. 2006), type families (=-=Chakravarty et al. 2005-=-) and rank-2 types. Despite these extensions, the technique is easy to use for the programmer, and does not require more effort than other approaches to generic programming (Section 3). • We show that... |

74 | A lightweight implementation of generics and dynamics - Cheney, Hinze - 2002 |

68 | Exploring Generic Haskell
- Löh
- 2004
(Show Context)
Citation Context ...ed by several datatypes with complex dependencies. Partially to overcome such limitations, several other approaches to generic programming have been developed, among them Generic Haskell (Hinze 2000; =-=Löh 2004-=-; Löh et al. 2008) and Scrap Your Boilerplate (Lämmel and Peyton Jones 2003). These approaches do not use fixed points to represent datatypes, and can handle mutually recursive types, and many or all ... |

58 | Type-indexed data types - HINZE, JEURING, et al. - 2004 |

52 | Generic programming within dependently typed programming - Altenkirch, McBride - 2003 |

51 | Generics for the masses - Hinze - 2004 |

44 |
Automatic synthesis of typed Λ-programs on term algebras
- Böhm, Berarducci
- 1985
(Show Context)
Citation Context ...ints for mutually recursive datatypes in Haskell suitable for implementing generic programs. Several authors discuss how to generate folds and other recursive schemes on mutually recursive datatypes (=-=Böhm and Berarducci 1985-=-; Sheard and Fegaras 1993; Swierstra et al. 1999; Lämmel et al. 2000). The definitions in these papers cannot be directly translated to Haskell because they require (type level) induction on the numbe... |

42 | Universes for generic programs and proofs in dependent type theory - Benke, Dybjer, et al. - 2003 |

39 | Designing and Implementing Combinator Languages
- Swierstra, Azero, et al.
- 1999
(Show Context)
Citation Context ...itable for implementing generic programs. Several authors discuss how to generate folds and other recursive schemes on mutually recursive datatypes (Böhm and Berarducci 1985; Sheard and Fegaras 1993; =-=Swierstra et al. 1999-=-; Lämmel et al. 2000). The definitions in these papers cannot be directly translated to Haskell because they require (type level) induction on the number of datatypes involved. Mitchell and Runciman (... |

37 | Type checking with open type functions - Schrijvers, Jones, et al. - 2008 |

36 | The derivative of a regular type is its type of one-hole contexts. Unpublished manuscript (2001
- McBride
- 2012
(Show Context)
Citation Context ... (Jansson and Jeuring 2000), functions for selecting subexpressions (Steenbergen et al. 2008), pattern matching (Jeuring 1995), design patterns (Gibbons 2006), the Zipper and its variants (Huet 1997; =-=McBride 2001-=-; Hinze et al. 2004; Morris et al. 2006; McBride 2008), etc. The recursive structure of datatypes also plays an important role when transforming programs or proving properties about programs, such as ... |

31 |
Category Theoretic Approach to Data Types
- Hagino
- 1987
(Show Context)
Citation Context ...es, and functions that automatically adapt to a changing datatype. Generic programming grew out of category theory, in which datatypes are represented as initial algebras or fixed points of functors (=-=Hagino 1987-=-; Malcolm 1990; Meijer et al. 1991). A functor is a datatype of kind ∗ → ∗ together with a map function. Fixed points are represented by an instance of the Fix datatype: {alexey,stefan,andres,johanj}@... |

28 | Polytypic pattern matching
- Jeuring
- 1995
(Show Context)
Citation Context ...Gibbons 1998), unification (Jansson and Jeuring 1998), rewriting and matching functions (Jansson and Jeuring 2000), functions for selecting subexpressions (Steenbergen et al. 2008), pattern matching (=-=Jeuring 1995-=-), design patterns (Gibbons 2006), the Zipper and its variants (Huet 1997; McBride 2001; Hinze et al. 2004; Morris et al. 2006; McBride 2008), etc. The recursive structure of datatypes also plays an i... |

28 | Dealing with Large Bananas
- Lammel, Visser, et al.
(Show Context)
Citation Context ... generic programs. Several authors discuss how to generate folds and other recursive schemes on mutually recursive datatypes (Böhm and Berarducci 1985; Sheard and Fegaras 1993; Swierstra et al. 1999; =-=Lämmel et al. 2000-=-). The definitions in these papers cannot be directly translated to Haskell because they require (type level) induction on the number of datatypes involved. Mitchell and Runciman (2007) show how to ob... |

25 | Generic views on data types
- Holdermans, Jeuring, et al.
- 2006
(Show Context)
Citation Context ...eneric programming system that does not use fixed points, such functions cannot be defined properly. In Generic Haskell, views on datatypes have been added, including a fixed-point view on datatypes (=-=Holdermans et al. 2006-=-): a programmer can choose to write a function that does not need access to the recursive positions and works on many datatypes, or to write a function that requires the fixed-point view, but that fun... |

22 | Foundations for structured programming with GADTs - Johann, Ghani - 2008 |

19 | Generic downwards accumulations
- Gibbons
- 2000
(Show Context)
Citation Context ...t the recursive structure of datatypes. Examples of such functions are the recursion schemes such as fold and its variants (Meijer et al. 1991), upwards and downwards accumulations (Bird et al. 1996; =-=Gibbons 1998-=-), unification (Jansson and Jeuring 1998), rewriting and matching functions (Jansson and Jeuring 2000), functions for selecting subexpressions (Steenbergen et al. 2008), pattern matching (Jeuring 1995... |

19 |
Polytypic unification
- Jansson, Jeuring
- 1998
(Show Context)
Citation Context ... datatypes. Examples of such functions are the recursion schemes such as fold and its variants (Meijer et al. 1991), upwards and downwards accumulations (Bird et al. 1996; Gibbons 1998), unification (=-=Jansson and Jeuring 1998-=-), rewriting and matching functions (Jansson and Jeuring 2000), functions for selecting subexpressions (Steenbergen et al. 2008), pattern matching (Jeuring 1995), design patterns (Gibbons 2006), the Z... |

18 | Oege de Moor, and Paul Hoogendijk. Generic functional programming with types and relations - Bird - 1996 |

16 | Exploring the regular tree types
- Morris, Altenkirch, et al.
- 2004
(Show Context)
Citation Context ...tions for selecting subexpressions (Steenbergen et al. 2008), pattern matching (Jeuring 1995), design patterns (Gibbons 2006), the Zipper and its variants (Huet 1997; McBride 2001; Hinze et al. 2004; =-=Morris et al. 2006-=-; McBride 2008), etc. The recursive structure of datatypes also plays an important role when transforming programs or proving properties about programs, such as the fold fusion theorem (Malcolm 1990),... |

16 | Polytypic programming in haskell
- Norell, Jansson
- 2005
(Show Context)
Citation Context ...ly: for different instantiations of the type index a, we can provide different definitions of PF a. The pattern functor PF corresponds to PolyP’s type constructor FunctorOf (Jansson and Jeuring 1997; =-=Norell and Jansson 2004-=-). The two methods from and to embed regular datatypes into their pattern functor-based representation. Here is the Regular instance for expressions:stype instance PF Expr = PF Expr instance Regular E... |

14 | Doaitse Swierstra. Typing dynamic typing - Baars, S - 2002 |

14 | A framework for polytypic programming on terms, with an application to rewriting
- Jansson, Jeuring
- 2000
(Show Context)
Citation Context ...mes such as fold and its variants (Meijer et al. 1991), upwards and downwards accumulations (Bird et al. 1996; Gibbons 1998), unification (Jansson and Jeuring 1998), rewriting and matching functions (=-=Jansson and Jeuring 2000-=-), functions for selecting subexpressions (Steenbergen et al. 2008), pattern matching (Jeuring 1995), design patterns (Gibbons 2006), the Zipper and its variants (Huet 1997; McBride 2001; Hinze et al.... |

9 | Clowns to the left of me, jokers to the right (pearl): dissecting data structures
- McBride
- 2008
(Show Context)
Citation Context ...subexpressions (Steenbergen et al. 2008), pattern matching (Jeuring 1995), design patterns (Gibbons 2006), the Zipper and its variants (Huet 1997; McBride 2001; Hinze et al. 2004; Morris et al. 2006; =-=McBride 2008-=-), etc. The recursive structure of datatypes also plays an important role when transforming programs or proving properties about programs, such as the fold fusion theorem (Malcolm 1990), the generic a... |

8 | Initial Algebra Semantics is Enough - Johann, Ghani - 2007 |

3 | The Generic Haskell user’s guide, Version 1.80 - Emerald release - Löh, Jeuring, et al. - 2008 |

1 | Jeroen Leeuwestein, Johan Jeuring, José Pedro Magalhães, and Sylvia Stuurman. Selecting (sub)expressions – generic programming without generic programs. Unpublished - Steenbergen - 2008 |