Optional parameters: Difference between revisions

{{task|Basic language learning}}

 

Define a function/method/subroutine which sorts a sequence ("table") of sequences ("rows") of strings ("cells"), by one of the strings. Besides the input to be sorted, it shall have the following optional parameters:

:{|

See also:

* [[Named Arguments]]

 

=={{header|Ada}}==

As described in [[Named_parameters]], all parameters have to be named. You can use positional or keyed association. Optional parameters are the ones with default values.

 

 

type Table is private;

private

... -- implementation specific

 

example of use:

procedure Table_Test is

My_Table : Tables.Table;

Sort (It => My_Table, Reverse_Ordering => True); -- use default sorting in reverse order

... -- other stuff

 

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

# easiest way to support these optional parameters in Algol 68 would be to have an array #

# with elements of these types #

configurable sort( data, ( 2, ( STRING a, STRING b )INT: default compare( a[ LWB a + 1 : ], b[ LWB b + 1 : ] ) ) );

# default sort #

 

=={{header|AppleScript}}==

AppleScript supports named, positional & prepositional parameters, but not default or optional parameters. Though that behavior can be simulated by passing lists or records as the parameter. Handler/functions can be passed as a parameter if they are part of a script object. AppleScript does not have built-in sorting functionality.

set {sortOrdering, sortColumn, sortReverse} to {sort_lexicographic, 1, false}

try

return table

end sort

Examples of use:

script sort_colex

on sort(table, column, reverse)

sortTable({sequence:table, ordering:sort_colex, column:2, reverse:true})

sortTable({sequence:table, reverse:true})

 

=={{header|AutoHotkey}}==

built in support for table sorting is available through the standard Win32 listview.

sort_table("Text", column := 2, reverse := 1) ; lexicographic sort

Sleep, 2000

 

GuiClose:

 

=={{header|BASIC}}==

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

BBC BASIC doesn't have optional parameters, but functions can have multiple entry points which take different numbers of parameters, avoiding the need to duplicate code or call a sub-function. Omitted parameters can be declared as LOCAL, which initialises them to zero/false.

PROCsort_default(table$())

PROCsort_options(table$(), TRUE, 1, FALSE)

REM The sort goes here, controlled by the options

REM Zero/FALSE values for the options shall select the defaults

 

=={{header|Bracmat}}==

Bracmat functions always have exactly one parameter, which is references by <code>!arg</code> in the function body. Positional and (optional) named 'parameters' are retrieved from this single parameter <code>!arg</code> by pattern matching. It is a good custom to separate positional parameters by commas or periods and to separate the named parameters by spaces.

= table ordering column reverse

. !arg

: ?table

& sortTable$(!table.(column.2) (reverse.yes))

 

=={{header|C}}==

#include <stdarg.h>

#include <stdio.h>

printTable(&table, stdout, colFmts);

return 0;

 

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

This implementation only accepts function pointers for the comparators, and does not accept function objects, for simplicity.

#include <algorithm>

#include <string>

 

return 0;

 

=={{header|D}}==

{{trans|Python}}

 

string[][] sortTable(string[][] table,

show(sortTable(data, null, 1, true));

show(sortTable(data, (a,b) => b.length > a.length));

{{out}}

<pre>["a", "b", "c"]

</pre>

Another way to emulate optional arguments is with function overloading, creating several functions with a different number of arguments.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|E}}==

In E, as in Java and Smalltalk, optional parameters are defined as different methods with the same base name. Methods are distinguished by name (''verb'') and number of parameters (''arity'').

 

 

def sort {

}

 

 

Named parameters are not builtin, but map-patterns may be used as a substitute. (TODO: Example of this) [[Category:E examples needing attention]]

 

=={{header|Elixir}}==

{{trans|Ruby}}

def sort( table, options\\[] ) do

options = options ++ [ ordering: :lexicographic, column: 0, reverse: false ]

end

 

 

{{out}}

 

=={{header|Erlang}}==

-module( optional_parameters ).

 

table_row2() -> {"456", "0789", "123"}.

table_row3() -> {"0789", "123", "456"}.

{{out}}

<pre>

sort numeric [{"123","456","0789"},{"456","0789","123"},{"0789","123","456"}]

reverse [{"0789","123","456"},{"456","0789","123"},{"123","456","0789"}]

</pre>

 

In Fortran, each argument has its "name". The <tt>optional</tt> attribute can be used to specify that an argument is optional, and its presence (or absence) can be tested using the <tt>present</tt> intrinsic (so that we can give a default value, or execute accordingly a totally different code).

 

! use any module needed for the sort function(s)

! and all the interfaces needed to make the code work

end subroutine sort_table

 

 

use ExampleOptionalParameter

implicit none

call sort_table(table, column=2)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

ordering func(cell, cell) bool

column int

reverse bool

the following struct literal fills in zero values for ordering and column and assigns true to the field reverse.

Structs in Go are values and are copied when passed as parameters. The result of having a single struct parameter is that the three fields are pushed on the stack, just about like they would if they were separate parameters. The effect is named parameters with unmentioned parameters defaulting to their zero value.

 

 

import (

})

t.printRows("sorted by descending string length on second column")

Output:

<pre>

["pail" "food"]

</pre>

 

=={{header|Groovy}}==

Optional Parameters:

table.sort(false) { x, y -> (reverse ? -1 : 1) * ordering.compare(x[column], y[column])}

 

Test code:

 

assert orderedSort(table) == [['', 'q', 'z'], ['a', 'b', 'c'], ['zap', 'zip', 'Zot']]

assert orderedSort(table, 1) == [['a', 'b', 'c'], ['', 'q', 'z'], ['zap', 'zip', 'Zot']]

assert orderedSort(table, 1, true) == [['zap', 'zip', 'Zot'],['', 'q', 'z'],['a', 'b', 'c']]

 

Named Parameters:

def column = params?.column ?: 0

def reverse = params?.reverse ?: false

 

table.sort(false) { x, y -> (reverse ? -1 : 1) * ordering.compare(x[column], y[column])}

 

Test Code:

 

 

assert table.orderedSort() == [['', 'q', 'z'], ['a', 'b', 'c'], ['zap', 'zip', 'Zot']]

assert table.orderedSort(column: 1) == [['a', 'b', 'c'], ['', 'q', 'z'], ['zap', 'zip', 'Zot']]

assert table.orderedSort(column: 1, reverse: true) == [['zap', 'zip', 'Zot'],['', 'q', 'z'],['a', 'b', 'c']]

 

=={{header|Haskell}}==

Option 1: Using haskell's record update syntax, we can simulate named default arguments. This method has the drawback of not allowing for a parameter to be positional and named simultaneously.

{-# LANGUAGE RecordWildCards #-}

 

sorter defSortArgs [[]]

return ()

 

Option 2: This method has the drawback of being a bit verbose and requiring you to supply "Maybe a" arguments.

import Data.Maybe (fromMaybe)

-- Use fromMaybe as an operator because its prettier

sorter (Just "foo") (Just 1) (Just True)

sorter Nothing Nothing Nothing

 

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

Optional named parameters are not the norm in Icon/Unicon. In the example below ''bubblesortf'' would be a version of [[Sorting_algorithms/Bubble_sort#Icon_and_Unicon|Bubble Sort]] modified to sort on a column number (Ordering is already supported). It could equally be replaced by any similarly modified Rosetta sort. The use of ''reverse'' on a list is a Unicon extension; in Icon a procedure from the IPL must be linked.

procedure main()

X := [ [1,2,3], [2,3,1], [3,1,2]) # A list of lists

}

return (\reverseorder|1)(bubblesortf(X,\c|1,\op|"<<")) # reverse or return the sorted list

 

=={{header|J}}==

 

'' srtbl y

:

'`ordering column reverse'=. x , (#x)}. ]`0:`0:

|.^:reverse y /: ordering (column {"1 ])y

 

For simplicity, the optional arguments are all functions, and are positional (on the left -- the table, with its arbitrary number of rows and columns, is on the right). Note also that the ordering function is expected to map its entire argument (since this offers much better efficiencies than a binary comparison).

 

'''Example Use'''

┌───┬───┬───┐

│a │b │c │

├───┼───┼───┤

│zip│zap│Zot│

 

=={{header|Java}}==

Java has no optional parameters, but methods can be overloaded on the number and types of arguments, which can be used to effectively achieve optional positional parameters.

 

 

public class OptionalParams {

// prints: [[zap, zip, Zot], [a, b, c], [, q, z]]

}

 

=={{header|JavaScript}}==

See [[Named parameters#JavaScript]], to pass named parameters one uses an object with properties set:

opts = {}

opts.ordering = options.ordering || 'lexicographic';

}

 

 

=={{header|jq}}==

interpreted by jq. The key to understanding this is that jq functions

are compiled into closures. Here is an example:

 

The expression <tt>3 | foo.a</tt> evaluates to 6.

 

sort_table(ordering; column; reverse) is already defined. To specify the lexicographic

ordering on strings in terms of an arity-0 filter, we define less_than_or_equal/0 as follows:

 

'''The Task''':

sort_table( if (options|has("ordering")) then options.ordering

else less_than_or_equal

 

# If jq > 1.4 is being used, we may also define:

'''Examples''':

 

[1,2] | sorter({ "reverse": true })

 

# If sorter/0 has also been defined:

 

=={{header|Julia}}==

Julia supports both named and positional optional parameters. We can define both versions at the same time if we want:

sort(T, by = t -> t[column], lt = reverse ? (a,b) -> ordering(b,a) : ordering)

sorttable(T, ordering=<, column=1, reverse=false) =

where the <code>;</code> in the argument list denotes the named-parameter variant, and we have used Julia's built-in higher-order <code>sort</code> function to do the work. Note that we simply pass a comparison function for the ordering, and the built-in <code><</code> operator is actually just a function that (on strings) compares in lexicographic order.

 

Example output:

3-element Array{Any,1}:

["a","b","c"]

["zap","zip","Zot"]

["","q","z"]

 

=={{header|Lasso}}==

Lasso can handle both positional and named params. Methods support multiple dispatch where each dispatch defines it's own set of parameters.

items::array, // required param

ordering::string = 'lexicographic', // optional param

sortarray(-items = #items, -reverse)

 

 

=={{header|Logo}}==

{{works with|UCB Logo}}

; ...

The function "sort" has a default arity of 1 for the required parameter. When overriding default parameters, you must wrap the call in parentheses to specify the different arity.

(sort :table 2)

 

=={{header|Maple}}==

OptionalSort := proc(input, {

ordering :: Or(procedures,identical("lexicographic")) := "lexicographic",

end if;

sort( input, compare );

 

Some examples of this procedure in action:

> L := [[1, 2], [3, 4], [-5, 7]]:

> OptionalSort(L);

> OptionalSort(L, reverse, column = 2);

[[-5, 7], [3, 4], [1, 2]]

 

OptionalSort[x_List,OptionsPattern[]]:=If[OptionValue[reverse]==True,

SortBy[x ,#[[OptionValue[column]]]&]//Reverse,

 

OptionalSort[{{"a" ,"b", "c"}, {"", "q", "z"},{"zap" ,"zip", "Zot"}},{ordering->lexicographic,column->2,reverse-> True} ]

 

=={{header|Nemerle}}==

It's possible to use either optional parameters or overloading on parameter number (or type). However, it's less code repetition to use optional parameters when possible (unless, of course, the implementation varies drastically with different parameters).

{

// implementation goes here

 

=={{header|Nim}}==

 

for row in a:

echo ""

echo ""

printTable sortTable(data, column = 1)

printTable sortTable(data, column = 1, reverse = true)

Output:

<pre>a b c

=={{header|Objective-C}}==

Without getting into any detail, here is one way you might implement optional arguments. (Note that since Objective-C is a strict superset of C, any C solution can be used as well.)

 

@interface MyArray : NSObject {}

}

 

 

=={{header|OCaml}}==

OCaml has optional named parameters. It is conventional to place a non-optional parameter after the optional parameters, because if the optional parameters were at the end, then if you don't provide them, it will just look like a partial application (because OCaml supports [[currying]]), resulting in a function which still expects the optional parameters.

 

let cmp x y = ordering (List.nth x column) (List.nth y column) * (if reverse then -1 else 1) in

 

Example uses:

val data : string list list =

[["a"; "b"; "c"]; [""; "q"; "z"]; ["zap"; "zip"; "Zot"]]

# sort_table ~ordering:(fun a b -> compare (String.length b) (String.length a)) data;;

- : string list list =

 

OCaml does not support optional positional parameters, because, since OCaml supports currying, it would conflict with partial applications, where you do not provide all the arguments to a function, and it results in a function which expects the remaining arguments.

=={{header|Oz}}==

Oz supports optional parameters only for methods, not for functions.

class Table

attr

{T sort(column:2)}

{T sort(column:2 reverse:true)}

 

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

As it happens the built-in <code>vecsort()</code> function fulfills all the requirements of this task. In general optional arguments are handled in GP by default values:

while in PARI it is handled by checking for NULL (assuming parser code DG, see 5.7.3 in the User's Guide to the PARI library):

GP;install("test_func", "vDG", "test", "path/to/test.gp.so");

*/

else

pari_printf("Argument was: %Ps\n", x);

 

=={{header|Perl}}==

This function expects its first argument to be a reference to an array of arrays. It interprets any remaining arguments as a hash of optional parameters.

 

{my @table = @{shift()};

my %opt =

{$func->($a->[$col], $b->[$col])}

@table;

 

An example of use:

 

foreach (@{sorttable $a, column => 1, reverse => 1})

{foreach (@$_)

{printf "%-5s", $_;}

 

=={{header|Phix}}==

Optional parameters are specified simply by declaring a default value. They must however be grouped on the right.

 

 

You can also use a variable length sequence to emulate optional parameters.

 

 

In other words printf always accepts exactly three arguments, but the third should contain the correct number of

The following incomplete snippet from demo\pGUI\listview.exw shows the basic idea for sorting a table by any column, up or down:

 

 

 

 

 

 

=={{header|PicoLisp}}==

(let (Ordering prog Column 1 Reverse NIL) # Set defaults

(bind (rest) # Bind optional params

sort

Tbl ) )

Output:

<pre>(de *Data ("a" "bcdef" "X") (" " "qrst" "z") ("zap" "zip" "Zot"))

 

Using a pretty-printer for the table

for row in data:

print ' '.join('%-5s' % ('"%s"' % cell) for cell in row)

"a" "b" "c"

"" "q" "z"

 

See the Python entry in [[Named_Arguments#Python|Named Arguments]] for a more comprehensive description of Python function parameters and call arguments.

=={{header|R}}==

Optional parameters are given using a name=value syntax within the function header.

{

# Implementation

 

# Usage is e.g.

 

=={{header|Racket}}==

 

#lang racket

 

ordering)

#:key (λ (row) (list-ref row column))))

 

=={{header|REXX}}==

The REXX language allows for default values for positional arguments as well as an easy method to check if a string is part of a parameter.

<br>Also allowed are named parameters.

select

end /*select*/

end /*j*/

... main body of string sort here ...

An example use is:

call sortStrings 'Reverse=no' 3

 

=={{header|Ruby}}==

Ruby allows default values for positional arguments, but they have disadvantages. In the next example, if you want to pass ''reverse=true'', you must also give values for ''ordering'' and ''column''.

 

 

Ruby 2.0 added keyword arguments to the language. These provide the most natural solution.

 

{{works with|Ruby|2.0}}

p = ordering.to_proc

if reverse

["Mexico City", "Mexico"],

]

 

Older versions of Ruby can fake the effect with a Hash (as detailed in [[Named parameters#Ruby]]). The next example needs Ruby 1.8.7 only because the sort code calls <code>Symbol#to_proc</code>; the passing of parameters would yet work with Ruby older than 1.8.7.

 

{{works with|Ruby|1.8.7}}

defaults = {:ordering => :<=>, :column => 0, :reverse => false}

opts = defaults.merge(opts)

table.sort {|a, b| p.call(a[c], b[c])}

end

 

=={{header|Scala}}==

With Scala 2.8 optional and named parameters are build in.

ordering: (String, String) => Boolean = (_ < _),

column: Int = 0,

val result = data.sortWith((a, b) => ordering(a(column), b(column)))

if (reverse) result.reverse else result

println(data)

//-> List(List(a, b, c), List(, q, z), List(zap, zip, Zot))

//-> List(List(zap, zip, Zot), List(a, b, c), List(, q, z))

println(sortTable(data, ((a, b)=> b.size<a.size)))

 

=={{header|Sidef}}==

if (reverse) {

table.sort {|a,b| b[column].$ordering(a[column])}

];

 

{{out}}

<pre>[["Ottowa", "Canada"], ["Mexico City", "Mexico"], ["Washington", "USA"]]</pre>

 

Missing the point, we can also create and provide a custom method for sorting to ''ordering'':

method my_sort(arg) {

(self.len <=> arg.len) ->

}

{{out}}

<pre>[["Washington", "USA"], ["Ottowa", "Canada"], ["Mexico City", "Mexico"]]</pre>

=={{header|Slate}}==

In Slate, named optional parameters may be specified in the method signature, but not defaults, so there is a macro <tt>defaultsTo:</tt> for specifying that within the method body at run-time.

[

column `defaultsTo: 0.

ifTrue: [sortBlock := [| :a :b | (sortBlock applyTo: {a. b}) not]].

s sortBy: [| :a :b | sortBlock applyTo: {a at: column. b at: column}]

 

=={{header|Swift}}==

 

func sortTable(table: [[String]], less: (String,String)->Bool = (<), column: Int = 0, reversed: Bool = false) {

// . . . Actual sort goes here . . .

 

=={{header|Tcl}}==

The optional positional parameter style works like this:<br>

{{works with|Tcl|8.4}}

set direction [expr {$reverse ? "-decreasing" : "-increasing"}]

if {$ordering ne ""} {

puts [tablesort $data {

apply {{a b} {expr {[string length $a]-[string length $b]}}}

 

When using the second style, it is often common to use [[Named Arguments]] (and in fact the “<code>lsort</code>” already works very much like this). Note that it is most common to use named arguments that start with a “<code>-</code>”, but we omit them here so that we formally match the requirements of the task.

<br>

{{works with|Tcl|8.5}}

 

proc tablesort {table args} {

puts [tablesort $data ordering {

apply {{a b} {expr {[string length $b]-[string length $a]}}}

 

=={{header|Ursala}}==

that is applicable to a list of data to be sorted.

 

#import nat

 

reversed %b

 

Here is a test program using the function above to sort a table

five different ways, mentioning only the information that differs from the

defaults. The table is stored as a list of lists, with one list for each

row, hence three rows and two columns.

 

<

(sorter ss[column: 2]) example_table, # etc.

(sorter ss[reversed: true]) example_table,

In practice, these five functions would have been more conveniently expressed using the

built in sort operator as <code>-<&h</code>, <code>leql-<&h</code>, <code>-<&th</code>, <code>-<x&h</code>, and <code>-<x&th</code>

<<'foo','b '>,<'bazzz','c'>,<'barr','a '>>,

<<'bazzz','c'>,<'foo','b '>,<'barr','a '>>></pre>

 

=={{header|XSLT}}==

You can give any template parameter a default value using the optional "select" attribute.

<xsl:param name="table" />

<xsl:param name="ordering" select="'lexicographic'" />

<xsl:param name="reversed" select="false()" />

...

 

=={{header|zkl}}==

zkl does left to right parameters, each with an optional default. No named parameters (ala Smalltalk). There isn't type enforcement either, a parameter can be anything (although you can set a hint to tell the compiler what you think it will be). If you do want to play named parameters, you can pass in a dictionary (ala Python). The parameters are basically a [varargs] list that you can access in traditional ways.

fcn mystrySort(table,ordering=lex,column=0,reverse=False,other){

vm.arglist.println();

mystrySort("table",lex,1,True,D("row",35,"type","foobar"));

 

{{out}}

<pre>

 

 

{{omit from|GUISS}}

{{omit from|TI-83 BASIC}} {{omit from|TI-89 BASIC}}