Interactive programming (repl): Difference between revisions

ACL2 !>(good-bye)

</pre>

=={{header|Arturo}}==

 

 

=={{header|BASIC}}==

 

A Basic interpreter is in command mode by default. Enter the following in command mode:

 

=={{header|Batch File}}==

CMD.EXE is the CLI for Batch Files. Batch Files do not have traditional functions and doing the [http://rosettacode.org/wiki/Call_a_function#Batch_File alternative] will not work in interactive mode. So this example uses blocks of code.

{{trans|BBC BASIC}}

 

>set c=Code

Rosetta::Code

 

 

=={{header|BBC BASIC}}==

'''&raquo;quit'''

$

 

=={{header|Bracmat}}==

 

=={{header|Brat}}==

# Interactive Brat

brat:1> f = { a, b, s | a + s + s + b }

#=> Rosetta::Code

brat:3> quit

 

=={{header|Burlesque}}==

 

C:\Burlesque>Burlesque.exe --shell

blsq ) {+]?+}hd"Rosetta""Code"':!a

"Rosetta:Code"

blsq )

 

=={{header|C sharp}}==

=={{header|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))

"Rosetta::Code"

user=>

 

=={{header|CoffeeScript}}==

With the [https://www.npmjs.com/package/coffee-script coffee-script] package for [https://www.npmjs.org/ NPM] on [http://nodejs.org/ Node.js]. The ''-n'' flag is '--node'.

$ coffee -n

coffee> f = (a, b, c) -> a + c + c + b

coffee> f "Rosetta", "Code", ":"

"Rosetta::Code"

 

=={{header|Common Lisp}}==

 

The details of interactive use vary widely between implementations; this example is from [[SBCL]]. <code>*</code> is the prompt. By default, SBCL compiles (not interprets) all code, unless <code>[http://www.sbcl.org/manual/Interpreter.html sb-ext:*evaluator-mode*]</code> is changed.

This is SBCL 1.0.25, an implementation of ANSI Common Lisp.

More information about SBCL is available at <http://www.sbcl.org/>.

 

"Rosetta::Code"

 

=={{header|Déjà Vu}}==

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

 

<1:1> f str1 str2 sep:

<1:2> join sep [ str2 "" str1 ]

<1:3>

<2:1> . f "Rosetta" "Code" ":"

 

=={{header|E}}==

 

 

"<code>?</code>" and "<code>&gt;</code>" are prompts for input; "<code>#</code>" marks output.

 

> return separator.rjoin(string1, "", string2)

> }

 

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

 

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

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

 

;; etc.

 

=={{header|Elena}}==

ELENA Script is a subset of the general language. ELT (Virtual machine terminal) can work in REPL mode

Initializing...

 

 

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

Rosetta::Code

>

 

=={{header|Elixir}}==

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

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(2)> g = fn str1,str2,sep -> str1 <> sep <> sep <> str2 end # Or concatenate strings

 

...(3)> def f(str1,str2,sep), do: [str1,"",str2] |> Enum.join(sep)

...(3)> def g(str1,str2,sep), do: str1 <> sep <> sep <> str2

 

'''Example:'''

"Rosetta::Code"

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

 

=={{header|Emacs Lisp}}==

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

 

(concat str1 sep sep str2))

my-join

(my-join "Rosetta" "Code" ":")

 

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

 

ELISP> (defun my-join (str1 str2 sep)

(concat str1 sep sep str2))

ELISP> (my-join "Rosetta" "Code" ":")

"Rosetta::Code"

 

=={{header|Erlang}}==

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"

 

=={{header|ERRE}}==

=={{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.

F# Version 1.9.6.2, compiling for .NET Framework Version v2.0.50727

 

 

> f "Rosetta" "Code" ":" ;;

 

=={{header|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 ) "Rosetta" "Code" ":" cool-func .

 

=={{header|Fantom}}==

 

All Forth systems come with an interpreter. On embedded systems, the interpreter functions as a monitor or lightweight operating system.

Gforth 0.7.0, Copyright (C) 1995-2008 Free Software Foundation, Inc.

Gforth comes with ABSOLUTELY NO WARRANTY; for details type `license'

ok

s" :" s" Code" s" Rosetta" f cr type

 

=={{header|FreeBASIC}}==

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

 

 

Dim As String s1, s2, sep

Input "Separator "; sep

Print : Print s1 + sep + sep + s2

 

{{out}}

Frink is distributed as a single <CODE>.jar</CODE> file that will run in a Java Virtual Machine. On many operating systems, just double-clicking this <CODE>.jar</CODE> file will run Frink with a graphical interface in an interactive mode. By specifying a different main-class (<CODE>frink.parser.Frink</CODE>) when starting Frink, it can be run in a text-mode interactive mode as well. These options and sample starter scripts for various operating systems are provided in the [https://frinklang.org/#RunningFrink Running Frink] section of the documentation.

 

 

f[a,b,s] := "$a$s$s$b"

 

{{out}}

Rosetta::Code

</pre>

 

=={{header|GAP}}==

######### ###### ########### ###

gap> join("Rosetta", "Code", ":");

"Rosetta::Code"

 

=={{header|Go}}==

 

The complete program satisfying the task is,

 

import "fmt"

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.

=={{header|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.

Groovy Shell (1.6.2, JVM: 1.6.0_13)

Type 'help' or '\h' for help.

groovy:000> exit

 

 

=={{header|Haskell}}==

The details of interactive use vary widely between implementations. This example is from [[GHC|GHCi]].

 

___ ___ _

/ _ \ /\ /\/ __(_)

Prelude> let f as bs sep = as ++ sep ++ sep ++ bs

Prelude> f "Rosetta" "Code" ":"

 

=={{header|HicEst}}==

"c:\Program Files\HicEst\HicEst.exe E:\Rosetta\Interactive_programming.hic f('Rosetta', 'Code', ':')"

<br>Type the following script. Each line is executed (and incrementally compiled) when it is typed:

 

READ(Text=$CMD_LINE, Format="'','','',") A, B, C

WRITE(ClipBoard, Name) A, B, C ! A=Rosetta; B=Code; C=:;

 

 

 

=={{header|Io}}==

 

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

f 'Rosetta';'Code';':'

 

=={{header|Java}}==

 

public static void main(String[] args) {

System.out.println(concat("Rosetta", "Code", ":"));

 

Rosetta::Code

 

=={{header|JavaScript}}==

{{works with|Rhino}}

Rhino 1.7 release 2 2009 03 22

js> function f(a,b,s) {return a + s + s + b;}

Rosetta::Code

js> quit()

 

=={{header|Jsish}}==

=={{header|K}}==

{{works with|Kona}}

K Console - Enter \ for help

f:{x,z,z,y}

f["Rosetta";"Code";":"]

 

=={{header|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:

Welcome to Kotlin version 1.0.6-release-127 (JRE 1.8.0_31-b13)

Type :help for help, :quit for quit

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

Rosetta::Code

 

=={{header|Lasso}}==

 

// filename: interactive_demo

 

// deliver the result

 

Called from the command line: ./interactive_demo

 

Result -> Rosetta::Code

 

=={{header|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.scripttext="on conc(a,b,c)"&RETURN&"return a&c&c&b"&RETURN&"end"

> put conc("Rosetta", "Code", ":")

 

=={{header|Logo}}==

{{works with|UCB Logo}}

Welcome to Berkeley Logo version 5.6

? <i>to f :prefix :suffix :separator</i>

? <i>show f "Rosetta "Code ":</i>

Rosetta::Code

 

=={{header|Lua}}==

Lua 5.1.2 Copyright (C) 1994-2007 Lua.org, PUC-Rio

> function conc(a, b, c)

> print(conc("Rosetta", "Code", ":"))

Rosetta::Code

 

=={{header|M2000 Interpreter}}==

</pre >

(we see Function F$() at the header of editor)

Read name1$, name2$, sep$

=name1$+sep$+sep$+name2$

So now we press Esc and return to command line (editor open as a layer, so console has the last state). Using Clipboard we sen unicode string to clipboard

<pre >

=={{header|M4}}==

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

define(`f',`$1`'$3`'$3`'$2')

==>

f(`Rosetta',`Code',`:')

==>Rosetta::Code

 

=={{header|Maple}}==

<pre>$ maple</pre>

Then enter the Maple commands.

 

Output:

<pre> "Rosetta::Code"</pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

->""

f["Rosetta","Code",":"]

 

=={{header|MATLAB}} / {{header|Octave}}==

 

Define an anonymous function in the Command Window

>> f = @(str1, str2, delim) [str1, delim, delim, str2];

 

Call of function and {{out}}

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

 

(%i2) f("Rosetta", "Code", ":");

 

=={{header|ML/I}}==

Start ML/I with (e.g.: $ ml1), then type:

 

MCINS %.

MCDEF F WITHS (,,)

 

=={{header|Nanoquery}}==

 

=={{header|Nim}}==

 

 

 

 

<pre>Rosetta::Code</pre>

 

 

=={{header|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.

 

Objective Caml version 3.12.1

 

# f "Rosetta" "Code" ":";;

- : string = "Rosetta::Code"

 

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

 

 

There is also [http://benediktmeurer.de/ocamlnat/ 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.<BR>

 

=={{header|Octave}}==

GNU Octave, version 3.0.2

Copyright (C) 2008 John W. Eaton and others.

octave:2> concat("Rosetta","Code",":");

Rosetta::Code

 

=={{header|Oforth}}==

Oforth interpreter is started using --i command line parameter :

 

 

Into the interpreter, you can create functions :

 

ok

>x("Rosetta", "Code", ":")

[1] (String) Rosetta::Code

ok

 

Alternatively you don't need the local variables

 

ok

> "Rosetta" "Code" ";" x .s

[1] (String) Rosetta::Code

ok

 

=={{header|Ol}}==

Ol comes with builtin REPL. Interactive web-based example can be found at the Ol [https://yuriy-chumak.github.io/ol project page].

 

$ ol

Welcome to Otus Lisp 2.1-2282-27a9b6c

type ',help' to help, ',quit' to end session.

> (define (f head tail mid)

;; Defined f

> (f "Rosetta" "Code" ":")

> ,quit

bye-bye :/

 

=={{header|ooRexx}}==

Mozart supports this style of programming with its Emacs interface.

Go to the "Oz" buffer and enter

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

 

Now enter

and again press C-. C-l to execute the code.

You will see the result in the "*Oz Emulator*" buffer.

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

 

 

=={{header|Perl}}==

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

 

Loading DB routines from perl5db.pl version 1.3

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

Rosetta::Code

 

Alternative way:

 

# 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};

^D

Rosetta::Code

 

Another:

 

sub f { join '' => @_[0, 2, 2, 1] }

 

f qw/Rosetta Code :/

 

=={{header|Phix}}==

<pre>

C:\Program Files (x86)\Phix>p -repl

Enter a statement such as "?remainder(floor(250/8),8)" or "puts(1,"Hi")"

 

 

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

 

</pre>

 

=={{header|PicoLisp}}==

(pack Str1 Sep Sep Str2) )

-> f

 

: (f "Rosetta" "Code" ":")

 

=={{header|Pike}}==

Pike v7.8 release 352 running Hilfe v3.5 (Incremental Pike Frontend)

> string f(string first, string second, string sep){

> f("Rosetta","Code",":");

(1) Result: "Rosetta::Code"

 

=={{header|PowerShell}}==

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

Copyright (C) 2009 Microsoft Corporation. All rights reserved.

 

PS Home:\> f 'Rosetta' 'Code' ':'

Rosetta::Code

 

=={{header|Prolog}}==

Prolog works in its own environnment.<BR>

Start the interpreter by typing pl at the command line (or by clicking on the exe).

% library(swi_hooks) compiled into pce_swi_hooks 0.00 sec, 2,404 bytes

% The graphical front-end will be used for subsequent tracing

 

3 ?-

 

=={{header|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 2.6.1 (r261:67517, Dec 4 2008, 16:51:00) [MSC v.1500 32 bit (Intel)] on

win32

>>> f('Rosetta', 'Code', ':')

'Rosetta::Code'

 

=={{header|R}}==

 

R version 2.7.2 (2008-08-25)

[1] "Rosetta::Code"

> q()

 

=={{header|Racket}}==

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

 

Welcome to Racket v5.3.3.5.

> (define (f string-1 string-2 separator)

"Rosetta::Code"

> ^D

 

=={{header|Raku}}==

(formerly Perl 6)

Using [[Rakudo]].

> sub f($str1,$str2,$sep) { $str1~$sep x 2~$str2 };

f

Rosetta::Code

>

 

=={{header|REBOL}}==

Start the REBOL/Core interpreter in quiet mode with -q. q to quit.

 

>> f: func [a b s] [print rejoin [a s s b]]

>> f "Rosetta" "Code" ":"

Rosetta::Code

 

=={{header|Retro}}==

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

 

 

=={{header|REXX}}==

===version 1===

say f(a,b,c)

exit

 

===version 2===

This REXX version allows blanks to be included in the three strings.

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 all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output''' &nbsp; when using the (internal) default strings:

<pre>

===version 3===

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

say '══════════════════ enter the function F with three comma-separated arguments:'

parse pull funky

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output''' (a screen scraping is shown)

<br><br>'''int_act3''' is the name of the REXX program [INT_ACT3.REX)

 

=={{header|Ring}}==

r = "Rosetta"

c = "Code"

s = ":"

see r+s+s+c

Output:

<pre>

</pre>

 

=={{header|Ruby}}==

The read-eval-print loop (REPL) for Ruby is ''irb'', the '''''i'''nteractive '''r'''u'''b'''y shell''.

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

 

irb(main):001:0> def f(string1, string2, separator)

irb(main):002:1> [string1, '', string2].join(separator)

=> "Rosetta::Code"

irb(main):005:0> exit

 

=={{header|Rust}}==

fn main() {

}

 

fn f<'a>(s1: &'a str, s2: &'a str, sep :&'a str) -> String{

[s1,sep,sep,s2].iter().map(|x| *x).collect()

Output:

<pre>

 

Without any arguments it starts from the command-line in [REPL] command-mode:

slsh version 0.9.1-2; S-Lang version: pre2.3.1-23

Copyright (C) 2005-2014 John E. Davis <jed@jedsoft.org>

Rosetta::Code

slsh> quit<Enter>

 

=={{header|Scala}}==

or a batch file depending on one's operating system:

 

Welcome to Scala version 2.8.0.r21356-b20100407020120 (Java HotSpot(TM) Client V

M, Java 1.6.0_05).

 

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

 

!= ## $asInstanceOf

 

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

Using these features, one can build the code for a method by testing it

part of it individually:

str2: java.lang.String = code

 

 

scala> str1 + separator + str2

If one makes a mistake, the REPL will print an error message, and display the

point at which the mistake was made.

<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 indented "|" sign, and

wait for more input. If one wishes to abort a definition, just enter two consecutive

empty lines.

| str1 + separator + str2

f: (str1: String,str2: String,separator: String)java.lang.String

 

scala> f("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.

res5: Int = 13

 

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).

res8: Array[Int] = Array(1, 2, 3, 4)

 

scala> println(res8)

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

=={{header|Scheme}}==

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

Scheme Microcode Version 14.9

MIT Scheme running under FreeBSD

End of input stream reached

Happy Happy Joy Joy.

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.

I'll only ask another 99 times.

Exit Scheme 48 (y/n)? y

 

=={{header|Sidef}}==

>>> func f(s1, s2, sep) { s1 + sep*2 + s2 };

f

>>> f('Rosetta', 'Code', ':')

"Rosetta::Code"

 

=={{header|Slate}}==

[rosettaWith:and:]

slate[2]> 'Rosetta' rosettaWith: 'Code' and: ':'.

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

GNU Smalltalk ready

 

Rosetta::Code

'Rosetta::Code'

{{works with|Smalltalk/X}}

Welcome...

 

Rosetta::Code

-> (Answer): 'Rosetta::Code'

 

=={{header|SNOBOL4}}==

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.

 

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];

- f ("Rosetta", "Code", ":");

val it = "Rosetta::Code" : string

 

=={{header|Tcl}}==

% proc f {s1 s2 sep} {

append result $s1 $sep $sep $s2

% f Rosetta Code :

Rosetta::Code

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

% proc f {a b s} {join [list $a "" $b] $s}

% f Rosetta Code :

Rosetta::Code

 

=={{header|TI-89 BASIC}}==

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

sh-3.2$ concat() { echo "$1$3$3$2"; }

sh-3.2$ concat Rosetta Code :

Rosetta::Code

 

==={{header|C Shell}}===

% alias concat 'echo "\!:1\!:3\!:3\!:2"'

% concat Rosetta Code :

Rosetta::Code

 

==={{header|es}}===

; fn concat a b s { result $a$s$s$b }

; echo <={concat Rosetta Code :}

Rosetta::Code

 

=={{header|Ursa}}==

cygnus/x ursa v0.76 (default, release 1)

[Oracle Corporation JVM 1.8.0_91 on Linux 3.16.0-4-686-pae i386]

> out (f "Rosetta" "Code" ":") endl console

Rosetta::Code

 

=={{header|Vedit macro language}}==

 

To define a macro in text register 100:

 

To call the macro:

 

=={{header|XLISP}}==

How to start a REPL depends on the operating system.

[1] (defun f (a b sep)

(string-append a sep sep b))

 

"Rosetta::Code"

 

=={{header|Wren}}==

$ ./wren

\\/"-

> var f = Fn.new { |s1, s2, sep| s1 + sep + sep + s2 }

> f.call("Rosetta", "Code", ":")

zkl:

</pre>

{{Omit From|Ada}}

{{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.}}