This articleneeds additional citations forverification. Please helpimprove this article byadding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Read–eval–print loop" – news ·newspapers ·books ·scholar ·JSTOR(June 2015) (Learn how and when to remove this message)

Aread–eval–print loop (REPL), also termed aninteractive toplevel orlanguage shell, is a simple interactivecomputer 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 classicLisp machine interactive environment. Common examples includecommand-lineshells and similar environments forprogramming languages, and the technique is very characteristic ofscripting languages.^[2]

In 1964, the expressionREAD-EVAL-PRINT cycle is used byL. Peter Deutsch andEdmund Berkeley for an implementation ofLisp on thePDP-1.^[3] Just one month later,Project Mac published a report byJoseph Weizenbaum (the creator ofELIZA, the world's first chatbot) describing a REPL-based language, called OPL-1, implemented in hisFortran-SLIP language on theCompatible Time Sharing System (CTSS).^[4][5][6]

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

Since at least the 1980s, the abbreviationsREP Loop andREPL are attested in the context ofScheme.^[8][9]

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

• Theread function accepts an expression from the user, andparses it into a data structure in memory. For instance, the user may enter thes-expression(+ 1 2 3), which is parsed into alinked list containing four data elements.
• Theeval function takes this internal data structure and evaluates it. In Lisp, evaluating an s-expression beginning with the name of a function means calling that function on the arguments that make up the rest of the expression. So the function+ is called on the arguments1 2 3, yielding the result6.
• Theprint function takes the result yielded byeval, and prints it out to the user. If it is a complex expression, it may bepretty-printed to make it easier to understand.

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

REPLs facilitateexploratory programming anddebugging 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 theprint function outputs in the same textual format that theread 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 ofCLIM,SLIME, and theSymbolicsLisp 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 aninterpreter on top of a virtual machine which provides an interface to the compiler. For example, starting with JDK 9,Java includedJShell 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.

As ashell, 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 interactiveprototyping.^[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 is:

(define(REPLenv)(print(evalenv(read)))(REPLenv))

whereenv represents initialeval-uation environment. It is also assumed thatenv can be destructively updated byeval.

Typical functionality provided by a Lisp REPL includes:

• History of inputs and outputs.
• Variables are set for the input expressions and results. These variables are also available in the REPL. For example in Common Lisp* refers to the last result,** and*** to the results before that.
• Levels of REPLs. In many Lisp systems if an error occurs during the reading, evaluation or printing of an expression, the system is not thrown back to the top level with an error message. Instead a new REPL, one level deeper, is started in the error context. The user can then inspect the problem, fix it and continue – if possible. If an error occurs in such a debug REPL, another REPL, again a level deeper, is started. Often the REPL offers special debug commands.
• Error handling. The REPL provides restarts. These restarts can be used, when an error occurs, to go back to a certain REPL level.
• Mouse sensitive input and output of data objects.
• Input editing and context specific completion over symbols, pathnames, class names and other objects.
• Help and documentation for commands.
• Variables to control the reader. For example, the variable *read-base* controls in which base numbers are read by default.
• Variables to control the printer. Example: maximum length or maximum depth of expressions to print.
• Additional command syntax. Some REPLs have commands that follow not the s-expression syntax, but often work with Lisp data as arguments.
• Graphical REPLs. Some Lisp REPLs (the CLIM Listener is an example) accept also graphical input and output.

• Direct mode
• Interpreter (computing)

• Paul Graham has written adescription of a REPL implementation in Common Lisp.
• Joël FranusicOnline-REPs-and-REPLs list

• Command shells
• Lisp (programming language)
• Interpreters (computing)
• User interface techniques

• CS1 maint: postscript
• Articles with short description
• Short description is different from Wikidata
• Articles needing additional references from June 2015
• All articles needing additional references