Menu: Difference between revisions

=={{header|11l}}==

L

I Int(reply) C 1..items.len

print(‘You chose: ’items[Int(reply) - 1])

{{out}}

=={{header|Action!}}==

BYTE FUNC Init(PTR ARRAY items)

res=GetMenuItem(items,count)

PrintF("You have chosen: %S%E",items(res))

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Menu.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

procedure menu is

put_line ("You chose " &

choice ((+"fee fie",+"huff and puff",+"mirror mirror",+"tick tock"),"Enter your choice "));

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

=={{header|Arturo}}==

selection: neg 1

while [not? in? selection 1..size items][

]

{{out}}

=={{header|AutoHotkey}}==

if !list ; if called with an empty list

return ; return an empty string

InputBox , Choice, Please Select From Menu, % string ,, % 200<len*7 ? 200 ? len*7 , % 120 + x.count()*20

return x[Choice]

(

fee fie

MsgBox % Menu(list) ; call menu with list

MsgBox % Menu() ; call menu with empty list

=={{header|AWK}}==

# syntax: GAWK -f MENU.AWK

BEGIN {

}

}

=={{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|Applesoft BASIC}}===

While the following example could be lengthened to demonstrate larger menu-driven projects, it is useful to simply print the resulting string indexed by the user input.

20 M$(3) = "MIRROR MIRROR"

30 M$(2) = "HUFF AND PUFF"

170 NEXT M

180 M$ = M$(N%)

==={{header|Commodore BASIC}}===

While the following example could be shortened to simply print the resulting string indexed by the user input, it is useful to demonstrate that larger menu-driven projects benefit from the use of the <code>ON n... GOSUB</code> statement to pass control to larger subroutines.

5 rem rosetta code

10 gosub 900

1010 data "Mirror, mirror","You seem to be the fairest of them all!"

1015 data "Tick tock","Time passes..."

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

Example 1

set "menuChoices="fee fie","huff and puff","mirror mirror","tick tock""

echo.Invalid Input. Please try again...

pause

Example 2

@echo off

echo.!string[%choice%]!

goto:eof

=={{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 sharp}}==

using System;

using System.Collections.Generic;

}

}

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

"mirror mirror", "tick tock"];

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

{{out}}

<pre>Choose one:

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Menu;

'tick tock'], 'Enter number: '));

readln;

{{out}}

<pre>

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

=={{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|F Sharp|F#}}==

let rec menuChoice (options : string list) prompt =

printfn "You chose: %s" choice

=={{header|Factor}}==

: print-menu ( seq -- )

] [ drop (select) ] if* ;

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

Out of the box Forth does not have lists. This version uses strings and a vector table, which arguably is more how one would do this task in Forth. It returns a nil string if a nil string is given otherwise the input string becomes the title of the menu.

\ vector table compiler

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 ;

CR SWAP {NTH}

THEN

Test at the gForth console

Please find the build instructions in the comments at the start of the FORTRAN 2008 source. Compiler: gfortran from the GNU compiler collection. Command interpreter: bash.

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

!gfortran -std=f2008 -Wall -fopenmp -ffree-form -fall-intrinsics -fimplicit-none f.f08 -o f

end program menu_demo

=={{header|FreeBASIC}}==

function menu_select( m() as string ) as string

end function

=={{header|Gambas}}==

Public Sub Main()

End

=={{header|Go}}==

import "fmt"

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

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

Output:

<pre>

=={{header|GW-BASIC}}==

10 DATA "Fee fie", "Huff and Puff", "Mirror mirror", "Tick tock"

20 VC = 0

150 PRINT "You picked ", M$(VC-1)

160 END

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

procedure main() shows how to call the choose_from_menu "function", which demonstrates use of differing menu lists and a empty list.

## menu.icn : rewrite of the faulty version on Rosetta Code site 24/4/2021

end ## displaymenu(X)

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

{{works with|Node.js}}

async function menuSelect(question, choices) {

menuSelect(question, choices).then((answer) => {

console.log(`\nYou chose ${answer}`);

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

function _menu(items)

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

=={{header|langur}}==

{{works with|langur|0.7.1}}

if not isArray(.entries): throw "invalid args"

if len(.entries) == 0: return ZLS

}

{{out}}

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

if not list or #list == 0 then

return ""

print("Nothing:", select {})

print()

{{out}}

Redisplays the list of choices on every invalid input as per the task description. In the notebook interface (of Wolfram Desktop, at least), Print[] would most pragmatically be located outside of the loop because Input[] uses a dialog box.

If[Length@data == 0, Return@""];

While[!(IntegerQ@choice && Length@data >= choice > 0),

];

data[[choice]]

{{out|Kernel (REPL) output|note=function definition omitted}}

<pre>Wolfram Desktop Kernel (using Wolfram Language 12.0.0) for Microsoft Windows (64-bit)

=={{header|MATLAB}}==

if numel(list) == 0

end

=={{header|min}}==

{{works with|min|0.19.3}}

min has an operator <code>choose</code> that nearly conforms to this task. The input list is altered so that the choice can be returned, and the empty list case is handled.

:prompt =list

(list bool)

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

"Enter an option" menu

{{out}}

<pre>

=={{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","^")

=={{header|Nanoquery}}==

{{trans|Ursa}}

for ($i = 0) ($i < len($items)) ($i = $i + 1)

println " " + $i + ") " + $items[$i]

append $items "fee fie" "huff and puff" "mirror mirror" "tick tock"

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

=={{header|Nim}}==

{{trans|Python}}

proc menu(xs: openArray[string]) =

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

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

{{out}}

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

(T (>= (length Items) N 1) (prinl (get Items N))) ) ) )

(choose "Which is from the three pigs?"

{{out}}

<pre>

=={{header|PL/I}}==

{{incorrect|PL/I|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.]}}

test: proc options (main);

end test;

=={{header|PowerShell}}==

function Select-TextItem

{

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

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

{

if (is.null(choices)) return("")

str <- showmenu(c("fee fie", "huff and puff", "mirror mirror", "tick tock"))

str <- showmenu()

=={{header|Racket}}==

#lang racket

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

Sample Run:

=={{header|Raku}}==

(formerly Perl 6)

return '' unless @items.elems;

repeat until my $selection ~~ /^ \d+ $/ && @items[--$selection] {

$answer = menu( $prompt, @choices );

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

You chose: huff and puff</pre>

=={{header|Red}}==

menu: function [items][

attempt [pick items to-integer ask "Your choice: "]

]]

{{out}}

=={{header|REXX}}==

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

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

return

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

{{out|output|text=&nbsp; (which includes what the user entered):}}

<pre>

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

=={{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|Swift}}==

guard !selections.isEmpty else {

return ""

])

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

=={{header|True BASIC}}==

MAT READ menu$

DATA "fee fie", "huff and puff", "mirror mirror", "tick tock"

PRINT sel$(menu$())

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

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

Function Menu(ArrList, Prompt)

Select Case False 'Non-standard usage hahaha

Sample = Array("fee fie", "huff and puff", "mirror mirror", "tick tock")

InputText = "Which is from the three pigs: "

{{Out}}

<pre>C:\>cscript /nologo menu.vbs

=={{header|Wren}}==

{{libheader|Wren-ioutil}}

var menu = Fn.new { |list|

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

var choice = menu.call(list)

{{out}}

=={{header|XPL0}}==

func Menu(List);

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

Example output:

=={{header|Yabasic}}==

// by Jjuanhdez, 06/2022

label menudata

data "Ack, not good", "fee fie ", "huff and puff"

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