Hostname: page-component-5db58dd55d-688nx Total loading time: 0 Render date: 2026-05-26T21:41:18.104Z Has data issue: false hasContentIssue false
  • English
  • Français

An incremental, exploratory and transformational environment for lazy functional programming

Published online by Cambridge University Press:  07 November 2008

Colin Runciman ,
Ian Toyn  and
Mike Firth
Colin Runciman
Affiliation:
Department of Computer Science, University of York, Heslington, York YO1 5DD, UK
Ian Toyn
Affiliation:
Department of Computer Science, University of York, Heslington, York YO1 5DD, UK
Mike Firth
Affiliation:
Department of Computer Science, University of York, Heslington, York YO1 5DD, UK
Rights & Permissions [Opens in a new window]

Abstract

Core share and HTML view are not available for this content. However, as you have access to this content, a full PDF is available via the 'Save PDF' action button.

Most programming environments for functional languages offer a single tool used to evaluate programs – either a batch compiler or an interpreter with a read-eval-print loop. This paper presents a programming environment that supports not only evaluation, but also a range of other programming activities including transformation. The environment is designed to encourage working in an incremental and exploratory style, avoiding constraints on the order in which things must be done yet guarenteeing security. What has already been done towards the development of a program automatically persists, as does information about what has yet to be done. For instance, new laws can be introduced as conjectures and used in program transformation, but full details of proof obligations and dependencies are maintained.

The paper outlines the functional language supported by the environment, and uses an extended example to illustrate program construction, execution, tracing, modification and transformation.

Information

Type
Research Article
Information
Journal of Functional Programming , Volume 3 , Issue 1 , January 1993 , pp. 93 - 115
Copyright
Copyright © Cambridge University Press 1993

References

Aditya, S. and Nikhil, R. S. 1991. Incremental Polymorphism. In Proc. 5th ACM Conf. on Functional Programming Languages and Computer Architecture,Springer-Verlag, pp. 379–405.Google Scholar
Augustsson, L. and Johnsson, T. 1987. LML Users' Manual. PMG Report, Department of Computer Science, Chalmers University of Technology.Google Scholar
Bird, R. 1988. Lectures on constructive functional programming. Technical Monograph PRG-69, Programming Research Group, Oxford University.Google Scholar
Bird, R. and Wadler, P. 1988. Introduction to Functional Programming. Prentice-Hall.Google Scholar
Burstall, R. M. 1977. Design considerations for a functional programming language. In The software revolution: state-of-the art conference, Pergamon Press, pp. 45–57.Google Scholar
Burstall, R. M. and Darlington, J. 1977. A transformation system for developing recursive programs. J. ACM, 24 (1): 44–67.CrossRefGoogle Scholar
Carlsson, M. and Widen, J. 1988. SICStus Prolog users, manual. Technical Report R88007, Swedish Institute of Computer Science.Google Scholar
Darlington, J. et al. 1989. A functional programming environment supporting execution, partial execution and transformation. In PARLE ‘89, Parallel Architectures and Languages Europe, Springer-Verlag, pp. 286–305.CrossRefGoogle Scholar
Ernst, G. and Newell, A. 1969. GPS: A Case Study in Generality and Problem Solving. Academic Press.Google Scholar
Fairbairn, J. and Wray, S. 1987. TIM: a simple, lazy abstract machine to execute supercombinators. In Kahn, G. (editor) Functional Programming Languages and Computer Architecture, Springer-Verlag, pp. 34–45.CrossRefGoogle Scholar
Feather, M. S. 1987. A system for assisting program transformation. ACM Transactions on Programming Languages and Systems, 4 (1): 1–20.CrossRefGoogle Scholar
Feather, M. S. 1987. A survey and classification of some program transformation approaches and techniques. In Meertens, L. G. L. T. (editor) Program Specification and Transformation: Proc. IFIP TC2/WG2.1 Working Conf.,North-Holland.Google Scholar
Firth, M. A. 1990. A Fold/Unfold System for a Non-strict Language. DPhil Thesis YCST 90/09, Department of Computer Science, University of York.Google Scholar
Gordon, M. J. C., Milner, R. and Wadsworth, C. P. 1979. Edinburgh LCF. Springer-Verlag.CrossRefGoogle Scholar
Hudak, P. and Wadler, P. (Eds.), 1990. Report on the Programming Language Haskell. Technical Report, Yale University and Glasgow University.Google Scholar
Huet, G. and Oppen, D. C. 1980. Equations and rewrite rules – a survey. In Formal Language Theory - Perspectives and Open Problems. Academic Press, pp. 349–405.CrossRefGoogle Scholar
Hullot, J. M. 1979. Associative commutative pattern matching. In Proc. 6th International Joint Conference on Artificial Intelligence, pp. 406–412.Google Scholar
Johnsson, T. 1984. Efficient compilation of lazy evaluation. ACM SIGPLAN Notices, 19 (6): 58–69.CrossRefGoogle Scholar
Meira, S. L. 1984. The Kent Recursive Calculator (KRC): Syntax and Semantics. Computing Laboratory, University of Kent.Google Scholar
Milner, R., Tofte, M. and Harper, R. 1990. The Definition of Standard ML. MIT Press.Google Scholar
Nikhil, R. S. 1985. Practical polymorphism. In Proc. 2nd ACM Conf. on Functional Programming Languages and Computer Architecture,Springer-Verlag, pp. 319–333.Google Scholar
O'Donnell, J. T. and Hall, C. V. 1988. Debugging in applicative languages. Lisp and Symbolic Computation, 1 (2).CrossRefGoogle Scholar
Peyton Jones, S. L. 1987. The Implementation of Functional Programming Languages. Prentice-Hall.Google Scholar
Peyton Jones, S. L. 1988. FLIC – a Functional Language Intermediate Code. ACM SIGPLAN Notices, 23 (8): 30–48.CrossRefGoogle Scholar
Runciman, C. 1989. What about the natural numbers? Computer Languages 14 (3): 181–191.CrossRefGoogle Scholar
Runciman, C., Firth, M. and Jagger, N. 1990. Transformation in a non-strict language: an approach to instantiation. In Proc. Glasgow Workshop on Functional Programming, Springer-Verlag, pp. 133–141.CrossRefGoogle Scholar
Runciman, C. and Toyn, I. 1991. Retrieving reusable software components by polymorphic type. J. Functional Programming 1 (2): 191–211.CrossRefGoogle Scholar
Snyder, R. M. 1990. Lazy debugging of lazy functional programs. New Generation Computing, 8 (2): 139–161.CrossRefGoogle Scholar
Taylor, J. 1991. A system for representing the evaluation of lazy functions. Technical Report 522, Department of Computer Science, Queen Mary and Westfield College, University of London.Google Scholar
Tichy, W. F. 1985. RCS – a system for version control. Software – Practice and Experience, 15 (7): 637–654.CrossRefGoogle Scholar
Tolmach, A. P. and Appel, A. W. 1990. Debugging standard ML without reverse engineering. In Proc. 6th ACM Conf. on LISP and Functional Programming, pp. 1–12.Google Scholar
Toyn, I. and Runciman, C. 1986. Adapting combinator and SECD machines to display snapshots of functional computations. J. New Generation Computing, 4: 339–363.CrossRefGoogle Scholar
Toyn, I. 1987. Exploratory Environments for Functional Programming. DPhil Thesis YCST 87/02. Department of Computer Science, University of York.Google Scholar
Toyn, I., Dix, A. and Runciman, C. 1987. Performance Polymorphism. In Proc. 3rd ACM Conf. on Functional Programming Languages and Computer Architecture, pp. 325–346.Google Scholar
Turner, D. A. 1976. SASL language manual. Technical report, Department of Computational Science, University of St Andrews.Google Scholar
Turner, D. A. 1979. A new implementation technique for applicative languages. Software – Practice and Experience 9 (1): 31–49.CrossRefGoogle Scholar
Turner, D. A. 1981. The semantic elegance of applicative languages. In Proc. ACM Conf. on Functional Programming Languages and Computer Architecture, ACM Press, pp. 85–92.Google Scholar
Turner, D. A. 1985. Miranda: a non-strict functional language with polymorphic types. In Jouannaud, J.-P. (editor), Functional Programming Languages and Computer Architecture, Volume 201 of Lecture Notes in Computer Science. Springer-Verlag, pp. 1–16.CrossRefGoogle Scholar
Wadler, P. 1985. How to replace failure by a list of successes. In Proc. 2nd ACM Conf. on Functional Programming Languages and Computer Architecture, Springer-Verlag, pp. 113–128.CrossRefGoogle Scholar
Wadler, P. 1989. Theorems for free! In Proc. ACM Conf. on Functional Programming Languages and Computer Architecture,ACM Press, pp. 347–359.Google Scholar
Young, J. and Hudak, P. 1986. Finding Fixpoints on Functional Spaces. RR-505, Department of Computer Science, Yale University.Google Scholar
Submit a response

Discussions

No Discussions have been published for this article.