Interactive programming (repl)

Many language implementations come with a command line interpreter (a.k.a. shell or REPL).

Show how to start the interpreter, then, as a small example of its use, interactively create a function of two strings and a separator that returns the strings separated by two concatenated instances of the separator.

For example, f('Rosetta', 'Code', ':') should return 'Rosetta::Code'

Note: this task is not about creating your own interpreter.

BASIC

Works with: SAM BASIC

This was tested with SAM BASIC, but it should work with most Basic interpreters.

A Basic interpreter is in command mode by default. Enter the following in command mode: <lang qbasic>10 DEF FN f$(a$, b$, s$) = a$+s$+s$+b$ PRINT FN f$("Rosetta", "Code", ":")</lang>

Common Lisp

The details of interactive use vary widely between implementations; this example is from SBCL. * is the prompt. By default, SBCL compiles (not interprets) all code, unless sb-ext:*evaluator-mode* is changed.

$ rlwrap sbcl
This is SBCL 1.0.25, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.
...
* (defun f (string-1 string-2 separator)
    (concatenate 'string string-1 separator separator string-2))

F
* (f "Rosetta" "Code" ":")

"Rosetta::Code"
*

E

<lang sh>$ rune # from an OS shell. On Windows there is also a desktop shortcut.</lang>

"?" and ">" are prompts for input; "#" marks output.

<lang e>? def f(string1 :String, string2 :String, separator :String) { > return separator.rjoin(string1, "", string2) > }

value: <f>

? f("Rosetta", "Code", ":")

value: "Rosetta::Code"

</lang>

If you type a definitely incomplete expression, such as "def f() {", then it gives an ">" prompt and takes additional lines. If the expression is not necessarily incomplete, you can continue anyway by ending a line with "\".

Forth

Works with: GNU Forth

All Forth systems come with an interpreter. On embedded systems, the interpreter functions as a monitor or lightweight operating system. (User input is shown here in italics.)

$ gforth
Gforth 0.7.0, Copyright (C) 1995-2008 Free Software Foundation, Inc.
Gforth comes with ABSOLUTELY NO WARRANTY; for details type `license'
Type `bye' to exit
: f ( separator suffix prefix -- )  compiled
  pad place  2swap 2dup pad +place  pad +place  pad +place  compiled
  pad count ;  ok
s" :" s" Code" s" Rosetta" f cr type
Rosetta::Code ok

Haskell

The details of interactive use vary widely between implementations. This example is from GHCi.

$ ghci
   ___         ___ _
  / _ \ /\  /\/ __(_)
 / /_\// /_/ / /  | |      GHC Interactive, version 6.4.2, for Haskell 98.
/ /_\\/ __  / /___| |      http://www.haskell.org/ghc/
\____/\/ /_/\____/|_|      Type :? for help.

Loading package base-1.0 ... linking ... done.
Prelude> let f as bs sep = as ++ sep ++ sep ++ bs
Prelude> f "Rosetta" "Code" ":"
"Rosetta::Code"

Logo

Works with: UCB Logo

$ logo
Welcome to Berkeley Logo version 5.6
? to f :prefix :suffix :separator
> output (word :prefix :separator :separator :suffix)
> end
f defined
? show f "Rosetta "Code ":
Rosetta::Code
?

OCaml

Because you can enter expressions that span multiple lines, you have to type the double semicolon (";;") at the end so that it knows you are done.

$ ocaml
        Objective Caml version 3.10.2

# let f s1 s2 sep = String.concat sep [s1; ""; s2];;
val f : string -> string -> string -> string = <fun>
# f "Rosetta" "Code" ":";;
- : string = "Rosetta::Code"
#

Octave

$ octave
GNU Octave, version 3.0.2
Copyright (C) 2008 John W. Eaton and others.
This is free software; see the source code for copying conditions.
There is ABSOLUTELY NO WARRANTY; not even for MERCHANTIBILITY or
FITNESS FOR A PARTICULAR PURPOSE.  For details, type `warranty'.

Octave was configured for "i586-mandriva-linux-gnu".

Additional information about Octave is available at http://www.octave.org.

Please contribute if you find this software useful.
For more information, visit http://www.octave.org/help-wanted.html

Report bugs to <bug@octave.org> (but first, please read
http://www.octave.org/bugs.html to learn how to write a helpful report).

For information about changes from previous versions, type `news'.

octave:1> function concat(a,b,c)
> disp(strcat(a,c,c,b));
> endfunction
octave:2> concat("Rosetta","Code",":");
Rosetta::Code
octave:3>

Perl

Perl doesn't have an interpreter, but there is an interactive debugger:

$ perl -de1

Loading DB routines from perl5db.pl version 1.3
Editor support available.

Enter h or `h h' for help, or `man perldebug' for more help.

main::(-e:1):   1
  DB<1> sub f {my ($s1, $s2, $sep) = @_; $s1 . $sep . $sep . $s2}

  DB<2> p f('Rosetta', 'Code', ':')
Rosetta::Code
  DB<3> q

Python

Start the interpreter by typing python at the command line (or select it from a menu). You get a response showing the version of the interpreter being run before giving an input prompt of three greater-than characters and a space:

<lang python>python Python 2.6.1 (r261:67517, Dec 4 2008, 16:51:00) [MSC v.1500 32 bit (Intel)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> def f(string1, string2, separator): return separator.join([string1, , string2])

>>> f('Rosetta', 'Code', ':') 'Rosetta::Code' >>> </lang>

Ruby

Start the interpreter by typing irb at the command line. You will see an input prompt, which by default is name of this program(name of main object):line number:indent level> :

<lang ruby>$ irb irb(main):001:0> def f(string1, string2, separator) irb(main):002:1> [string1, , string2].join(separator) irb(main):003:1> end => nil irb(main):004:0> f('Rosetta', 'Code', ':') => "Rosetta::Code" irb(main):005:0> </lang>

Smalltalk

Works with: GNU Smalltalk

$ gst
GNU Smalltalk ready

st> |concat|
st> concat := [ :a :b :c | (a,c,c,b) displayNl ].
a BlockClosure
st> concat value: 'Rosetta' value: 'Code' value: ':'.
Rosetta::Code
'Rosetta::Code'
st>

Standard ML

Works with: SML/NJ

Because you can enter expressions that span multiple lines, you have to type the semicolon (";") at the end so that it knows you are done.

$ sml
Standard ML of New Jersey v110.67 [built: Fri Jul  4 09:00:58 2008]
- fun f (s1, s2, sep) = String.concatWith sep [s1, "", s2];
[autoloading]
[library $SMLNJ-BASIS/basis.cm is stable]
[autoloading done]
val f = fn : string * string * string -> string
- f ("Rosetta", "Code", ":");
val it = "Rosetta::Code" : string
-

Tcl

$ tclsh
% proc f {s1 s2 sep} {
    append result $s1 $sep $sep $s2
}
% f Rosetta Code :
Rosetta::Code
% exit

UNIX Shell

This appears strange: I am calling sh (which is bash indeed, but it recognizes it is called as sh and it behaves like if called with bash --posix, i.e. in POSIX compatibility mode) from the bash (the bash prompt is shortened to simply $, the sh prompt is as it appears).

$ sh
sh-3.2$ concat()
> {
> echo "$1$3$3$2"
> }
sh-3.2$ concat Rosetta Code :
Rosetta::Code
sh-3.2$

Vedit macro language

To enter command mode, type <Esc>c, or to open command mode window, type <Esc>w. Or if the command mode window is already open, just click on the window.

To define a macro in text register 100: <lang vedit> RS(100, "RS(10, @1) RS(10, @3, APPEND) RS(10, @3, APPEND) RS(10, @2, APPEND)") </lang>

To call the macro: <lang vedit> RS(1,"Rosetta") RS(2,"Code") RS(3,":") Call(100) Message(@10) </lang>