Basic polymorphic typechecking
Science of Computer Programming
Fixing some space leaks with a garbage collector
Software—Practice & Experience
I-structures: data structures for parallel computing
ACM Transactions on Programming Languages and Systems (TOPLAS)
The essence of functional programming
POPL '92 Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Imperative functional programming
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Fixing some space leaks without a garbage collector
FPCA '93 Proceedings of the conference on Functional programming languages and computer architecture
Structuring depth-first search algorithms in Haskell
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Lisp and Symbolic Computation - Special issue on state in programming languages (part I)
Inductive graphs and functional graph algorithms
Journal of Functional Programming
Using relations to develop a haskell program for computing maximum bipartite matchings
RAMiCS'12 Proceedings of the 13th international conference on Relational and Algebraic Methods in Computer Science
Structural recursion for querying ordered graphs
Proceedings of the 18th ACM SIGPLAN international conference on Functional programming
Hi-index | 0.00 |
Many, perhaps even most, algorithms that involve data structures are traditionally expressed by incremental updates of the data structures. In functional languages, however, incremental updates are usually both clumsy and inefficient, especially when the data structure is an array.In functional languages, we instead prefer to express such array algorithms using monolithic arrays – wholesale creation of the final answer – both for succinctness of expression, efficiency (only one array created) and (sometimes) implicit parallelism. The ease with which the solution can be reformulated of course depends on the problem, and varies from trivial (e.g. matrix multiplication), to challenging (e.g. solving linear equation systems using Gauss elimination, which in fact can be done by creating only two arrays, recursively defined, of which one is the answer). Other problems have been notoriously resistant to attack; these usually involve some unpredictable processing order of the elements. One such problem is graph marking, i.e. marking the nodes reachable from a set of roots. Hitherto, no functional method has been known except emulating the traditional imperative solution (King & Launchbury, 1995; Launchbury & Peyton Jones, 1995).The contribution of this paper is to show how this problem, and some related ones, can be solved using a novel array creation primitive, lazier than previous ones.