You can start Racket with
racket -il readline
in the Racket read-eval-print-loop to load Readline manually. You can also put (require readline) in your "~/.racketrc", so that Racket automatically loads Readline support in interactive mode.
If you want to enable Readline support only sometimes—
(when (regexp-match? #rx"xterm" (getenv "TERM")) (dynamic-require 'readline #f))
The readline library automatically checks whether the current input port is a terminal, as determined by terminal-port?, and it installs Readline only to replace terminal ports. The readline/rep-start module installs Readline without a terminal check.
By default, Readline’s completion is set to use the visible bindings in the current namespace. This is far from ideal, but it’s better than Readline’s default filename completion which is rarely useful. In addition, the Readline history is stored across invocations in Racket’s preferences file, assuming that Racket exits normally.
The readline library adjusts read-eval-print-loop by setting the prompt read handler as determined by current-prompt-read. The call to the read interaction handler (as determined by current-read-interaction) is parameterized to set readline-prompt, so that a prompt will be printed when reading starts. To compensate for the prompt printed via readline-prompt, when the interaction input port’s name (as produced by function in the current-get-interaction-input-port parameter) is 'readline-input, the prompt read handler skips printing a prompt; otherwise, it displays a prompt as determined by current-prompt.
For more fine-grained control, such as conditionally loading Readline based on an environment variable, edit "~/.racketrc" manually.
The reading facility that the new input port provides can be customized with the following parameters.
(max-history n) → void? n : exact-nonnegative-integer?
(keep-duplicates keep?) → void? keep? : (one-of/c #f 'unconsecutive #t)
(parameterize ([readline-prompt some-byte-string]) ...code-that-reads...)
This expression makes the first call to Readline use the prompt, and subsequent calls will use an all-spaces prompt of the same length (for example, when you’re reading an S-expression). The normal value of readline-prompt is #f for an empty prompt (and spaces after the prompt is used, which is why you should use parameterize to restore it to #f).
A proper solution would be to install a custom output port, too, which keeps track of text that is displayed without a trailing newline. As a cheaper solution, if line-counting is enabled for the terminal’s output-port, then a newline is printed before reading if the column is not 0. (The readline library enables line-counting for the output port.)
Warning: The Readline library uses the output port directly. You should not use it when current-input-port has been modified, or when it was not a terminal port when Racket was started (eg, when reading input from a pipe). Expect some problems if you ignore this warning (not too bad, mostly problems with detecting an EOF).
The readline-redisplay function can be used together with readline-newline to prevent a background thread from cluttering up the user input by interleaving its output. For example, an unsafe wrapper function for the thread’s output might look like the following:
(define (with-thread-safe-output output-thunk) (dynamic-wind (lambda () (start-atomic) (readline-newline)) output-thunk (lambda () (readline-redisplay) (end-atomic))))
GNU’s Readline library is covered by the GPL, and that applies to code that links with it. Racket is licensed with the LGPL, so the Readline code is not used by default; you should explicitly enable it if you want to. Also, be aware that if you write code that uses this library, it will make your code link to the Readline library when invoked, with the usual GPL implications.