Optional parameters: Difference between revisions

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

column: "0"

reversed?: false

printTable sortTable.column:1 lst "Sorting by column=1"

printTable sortTable.reverse lst "Sorting, reversed"

{{out}}

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

There is a built-in sort routine, but rather than figure out what all these arguments are supposed to mean, I've just defined the interface.

:or {ordering :lex, column 1}}]

(println table ordering column reverse?))

(sort [1 8 3] :reverse? true)

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

Common Lisp has both named and positional parameters. The following example shows optional named parameters, using the <code>&key</code> keyword. Optional positional parameters are specified using the <code>&optional</code> keyword.

(column 0)

reverse)

(complement ordering)

ordering)

(Notes: The builtin [http://www.lispworks.com/documentation/HyperSpec/Body/f_sort_.htm sort] takes a "less than" predicate function. The [http://www.lispworks.com/documentation/HyperSpec/Body/f_comple.htm complement] function inverts a predicate.)

Example uses:

*DATA*

CL-USER> (sort-table *data* :ordering (lambda (a b) (> (length a) (length b))))

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

{{libheader| System.SysUtils}}

{{Trans|D}}

{$APPTYPE CONSOLE}

end).ToString, #10);

Readln;

{{out}}

<pre>

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>

Typically, parameters are named at the caller site when optional parameters are involved. However, this is not technically required as long as only right-most arguments are omitted.

// in-place sorting of rows

member x.Sort(?ordering, ?column, ?reverse) =

t.Sort(ordering=fun s1 s2 -> compare s2.Length s1.Length)

Output:

=={{header|Factor}}==

Factor doesn't have special support for optional parameters, so the idiom is to define a tuple with desired initial values, set the desired slots, then pass it to a word.

sequences sorting ;

t >>reversed?

[ length ] >>ordering

{{out}}

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

=={{header|FreeBASIC}}==

Return n ^ p

End Function

Print power(2) ' muestra 4

Print power(2, 3) ' muestra 8

Here is a partial example, partial because it doesn't really have the feel yet of "optional parameters." Note the call to do the reverse sort takes three lines of code, one to construct the parameter struct, one to set the option, and one more to make the call.

type spec struct {

s := newSpec

s.reverse = true

===Struct literal with keyed elements===

A solution providing more the feel of optional parameters is to pass a struct literal. Go allows a

struct literal to be initialized with named fields but does not require all fields to be specified and does not require them to be specified in order. Thus passing a struct literal can provide very much the feel of optional named parameters. Given,

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.

Nevertheless, a complete program to demonstrate:

import (

})

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

Output:

<pre>

A technique that gets a nod of approval from the idiom police is sometimes termed "functional options." This technique involves a bit of tricky machinery though and so has not really gained wide popularity. It makes use of Go's variadic arguments and uses functions to initialize a parameter struct. A full solution:

import (

t.sort(column(1), ordering(byLen))

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

Output same as previous solution.

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

:mypower

"2 ^3 = " print ( 2 3 ) mypower ?

=={{header|Kotlin}}==

typealias Table = List<List<String>>

val table3 = table.sort(ordering = comp)

table3.print("Reverse case insensitive sort by col 2:")

{{out}}

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

function showTable(tbl)

if type(tbl)=='table' then

sortTable{table=A, cmp=(function (a, b) return #a < #b end)}

print('by length', showTable(A))

{{out}}

<pre>

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

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

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

proc printTable(a: seq[seq[string]]) =

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.

<span style="color: #008080;">function</span> <span style="color: #000000;">increment</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">inc</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">inc</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">increment</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- shows 6</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">increment</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- shows 7</span>

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

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d records sorted in %3.2s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">records</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">})</span>

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:

<span style="color: #004080;">integer</span> <span style="color: #000000;">sortcol</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span>

<span style="color: #000000;">sortdir</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>

<span style="color: #008080;">return</span> <span style="color: #000000;">data</span><span style="color: #0000FF;">[</span><span style="color: #000000;">l</span><span style="color: #0000FF;">][</span><span style="color: #000000;">c</span><span style="color: #0000FF;">]</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

=={{header|Phixmonti}}==

1 tolist flatten len

1 == if

"2 ^2 = " print 2 mypower print nl

More elegant.

def mypower

"2 ^2: " print 2 mypower ?

More in line with the task description

( ( "a" "b" "c" )

( 2 ) mysort pstack

( 2 true ) mysort pstack

{{out}}

<pre>

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

(formerly Perl 6)

Using named parameters:

my @result = self»[$column].sort: &ordering;

return $reverse ?? @result.reverse !! @result;

Using optional positional parameters:

my @result = self»[$column].sort: &ordering;

return $reverse ?? @result.reverse !! @result;

=={{header|REXX}}==

<br>Also allowed are named parameters.

<br><br>The REXX language doesn't have any native sorting functions, &nbsp; so you have to write your own sorting subroutine.

col= 1 /*set some defaults (here and below). */

reverse= 'NO'

... 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|Rust}}==

Here we use Rust's "standard way" to have optional parameters, i.e. by using builders instead.

struct Table {

}

}

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

TIScript allows to define optional parameters with default values:

// ...

}

=={{header|Unix Shell}}==

{{works with|bash|4.2}}

# sort-args.sh

echo sort numeric ; data | sort_table numeric

echo sort numeric reverse ; data | sort_table numeric reverse

{{out}}

<pre>

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>

=={{header|VBA}}==

Optional ordering As Integer = 0, _

Optional column As Integer = 1, _

'Specifying reverse:=2 will sort in descending order.

optional_parameters theRange:="A1:C4", ordering:=1, column:=2, reverse:=1

=={{header|Wren}}==

{{libheader|Wren-seq}}

Wren doesn't support optional parameters as such but does support method overloading by ''arity'' (i.e. number of parameters) which makes it easy to simulate them.

import "./seq" for Lst

System.print("\nAfter reverse lexicographic sort by second column:")

table2 = TableSorter.sort(table, null, 1, true)

{{out}}

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

if numparams = 1 p = 2

return n^p

print power(2)

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