Maintaining order in a generalized linked list
Acta Informatica
Detecting global variables in denotational specifications
ACM Transactions on Programming Languages and Systems (TOPLAS) - Lecture notes in computer science Vol. 174
Self-adjusting binary search trees
Journal of the ACM (JACM)
ACM SIGPLAN Notices
Two algorithms for maintaining order in a list
STOC '87 Proceedings of the nineteenth annual ACM symposium on Theory of computing
Making data structures persistent
Journal of Computer and System Sciences - 18th Annual ACM Symposium on Theory of Computing (STOC), May 28-30, 1986
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
Update analysis and the efficient implementation of functional aggregates
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
ML for the working programmer
Shallow binding makes functional arrays fast
ACM SIGPLAN Notices
Report on the programming language Haskell: a non-strict, purely functional language version 1.2
ACM SIGPLAN Notices - Haskell special issue
The essence of functional programming
POPL '92 Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A randomized implementation of multiple functional arrays
LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
Communications of the ACM
Design of Dynamic Data Structures
Design of Dynamic Data Structures
Fully Persistent Arrays for Efficient Incremental Updates and Voluminous Reads
ESOP '92 Proceedings of the 4th European Symposium on Programming
Fully Persistent Arrays (Extended Array)
WADS '89 Proceedings of the Workshop on Algorithms and Data Structures
High Level Specification of I/O in Functional Languages
Proceedings of the 1992 Glasgow Workshop on Functional Programming
A Logarithmic Implementation of Flexible Arrays
Proceedings of the Second International Conference on Mathematics of Program Construction
Efficient applicative data types
POPL '84 Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Some practical methods for rapid combinator reduction
LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
Efficient integration and aggregation of historical information
Proceedings of the 2002 ACM SIGMOD international conference on Management of data
Bootstrapping one-sided flexible arrays
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Categorical Programming with Abstract Data Types
AMAST '98 Proceedings of the 7th International Conference on Algebraic Methodology and Software Technology
Automated Benchmarking of Functional Data Structures
PADL '99 Proceedings of the First International Workshop on Practical Aspects of Declarative Languages
Journal of Functional Programming
Inductive graphs and functional graph algorithms
Journal of Functional Programming
Inductive benchmarking for purely functional data structures
Journal of Functional Programming
Information Processing Letters
Copy-on-write in the PHP language
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Hi-index | 0.00 |
Arrays are probably the most widely used data structure in imperative programming languages, yet functional languages typically only support arrays in a limited manner, or prohibit them entirely. This is not too surprising, since most other mutable data structures, such as trees, have elegant immutable analogues in the functional world, whereas arrays do not. Previous attempts at addressing the problem have suffered from one of three weaknesses, either that they don't support arrays as a persistent data structure (unlike the functional analogues of other imperative data structures), or that the range of operations is too restrictive to support some common array algorithms efficiently, or that they have performance problems. Our technique provides arrays as a true functional analogue of imperative arrays with the properties that functional programmers have come to expect from their data structures. To efficiently support array algorithms from the imperative world, we provide O(1) operations for single-threaded array use. Fully persistent array use can also be provided at O(1) amortized cost, provided that the algorithm satisfies a simple requirement as to uniformity of access. For those algorithms which do not access the array uniformly or single-threadedly, array reads or updates take at most O(log n) amortized time, where n is the size of the array. Experimental results indicate that the overheads of our technique are acceptable in practice for many applications.