► |  | Dr Scheme: PLT Programming Environment

1 | Interface Essentials
2 | Languages
3 | Interface Reference
4 | Extending Dr Scheme
| Index

▼ | 1 | Interface Essentials

1.1 | Buttons
1.2 | Choosing a Language
1.3 | Editing with Parentheses
1.4 | Searching
1.5 | Tabbed Editing
1.6 | The Interactions Window
1.7 | Graphical Syntax
1.8 | Graphical Debugging Interface
1.9 | The Module Browser
1.10 | Creating Executables

► | 1.6 | The Interactions Window

1.6.1 | Errors
1.6.2 | Input and Output

On this page:

1.6.1`` Errors
1.6.2`` Input and Output

top← prev up next →

#### 1.6`` The Interactions Window

The interactions window lets you type an expression after the > prompt for immediate evaluation. You cannot modify any text before the last > prompt. To enter an expression, the blinking caret must appear after the last prompt, and also after the space following the prompt.

When you type a complete expression and hit Enter or Return, DrScheme evaluates the expression and prints the result. After printing the result, DrScheme creates a new prompt for another expression. Some expressions return a special “void” value; DrScheme never prints void, but instead produces a new prompt immediately.

If the expression following the current prompt is incomplete, then DrScheme will not try to evaluate it. In that case, hitting Enter or Return produces a new, auto-indented line. You can force DrScheme to evaluate the expression by typing Alt-Return or Command-Return (depending on your platform).

To copy the previous expression to the current prompt, type ESC-p (i.e., type Escape and then type p). Type ESC-p multiple times to cycle back through old expressions. Type ESC-n to cycle forward through old expressions.

Clicking the Run button evaluates the program in the definitions window and makes the program’s definitions available in the interactions window. Clicking Run also resets the interactions window, erasing all old interactions and removing old definitions from the interaction environment. Although Run erases old > prompts, ESC-p and ESC-n can still retrieve old expressions.

##### 1.6.1`` Errors

Whenever DrScheme encounters an error while evaluating an expression, it prints an error message in the interactions window and highlights the expression that triggered the error. The highlighted expression might be in the definitions window, or it might be after an old prompt in the interactions window.

For certain kinds of errors, DrScheme turns a portion of the error message into a hyperlink. Click the hyperlink to get help regarding a function or keyword related to the error.

For some run-time errors, DrScheme shows a bug icon next to the error message. Click the bug icon to open a window that shows a “stack” of expressions that were being evaluated at the time of the error. In addition, if the expressions in the stack appear in the definitions window, a red arrow is drawn to each expression from the next deeper one in the stack.

##### 1.6.2`` Input and Output

Many Scheme programs avoid explicit input and output operations, obtaining input via direct function calls in the interactions window, and producing output by returning values. Other Scheme programs explicitly print output for the user during evaluation using write or display, or explicitly request input from the user using read or read-char.

Explicit input and output appear in the interactions window, but within special boxes that separate explicit I/O from normal expressions and results. For example, evaluating

> (read)

in the interactions window produces a special box for entering input:

Type a number into the box and hit Enter, and that number becomes the result of the (read) expression. Once text is submitted for an input box, it is moved outside the input box, and when DrScheme shows a new prompt, it hides the interaction box. Thus, if you type 5 in the above input box and hit Return, the result appears as follows:

> (read)
5
5
> _

In this case, the first 5 is the input, and the second 5 is the result of the (read) expression. The second 5 is colored blue, as usual for a result printed by DrScheme. (The underscore indicates the location of the blinking caret.)

Output goes into the interactions window directly. If you run the program

#lang scheme
(define v (read))
(display v) (newline)
v

and provide the input S-expression (1 2), the interactions window ultimately appears as follows:

(1 2)
(1 2)
(1 2)
> _

In this example, display produces output immediately beneath the input you typed, and the final result is printed last. The displayed output is drawn in purple. (The above example assumes default printing. With constructor-style value printing, the final before the prompt would be (list 1 2).)

Entering the same program line-by-line in the interactions window produces a different-looking result:

> (define v (read))
(1 2)
> (display v)
(1 2)
> v
(1 2)
> _

Depending on the input operation, you may enter more text into an input box than is consumed. In that case, the leftover text remains in the input stream for later reads. For example, in the following interaction, two values are provided in response to the first (read), so the second value is returned immediately for the second (read):

> (read)
5 6
5
> (read)
6
> _

The following example illustrates that submitting input with Return inserts a newline character into the input stream:

> (read)
5
5
> (read-char)
#\newline
> _

Within a #lang scheme module, the results of top-level expression print the same as the results of an expression entered in the interactions window. The reason is that #lang scheme explicitly prints the results of top-level expressions using (current-print), and DrScheme sets (current-print) to print values in the same way as for interactions.

top← prev up next →