Datatype-generic programming workshop 2005
Details | Programme | Participants | Registration and Contact
Details | Programme | Participants | Registration and Contact
On Thursday August 25 and Friday August 26, 2005, we will organise a datatype-generic programming workshop. Last year this workshop was organised by Jeremy Gibbons in Oxford.
The scope of the workshop is techniques for reasoning about and implementing programs that are parametrized by a datatype. Think Algebra of Programming, PolyP, Generic Haskell, Scrap your Boilerplate, Template MetaHaskell, Dependent Types, etc.
Participation is by invitation only, but let me know if you think you should be invited.
The workshop will be held at Utrecht University on the Uithof. Here is some information about how to travel to the Uithof.
Information about hotels is available here. I'd appreciate it if you book your hotel yourself. Note: via www.nstravel.nl you can book good hotels relatively cheap. You need to use the codes that are mentioned on the `prijzen'page. Contact me if you need more info, or don't understand the Dutch.
I propose we meet on Wednesday night in Oudaen. You can find Oudaen at the red flag on the map, on Oudegracht 99. I'll be there from 8:30 pm to approximately 10 pm (and maybe longer).
I think I'll arrange a barbecue (weather permitting) on Thursday night in the garden of our new house, at Weerdsingel oz 77. You can find our house at the green flag on the map.
We draw together ideas from the Design Patterns community (the Gang of Four: Gamma, Helm, Johnson, Vlissides) and the Functional Programming world (eg Bird, Meertens, Hughes). In particular, the thesis is that whereas design patterns must be expressed extra-linguistically (as prose, diagrams, examples) in object-oriented languages, they may be captured directly as abstractions using higher-order operators in datatype-generic programming languages. Therefore, they may be reasoned about, type-checked, applied and reused, just as any other abstractions may be. We argue this case by developing the idea of higher-order operators, specifically for capturing patterns of computation in programs. We then show how the intentions behind a number of the Gang of Four patterns - specifically Composite, Visitor, Iterator, and Builder - may be expressed as higher-order datatype-generic operators.
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 type-indexed 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.
Please register by sending an email to Johan Jeuring. Let me know at the same time whether or not you want to give a talk, and if you want to give a talk, about what.
We will charge a small registration fee (40 euros), covering lunches etc.
For contact information, consult my homepage.