Interactive programming

From Rosetta Code
Jump to: navigation, search
Task
Interactive programming
You are encouraged to solve this task according to the task description, using any language you may know.

Many language implementations come with an interactive mode. This is a command-line interpreter that reads lines from the user and evaluates these lines as statements or expressions. An interactive mode may also be known as a command mode, a read-eval-print loop (REPL), or a shell.

Show how to start this mode, 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 interactive mode.

Contents

[edit] ACL2

$ acl2
Welcome to Clozure Common Lisp Version 1.7-r14925M  (DarwinX8664)!

 ACL2 Version 4.3 built September 8, 2011  09:08:23.
 Copyright (C) 2011  University of Texas at Austin
 ACL2 comes with ABSOLUTELY NO WARRANTY.  This is free software and you
 are welcome to redistribute it under certain conditions.  For details,
 see the GNU General Public License.

 Initialized with (INITIALIZE-ACL2 'INCLUDE-BOOK *ACL2-PASS-2-FILES*).
 See the documentation topic note-4-3 for recent changes.
 Note: We have modified the prompt in some underlying Lisps to further
 distinguish it from the ACL2 prompt.

ACL2 Version 4.3.  Level 1.  Cbd "/Users/username/".
Distributed books directory "/Users/username/Code/acl2/books/".
Type :help for help.
Type (good-bye) to quit completely out of ACL2.

ACL2 !>(defun f (s1 s2 sep)
(concatenate 'string s1 sep sep s2))

Since F is non-recursive, its admission is trivial.  We observe that
the type of F is described by the theorem (STRINGP (F S1 S2 SEP)).
We used the :type-prescription rule STRING-APPEND-LST.

Summary
Form:  ( DEFUN F ...)
Rules: ((:TYPE-PRESCRIPTION STRING-APPEND-LST))
Time:  0.01 seconds (prove: 0.00, print: 0.00, other: 0.00)
 F
ACL2 !>(f "Rosetta" "Code" ":")
"Rosetta::Code"
ACL2 !>(good-bye)

[edit] 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:

10 DEF FN f$(a$, b$, s$) = a$+s$+s$+b$
PRINT FN f$("Rosetta", "Code", ":")

[edit] Batch File

command.com
color f0

[edit] BBC BASIC

Interactive mode is entered by clicking on the 'Immediate' toolbar button or selecting Immediate from the Run menu. Functions cannot be defined in immediate mode so the example below uses inline code:

>r$ = "Rosetta"
>c$ = "Code"
>s$ = ":"
>PRINT r$+s$+s$+c$
Rosetta::Code
>

[edit] bc

bc has no string operations, so I will instead show how to use hexadecimal numbers such that f(205E77A, C0DE, 1) returns 205E77A11C0DE.

Step 1. I start the interactive interpreter, switch from base 10 to base 16, and check that 1000 - 2 is FFE, not 998. My bc has no prompt, so I will use »bold text to show where I typed my input.

$ »bc
»obase = ibase = 16
»1000 - 2
FFE

Step 2. I define a helper function d() to count the number of digits in a number. I check that d() works for positive numbers.

»define d(a) {
»  auto r
»  r = 0
»  while (a != 0) {
»    r += 1
»    a /= 10
»  }
»  return (r)
»}
»d(4)
1
»d(5A)
2
»d(67B)
3

Step 3. I define f() and call it.

»define f(a, b, c) {
»  auto d, e, f       
»  d = d(b)
»  e = d + d(c)
»  f = e + d(c)
»  return (a * 10 ^ f + c * 10 ^ e + c * 10 ^ d + b)
»}
»f(205E77A, C0DE, 1)
205E77A11C0DE

Step 4. I quit. (Control-D also works.)

»quit
$

[edit] Bracmat

Running Bracmat without arguments starts the program in interactive mode. The prompt is {?}. After evaluation, Bracmat prints {!} followed by the result. Input can extend over multiple lines, but is terminated by a new line if all parentheses are balanced (() or {}) and any string introduced with " also is closed with ". The number of needed closing parentheses is indicated at the start of a new input line. Provided the file help is in the current working directory, the user can get interactive help by entering get$help. The program is closed by entering an extra closing parenthesis, followed by a confirming y.

D:\projects\Bracmat>bracmat
Bracmat version 5, build 105 (1 December 2011)
Copyright (C) 2002 Bart Jongejan
Bracmat comes with ABSOLUTELY NO WARRANTY; for details type `!w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `!c' for details.



{?} get$help { tutorial }
{?} )        { stop }
{?} (f=a b c.
{1}   !arg:(?a,?b,?c)
{1}   & str$(!a !c !b)
{1}   )
{!} f
    S   0,00 sec  (2156.2173.0)
{?} f$(Rosetta,Code,":")
{!} Rosetta:Code
    S   0,00 sec  (2156.2173.0)
{?}

[edit] Brat

$ brat
# Interactive Brat
brat:1> f = { a, b, s | a + s + s + b }
#=> function: 0xb737ac08
brat:2> f "Rosetta" "Code" ":"
#=> Rosetta::Code
brat:3> quit
Exiting

[edit] Burlesque

 
C:\Burlesque>Burlesque.exe --shell
blsq ) {+]?+}hd"Rosetta""Code"':!a
"Rosetta:Code"
blsq )
 

[edit] Clojure

With clojure.jar on the Java classpath, the Clojure REPL is invoked with java clojure.main.

 
Clojure 1.1.0
user=> (defn f [s1 s2 sep] (str s1 sep sep s2))
#'user/f
user=> (f "Rosetta" "Code" ":")
"Rosetta::Code"
user=>
 

[edit] 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"
*

[edit] Déjà Vu

The interactive interpreter provides . as a shortcut for !. and ; as a shortcut for !(print-stack).

$ vu
<1:1> f str1 str2 sep:
<1:2> join sep [ str2 "" str1 ]
<1:3>
<2:1> . f "Rosetta" "Code" ":"
"Rosetta::Code"

[edit] E

$ rune   # from an OS shell. On Windows there is also a desktop shortcut.

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

? def f(string1 :String, string2 :String, separator :String) {
> return separator.rjoin(string1, "", string2)
> }
# value: <f>
 
? f("Rosetta", "Code", ":")
# value: "Rosetta::Code"

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 "\".

[edit] Emacs Lisp

Emacs opens a *scratch* buffer by default. This buffer is in Lisp Interaction mode; C-j evaluates the Lisp expression before point, and prints the result.

Switch to the buffer (C-x b *scratch*, or use the Buffers menu), type some Lisp expressions, and press C-j after each expression.

(defun my-join (str1 str2 sep)
(concat str1 sep sep str2))
my-join
(my-join "Rosetta" "Code" ":")
"Rosetta::Code"

Emacs also provides ielm, the interactive Emacs Lisp mode. Start it with M-x ielm, type some expressions and press RET.

*** Welcome to IELM ***  Type (describe-mode) for help.
ELISP> (defun my-join (str1 str2 sep)
(concat str1 sep sep str2))
my-join
ELISP> (my-join "Rosetta" "Code" ":")
"Rosetta::Code"
ELISP>

[edit] Erlang

$erl
1> F = fun(X,Y,Z) -> string:concat(string:concat(X,Z),string:concat(Z,Y)) end.
#Fun<erl_eval.18.105910772>
2> F("Rosetta", "Code", ":").
"Rosetta::Code"
 

[edit] Factor

Factor comes with a graphical interpreter called the listener. The listener can also be run in a console with the following command :

./factor -run=listener
( scratchpad ) : cool-func ( w1 w2 sep -- res ) dup append glue ;
( scratchpad ) "Rosetta" "Code" ":" cool-func .
"Rosetta::Code"

[edit] Fantom

Fantom comes with a command-line interpreter called 'fansh'

$ fansh
Fantom Shell v1.0.57 ('?' for help)
fansh> f := |Str a, Str b, Str c -> Str| {"$a$c$c$b"}
|sys::Str,sys::Str,sys::Str->sys::Str|
fansh> f("Rosetta", "Code", ":")
Rosetta::Code

[edit] 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.)

$ <i>gforth</i>
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
<i>: f ( separator suffix prefix -- )</i> compiled
<i>pad place 2swap 2dup pad +place pad +place pad +place</i> compiled
<i>pad count ;</i> ok
<i>s" :" s" Code" s" Rosetta" f cr type</i>
Rosetta::Code ok

[edit] F#

The F# interpreter is called fsi. As F# accepts multi-line input it will not evaluate the input until you enter two semi-colons together.

Microsoft F# Interactive, (c) Microsoft Corporation, All Rights Reserved
F# Version 1.9.6.2, compiling for .NET Framework Version v2.0.50727
 
Please send bug reports to fsbugs@microsoft.com
For help type #help;;
 
> let f a b sep = String.concat sep [a; ""; b] ;;
 
val f : string -> string -> string -> string
 
> f "Rosetta" "Code" ":" ;;
val it : string = "Rosetta::Code"

[edit] GAP

~% gap
 
######### ###### ########### ###
############# ###### ############ ####
############## ######## ############# #####
############### ######## ##### ###### #####
###### # ######### ##### ##### ######
###### ########## ##### ##### #######
##### ##### #### ##### ###### ########
#### ##### ##### ############# ### ####
##### ####### #### #### ########### #### ####
##### ####### ##### ##### ###### #### ####
##### ####### ##### ##### ##### #############
##### ##### ################ ##### #############
###### ##### ################ ##### #############
################ ################## ##### ####
############### ##### ##### ##### ####
############# ##### ##### ##### ####
######### ##### ##### ##### ####
 
Information at: http://www.gap-system.org
Try '?help' for help. See also '?copyright' and '?authors'
 
Loading the library. Please be patient, this may take a while.
GAP4, Version: 4.4.12 of 17-Dec-2008, x86_64-unknown-linux-gnu-gcc
Components: small 2.1, small2 2.0, small3 2.0, small4 1.0, small5 1.0, small6 1.0, small7 1.0, small8 1.0,
small9 1.0, small10 0.2, id2 3.0, id3 2.1, id4 1.0, id5 1.0, id6 1.0, id9 1.0, id10 0.1, trans 1.0,
prim 2.1 loaded.
Packages: AClib 1.1, Polycyclic 2.6, Alnuth 2.2.5, AutPGrp 1.4, CrystCat 1.1.3, Cryst 4.1.6, CRISP 1.3.2,
CTblLib 1.1.3, TomLib 1.1.4, FactInt 1.5.2, GAPDoc 1.2, FGA 1.1.0.1, IRREDSOL 1.1.2, LAGUNA 3.5.0,
Sophus 1.23, Polenta 1.2.7, ResClasses 2.5.3 loaded.
gap> join := function(a, b, sep)
> return Concatenation(a, sep, sep, b);
> end;
function( a, b, sep ) ... end
gap>
gap> join("Rosetta", "Code", ":");
"Rosetta::Code"
gap>

[edit] Go

To satisfy some of the desire for a REPL, Go includes a browser-based "playground" that compiles and executes directly from a browser edit box. You still have to type complete programs with all the usual boilerplate, but at least you don't have to create a source file, run the compiler, run the linker, and run the program. It has a convenient checkbox for "compile and run after each keystoke" that works quite well. You just type, and as soon as your program is valid, you see outupt.

Running goplay takes two steps. First, start the program with "goplay" on the command line, then visit http://localhost:3999/ with a browser.

The complete program satisfying the task is,

package main
 
import "fmt"
 
func f(s1, s2, sep string) string {
return s1+sep+sep+s2
}
 
func main() {
fmt.Println(f("Rosetta", "Code", ":"))
}

It works well to enter the program, check "every keystroke" to see syntax errors from whatever silly oversights you made, then fix them one by one until your desired output appears.

Rosetta::Code

[edit] Groovy

The groovysh interpreter requires a command-line interpreter (terminal) environment in which to run. This example was run under the CMD command-line interpreter on Microsoft Windows XP.

C:\Apps\groovy>groovysh
Groovy Shell (1.6.2, JVM: 1.6.0_13)
Type 'help' or '\h' for help.
---------------------------------------------------------------------------------------------------
groovy:000> f = { a, b, sep -> a + sep + sep + b }
===> groovysh_evaluate$_run_closure1@5e8d7d
groovy:000> println f('Rosetta','Code',':')
Rosetta::Code
===> null
groovy:000> exit
 
C:\Apps\groovy>

[edit] 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"

[edit] HicEst

Start HicEst e.g. with:
"c:\Program Files\HicEst\HicEst.exe E:\Rosetta\Interactive_programming.hic f('Rosetta', 'Code', ':')"
Type the following script. Each line is executed (and incrementally compiled) when it is typed:

CHARACTER A*40, B*40, C*40
 
READ(Text=$CMD_LINE, Format="'','','',") A, B, C
WRITE(ClipBoard, Name) A, B, C ! A=Rosetta; B=Code; C=:;
 
WRITE(ClipBoard) TRIM(A) // ':' // TRIM(C) // TRIM(B) ! Rosetta::Code

[edit] J

J runs in command mode by default. Starting J depends on your operating system and other factors, but typically would involve double clicking on an icon, or starting one of several programs from a command line (j, jwd, jconsole, jee, jhs -- though note that jhs would also require a web browser and visiting a localhost url).

This is a session log once the os specific stuff has been handled:

   f=: [: ; 0 2 2 1&{
f 'Rosetta';'Code';':'
Rosetta::Code

[edit] JavaScript

Works with: Rhino
$ java -cp js.jar org.mozilla.javascript.tools.shell.Main
Rhino 1.7 release 2 2009 03 22
js> function f(a,b,s) {return a + s + s + b;}
js> f('Rosetta', 'Code', ':')
Rosetta::Code
js> quit()
$

[edit] K

Works with: Kona
$ rlwrap k
K Console - Enter \ for help
f:{x,z,z,y}
f["Rosetta";"Code";":"]
"Rosetta::Code"

[edit] Lasso

#!/usr/bin/lasso9
 
// filename: interactive_demo
 
define concatenate_with_delimiter(
string1::string,
string2::string,
delimiter::string
 
) => #string1 + (#delimiter*2) + #string2
 
define read_input(prompt::string) => {
 
local(string)
 
// display prompt
stdout(#prompt)
// the following bits wait until the terminal gives you back a line of input
while(not #string or #string -> size == 0) => {
#string = file_stdin -> readsomebytes(1024, 1000)
}
#string -> replace(bytes('\n'), bytes(''))
 
return #string -> asstring
 
}
 
local(
string1,
string2,
delimiter
)
 
// get first string
#string1 = read_input('Enter the first string: ')
 
// get second string
#string2 = read_input('Enter the second string: ')
 
// get delimiter
#delimiter = read_input('Enter the delimiter: ')
 
// deliver the result
stdoutnl(concatenate_with_delimiter(#string1, #string2, #delimiter))

Called from the command line: ./interactive_demo

Result -> Rosetta::Code

[edit]

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

[edit] Lua

$ lua
Lua 5.1.2 Copyright (C) 1994-2007 Lua.org, PUC-Rio
> function conc(a, b, c)
>> return a..c..c..b
>> end
> print(conc("Rosetta", "Code", ":"))
Rosetta::Code
>

[edit] M4

Here is a terminal session with output lines marked by "==>":

$ m4
define(`f',`$1`'$3`'$3`'$2')
==>
f(`Rosetta',`Code',`:')
==>Rosetta::Code
m4exit


[edit] Maple

Start Maple's commandline interface by issuing the command maple in a terminal shell. Ie,

$ maple

Then enter the Maple commands.

f := (a,b,c)->cat(a,c,c,b):
 
f("Rosetta","Code",":");

Output:

                        "Rosetta::Code"

[edit] Mathematica

$ math
f[x_,y_,z_]:=Print[x,z,z,y]
->""
f["Rosetta","Code",":"]
->Rosetta::Code


[edit] MATLAB / Octave

Start Matlab or Octave and enter the following code:

 
function x=f(a,b,sep)
x = [a,sep,b];
return;
end;
f('Rosetta', 'Code', ':')
 

Output:

>>   function x=f(a,b,sep) 
>>     x = [a,sep,b];
>>     return;
>>   end; 
>>   f('Rosetta', 'Code', ':') 
ans = Rosetta:Code
>> 

[edit] Maxima

Simply run wxMaxima, xMaxima (or simply maxima in a Linux or Windows command line) to start a REPL.

(%i1) f(a, b, c) := sconcat(a, c, c, b)$
(%i2) f("Rosetta", "Code", ":");
(%o2) "Rosetta::Code"

[edit] ML/I

The following is exactly what should be fed to ML/I to start a suitable interactive session. Start ML/I with (e.g.: $ ml1), then type:

MCSKIP MT,<>
MCINS %.
MCDEF F WITHS (,,)
AS <%WA1.%WA3.%WA2.%WA2.>

[edit] Nimrod

Type nimrod i to run the interactive interpreter:

$ nimrod i
>>> proc f(x, y, z): string = x & z & z & y
>>> f("Rosetta", "Code", ":")
Rosetta::Code

To get working arrow keys, compile nimrod with readline, like this: ./koch boot -d:release -d:useGnuReadline or just run rlwrap nimrod i instead.

[edit] OCaml

The default interactive interpreter is called the toplevel. In the toplevel because we can enter expressions that span multiple lines, we have to type the double semicolon (";;") at the end of an expression so that it knows we are done.

$ ocaml
Objective Caml version 3.12.1
 
# let f s1 s2 sep = String.concat sep [s1; ""; s2];;
val f : string -> string -> string -> string = <fun>
# f "Rosetta" "Code" ":";;
- : string = "Rosetta::Code"
#

Also a lot of OCaml users invoke the toplevel with rlwrap or ledit to gain readline capabilities:

$ rlwrap ocaml

There is also ocamlnat that is a native toplevel. It permits interactive use of the OCaml system through a read-eval-print loop, similar to the standard OCaml toplevel, but up to 100 times faster.
Using a module in the default toplevel is made with .cma files, with ocamlnat just use .cmxs files instead.

[edit] 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>

[edit] Oz

Mozart supports this style of programming with its Emacs interface. Go to the "Oz" buffer and enter

declare fun {F As Bs Sep} {Append As Sep|Sep|Bs} end

Press C-. C-l to evaluate the line.

Now enter

{System.showInfo {F "Rosetta" "Code" &:}}

and again press C-. C-l to execute the code. You will see the result in the "*Oz Emulator*" buffer.

[edit] PARI/GP

gp *is* a REPL built on the PARI library. You can start it from the command line with gp, though you may wish to change to your Pari directory first so it can read your .gprc file. Alternatively, if you are using a GUI, double-click the shortcut.

f(s1,s2,sep)=Str(s1, sep, sep, s2);

[edit] 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

Alternative way:

$ perl
# Write the script here and press Ctrl+D plus ENTER when finished (^D means Ctrl+D):
sub f {my ($s1, $s2, $sep) = @_; $s1 . $sep . $sep . $s2};
print f('Rosetta', 'Code', ':');
^D
Rosetta::Code
$

Another:

$ perl -lpe '$_=eval||$@'
sub f { join '' => @_[0, 2, 2, 1] }
 
f qw/Rosetta Code :/
Rosetta::Code

[edit] Perl 6

Using Rakudo.

$ rakudo/perl6
> sub f($str1,$str2,$sep) { $str1~$sep x 2~$str2 };
f
> f("Rosetta","Code",":");
Rosetta::Code
>
 

[edit] PicoLisp

$ pil +
: (de f (Str1 Str2 Sep)
(pack Str1 Sep Sep Str2) )
-> f
 
: (f "Rosetta" "Code" ":")
-> "Rosetta::Code"

[edit] Pike

$ pike
Pike v7.8 release 352 running Hilfe v3.5 (Incremental Pike Frontend)
> string f(string first, string second, string sep){
>> return(first + sep + sep + second);
>> }
> f("Rosetta","Code",":");
(1) Result: "Rosetta::Code"
>

[edit] PowerShell

PowerShell itself is already a shell and therefore an interactive environment is the default.

Windows PowerShell
Copyright (C) 2009 Microsoft Corporation. All rights reserved.
 
PS Home:\> function f ([string] $string1, [string] $string2, [string] $separator) {
>> $string1 + $separator * 2 + $string2
>> }
>>
PS Home:\> f 'Rosetta' 'Code' ':'
Rosetta::Code
PS Home:\>

[edit] Prolog

Works with SWI-Prolog.
Prolog works in its own environnment.
Start the interpreter by typing pl at the command line (or by clicking on the exe).

% library(win_menu) compiled into win_menu 0.00 sec, 12,872 bytes
% library(swi_hooks) compiled into pce_swi_hooks 0.00 sec, 2,404 bytes
% The graphical front-end will be used for subsequent tracing
% c:/users/joel-seven/appdata/roaming/swi-prolog/pl.ini compiled 0.13 sec, 876,172 bytes
XPCE 6.6.66, July 2009 for Win32: NT,2000,XP
Copyright (C) 1993-2009 University of Amsterdam.
XPCE comes with ABSOLUTELY NO WARRANTY. This is free software,
and you are welcome to redistribute it under certain conditions.
The host-language is SWI-Prolog version 5.10.0
 
For HELP on prolog, please type help. or apropos(topic).
on xpce, please type manpce.
 
1 ?- assert((f(A, B,C) :- format('~w~w~w~w~n', [A, C, C, B]))).
true.
 
2 ?- f('Rosetta', 'Code', ':').
Rosetta::Code
true.
 
3 ?-
 

[edit] 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:

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'
>>>

[edit] R

$ R
 
R version 2.7.2 (2008-08-25)
Copyright (C) 2008 The R Foundation for Statistical Computing
ISBN 3-900051-07-0
 
R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.
 
Natural language support but running in an English locale
 
R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.
 
Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.
 
> f <- function(a, b, s) paste(a, "", b, sep=s)
> f("Rosetta", "Code", ":")
[1] "Rosetta::Code"
> q()
Save workspace image? [y/n/c]: n

[edit] Racket

Much like Scheme, Racket features a full-featured REPL:

oiseau:/tmp> racket
Welcome to Racket v5.3.3.5.
> (define (f string-1 string-2 separator)
(string-append string-1 separator separator string-2))
> (f "Rosetta" "Code" ":")
"Rosetta::Code"
> ^D
oiseau:/tmp>

[edit] Retro

Retro's interpreter is started automatically. Once you see the "ok" prompt, you can proceed to enter code:

: f ( $$$-$ ) [ ^strings'prepend ] sip ^strings'prepend ^strings'append tempString ;
"Rosetta" "Code" ":" f

[edit] REXX

[edit] version 1

/*REXX*/  parse arg a b c
say f(a,b,c)
exit
f:return arg(1)arg(3)arg(3)arg(2)

[edit] version 2

/*REXX program to show interactive programming by using a function [F]. */
say f('Rosetta', "Code", ':')
say f('The definition of a trivial program is '," one that has no bugs.",'───')
exit /*stick a fork in it, we're done.*/
 
/*──────────────────────────────────F subroutine────────────────────────*/
f: return arg(1) || copies(arg(3),2) || arg(2) /*return required str.*/

output

Rosetta::Code
The definition of a trivial program is ────── one that has no bugs.

[edit] version 3

This REXX version is more to the keeping of the spirit of the task requirements.

/*REXX program to show interactive programming by using a function [F]. */
say '══════════════════ enter the function F with three arguments:'
parse pull funky
interpret 'SAY' funky
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────F subroutine────────────────────────*/
f: return arg(1) || copies(arg(3),2) || arg(2) /*return required str.*/

output (a screen scraping is shown)

int_act3 is the name of the REXX program [INT_ACT3.REX)

─────────────────────────────────────────────────────────Thu 10/18/2012 15:00:01
C:\►int_act3
══════════════════ enter the function  F  with three arguments:
f('what the', "hey", '--')
what the----hey

─────────────────────────────────────────────────────────Thu 10/18/2012 15:00:38
C:\►

Note that the timestamp and the C:\► text is part of my (wrapped) two-line prompt message.

The f('what the', "hey", '--') is the text that I entered.

[edit] Ruby

The read-eval-print loop (REPL) for Ruby is irb, the interactive ruby shell.

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> :

$ 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> exit
$

[edit] Scala

Scala has a REPL -- Read, Evaluate & Print Loop. Being a compiled language, everything you type is encapsulated into a compilable template, compiled, executed, and the return value assigned to a special variable and displayed.

One invokes the REPL by just typing "scala", which is either a shell script or a batch file depending on one's operating system:

C:\>scala
Welcome to Scala version 2.8.0.r21356-b20100407020120 (Java HotSpot(TM) Client V
M, Java 1.6.0_05).
Type in expressions to have them evaluated.
Type :help for more information.
 
scala> "rosetta"
res0: java.lang.String = rosetta

Scala's REPL, starting with version 2.8, offers both auto-completion and alternatives when typing TAB. For instance, to check what methods are available on a String, one may do the following:

scala> "rosetta".
 
!= ## $asInstanceOf
$isInstanceOf + ==
charAt clone codePointAt
codePointBefore codePointCount compareTo
compareToIgnoreCase concat contains
contentEquals endsWith eq
equals equalsIgnoreCase finalize
getBytes getChars getClass
hashCode indexOf intern
isEmpty lastIndexOf length
matches ne notify
notifyAll offsetByCodePoints regionMatches
replace replaceAll replaceFirst
split startsWith subSequence
substring synchronized this
toCharArray toLowerCase toString
toUpperCase trim wait
 
scala> "rosetta".+(":")
res1: java.lang.String = rosetta:

One can use `object`, `class`, `trait`, `case object`, `case class`, `def`, `val` and `var` definitions at any point. However, `package` and `package object` definitions are not allowed.

scala> val str1 = "rosetta"
str1: java.lang.String = rosetta

Using these features, one can build the code for a method by testing it part of it individually:

scala> val str2 = "code"
str2: java.lang.String = code
 
scala> val separator = ":"
separator: java.lang.String = :
 
scala> str1 + separator + str2
res2: java.lang.String = rosetta:code

If one makes a mistake, the REPL will print an error message, and display the point at which the mistake was made.

scala> def (str1: String, str2: String, separator: String) =
<console>:1: error: identifier expected but '(' found.
def (str1: String, str2: String, separator: String) =
^

If a definition takes more than a line, the REPL will print an idented "|" sign, and wait for more input. If one wishes to abort a definition, just enter two consecutive empty lines.

scala> def f(str1: String, str2: String, separator: String) =
| str1 + separator + str2
f: (str1: String,str2: String,separator: String)java.lang.String
 
scala> f("rosetta", "code", ":")
res3: java.lang.String = rosetta:code
 
scala> f("code", "rosetta", ", ")
res4: java.lang.String = code, rosetta

Also starting with version 2.8, a line starting with a dot will be interpreted as a method call on the last result produced.

scala> .length
res5: Int = 13
 
scala>

The results are actually displayed with a special function, which pretty prints some results, and avoid eagerly evaluating others, where that could cause problems (such as infinite collections).

scala> Array(1, 2, 3, 4)
res8: Array[Int] = Array(1, 2, 3, 4)
 
scala> println(res8)
[I@383244

There are many other features, such as the ability to add new jars to the class path, executing commands on the shell, retrieving the last exception thrown, etc.

[edit] Scheme

Several interpreters exist for Scheme. These are just some examples.

> scheme
Scheme Microcode Version 14.9
MIT Scheme running under FreeBSD
Type `^C' (control-C) followed by `H' to obtain information about interrupts.
Scheme saved on Monday June 17, 2002 at 10:03:44 PM
Release 7.7.1
Microcode 14.9
Runtime 15.1
 
1 ]=> (define (f string-1 string-2 separator)
(string-append string-1 separator separator string-2))
 
;Value: f
 
1 ]=> (f "Rosetta" "Code" ":")
 
;Value 1: "Rosetta::Code"
 
1 ]=> ^D
End of input stream reached
Happy Happy Joy Joy.
>
> scheme48
Welcome to Scheme 48 1.8 (made by root on Wed Sep 24 22:37:08 UTC 2008)
Copyright (c) 1993-2008 by Richard Kelsey and Jonathan Rees.
Please report bugs to [email protected]
Get more information at http://www.s48.org/.
Type ,? (comma question-mark) for help.
> (define (f string-1 string-2 separator)
(string-append string-1 separator separator string-2))
; no values returned
> (f "Rosetta" "Code" ":")
"Rosetta::Code"
> ^D
Exit Scheme 48 (y/n)? ^D
I'll only ask another 100 times.
Exit Scheme 48 (y/n)? ^D
I'll only ask another 99 times.
Exit Scheme 48 (y/n)? y
>

[edit] Slate

slate[1]> s@(String traits) rosettaWith: s2@(String traits) and: s3@(String traits) [s ; s3 ; s3 ; s2].
[rosettaWith:and:]
slate[2]> 'Rosetta' rosettaWith: 'Code' and: ':'.
'Rosetta::Code'

[edit] 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>

[edit] SNOBOL4

Works with: Macro Spitbol
>spitbol code
SPITBOL-386   Release 3.7(ver 1.30.20)   Serial xxxxx
...
Enter SPITBOL statements:
? define('f(a,b,s)'):(z);f f = a s s b:(return);z
Success
?= f('Rosetta','Code',':')
Rosetta::Code
Success
?end
>

[edit] 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
-

[edit] Tcl

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

A simple alternative (one-liners are most convenient in an interactive shell):

$ tclsh
% proc f {a b s} {join [list $a "" $b] $s}
% f Rosetta Code :
Rosetta::Code
%

[edit] TI-89 BASIC

To switch to the interpreter ("home screen"), press the HOME key.

■ x & s & s & y → f(x,y,s)
                                  Done
■ f("Rosetta", "Code", ":")
                       "Rosetta::Code"

Input is left-aligned, output is right-aligned. “→” is typed by pressing STO▸, and “&” by pressing ◆ ×. All whitespace is optional.

[edit] UNIX Shell

Works with: Bourne Shell
$ sh
sh-3.2$ concat() { echo "$1$3$3$2"; }
sh-3.2$ concat Rosetta Code :
Rosetta::Code
sh-3.2$

[edit] C Shell

$ csh -f
% alias concat 'echo "\!:1\!:3\!:3\!:2"'
% concat Rosetta Code :
Rosetta::Code
%

[edit] es

$ es
; fn concat a b s { result $a$s$s$b }
; echo <={concat Rosetta Code :}
Rosetta::Code
;

[edit] 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:

RS(100, "RS(10, @1) RS(10, @3, APPEND) RS(10, @3, APPEND) RS(10, @2, APPEND)")

To call the macro:

RS(1,"Rosetta") RS(2,"Code") RS(3,":") Call(100)
Message(@10)

[edit] zkl

$ zkl
zkl 1.12.8, released 2014-04-01
zkl: fcn f(a,b,c){String(a,c,c,b)}
Void
zkl: f("Rosetta", "Code", ":")
Rosetta::Code
zkl: 
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox