Interactive programming (repl): Difference between revisions
m (Added to basic lang learning cat) |
m ({{Omit From|ALGOL 68}}) |
||
Line 243: | Line 243: | ||
Message(@10) |
Message(@10) |
||
</lang> |
</lang> |
||
{{Omit From|ALGOL 68}} <!-- might be possible, esp given that some A68 compilers are written in A68. Cubum autem in duos cubos, aut quadratoquadratum in duos quadratoquadratos, et generaliter nullam in infinitum ultra quadratum potestatem in duos eiusdem nominis fas est dividere cuius rei demonstrationem mirabilem sane detexi. Hanc rosettacode.org exiguitas non caperet.--> |
Revision as of 11:34, 15 May 2009
You are encouraged to solve this task according to the task description, using any language you may know.
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
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
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
$ 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
$ 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
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>