Read–eval–print loop (original) (raw)

From Wikipedia, the free encyclopedia

Computer programming environment

"Repl" redirects here; not to be confused with Replit.

A read–eval–print loop (REPL), also termed an interactive toplevel or language shell, is a simple interactive computer programming environment that takes single user inputs, executes them, and returns the result to the user; a program written in a REPL environment is executed piecewise.[1] The term usually refers to programming interfaces similar to the classic Lisp machine interactive environment or to Common Lisp with the SLIME development environment. Common examples include command-line shells and similar environments for programming languages, and the technique is very characteristic of scripting languages,[2] even though their characteristics can vary greatly.

The expression READ-EVAL-PRINT cycle is used by L. Peter Deutsch and Edmund Berkeley for a 1964 implementation of Lisp on the PDP-1.[3] Just one month later, Project Mac published a report by Joseph Weizenbaum (the creator of ELIZA, the world's first chatbot) describing a REPL-based language, called OPL-1, implemented in his Fortran-SLIP language on the Compatible Time Sharing System (CTSS).[4][5][6]

The 1974 Maclisp reference manual by David A. Moon attests "Read-eval-print loop" on page 89, but does not use the acronym REPL.[7]

Since at least the 1980s, the abbreviations REP Loop and REPL are attested in the context of Scheme.[8][9]

In a REPL, the user enters one or more expressions (rather than an entire compilation unit) and the REPL evaluates them and displays the results.[1] The name read–eval–print loop comes from the names of the Lisp primitive functions which implement this functionality:

The development environment then returns to the read state, creating a loop, which terminates when the program is closed.

REPLs facilitate exploratory programming and debugging because the programmer can inspect the printed result before deciding what expression to provide for the next read. The read–eval–print loop involves the programmer more frequently than the classic edit–compile–run–debug cycle.

Because the print function outputs in the same textual format that the read function uses for input, most results are printed in a form that could be copied and pasted back into the REPL. However, it is sometimes necessary to print representations of elements that cannot sensibly be read back in, such as a socket handle or a complex class instance. In these cases, there must exist a syntax for unreadable objects. In Python, it is the <__module__.class instance> notation, and in Common Lisp, the #<whatever> form. The REPL of CLIM, SLIME, and the Symbolics Lisp Machine can also read back unreadable objects. They record for each output which object was printed. Later when the code is read back, the object will be retrieved from the printed output.

REPLs can be created to support any text-based language. REPL support for compiled languages is usually achieved by implementing an interpreter on top of a virtual machine which provides an interface to the compiler. For example, starting with JDK 9, Java included JShell as a command-line interface to the language. Various other languages have third-party tools available for download that provide similar shell interaction with the language, although the features can vary greatly.

As a shell, a REPL environment allows users to access relevant features of an operating system in addition to providing access to programming capabilities. The most common use for REPLs outside of operating system shells is for interactive prototyping.[10] Other uses include mathematical calculation, creating documents that integrate scientific analysis (e.g. IPython), interactive software maintenance, benchmarking, and algorithm exploration.

A minimal definition in Common Lisp is:

(loop (print (eval (read))))

where read waits for user input and eval evaluates it. print prints the result, and loop loops indefinitely. You can enter (+ 1 1) and stop the loop with C-c.

Typical functionality provided by a Common Lisp REPL includes:

Combining source files and REPL development

[edit]

Developers of Lisp applications typically do not write or copy-paste code to a REPL. They use the REPL for quick tests, for debugging and to explore a running system. They write their application in a source file under version control, they use commands or keyboard shortcuts to compile their code interactively. The Lisp process is running and connected to their editor, and it compiles new code "on the fly", without restarting.

In Common Lisp, developers typically compile the current function they are working on. They can also compile a whole file, or compile a whole project. When a function is compiled, they may get type warnings (specially with the SBCL implementation), and they can invoke the newly created function from the REPL. If an error occurs, they are given an interactive debugger.

This process of compiling one single function and testing it on the REPL is very fast. The cycle of writing a new function, compiling it and testing is very short, and interactive.

Doing so also allows to not loose the application state during development.

It is only when they choose to do so that they run or compile all the application from scratch.

  1. ^ a b Grillmeyer, O. (2013). Exploring Computer Science with Scheme. Undergraduate Texts in Computer Science. Springer New York. p. 239. ISBN 978-1-4757-2937-5. Retrieved 2021-06-26. The central component to the Scheme interpreter is the read-eval-print loop. Commands are read in, then evaluated. Finally, the evaluated result is printed.
  2. ^ Hey, Tony; Pápay, Gyuri (2014). The Computing Universe: A Journey through a Revolution. Cambridge University Press. p. 76. ISBN 978-1-316-12322-5, "A major characteristic of modern scripting languages is their interactivity, sometimes referred to as a REPL programming environment. ... The characteristics of ease of use and immediate execution with a REPL environment are sometimes taken as the definition of a scripting language"{{[cite book](/wiki/Template:Cite%5Fbook "Template:Cite book")}}: CS1 maint: postscript (link)
  3. ^ L. Peter Deutsch; Edmund Berkeley, The LISP Implementation for the PDP-1 Computer (PDF), p. 15
  4. ^ Joseph Weizenbaum, OPL-I: AN OPEN santichaymi2@gmail.comENDED PROGRAMMING SYSTEM WITHIN CTSS
  5. ^ Both of these projects were likely carried out in 1963, well before the respective publications appeared. However, it is impossible to place the dates of invention exactly.
  6. ^ There is a complex and interesting relationship between Lisp and SLIP, both being eponymous "list processing languages" invented by MIT-related academics: Shrager, Jeff (2024), ELIZA Reinterpreted: The world's first chatbot was not intended as a chatbot at all, arXiv:2406.17650
  7. ^ David A. Moon (April 8, 1974), MACLISP Reference Manual (PDF), p. 89
  8. ^ Smith, Jerry D. (1988). An introduction to Scheme. Englewood Cliffs, N.J. : Prentice Hall. p. 8. ISBN 978-0-13-496712-7.
  9. ^ Hanson, Chris (1986). "rep.scm -- Initial 1986 revision of MIT-Scheme". GitHub. Retrieved 11 June 2023.
  10. ^ van Binsbergen, L. Thomas; Verano Merino, Mauricio; Jeanjean, Pierre; van der Storm, Tijs; Combemale, Benoit; Barais, Olivier (2020-11-17). "A principled approach to REPL interpreters". Proceedings of the 2020 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (PDF). New York, NY, USA: ACM. pp. 84–100. doi:10.1145/3426428.3426917. ISBN 978-1-4503-8178-9.