HOPE: An experimental applicative language

An applicative language called HOPE is described and discussed. The underlying goal of the design and implementation effort was to produce a very simple programming language which encourages the construction of clear and manipulable programs. HOPE does not include an assignment statement; this is felt to be an important simplification. The user may freely define his own data types, without the need to devise a complicated encoding in terms of low-level types. The language is very strongly typed, and as implemented it incorporates a typechecker which handles polymorphic types and overloaded operators. Functions are defined by a set of recursion equations; the left-hand side of each equation includes a pattern used to determine which equation to use for a given argument. The availability of arbitrary higher-order types allows functions to be defined which 'package' recursion. Lazily-evaluated lists are provided, allowing the use of infinite lists which could be used to provide interactive input/output and concurrency. HOPE also includes a simple modularisation facility which may be used to protect the implementation of an abstract data type.

[1]  Edmond Schonberg,et al.  Programming by Refinement, as Exemplified by the SETL Representation Sublanguage , 1979, TOPL.

[2]  Peter Henderson,et al.  An experiment in structured programming , 1972 .

[3]  Mary Shaw,et al.  An introduction to the construction and verification of Alphard programs , 1976, ICSE '76.

[4]  David H. D. Warren,et al.  Prolog - the language and its implementation compared with Lisp , 1977, Artificial Intelligence and Programming Languages.

[5]  Robin Milner,et al.  A Theory of Type Polymorphism in Programming , 1978, J. Comput. Syst. Sci..

[6]  Peter Henderson,et al.  A lazy evaluator , 1976, POPL.

[7]  Michael J. C. Gordon,et al.  The denotational description of programming languages - an introduction , 1979 .

[8]  Martin S. Feather,et al.  A system for developing programs by transformation , 1979 .

[9]  William H. Burge,et al.  Recursive Programming Techniques , 1975 .

[10]  J. D. Ichbiah,et al.  Preliminary Ada reference manual , 1979, SIGP.

[11]  N. Falconer Structured Programming , 1973, Nature.

[12]  Brian W. Kernighan,et al.  Software tools , 1976, SOEN.

[13]  Joseph A. Goguen,et al.  Putting Theories Together to Make Specifications , 1977, IJCAI.

[14]  Kenneth E. Iverson,et al.  A programming language , 1899, AIEE-IRE '62 (Spring).

[15]  John W. Backus,et al.  Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs , 1978, CACM.

[16]  P. J. Landin,et al.  The next 700 programming languages , 1966, CACM.

[17]  Raymond Aubin,et al.  Strategies for Mechanizing Structural Induction , 1977, IJCAI.

[18]  Craig Schaffert,et al.  Abstraction mechanisms in CLU , 1977 .

[19]  Robin Milner,et al.  A Metalanguage for interactive proof in LCF , 1978, POPL.

[20]  Robin Milner,et al.  Concurrent Processes and Their Syntax , 1979, JACM.

[21]  John Darlington,et al.  A Transformation System for Developing Recursive Programs , 1977, J. ACM.

[22]  Rod M. Burstall,et al.  Electronic Category Theory , 1980, MFCS.