18th February 2009, 06:34 pm
I’ve just finished a draft of a paper called Denotational design with type class morphisms, for submission to ICFP 2009.
The paper is on a theme I’ve explored in several posts, which is semantics-based design, guided by type class morphisms.
I’d love to get some readings and feedback.
Pointers to related work would be particularly appreciated, as well as what’s unclear and what could be cut.
It’s an entire page over the limit, so I’ll have to do some trimming before submitting.
The abstract:
Type classes provide a mechanism for varied implementations of standard
interfaces. Many of these interfaces are founded in mathematical
tradition and so have regularity not only of types but also of
properties (laws) that must hold. Types and properties give strong
guidance to the library implementor, while leaving freedom as well. Some
of the remaining freedom is in how the implementation works, and some
is in what it accomplishes.
To give additional guidance to the what, without impinging on the
how, this paper proposes a principle of type class morphisms (TCMs),
which further refines the compositional style of denotational
semantics. The TCM idea is simply that the instance’s meaning is the
meaning’s instance. This principle determines the meaning of each type
class instance, and hence defines correctness of implementation. In some
cases, it also provides a systematic guide to implementation, and in
some cases, valuable design feedback.
The paper is illustrated with several examples of type, meanings, and
morphisms.
You can get the paper and see current errata here.
The submission deadline is March 2, so comments before then are most helpful to me.
Enjoy, and thanks!
19th October 2008, 05:26 pm
A previous post described a data type of functional linear maps.
As Andy Gill pointed out, we had a heck of a time trying to get good performance.
This note describes a new representation that is very simple and much more efficient.
It’s terribly obvious in retrospect but took me a good while to stumble onto.
The Haskell module described here is part of the vector-space library (version 0.5 or later) and requires ghc version 6.10 or better (for associated types).
Edits:
- 2008-11-09: Changed remarks about versions. The vector-space version 0.5 depends on ghc 6.10.
- 2008-10-21: Fixed the vector-space library link in the teaser.
Continue reading ‘Simpler, more efficient, functional linear maps’ »
15th October 2008, 06:18 pm
The post Elegant memoization with functional memo tries showed a simple type of search tries and their use for functional memoization of functions.
This post provides some composition tools for memo tries, whose definitions are inevitable, in that they are determined by the principle presented in Simplifying semantics with type class morphisms.
Continue reading ‘Composing memo tries’ »
15th October 2008, 06:17 pm
Function memoization goes back at least as far as Donald Michie’s 1968 paper.
The idea is to stash away results of a function call for reuse when a function is called more than once with the same argument.
Given an argument, the memoized function looks up the argument in the internal memo table (often a hash table).
If found, the previously computed result is reused.
Otherwise, the function is applied, and the result is stored in the table, keyed by the argument.
The table and its mutation are kept private from clients of the memo function.
Perhaps surprisingly, memoization can be implemented simply and purely functionally in a lazy functional language.
Laziness allows the implementation to build the memo table once and for all, filling in all the results for the function at all domain values.
Thanks to laziness, the values don’t actually get computed until they’re used.
As usual with lazy data structures, once a component has been evaluated, future accesses come for free.
The implementation described in this post is based one I got from Spencer Janssen.
It uses the essential idea of Ralf Hinze’s paper Generalizing Generalized Tries.
The library is available on Hackage and a darcs repository.
See the wiki page and hackage page for documentation and source code.
I’ve compiled it successfully with ghc versions 6.8.2 through 6.10.3.
Edits:
- 2009-02-12: Fixed typo.
- 2009-11-14: Hackage page pointer.
- 2009-11-20: Fixed source code pointer.
Continue reading ‘Elegant memoization with functional memo tries’ »