Basic polymorphic typechecking
Science of Computer Programming
A type-theoretic approach to higher-order modules with sharing
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Building interpreters by composing monads
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
PLDI '94 Proceedings of the ACM SIGPLAN 1994 conference on Programming language design and implementation
Monad transformers and modular interpreters
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Putting type annotations to work
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Using parameterized signatures to express modular structure
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Multi-stage programming with explicit annotations
PEPM '97 Proceedings of the 1997 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
PolyP—a polytypic programming language extension
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A new approach to generic functional programming
Proceedings of the 27th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
DSL implementation using staging and monads
Proceedings of the 2nd conference on Domain-specific languages
Advanced module systems (invited talk): a guide for the perplexed
ICFP '00 Proceedings of the fifth ACM SIGPLAN international conference on Functional programming
Generic unification via two-level types and parameterized modules
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
Template meta-programming for Haskell
Proceedings of the 2002 ACM SIGPLAN workshop on Haskell
Scrap your boilerplate: a practical design pattern for generic programming
Proceedings of the 2003 ACM SIGPLAN international workshop on Types in languages design and implementation
Modular Denotational Semantics for Compiler Construction
ESOP '96 Proceedings of the 6th European Symposium on Programming Languages and Systems
Advanced Functional Programming, Second International School-Tutorial Text
Journal of Functional Programming
Journal of Functional Programming
Asymptotic Improvement of Computations over Free Monads
MPC '08 Proceedings of the 9th international conference on Mathematics of Program Construction
Transforming Data by Calculation
Generative and Transformational Techniques in Software Engineering II
A pattern for almost compositional functions
Journal of Functional Programming
ML Module Mania: A Type-Safe, Separately Compiled, Extensible Interpreter
Electronic Notes in Theoretical Computer Science (ENTCS)
Constructing language processors with algebra combinators
Science of Computer Programming
Adjoint folds and unfolds: or: scything through the thicket of morphisms
MPC'10 Proceedings of the 10th international conference on Mathematics of program construction
Mikibeta: a general GUI library for visualizing proof trees system description and demonstration
LOPSTR'10 Proceedings of the 20th international conference on Logic-based program synthesis and transformation
SLE'11 Proceedings of the 4th international conference on Software Language Engineering
Generic programming with adjunctions
SSGIP'10 Proceedings of the 2010 international spring school conference on Generic and Indexed Programming
Adjoint folds and unfolds-An extended study
Science of Computer Programming
Hi-index | 0.00 |
In this paper, we describe two techniques for the efficient, modularized implementation of a large class of algorithms. We illustrate these techniques using several examples, including efficient generic unification algorithms that use reference cells to encode substitutions, and highly modular language implementations. We chose these examples to illustrate the following important techniques that we believe many functional programmers would find useful. First, defining recursive data types by splitting them into two levels: a structure defining level, and a recursive knot-tying level. Second, the use of rank-2 polymorphism inside Haskell's record types to implement a kind of type-parameterized modules. Finally, we explore techniques that allow us to combine already existing recursive Haskell data-types with the highly modular style of programming proposed here.