EchoLisp

EchoLisp runs in a browser window, and is -par essence - interactive. To start the REPL mode, type http://www.echolalie.org/echolisp in the browser URL address field.

;; screen copy of the REPL
;; note that the &i variables remember expression evaluation, and may be used in other expressions

EchoLisp - 2.16.2
📗 local-db: db.version: 3
(define ( f s1 s2 s3) (string-append s1 s3 s3 s2))
[0]→ f
(f "Rosetta" "Code" ":")
[1]→ "Rosetta::Code"
(+ 4 8)
[2]→ 12
(* 4 8)
[3]→ 32
(* &2 &3)
[4]→ 384
(f &1 &1 ":")
[5]→ "Rosetta::Code::Rosetta::Code"

;; etc.

Elixir

Elixir's Interactive REPL is IEx, Interactive Elixir. To open IEx, open a shell and type: iex

The 'def' keyword isn't allowed outside of modules in Elixir, so the easiest way to write a function in iex is usually by writing an anonymous function.

iex(1)> f = fn str1,str2,sep -> [str1,"",str2] |> Enum.join(sep) end # Join list on separator
iex(2)> g = fn str1,str2,sep -> str1 <> sep <> sep <> str2 end       # Or concatenate strings

iex(3)> defmodule JoinStrings do
...(3)>   def f(str1,str2,sep), do: [str1,"",str2] |> Enum.join(sep)
...(3)>   def g(str1,str2,sep), do: str1 <> sep <> sep <> str2
...(3)> end

'''Example:'''

iex(4)> f.("Rosetta","Code",":")
"Rosetta::Code"
iex(5)> JoinStrings.f("Rosetta","Code",":")
"Rosetta::Code"

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>

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"

ERRE

ERRE hasn't no ''interactive mode''. You can only execute the R-Code Interpreter in this way: from main menu do Utilità --> Dos Shell and then from command prompt RCODE and then type this

 r$="Rosetta"
 Ok   <--- from interpreter
 c$="Code"
 Ok   <--- from interpreter
 s$="-"
 Ok   <--- from interpreter
 PRINT r$+s$+c$
 Rosetta-Code
 Ok   <--- from interpreter

Type system to return to command prompt.

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"

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

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.

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

FreeBASIC

FreeBASIC is a compiler rather than an interpreter and doesn't have an interactive mode as such.

However, as simple programs can be written in a few lines and compile and execute very quickly, I think it's fair to say that the lack of an interpreter is not considered much of a drawback by most FB developers.

For example, the current task can be coded as follows and compiles/runs instantly :

' FB 1.05.0 Win64

Dim As String s1, s2, sep
Input "First string  "; s1
Input "Second string "; s2
Input "Separator     "; sep
Print : Print  s1 + sep + sep + s2
Sleep

{{out}}

First string  ? Rosetta
Second string ? Code
Separator     ? :

Rosetta::Code

=={{header|F_Sharp|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"

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>

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 keystroke" that works quite well. You just type, and as soon as your program is valid, you see output.

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

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.

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>

Haskell

The details of interactive use vary widely between implementations. This example is from [[GHC|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"

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

Huginn

[[File:huginn_interactive.gif]]

Io

$ io
Io 20110905
Io> f := method(str1,str2,sep,
... str1 .. sep .. sep .. str2)
==> method(str1, str2, sep,
    str1 .. sep .. sep .. str2
)
Io> f("Rosetta","Code",":")
==> Rosetta::Code
Io> writeln("I am going to exit now")
I am going to exit now
==> nil
Io> exit
$

The function could have been written on one line but I wanted to show multi-line input with the continuation prompt .... The result of the expression that is entered appears after ==> and any output or error message appears before.

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

Java

public static void main(String[] args) {
    System.out.println(concat("Rosetta", "Code", ":"));
}

public static String concat(String a, String b, String c) {
   return a + c + c + b;
}

Rosetta::Code

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()
$

Jsish

prompt$ jsish
Jsish interactive: see 'help [cmd]'
# function f(a:string, b:string, s:string):string { return a+s+s+b; }
# f('Rosetta', 'Code', 1)
warn: type mismatch for argument arg 3 's': expected "string" but got "number", in call to 'f' <1>.    (at or near "Code")

"Rosetta11Code"
# f('Rosetta', 'Code', ':')
"Rosetta::Code"

Julia

Julia has a fine REPL which is invoked by the command julia when no arguments are supplied.

usr@host:~/rosetta/julia$ julia
               _
   _       _ _(_)_     |  A fresh approach to technical computing
  (_)     | (_) (_)    |  Documentation: http://docs.julialang.org
   _ _   _| |_  __ _   |  Type "help()" for help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 0.3.7 (2015-03-23 21:36 UTC)
 _/ |\__'_|_|_|\__'_|  |  Official http://julialang.org release
|__/                   |  x86_64-linux-gnu

julia> function strcat(a::String, b::String, sep::String)
                  a*(sep^2)*b
       end
strcat (generic function with 1 method)

julia> strcat("rosetta", "code", "_")
"rosetta__code"

julia>

K

{{works with|Kona}}

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

Kotlin

Kotlin has an interactive shell for the JVM which can be started by simply typing 'kotlinc' at the command line. Here's a sample interactive session to accomplish the specified task on Windows 10:

c:\kotlin-compiler-1.0.6>kotlinc
Welcome to Kotlin version 1.0.6-release-127 (JRE 1.8.0_31-b13)
Type :help for help, :quit for quit
>>> fun f(s1: String, s2: String, sep: String) = s1 + sep + sep + s2
>>> f("Rosetta", "Code", ":")
Rosetta::Code
>>> :quit

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

Lingo

Lingo/Director is usually started as GUI program and has no access to the standard system console (unless using a binary plugin). But it has its own interactive Lingo console called "Message Window", that can be activated/displayed by executing "_player.debugPlaybackEnabled=1". Using this Message Window, the task can be solved like this:

 m=new(#script)
> m.scripttext="on conc(a,b,c)"&RETURN&"return a&c&c&b"&RETURN&"end"
> put conc("Rosetta", "Code", ":")
-- "Rosetta::Code"

Logo

{{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
?

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
>

M2000 Interpreter

M2000 run through an environment (the M2000 Environment), and this can run a script by using command line arguments, or run in interactive mode, just opening the environment, in full screen.

To exit interactive mode just type END and press enter after prompt >, Old commands are back again using arrows up or down. We can open editor for these commands (internal editor has syntax color).

Command line has a some special commands (we need to use Set to send command to this line, from a program), to change many things. Type Help All to see help for all topics, or type Help Print to see help for Print.

We an use ? as a Print command. Any variable, array, module, function, group we make at command line is global.

We can make functions using edit, so edit f$() open editor and we write these

>edit f$()

>? f$("Rosseta","Code",":")
Rosseta::Code
>clipboard f$("Rosseta","Code",":")
>New  ' now we clear any stored function/module
>function f$(a$,b$,c$) {=a$+c$+c$+b$}    'in one line function
>? f$("Rosseta","Code",":")
Rosseta::Code
>Save ros1
>New
>Load ros1
>? f$("Rosseta","Code",":")
Rosseta::Code
>New
>f$=Lambda$ (a$,b$,c$)->a$+c$+c$+b$
>? f$("Rosseta","Code",":")
Rosseta::Code
>B$=F$  ' lambda functions as variables.
>? B$("Rosseta","Code",":")
Rosseta::Code