Menu: Difference between revisions

This task is fashioned after the action of the [http://www.softpanorama.org/Scripting/Shellorama/Control_structures/select_statements.shtml Bash select statement].

 

 

 

 

 

 

 

 

 

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''}}

(

INT choice;

 

printf(($"You chose "g"."l$, menu select(items, prompt)))

Output:

<pre>

</pre>

 

 

 

 

 

 

# syntax: GAWK -f MENU.AWK

BEGIN {

while (1) {

print("")

printf("%d - %s\n",i,arr[i])

}

getline ans

if (ans in arr) {

}

print("invalid choice")

}

}

 

=={{header|Axe}}==

{{incorrect|Axe|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

In Axe, static data (such as strings) is laid out sequentially in memory. So the H in "HUFF" is the byte after the null terminator for "FIE". However, null terminators are only added to strings when they are stored with the store symbol →. strGet returns a pointer to the start of the nth null-terminated string in the data, which is why the strings must be laid out in memory correctly.

"HUFF AND PUFF"→Str2

"MIRROR MIRROR"→Str3

Return

End

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

if ubound(choices$) - lbound(choices$) = 0 then sel$ = ""

ret$ = ""

while ret$ = ""

sel$ = ret$

 

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

 

 

:tryagain

cls&echo.

echo.

)

echo.

echo.Invalid Input. Please try again...

pause>nul

 

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

list$() = "fee fie", "huff and puff", "mirror mirror", "tick tock"

selected$ = FNmenu(list$(), "Please make a selection: ")

IF index%>=0 IF index%<=DIM(list$() ,1) IF list$(index%)="" index% = -1

UNTIL index%>=0 AND index%<=DIM(list$(), 1)

Empty entries in the list are not offered as options, nor accepted as a selection.

 

=={{header|Brat}}==

true? choices.empty?

{ "" }

}

 

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

 

return items[choice - 1];

 

=={{header|C++}}==

#include <string>

#include <vector>

std::cout << "You chose: " << data_entry("> ", terms) << std::endl;

}

 

=={{header|Ceylon}}==

shared void run() {

value selection = menu("fee fie", "huff And puff", "mirror mirror", "tick tock");

}

 

 

=={{header|Clojure}}==

(if (empty? choices)

""

(println "You chose: "

(menu "Which is from the three pigs: "

 

=={{header|COBOL}}==

PROGRAM-ID. Test-Prompt-Menu.

 

.

 

 

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

(if (null choices)

""

(force-output)

(setf n (parse-integer (read-line *standard-input* nil)

 

=={{header|D}}==

 

string menuSelect(in string[] entries) {

try {

immutable n = input.to!int;

return typeof(return)((n >= 0 && n <= nEntries) ? n : -1);

} catch (Exception e) // Very generic

writefln(" %d) %s", i, entry);

"> ".write;

immutable input = readln.chomp;

if (choice.isNull)

"Wrong choice.".writeln;

immutable items = ["fee fie", "huff and puff",

"mirror mirror", "tick tock"];

writeln("You chose '", items.menuSelect, "'.");

{{out}}

0) fee fie

1) huff and puff

3) tick tock

> 2

 

=={{header|Elixir}}==

def select(_, []), do: ""

def select(prompt, items) do

items = ["fee fie", "huff and puff", "mirror mirror", "tick tock"]

response = Menu.select("Which is from the three pigs", items)

 

{{out}}

you chose: "tick tock"

</pre>

 

=={{header|ERRE}}==

PROCEDURE Selection(choices$[],prompt$->sel$)

IF UBOUND(choices$,1)-LBOUND(choices$,1)=0 THEN

sel$=ret$

END PROCEDURE

 

=={{header|Euphoria}}==

 

function menu_select(sequence items, object prompt)

constant prompt = "Which is from the three pigs? "

 

 

=={{header|Factor}}==

 

: print-menu ( seq -- )

"Your choice? " write flush ;

 

 

Example usage:

=={{header|Fantom}}==

{{incorrect|Fantom|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

{

static Void displayList (Str[] items)

echo ("You chose: $choice")

}

 

=={{header|Forth}}==

===Idiomatic Forth===

 

\ vector table compiler

: CASE: ( -- ) CREATE ;

: | ( -- <text>) ' , ; IMMEDIATE

 

: NIL ( -- addr len) S" " ;

2DROP NIL EXIT

ELSE

BEGIN

CR

CR [CHAR] 0 - SELECT

THEN

 

===If there must be lists===

Here we extend Forth to support simple lists and complete the task using the language extensions.

 

: STRING, ( caddr len -- ) HERE OVER CHAR+ ALLOT PLACE ;

: {NTH} ( n array_addr -- str) SWAP 0 DO {NEXT} LOOP ;

 

0 >R \ Counter on Rstack

{NEXT} \ skip 1st empty string

R> ; \ return counter to data stack

 

: '"' ( -- ) [CHAR] " EMIT ;

 

\ ===== TASK BEGINS =====

CR SWAP {NTH}

THEN

 

Test at the gForth console

Choice: 2

ok

ok

NIL MENU ok

 

=={{header|Fortran}}==

!a=./f && make $a && OMP_NUM_THREADS=2 $a

 

 

 

 

 

 

 

 

 

=={{header|Gambas}}==

 

 

 

=={{header|Go}}==

 

import "fmt"

pick = menu(choices, "Enter number: ")

fmt.Printf("You picked %q\n", pick)

Output:

<pre>

You picked "huff and puff"

</pre>

 

=={{header|Haskell}}==

 

import Data.Maybe (listToMaybe)

 

maybeRead :: Read a => String -> Maybe a

 

Example usage, at the GHCI prompt:

1) fee fie

2) huff and puff

Choose an item: 3

"mirror mirror"

 

=={{header|HicEst}}==

{{incorrect|HicEst|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

 

POP(Menu=list, SelTxt=answer)

! The global variable $$ returns the selected list index

WRITE(Messagebox, Name) answer, $$

 

=={{header|Icon}} and {{header|Unicon}}==

 

L := ["fee fie", "huff and puff", "mirror mirror", "tick tock"]

 

repeat {

writes("Choose a number from the menu above: ")

a := read()

}

 

=={{header|J}}==

 

'''Solution:'''

CHOICES =: ];._2 'fee fie;huff and puff;mirror mirror;tick tock;'

PROMPT =: 'Which is from the three pigs? '

RESULT {:: CHOICES

)

 

See [[Talk:Select#J_implementation|Talk page]] for explanation.

 

=={{header|Java}}==

if(list.size() == 0) return "";

Scanner sc = new Scanner(System.in);

}while(ret == null);

return ret;

 

=={{header|JavaScript}}==

 

}

 

 

=={{header|jq}}==

{{works with|jq|1.5}}

This version uses jq 1.5's 'input' builtin to read programmatically from STDIN.

def read(prompt; max):

def __read__:

| if ($read|type) == "string" then $read

else "Thank you for selecting \($in[$read-1])" end

'''Example:'''

$ jq -n -r -f Menu.jq

Enter your choice:

 

1

 

=={{header|Julia}}==

{{trans|Python}}

 

for (ind, item) in enumerate(items)

@printf " %2i) %s\n" ind item

items = ["fee fie", "huff and puff", "mirror mirror", "tick tock"]

item = _selector(items, "Which is from the three pigs: ")

 

=={{header|Kotlin}}==

 

fun menu(list: List<String>): String {

val choice = menu(list)

println("\nYou chose : $choice")

Sample session:

{{out}}

You chose : huff and puff

</pre>

 

=={{header|Logo}}==

{{incorrect|Logo|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

{{works with|UCB Logo}}

foreach :options [(print # ?)]

forever [

[Which is from the three pigs?]

[fee fie] [huff and puff] [mirror mirror] [tick tock])

 

=={{header|Lua}}==

 

 

 

 

 

=={{header|MATLAB}}==

if numel(list) == 0

end

 

=={{header|Modula-2}}==

{{incorrect|Modula-2|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

 

FROM InOut IMPORT WriteString, WriteCard, WriteLn, ReadCard;

WriteLn;

END (*of IF*)

 

=={{header|MUMPS}}==

;http://rosettacode.org/wiki/Menu

NEW I,A,MAX

IF (A<1)!(A>MAX)!(A\1'=A) GOTO WRITEMENU

KILL I,MAX

Usage:<pre>

USER>W !,$$MENU^ROSETTA("fee fie^huff and puff^mirror mirror^tick tock","^")

</pre>

 

 

 

try:

let n = parseInt(reply)

return 0 <= n and n < count

except: return false

if xs.len == 0: return ""

var reply = "-1"

reply = readLineFromStdin(prompt).strip()

return xs[parseInt(reply)]

const xs = ["fee fie", "huff and puff", "mirror mirror", "tick tock"]

let item = selector(xs, "Which is from the three pigs: ")

<pre> 0) fee fie

1) huff and puff

 

=={{header|OCaml}}==

let select ?(prompt="Choice? ") = function

| [] -> ""

with _ -> menu ()

in menu ()

 

Example use in the REPL:

# select ["fee fie"; "huff and puff"; "mirror mirror"; "tick tock"];;

0: fee fie

Choice? 2

- : string = "mirror mirror"

 

=={{header|OpenEdge/Progress}}==

i_c AS CHAR

):

MESSAGE

bashMenu( "fee fie,huff and puff,mirror mirror,tick tock" )

 

=={{header|Oz}}==

fun {Select Prompt Items}

case Items of nil then ""

in

 

=={{header|PARI/GP}}==

{{incorrect|PARI/GP|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

Tested with Free Pascal 2.6.4 (arm).

{$ASSERTIONS ON}

uses

 

dispose(MenuItems, Done);

 

{{out}}

 

=={{header|Perl}}==

{

my ($prompt,@array) = @_;

$a = &menu($prompt,@a);

 

 

=={{header|Phix}}==

sequence res = ""

items = remove_all("",items)

constant prompt = "Which is from the three pigs? "

string res = menu_select(items,prompt)

 

=={{header|PHP}}==

$stdin = fopen("php://stdin", "r");

$allowed = array(1 => 'fee fie', 'huff and puff', 'mirror mirror', 'tick tock');

break;

}

 

=={{header|PicoLisp}}==

(use N

(loop

(prinl I ": " Item) )

(prin Prompt " ")

(NIL (setq N (in NIL (read))))

(choose "Which is from the three pigs?"

2: huff and puff

3: mirror mirror

4: tick tock

Which is from the three pigs? 2

 

 

=={{header|PowerShell}}==

function Select-TextItem

{

End

{

do

{

Write-Host ("{0,3}: {1}" -f 0,"To cancel")

 

 

$selectedValue = ""

$selectedValue = $menuOptions[$choice - 1]

}

}

 

return $selectedValue

 

“fee fie”, “huff and puff”, “mirror mirror”, “tick tock” | Select-TextItem -Prompt "Select a string"

 

{{Out}}

=={{header|ProDOS}}==

{{incorrect|ProDOS|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

:a

printline ==========MENU==========

printline You either chose an invalid choice or didn't chose.

editvar /newvar /value=goback /userinput=1 /title=Do you want to chose something else?

 

=={{header|Prolog}}==

{{works with|SWI-Prolog|6}}

rosetta_menu([], "") :- !. %% Incase of an empty list.

rosetta_menu(Items, SelectedItem) :-

prompt1('Select a menu item by number:'),

read(Choice).

 

Example run:

 

?- rosetta_menu(["fee fie", "huff and puff", "mirror mirror", "tick tock"], String).

 

Select a menu item by number:3.

String = "mirror mirror".

 

=={{header|PureBasic}}==

Define i, txt$, choice

Dim txts.s(4)

TheStrings:

Data.s "fee fie", "huff And puff", "mirror mirror", "tick tock"

 

=={{header|Python}}==

 

for indexitem in enumerate(items):

print (" %2i) %s" % indexitem)

items = ['fee fie', 'huff and puff', 'mirror mirror', 'tick tock']

item = selector(items, 'Which is from the three pigs: ')

 

Sample runs:

 

=={{header|R}}==

Uses [http://www.stat.ucl.ac.be/ISdidactique/Rhelp/library/base/html/menu.html menu].

{

ans <- menu(choices)

if(ans==0) "" else choices[ans]

}

 

=={{header|Racket}}==

 

#lang racket

 

 

(menu '("fee fie" "huff and puff" "mirror mirror" "tick tock"))

 

Sample Run:

"mirror mirror"

</pre>

 

=={{header|REBOL}}==

{{incorrect|REBOL|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

Title: "Text Menu"

URL: http://rosettacode.org/wiki/Select

choice: ask "Which is from the three pigs? "

]

 

Output:

Which is from the three pigs? 2

You chose: huff and puff</pre>

 

=={{header|REXX}}==

do forever /*keep prompting until response is OK. */

call list_create /*create the list from scratch. */

return

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

<pre>

[item 1] fee fie

 

=={{header|Ring}}==

aList = ["fee fie", "huff and puff", "mirror mirror", "tick tock"]

selected = menu(aList, "please make a selection: ")

end

return aList[index]

Output:

<pre>

mirror mirror

</pre>

 

=={{header|Ruby}}==

def select(prompt, items = [])

if items.empty?

response = select('Which is from the three pigs', items)

puts "you chose: >#{response}<"

 

=={{header|Run BASIC}}==

choose$(1) = "1 Fee Fie"

choose$(2) = "2 Huff Puff"

cls

end

 

=={{header|Rust}}==

fn menu_select<'a>(items: &'a [&'a str]) -> &'a str {

if items.len() == 0 {

println!("You chose: {}", selection);

}

 

=={{header|Scala}}==

===Scala idiom (Functional)===

 

object Menu extends App {

 

println(s"\nYou chose : $choice")

 

=={{header|Seed7}}==

 

const func string: menuSelect (in array string: items, in string: prompt) is func

begin

writeln("You chose " <& menuSelect(items, prompt));

 

=={{header|Sidef}}==

arr.len > 0 || return ''

loop {

 

var answer = menu(prompt, list)

 

=={{header|Tcl}}==

set nc [llength $choices]

if {!$nc} {

}

}

Testing it out interactively...

><

% puts >[select "Which is from the three pigs" {

4: tick tock

Which is from the three pigs: 2

 

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

Output with <tt>FEE FIE:HUFF AND PUFF:MIRROR MIRROR:TICK TOCK</tt>

 

2:HUFF AND PUFF

3:MIRROR MIRROR

4:TICK TOCK

 

 

Lbl D

Disp Str3

 

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

This example uses the [http://www.softpanorama.org/Scripting/Shellorama/Control_structures/select_statements.shtml Bash select statement], but Bash did not invent this feature. The ''select'' loop comes originally from the [[Korn Shell]], and appears in some other shells. This loop always continues to read menu choices until the script breaks the loop, or the standard input reaches end of file (EOF).

 

{{works with|pdksh}}

{{works with|zsh}}

# Prints menu to standard error. Prompts with PS3.

# Reads REPLY from standard input. Sets CHOICE.

choose 'fee fie' 'huff and puff' 'mirror mirror' 'tick tock'

[[ -n $CHOICE ]] && echo You chose: $CHOICE

 

<pre>$ bash menu.sh

* ''Deviation from task:'' When the list of choices is empty, this function returns an empty list, not an empty string.

 

# Prints menu to standard error. Prompts with $prompt.

# Returns choice. If no input, returns empty list.

~ $#choice 1 && echo You chose: $choice

~ $#choice 0 && echo No input.

 

<pre>$ es menu.es

=={{header|Ursa}}==

{{trans|Python}}

for (decl int i) (< i (size items)) (inc i)

out " " i ") " items<i> endl console

decl string item

set item (selector items "Which is from the three pigs: ")

 

=={{header|VBScript}}==

 

{{Out}}

<pre>

 

1. fee fie

3. mirror mirror

4. tick tock

 

1. fee fie

3. mirror mirror

4. tick tock

 

1. fee fie

3. mirror mirror

4. tick tock

</pre>

 

=={{header|XPL0}}==

 

func Menu(List);

int Size, I, C;

[Size:= List(0);

for I:= 1 to Size-1 do

[IntOut(0, I); Text(0, ": ");

 

Text(0, Menu([5, "fee fie", "huff and puff", "mirror mirror", "tick tock",

 

Example output:

huff and puff

</pre>

 

=={{header|zkl}}==

os:=T("exit").extend(vm.arglist); N:=os.len();

if(N==1) return("");

 

teleprompter("fee fie" , "huff and puff" , "mirror mirror" , "tick tock")

{{out}}

<pre>