tasks a-s

Task/Optional-parameters/0DESCRIPTION

@@ -0,0 +1,19 @@
+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:
+:{|
+|
+----
+; ordering
+: A function specifying the ordering of strings; lexicographic by default.
+; column
+: An integer specifying which string of each row to compare; the first by default.
+; reverse
+: Reverses the ordering.
+----
+|}
+
+This task should be considered to include both positional and named optional parameters, as well as overloading on argument count as in Java or selector name as in Smalltalk, or, in the extreme, using different function names. Provide these variations of sorting '''in whatever way is most natural to your language'''. If the language supports both methods naturally, you are encouraged to describe both.
+
+Do not implement a sorting algorithm; this task is about the interface. If you can't use a built-in sort routine, just omit the implementation (with a comment).
+
+See also:
+* [[Named Arguments]]

Task/Optional-parameters/1META.yaml

@@ -0,0 +1,2 @@
+---
+note: Basic language learning

Task/Optional-parameters/Ada/optional-parameters-1.ada

@@ -0,0 +1,14 @@
+package Tables is
+
+   type Table is private;
+
+   type Ordering is (Lexicographic, Psionic, ...); -- add others
+
+   procedure Sort (It               : in out Table;
+                   Order_By         : in Ordering := Lexicographic;
+                   Column           : in Positive := 1;
+                   Reverse_Ordering : in Boolean  := False);
+
+private
+   ... -- implementation specific
+end Tables;

Task/Optional-parameters/Ada/optional-parameters-2.ada

@@ -0,0 +1,10 @@
+with Tables;
+procedure Table_Test is
+   My_Table : Tables.Table;
+begin
+   ... -- insert stuff in table
+   Sort (My_Table); -- use default sorting
+   Sort (My_Table, Psionic, 5, True); -- use psionic sorting by 5th column in reverse order
+   Sort (It => My_Table, Reverse_Ordering => True); -- use default sorting in reverse order
+   ... -- other stuff
+end Table_Test;

Task/Optional-parameters/AppleScript/optional-parameters-1.applescript

@@ -0,0 +1,20 @@
+on sortTable(x)
+	set {sortOrdering, sortColumn, sortReverse} to {sort_lexicographic, 1, false}
+	try
+		set sortOrdering to x's ordering
+	end try
+	try
+		set sortColumn to x's column
+	end try
+	try
+		set sortReverse to x's reverse
+	end try
+	return sortOrdering's sort(x's sequence, sortColumn, sortReverse)
+end sortTable
+
+script sort_lexicographic
+	on sort(table, column, reverse)
+		-- Implement lexicographic Sorting process here.
+		return table
+	end sort
+end script

Task/Optional-parameters/AppleScript/optional-parameters-2.applescript

@@ -0,0 +1,15 @@
+-- Another sort function.
+script sort_colex
+	on sort(table, column, reverse)
+		-- Implement colexicographic Sorting process here.
+		return table
+	end sort
+end script
+
+-- Populate a table (list) with data.
+set table to {{1,2},{3,4}}
+
+sortTable({sequence:table, ordering:sort_lexicographic, column:1, reverse:false})
+sortTable({sequence:table, ordering:sort_colex, column:2, reverse:true})
+sortTable({sequence:table, reverse:true})
+sortTable({sequence:table})

Task/Optional-parameters/AutoHotkey/optional-parameters.ahk

@@ -0,0 +1,33 @@
+Gosub start ; create and show the gui
+sort_table("Text", column := 2, reverse := 1)  ;  lexicographic sort
+Sleep, 2000
+sort_table("Integer", column := 2, reverse := 1)  ;  numerical sort
+Return
+
+start:
+  Gui, Add, ListView, r20 w200, 1|2|3
+  data =
+  (
+  1,2,3
+  b,q,z
+  c,z,z
+  )
+  Loop, Parse, data, `n
+  {
+    StringSplit, row, A_LoopField, `,
+    LV_Add(row, row1, row2, row3)
+  }
+  LV_ModifyCol(50)  ; Auto-size columns
+  Gui, Show
+Return
+
+; The function supporting named, defaulted arguments
+sort_table(ordering = "Text", column = 0, reverse = 0)
+{
+  If reverse
+    desc = desc
+  LV_ModifyCol(column, "sort" . desc . " " . ordering)
+}
+
+GuiClose:
+  ExitApp

Task/Optional-parameters/BBC-BASIC/optional-parameters.bbc

@@ -0,0 +1,10 @@
+      DIM table$(100,100)
+      PROCsort_default(table$())
+      PROCsort_options(table$(), TRUE, 1, FALSE)
+      END
+
+      DEF PROCsort_options(table$(), ordering%, column%, reverse%)
+      DEF PROCsort_default(table$()) : LOCAL ordering%, column%, reverse%
+      REM The sort goes here, controlled by the options
+      REM Zero/FALSE values for the options shall select the defaults
+      ENDPROC

Task/Optional-parameters/C++/optional-parameters.cpp

@@ -0,0 +1,91 @@
+#include <vector>
+#include <algorithm>
+#include <string>
+
+// helper comparator that is passed to std::sort()
+template <class T>
+struct sort_table_functor {
+  typedef bool (*CompFun)(const T &, const T &);
+  const CompFun ordering;
+  const int column;
+  const bool reverse;
+  sort_table_functor(CompFun o, int c, bool r) :
+    ordering(o), column(c), reverse(r) { }
+  bool operator()(const std::vector<T> &x, const std::vector<T> &y) const {
+    const T &a = x[column],
+            &b = y[column];
+    return reverse ? ordering(b, a)
+                   : ordering(a, b);
+  }
+};
+
+// natural-order less-than comparator
+template <class T>
+bool myLess(const T &x, const T &y) { return x < y; }
+
+// this is the function we call, which takes optional parameters
+template <class T>
+void sort_table(std::vector<std::vector<T> > &table,
+                int column = 0, bool reverse = false,
+                bool (*ordering)(const T &, const T &) = myLess) {
+  std::sort(table.begin(), table.end(),
+            sort_table_functor<T>(ordering, column, reverse));
+}
+
+#include <iostream>
+
+// helper function to print our 3x3 matrix
+template <class T>
+void print_matrix(std::vector<std::vector<T> > &data) {
+  for () {
+    for (int j = 0; j < 3; j++)
+      std::cout << data[i][j] << "\t";
+    std::cout << std::endl;
+  }
+}
+
+// order in descending length
+bool desc_len_comparator(const std::string &x, const std::string &y) {
+  return x.length() > y.length();
+}
+
+int main() {
+
+  std::string data_array[3][3] =
+    {
+      {"a", "b", "c"},
+      {"", "q", "z"},
+      {"zap", "zip", "Zot"}
+    };
+
+  std::vector<std::vector<std::string> > data_orig;
+  for (int i = 0; i < 3; i++) {
+    std::vector<std::string> row;
+    for (int j = 0; j < 3; j++)
+      row.push_back(data_array[i][j]);
+    data_orig.push_back(row);
+  }
+  print_matrix(data_orig);
+
+  std::vector<std::vector<std::string> > data = data_orig;
+  sort_table(data);
+  print_matrix(data);
+
+  data = data_orig;
+  sort_table(data, 2);
+  print_matrix(data);
+
+  data = data_orig;
+  sort_table(data, 1);
+  print_matrix(data);
+
+  data = data_orig;
+  sort_table(data, 1, true);
+  print_matrix(data);
+
+  data = data_orig;
+  sort_table(data, 0, false, desc_len_comparator);
+  print_matrix(data);
+
+  return 0;
+}

Task/Optional-parameters/C/optional-parameters.c

@@ -0,0 +1,167 @@
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+typedef const char * String;
+typedef struct sTable {
+    String * *rows;
+    int      n_rows,n_cols;
+} *Table;
+
+typedef int (*CompareFctn)(String a, String b);
+
+struct {
+   CompareFctn  compare;
+   int   column;
+   int   reversed;
+} sortSpec;
+
+int CmprRows( const void *aa, const void *bb)
+{
+   String *rA = *(String **)aa;
+   String *rB = *(String **)bb;
+   int sortCol = sortSpec.column;
+
+   String left = sortSpec.reversed ? rB[sortCol] : rA[sortCol];
+   String right = sortSpec.reversed ? rA[sortCol] : rB[sortCol];
+   return sortSpec.compare( left, right );
+}
+
+/** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * tbl parameter is a table of rows of strings
+ * argSpec is a string containing zero or more of the letters o,c,r
+ * if o is present - the corresponding optional argument is a function which
+ *      determines the ordering of the strings.
+ * if c is present - the corresponding optional argument is an integer that
+ *      specifies the column to sort on.
+ * if r is present - the corresponding optional argument is either
+ *      true(nonzero) or false(zero) and if true, the sort will b in reverse order
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+int sortTable(Table tbl, const char* argSpec,... )
+{
+   va_list vl;
+   const char *p;
+   int c;
+   sortSpec.compare = &strcmp;
+   sortSpec.column = 0;
+   sortSpec.reversed = 0;
+
+   va_start(vl, argSpec);
+   if (argSpec)
+      for (p=argSpec; *p; p++) {
+         switch (*p) {
+         case 'o':
+            sortSpec.compare = va_arg(vl,CompareFctn);
+            break;
+         case 'c':
+            c = va_arg(vl,int);
+            if ( 0<=c && c<tbl->n_cols)
+               sortSpec.column  = c;
+            break;
+         case 'r':
+            sortSpec.reversed = (0!=va_arg(vl,int));
+            break;
+         }
+      }
+   va_end(vl);
+   qsort( tbl->rows, tbl->n_rows, sizeof(String *), &CmprRows);
+   return 0;
+}
+
+void printTable( Table tbl, FILE *fout, const char *colFmts[])
+{
+   int row, col;
+
+   for (row=0; row<tbl->n_rows; row++) {
+      fprintf(fout, "   ");
+      for(col=0; col<tbl->n_cols; col++) {
+         fprintf(fout, colFmts[col], tbl->rows[row][col]);
+      }
+      fprintf(fout, "\n");
+   }
+   fprintf(fout, "\n");
+}
+
+int ord(char v)
+{
+    return v-'0';
+}
+
+/* an alternative comparison function */
+int cmprStrgs(String s1, String s2)
+{
+    const char *p1 = s1;
+    const char *p2 = s2;
+    const char *mrk1, *mrk2;
+    while ((tolower(*p1) == tolower(*p2)) && *p1) {
+       p1++; p2++;
+    }
+    if (isdigit(*p1) && isdigit(*p2)) {
+        long v1, v2;
+        if ((*p1 == '0') ||(*p2 == '0')) {
+            while (p1 > s1) {
+                p1--; p2--;
+                if (*p1 != '0') break;
+            }
+            if (!isdigit(*p1)) {
+                p1++; p2++;
+            }
+        }
+        mrk1 = p1; mrk2 = p2;
+        v1 = 0;
+        while(isdigit(*p1)) {
+            v1 = 10*v1+ord(*p1);
+            p1++;
+        }
+        v2 = 0;
+        while(isdigit(*p2)) {
+            v2 = 10*v2+ord(*p2);
+            p2++;
+        }
+        if (v1 == v2)
+           return(p2-mrk2)-(p1-mrk1);
+        return v1 - v2;
+    }
+    if (tolower(*p1) != tolower(*p2))
+       return (tolower(*p1) - tolower(*p2));
+    for(p1=s1, p2=s2; (*p1 == *p2) && *p1; p1++, p2++);
+    return (*p1 -*p2);
+}
+
+int main()
+{
+   const char *colFmts[] = {" %-5.5s"," %-5.5s"," %-9.9s"};
+   String r1[] = { "a101", "red",  "Java" };
+   String r2[] = { "ab40", "gren", "Smalltalk" };
+   String r3[] = { "ab9",  "blue", "Fortran" };
+   String r4[] = { "ab09", "ylow", "Python" };
+   String r5[] = { "ab1a", "blak", "Factor" };
+   String r6[] = { "ab1b", "brwn", "C Sharp" };
+   String r7[] = { "Ab1b", "pink", "Ruby" };
+   String r8[] = { "ab1",  "orng", "Scheme" };
+
+   String *rows[] = { r1, r2, r3, r4, r5, r6, r7, r8 };
+   struct sTable table;
+   table.rows = rows;
+   table.n_rows = 8;
+   table.n_cols = 3;
+
+   sortTable(&table, "");
+   printf("sort on col 0, ascending\n");
+   printTable(&table, stdout, colFmts);
+
+   sortTable(&table, "ro", 1, &cmprStrgs);
+   printf("sort on col 0, reverse.special\n");
+   printTable(&table, stdout, colFmts);
+
+   sortTable(&table, "c", 1);
+   printf("sort on col 1, ascending\n");
+   printTable(&table, stdout, colFmts);
+
+   sortTable(&table, "cr", 2, 1);
+   printf("sort on col 2, reverse\n");
+   printTable(&table, stdout, colFmts);
+   return 0;
+}

Task/Optional-parameters/Clojure/optional-parameters.clj

@@ -0,0 +1,6 @@
+(defn sort [table & {:keys [ordering column reverse?]
+                     :or {ordering :lex, column 1}}]
+  (println table ordering column reverse?))
+
+(sort [1 8 3] :reverse? true)
+[1 8 3] :lex 1 true

Task/Optional-parameters/Common-Lisp/optional-parameters-1.lisp

@@ -0,0 +1,7 @@
+(defun sort-table (table &key (ordering #'string<)
+                              (column 0)
+                              reverse)
+  (sort table (if reverse
+                  (complement ordering)
+                  ordering)
+              :key (lambda (row) (elt row column))))

Task/Optional-parameters/Common-Lisp/optional-parameters-2.lisp

@@ -0,0 +1,17 @@
+CL-USER> (defparameter *data* '(("a" "b" "c") ("" "q" "z") ("zap" "zip" "Zot")))
+*DATA*
+
+CL-USER> (sort-table *data*)
+(("" "q" "z") ("a" "b" "c") ("zap" "zip" "Zot"))
+
+CL-USER> (sort-table *data* :column 2)
+(("zap" "zip" "Zot") ("a" "b" "c") ("" "q" "z"))
+
+CL-USER> (sort-table *data* :column 1)
+(("a" "b" "c") ("" "q" "z") ("zap" "zip" "Zot"))
+
+CL-USER> (sort-table *data* :column 1 :reverse t)
+(("zap" "zip" "Zot") ("" "q" "z") ("a" "b" "c"))
+
+CL-USER> (sort-table *data* :ordering (lambda (a b) (> (length a) (length b))))
+(("zap" "zip" "Zot") ("a" "b" "c") ("" "q" "z"))

Task/Optional-parameters/D/optional-parameters.d

@@ -0,0 +1,28 @@
+import std.stdio, std.algorithm, std.functional;
+
+string[][] sortTable(string[][] table,
+                     in bool function(string[],string[]) ordering=null,
+                     in int column = 0,
+                     in bool reverse = false) {
+    if (ordering is null)
+        table.schwartzSort!(row => row[column])();
+    else
+        table.sort!ordering();
+    if (reverse)
+        table.reverse();
+    return table;
+}
+
+void main() {
+    auto data = [["a", "b", "c"],
+                 ["", "q", "z"],
+                 ["zap", "zip", "Zot"]];
+
+    alias show = curry!(writefln, "%-(%s\n%)\n");
+    show(data);
+    show(sortTable(data));
+    show(sortTable(data, null, 2));
+    show(sortTable(data, null, 1));
+    show(sortTable(data, null, 1, true));
+    show(sortTable(data, (a,b) => b.length > a.length));
+}

Task/Optional-parameters/E/optional-parameters.e

@@ -0,0 +1,22 @@
+def defaultOrdering(a, b) { return a.op__cmp(b) }
+
+def sort {
+
+    to run(table) {
+        return sort(table, 0, false, defaultOrdering)
+    }
+    to run(table, column) {
+        return sort(table, column, false, defaultOrdering)
+    }
+    to run(table, column, reverse) {
+        return sort(table, column, reverse, defaultOrdering)
+    }
+
+    to run(table :List[List[String]], column :int, reverse :boolean, ordering) {
+        return table.sort(fn a, b {
+            def ord := ordering(a[column], b[column])
+            if (reverse) { -ord } else { ord }
+        })
+    }
+
+}

Task/Optional-parameters/Fortran/optional-parameters-1.f

@@ -0,0 +1,69 @@
+module ExampleOptionalParameter
+  ! use any module needed for the sort function(s)
+  ! and all the interfaces needed to make the code work
+  implicit none
+contains
+
+  subroutine sort_table(table, ordering, column, reverse)
+    type(table_type), intent(inout) :: table
+    integer, optional :: column
+    logical, optional :: reverse
+    optional :: ordering
+    interface
+       integer function ordering(a, b)
+         type(table_element), intent(in) :: a, b
+       end function ordering
+    end interface
+
+    integer :: the_column, i
+    logical :: reversing
+    type(table_row) :: rowA, rowB
+
+    if ( present(column) ) then
+       if ( column > get_num_of_columns(table) ) then
+          ! raise an error?
+       else
+          the_column = column
+       end if
+    else
+       the_column = 1   ! a default value, de facto
+    end if
+
+    reversing = .false.  ! default value
+    if ( present(reverse) ) reversing = reverse
+
+    do
+       ! loops over the rows to sort... at some point, we need
+       ! comparing an element (cell) of the row, with the element
+       ! in another row; ... let us suppose rowA and rowB are
+       ! the two rows we are considering
+       ea = get_element(rowA, the_column)
+       eb = get_element(rowB, the_column)
+       if ( present(ordering) ) then
+          if ( .not. reversing ) then
+             if ( ordering(ea, eb) > 0 ) then
+                ! swap the rowA with the rowB
+             end if
+          else   ! < instead of >
+             if ( ordering(ea, eb) < 0 ) then
+                ! swap the rowA with the rowB
+             end if
+          end if
+       else
+          if ( .not. reversing ) then
+             if ( lexinternal(ea, eb) > 0 ) then
+                ! swap the rowA with the rowB
+             end if
+          else   ! < instead of >
+             if ( lexinternal(ea, eb) < 0 ) then
+                ! swap the rowA with the rowB
+             end if
+          end if
+       end if
+       ! ... more of the sorting algo ...
+       ! ... and rows traversing ... (and an exit condition of course!)
+    end do
+
+  end subroutine sort_table
+
+end module ExampleOptionalParameter

Task/Optional-parameters/Fortran/optional-parameters-2.f

@@ -0,0 +1,36 @@
+program UsingTest
+  use ExampleOptionalParameter
+  implicit none
+
+  type(table_type) :: table
+
+  ! create the table...
+
+  ! sorting taking from column 1, not reversed, using internal
+  ! default comparator
+  call sort_table(table)
+
+  ! the same as above, but in reversed order; we MUST specify
+  ! the name of the argument since it is not given in the same
+  ! order of the subroutine spec
+  call sort_table(table, reverse=.true.)
+
+  ! sort the table using a custom comparator
+  call sort_table(table, my_cmp)
+  ! or
+  call sort_table(table, ordering=my_cmp)
+
+  ! as above, but taking from column 2
+  call sort_table(table, my_cmp, 2)
+  ! or (swapping the order of args for fun)
+  call sort_table(table, column=2, ordering=my_cmp)
+
+  ! with custom comparator, column 2 and reversing...
+  call sort_table(table, my_cmp, 2, .true.)
+  ! of course we can swap the order of optional args
+  ! by prefixing them with the name of the arg
+
+  ! sort from column 2, with internal comparator
+  call sort_table(table, column=2)
+
+end program UsingTest

Task/Optional-parameters/Go/optional-parameters-1.go

@@ -0,0 +1,5 @@
+type spec struct {
+    ordering func(cell, cell) bool
+    column   int
+    reverse  bool
+}

Task/Optional-parameters/Go/optional-parameters-2.go

@@ -0,0 +1 @@
+spec{reverse: true}

Task/Optional-parameters/Go/optional-parameters-3.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+    "fmt"
+    "sort"
+)
+
+type cell string
+type row []cell
+type table struct {
+    rows   []row
+    column int
+    less   func(cell, cell) bool
+}
+
+func (c cell) String() string {
+    return fmt.Sprintf("%q", string(c))
+}
+
+func (t table) printRows(heading string) {
+    fmt.Println("--", heading)
+    for _, row := range t.rows {
+        fmt.Println(row)
+    }
+    fmt.Println()
+}
+
+// sort.Interface
+func (t table) Len() int      { return len(t.rows) }
+func (t table) Swap(i, j int) { t.rows[i], t.rows[j] = t.rows[j], t.rows[i] }
+func (t table) Less(i, j int) bool {
+    return t.less(t.rows[i][t.column], t.rows[j][t.column])
+}
+
+// struct implements named parameter-like capability
+type spec struct {
+    ordering func(cell, cell) bool
+    column   int
+    reverse  bool
+}
+
+
+func (t *table) sort(s spec) {
+    // set up column and comparison function for sort
+    t.column = s.column
+    switch {
+    case s.ordering != nil:
+        t.less = s.ordering
+    case s.reverse:
+        t.less = func(a, b cell) bool { return a > b }
+    default:
+        t.less = func(a, b cell) bool { return a < b }
+    }
+
+    // sort
+    sort.Sort(t)
+
+    // reverse if necessary
+    if s.ordering == nil || !s.reverse {
+        return
+    }
+    last := len(t.rows) - 1
+    for i := last / 2; i >= 0; i-- {
+        t.rows[i], t.rows[last-i] = t.rows[last-i], t.rows[i]
+    }
+}
+
+func main() {
+    t := table{rows: []row{
+        {"pail", "food"},
+        {"pillbox", "nurse maids"},
+        {"suitcase", "airedales"},
+        {"bathtub", "chocolate"},
+        {"schooner", "ice cream sodas"},
+    }}
+
+    t.printRows("song")
+
+    // no "parameters"
+    t.sort(spec{})
+    t.printRows("sorted on first column")
+
+    // "named parameter" reverse.
+    t.sort(spec{reverse: true})
+    t.printRows("reverse sorted on first column")
+
+    // "named parameters" column and ordering
+    t.sort(spec{
+        column:   1,
+        ordering: func(a, b cell) bool { return len(a) > len(b) },
+    })
+    t.printRows("sorted by descending string length on second column")
+}

Task/Optional-parameters/Icon/optional-parameters.icon

@@ -0,0 +1,20 @@
+procedure main()
+   X := [ [1,2,3], [2,3,1], [3,1,2])                       # A list of lists
+   Sort(X)                                                 # vanilla sort
+   Sort(X,"ordering","numeric","column",2,"reverse")       # using optional parameters
+end
+
+procedure Sort(X,A[])                                      # A[] provides for a variable number of arguments
+   while a := get(A) do {
+      case a of {
+         "ordering" :  op := case get(A) | runerr(205,a) of {
+            "lexicographic"|"string":  "<<"
+            "numeric": "<"
+            default:  runerr(205,op)
+            }
+         "column"   : col := 0 < integer(col := get(A)) | runerr(205,col)
+         "reverse"  : reverseorder := reverse
+         default: runerr(205,a)
+         }
+   return (\reverseorder|1)(bubblesortf(X,\c|1,\op|"<<"))  # reverse or return the sorted list
+end

Task/Optional-parameters/J/optional-parameters-1.j

@@ -0,0 +1,6 @@
+srtbl=: verb define
+  '' srtbl y
+:
+  '`ordering column reverse'=. x , (#x)}. ]`0:`0:
+  |.^:reverse y /: ordering (column {"1 ])y
+)

Task/Optional-parameters/J/optional-parameters-2.j

@@ -0,0 +1,40 @@
+   ]Table=: ('a';'b';'c'),('';'q';'z'),:'zip';'zap';'Zot'
+┌───┬───┬───┐
+│a  │b  │c  │
+├───┼───┼───┤
+│   │q  │z  │
+├───┼───┼───┤
+│zip│zap│Zot│
+└───┴───┴───┘
+   srtbl Table           NB. default sort
+┌───┬───┬───┐
+│   │q  │z  │
+├───┼───┼───┤
+│a  │b  │c  │
+├───┼───┼───┤
+│zip│zap│Zot│
+└───┴───┴───┘
+   ]`1: srtbl Table      NB. sort by column 1
+┌───┬───┬───┐
+│a  │b  │c  │
+├───┼───┼───┤
+│   │q  │z  │
+├───┼───┼───┤
+│zip│zap│Zot│
+└───┴───┴───┘
+   ]`2:`1: srtbl Table   NB. reverse sort by column 2
+┌───┬───┬───┐
+│zip│zap│Zot│
+├───┼───┼───┤
+│   │q  │z  │
+├───┼───┼───┤
+│a  │b  │c  │
+└───┴───┴───┘
+   #&>`0: srtbl Table    NB. sort by length
+┌───┬───┬───┐
+│   │q  │z  │
+├───┼───┼───┤
+│a  │b  │c  │
+├───┼───┼───┤
+│zip│zap│Zot│
+└───┴───┴───┘

Task/Optional-parameters/Java/optional-parameters.java

@@ -0,0 +1,73 @@
+import java.util.*;
+
+public class OptionalParams {
+    // "natural ordering" comparator
+    static <T extends Comparable<? super T>> Comparator<T> naturalOrdering() {
+        return Collections.reverseOrder(Collections.<T>reverseOrder());
+    }
+
+    public static <T extends Comparable<? super T>> void
+                             sortTable(T[][] table) {
+        sortTable(table, 0);
+    }
+    public static <T extends Comparable<? super T>> void
+                             sortTable(T[][] table,
+                                       int column) {
+        sortTable(table, column, false);
+    }
+    public static <T extends Comparable<? super T>> void
+                             sortTable(T[][] table,
+                                       int column, boolean reverse) {
+        sortTable(table, column, reverse, OptionalParams.<T>naturalOrdering());
+    }
+    public static <T> void sortTable(T[][] table,
+                                     final int column,
+                                     final boolean reverse,
+                                     final Comparator<T> ordering) {
+        Comparator<T[]> myCmp = new Comparator<T[]>() {
+            public int compare(T[] x, T[] y) {
+                return (reverse ? -1 : 1) *
+                       ordering.compare(x[column], y[column]);
+            }
+        };
+        Arrays.sort(table, myCmp);
+    }
+
+    public static void main(String[] args) {
+        String[][] data0 = {{"a", "b", "c"},
+                            {"", "q", "z"},
+                            {"zap", "zip", "Zot"}};
+        System.out.println(Arrays.deepToString(data0));
+        // prints: [[a, b, c], [, q, z], [zap, zip, Zot]]
+
+        // we copy it so that we don't change the original copy
+        String[][] data = data0.clone();
+        sortTable(data);
+        System.out.println(Arrays.deepToString(data));
+        // prints: [[, q, z], [a, b, c], [zap, zip, Zot]]
+
+        data = data0.clone();
+        sortTable(data, 2);
+        System.out.println(Arrays.deepToString(data));
+        // prints: [[zap, zip, Zot], [a, b, c], [, q, z]]
+
+        data = data0.clone();
+        sortTable(data, 1);
+        System.out.println(Arrays.deepToString(data));
+        // prints: [[a, b, c], [, q, z], [zap, zip, Zot]]
+
+        data = data0.clone();
+        sortTable(data, 1, true);
+        System.out.println(Arrays.deepToString(data));
+        // prints: [[zap, zip, Zot], [, q, z], [a, b, c]]
+
+        data = data0.clone();
+        sortTable(data, 0, false, new Comparator<String>() {
+                public int compare(String a, String b) {
+                    return b.length() - a.length();
+                }
+            });
+        System.out.println(Arrays.deepToString(data));
+        // prints: [[zap, zip, Zot], [a, b, c], [, q, z]]
+    }
+}

Task/Optional-parameters/JavaScript/optional-parameters.js

@@ -0,0 +1,10 @@
+function sorter(table, options) {
+    opts = {}
+    opts.ordering = options.ordering || 'lexicographic';
+    opts.column   = options.column || 0;
+    opts.reverse  = options.reverse || false;
+
+    // ...
+}
+
+sorter(the_data, {reverse: true, ordering: 'numeric'});

Task/Optional-parameters/Logo/optional-parameters-1.logo

@@ -0,0 +1,3 @@
+to sort :table [:column 1] [:ordering "before?] [:reverse "false]
+  ; ...
+end

Task/Optional-parameters/Logo/optional-parameters-2.logo

@@ -0,0 +1,3 @@
+sort :table
+(sort :table 2)
+(sort :table 3 "less? "true)

Task/Optional-parameters/Mathematica/optional-parameters.math

@@ -0,0 +1,10 @@
+Options[OptionalSort]={ordering->lexicographic,column->1,reverse-> False};
+OptionalSort[x_List,OptionsPattern[]]:=If[OptionValue[reverse]==True,
+SortBy[x ,#[[OptionValue[column]]]&]//Reverse,
+SortBy[x,#[[OptionValue[column]]]&] ]
+
+OptionalSort[{{"a" ,"b", "c"}, {"", "q", "z"},{"zap" ,"zip", "Zot"}} ]
+->{{,q,z},{a,b,c},{zap,zip,Zot}}
+
+OptionalSort[{{"a" ,"b", "c"}, {"", "q", "z"},{"zap" ,"zip", "Zot"}},{ordering->lexicographic,column->2,reverse-> True} ]
+->{{zap,zip,Zot},{,q,z},{a,b,c}}

Task/Optional-parameters/Nemerle/optional-parameters.nemerle

@@ -0,0 +1,4 @@
+Sorter (table : list[list[string]], ordering = "lexicographic", column = 0, reverse = false) : list[list[string]]
+{
+    // implementation goes here
+}

Task/Optional-parameters/OCaml/optional-parameters-1.ocaml

@@ -0,0 +1,3 @@
+let sort_table ?(ordering = compare) ?(column = 0) ?(reverse = false) table =
+  let cmp x y = ordering (List.nth x column) (List.nth y column) * (if reverse then -1 else 1) in
+    List.sort cmp table

Task/Optional-parameters/OCaml/optional-parameters-2.ocaml

@@ -0,0 +1,18 @@
+# let data = [["a"; "b"; "c"]; [""; "q"; "z"]; ["zap"; "zip"; "Zot"]];;
+val data : string list list =
+  [["a"; "b"; "c"]; [""; "q"; "z"]; ["zap"; "zip"; "Zot"]]
+# sort_table data;;
+- : string list list =
+[[""; "q"; "z"]; ["a"; "b"; "c"]; ["zap"; "zip"; "Zot"]]
+# sort_table ~column:2 data;;
+- : string list list =
+[["zap"; "zip"; "Zot"]; ["a"; "b"; "c"]; [""; "q"; "z"]]
+# sort_table ~column:1 data;;
+- : string list list =
+[["a"; "b"; "c"]; [""; "q"; "z"]; ["zap"; "zip"; "Zot"]]
+# sort_table ~column:1 ~reverse:true data;;
+- : string list list =
+[["zap"; "zip"; "Zot"]; [""; "q"; "z"]; ["a"; "b"; "c"]]
+# sort_table ~ordering:(fun a b -> compare (String.length b) (String.length a)) data;;
+- : string list list =
+[["zap"; "zip"; "Zot"]; ["a"; "b"; "c"]; [""; "q"; "z"]]

Task/Optional-parameters/Objective-C/optional-parameters.m

@@ -0,0 +1,25 @@
+typedef enum { kOrdNone, kOrdLex, kOrdByAddress, kOrdNumeric } SortOrder;
+
+@interface MyArray : NSObject {}
+// . . .
+@end
+
+@implementation MyArray
+
+- (void)sort {
+    [self sortWithOrdering:kOrdLex onColumn:0 reversed:NO];
+}
+
+- (void)sortWithOrdering:(SortOrder)ord {
+    [self sortWithOrdering:ord onColumn:0 reversed:NO];
+}
+
+- (void)sortWithOrdering:(SortOrder)ord onColumn:(int)col {
+    [self sortWithOrdering:ord onColumn:col reversed:NO];
+}
+
+- (void)sortWithOrdering:(SortOrder)ord onColumn:(int)col reversed:(BOOL)rev {
+    // . . . Actual sort goes here . . .
+}
+
+@end

Task/Optional-parameters/Oz/optional-parameters.oz

@@ -0,0 +1,30 @@
+declare
+  class Table
+     attr
+        rows
+
+     meth init(Rows)
+        rows := Rows
+     end
+
+     meth sort(ordering:O<=Lexicographic  column:C<=1  reverse:R<=false)
+        fun {Predicate Row1 Row2}
+           Res = {O {Nth Row1 C} {Nth Row2 C}}
+        in
+           if R then {Not Res} else Res end
+        end
+     in
+        rows := {Sort @rows Predicate}
+     end
+  end
+
+  fun {Lexicographic As Bs}  %% omitted for brevity
+  end
+
+  T = {New Table init([["a" "b" "c"] ["" "q" "z"] ["zap" "zip" "Zot"]])}
+in
+  {T sort}
+  {T sort(column:3)}
+  {T sort(column:2)}
+  {T sort(column:2 reverse:true)}
+  {T sort(ordering:fun {$ A B} {Length B} < {Length A} end)}

Task/Optional-parameters/PARI-GP/optional-parameters-1.pari

@@ -0,0 +1 @@
+sort(v, ordering=0, column=0, reverse=0)

Task/Optional-parameters/PARI-GP/optional-parameters-2.pari

@@ -0,0 +1,10 @@
+/*
+GP;install("test_func", "vDG", "test", "path/to/test.gp.so");
+*/
+void
+test_func(GEN x) {
+  if (x == NULL)
+    pari_printf("Argument omitted.\n");
+  else
+    pari_printf("Argument was: %Ps\n", x);
+}

Task/Optional-parameters/Perl-6/optional-parameters.pl6

@@ -0,0 +1,4 @@
+method sorttable(:$column = 0, :$reverse, :&ordering = &infix:<cmp>) {
+    my @result = self»[$column].sort: &ordering;
+    return $reverse ?? @result.reverse !! @result;
+}

Task/Optional-parameters/Perl/optional-parameters-1.pl

@@ -0,0 +1,10 @@
+sub sorttable
+ {my @table = @{shift()};
+  my %opt =
+     (ordering => sub {$_[0] cmp $_[1]}, column => 0, reverse => 0, @_);
+  my $col = $opt{column};
+  my $func = $opt{ordering};
+  my @result = sort
+      {$func->($a->[$col], $b->[$col])}
+      @table;
+  return ($opt{reverse} ? [reverse @result] : \@result);}

Task/Optional-parameters/Perl/optional-parameters-2.pl

@@ -0,0 +1,5 @@
+my $a = [["a", "b", "c"], ["", "q", "z"], ["zap", "zip", "Zot"]];
+foreach (@{sorttable $a, column => 1, reverse => 1})
+   {foreach (@$_)
+       {printf "%-5s", $_;}
+    print "\n";}

Task/Optional-parameters/PicoLisp/optional-parameters.l

@@ -0,0 +1,8 @@
+(de sortTable (Tbl . @)
+   (let (Ordering prog  Column 1  Reverse NIL)  # Set defaults
+      (bind (rest)                              # Bind optional params
+         (setq Tbl
+            (by '((L) (Ordering (get L Column)))
+               sort
+               Tbl ) )
+         (if Reverse (flip Tbl) Tbl) ) ) )

Task/Optional-parameters/Python/optional-parameters.py

@@ -0,0 +1,35 @@
+>>> def printtable(data):
+    for row in data:
+        print ' '.join('%-5s' % ('"%s"' % cell) for cell in row)
+
+
+>>> import operator
+>>> def sorttable(table, ordering=None, column=0, reverse=False):
+    return sorted(table, cmp=ordering, key=operator.itemgetter(column), reverse=reverse)
+
+>>> data = [["a", "b", "c"], ["", "q", "z"], ["zap", "zip", "Zot"]]
+>>> printtable(data)
+"a"   "b"   "c"
+""    "q"   "z"
+"zap" "zip" "Zot"
+>>> printtable( sorttable(data) )
+""    "q"   "z"
+"a"   "b"   "c"
+"zap" "zip" "Zot"
+>>> printtable( sorttable(data, column=2) )
+"zap" "zip" "Zot"
+"a"   "b"   "c"
+""    "q"   "z"
+>>> printtable( sorttable(data, column=1) )
+"a"   "b"   "c"
+""    "q"   "z"
+"zap" "zip" "Zot"
+>>> printtable( sorttable(data, column=1, reverse=True) )
+"zap" "zip" "Zot"
+""    "q"   "z"
+"a"   "b"   "c"
+>>> printtable( sorttable(data, ordering=lambda a,b: cmp(len(b),len(a))) )
+"zap" "zip" "Zot"
+"a"   "b"   "c"
+""    "q"   "z"
+>>>

Task/Optional-parameters/R/optional-parameters.r

@@ -0,0 +1,7 @@
+tablesort <- function(x, ordering="lexicographic", column=1, reverse=false)
+{
+   # Implementation
+}
+
+# Usage is e.g.
+tablesort(mytable, column=3)

Task/Optional-parameters/Racket/optional-parameters.rkt

@@ -0,0 +1,10 @@
+#lang racket
+
+(define (sort-table table
+                    [ordering string<=?]
+                    [column 0]
+                    [reverse? #f])
+  (sort table (if reverse?
+                  (negate ordering)
+                  ordering)
+        #:key (λ (row) (list-ref row column))))

Task/Optional-parameters/Ruby/optional-parameters-1.rb

@@ -0,0 +1,2 @@
+def table_sort(table, ordering=:<=>, column=0, reverse=false)
+  # ...

Task/Optional-parameters/Ruby/optional-parameters-2.rb

@@ -0,0 +1,16 @@
+def table_sort(table, ordering: :<=>, column: 0, reverse: false)
+  p = ordering.to_proc
+  if reverse
+    table.sort {|a, b| p.(b[column], a[column])}
+  else
+    table.sort {|a, b| p.(a[column], b[column])}
+  end
+end
+
+# Quick example:
+table = [
+  ["Ottowa", "Canada"],
+  ["Washington", "USA"],
+  ["Mexico City", "Mexico"],
+]
+p table_sort(table, column: 1)

Task/Optional-parameters/Ruby/optional-parameters-3.rb

@@ -0,0 +1,12 @@
+def table_sort(table, opts = {})
+  defaults = {:ordering => :<=>, :column => 0, :reverse => false}
+  opts = defaults.merge(opts)
+
+  c = opts[:column]
+  p = opts[:ordering].to_proc
+  if opts[:reverse]
+    table.sort {|a, b| p.call(b[c], a[c])}
+  else
+    table.sort {|a, b| p.call(a[c], b[c])}
+  end
+end

Task/Optional-parameters/Scala/optional-parameters-1.scala

@@ -0,0 +1,5 @@
+def sortTable(data:List[List[String]], ordering:(String, String)=>Boolean =(_<_),
+   column:Int =0, reverse:Boolean =false)={
+   val result=data.sortWith((a, b)=> ordering(a(column), b(column)))
+   if(reverse) result.reverse else result
+}

Task/Optional-parameters/Scala/optional-parameters-2.scala

@@ -0,0 +1,11 @@
+val data=List(List("a","b","c"), List("","q","z"), List("zap","zip","Zot"))
+println(data)
+   //-> List(List(a, b, c), List(, q, z), List(zap, zip, Zot))
+println(sortTable(data))
+   //-> List(List(, q, z), List(a, b, c), List(zap, zip, Zot))
+println(sortTable(data, reverse=true))
+   //-> List(List(zap, zip, Zot), List(a, b, c), List(, q, z))
+println(sortTable(data, column=2))
+   //-> List(List(zap, zip, Zot), List(a, b, c), List(, q, z))
+println(sortTable(data, ((a, b)=> b.size<a.size)))
+   //-> List(List(zap, zip, Zot), List(a, b, c), List(, q, z))

Task/Optional-parameters/Slate/optional-parameters.slate

@@ -0,0 +1,8 @@
+s@(Sequence traits) tableSort &column: column &sortBy: sortBlock &reverse: reverse
+[
+  column `defaultsTo: 0.
+  sortBlock `defaultsTo: [| :a :b | (a lexicographicallyCompare: b) isNegative].
+  (reverse `defaultsTo: False)
+    ifTrue: [sortBlock := [| :a :b | (sortBlock applyTo: {a. b}) not]].
+  s sortBy: [| :a :b | sortBlock applyTo: {a at: column. b at: column}]
+].

Task/Optional-parameters/TIScript/optional-parameters.tiscript

@@ -0,0 +1,5 @@
+function sorter(table, ordering = "lexicographic", column = 0, reverse = false) {
+    // ...
+}
+
+sorter(the_data,"numeric");

Task/Optional-parameters/Tcl/optional-parameters-1.tcl

@@ -0,0 +1,15 @@
+proc tablesort {table {ordering ""} {column 0} {reverse 0}} {
+    set direction [expr {$reverse ? "-decreasing" : "-increasing"}]
+    if {$ordering ne ""} {
+        lsort -command $ordering $direction -index $column $table
+    } else {
+        lsort $direction -index $column $table
+    }
+}
+
+puts [tablesort $data]
+puts [tablesort $data "" 1]
+puts [tablesort $data "" 0 1]
+puts [tablesort $data {
+    apply {{a b} {expr {[string length $a]-[string length $b]}}}
+}]

Task/Optional-parameters/Tcl/optional-parameters-2.tcl

@@ -0,0 +1,18 @@
+package require Tcl 8.5;  # Only for the list expansion syntax
+
+proc tablesort {table args} {
+    array set opt {ordering "" column 0 reverse 0}
+    array set opt $args
+    set pars [list -index $opt(column)]
+    if {$opt(reverse)} {lappend pars -decreasing}
+    if {$opt(ordering) ne ""} {lappend pars -command $opt(ordering)}
+    lsort {*}$pars $table
+}
+
+puts [tablesort $data]
+puts [tablesort $data column 1]
+puts [tablesort $data column 0]
+puts [tablesort $data column 0 reverse 1]
+puts [tablesort $data ordering {
+    apply {{a b} {expr {[string length $b]-[string length $a]}}}
+}]

Task/Optional-parameters/Ursala/optional-parameters-1.ursala

@@ -0,0 +1,10 @@
+#import std
+#import nat
+
+ss ::
+
+ordering   %fZ ~ordering||lleq!
+column     %n  ~column||1!
+reversed   %b
+
+sorter = +^(~reversed?/~&x! ~&!,-<+ +^/~ordering ~~+ ~&h++ //skip+ predecessor+ ~column)

Task/Optional-parameters/Ursala/optional-parameters-2.ursala

@@ -0,0 +1,17 @@
+example_table =
+
+<
+   <'foo','b  '>,
+   <'barr','a '>,
+   <'bazzz','c'>>
+
+#cast %sLLL
+
+examples =
+
+<
+   (sorter ss&) example_table,                      # default sorting algorithm
+   (sorter ss[ordering: leql]) example_table,       # sort by field lengths but otherwise default
+   (sorter ss[column: 2]) example_table,            # etc.
+   (sorter ss[reversed: true]) example_table,
+   (sorter ss[reversed: true,column: 2]) example_table>

Task/Optional-parameters/XSLT/optional-parameters.xslt

@@ -0,0 +1,7 @@
+<xsl:template name="sort">
+  <xsl:param name="table" />
+  <xsl:param name="ordering" select="'lexicographic'" />
+  <xsl:param name="column" select="1" />
+  <xsl:param name="reversed" select="false()" />
+  ...
+</xsl:template>