use strict; use vars qw(@static @dynamic @OO @functional @reflexive @typed @rare @has_lambda @various); ######################################################################################## # kinds ################################################################################ ######################################################################################## my @OO_dynamic = qw(E JavaScript Perl Perl6 MSH PHP Python Rebol Ruby Smalltalk Io VisualBasic YCP Tcl MzScheme Oz Scilab Matlab Julia CoffeeScript); my @OO_static = ('C#', qw(Ada Beta C++ Cecil D Pike Objective-C Java Eiffel Sather Delphi-Kylix Pliant Simula)); my @functional_dynamic = qw(Scheme Erlang FL Logo); my @functional_static = qw(Mercury SML Haskell); @static = (@OO_static, @functional_static, qw(C Cobol Pascal Fortran merd Modula-2 Modula-3 OCaml Go), 'F#'); @dynamic = (@functional_dynamic, @OO_dynamic, qw(Awk Basic Dylan Forth Maple Lua Icon XPath XSLT Pike PostScript Prolog BourneShell FishShell Oz EmacsLisp CommonLisp ClassicREXX Yorick Vimscript)); @OO = (@OO_dynamic, @OO_static, qw(OCaml CommonLisp Dylan merd)); @functional = (@functional_dynamic, @functional_static, qw(OCaml EmacsLisp CommonLisp Dylan merd Smalltalk)); @reflexive = (@dynamic, qw(Java merd Pliant)); @typed = (@static, qw(Dylan Smalltalk Perl6 VisualBasic YCP)); @has_lambda = (@functional, qw(Ruby Python Perl Perl6 MSH Mathematica JavaScript CoffeeScript), 'C#2', 'C#3', 'Tcl'); @various = qw(APL BCPL B J PL/I MUMPS HTML CSS TeX SGML XML YAML Assembler SQL92 GNU-sed GNU-bc); my %kind_dependencies = ( reflexive => 'dynamic', typed => 'static', has_lambda => 'functional', ); my %kind_descriptions = ( static => 'Statically typed', dynamic => 'Dynamically typed', OO => 'Object Oriented', functional => 'Functional', reflexive => 'Reflexive', typed => 'Has types', has_lambda => 'Has anonymous functions', ); my %kinds = map { $_ => \@{$::{$_}} } (qw(rare various), keys %kind_descriptions); my %hierarchy = ( 'Fortran90' => ['Fortran'], 'C99' => ['C'], 'C++-0x' => ['C++'], 'C#2' => ['C#'], 'C#3' => ['C#2', 'C#'], 'SQL99' => ['SQL92'], 'Delphi-Kylix' => ['Pascal'], 'Objective-C' => ['C'], 'VisualBasic' => ['Basic'], 'PHP5' => ['PHP'], 'SML-NJ' => ['SML'], 'Scheme-SRFI1' => ['Scheme'], 'Scheme-SRFI28' => ['Scheme'], 'Scheme-SRFI34' => ['Scheme'], 'MzScheme' => ['Scheme-SRFI1', 'Scheme-SRFI28','Scheme'], 'Squeak' => ['Smalltalk'], 'XSLT' => ['XPath', 'XML'], 'Tcl8.5' => ['Tcl'], 'KornShell' => ['BourneShell'], 'CoffeeScript' => ['JavaScript'], ); # complete kinds using the hierarchy of languages # and fill_in rev_hierarchy my %rev_hierarchy; while (my ($l, $subls) = each %hierarchy) { foreach my $subl (@$subls) { push @{$rev_hierarchy{$subl}}, $l; next if @$subls > 1; foreach (values %kinds) { push @$_, $l if member($subl, @$_); } } } my @langs = uniq(map { @$_ } values %kinds); ######################################################################################## # main ################################################################################# ######################################################################################## my $all_raw = [ 'Various' => [ 'commenting' => [ 'until end of line' => [ '#' => "Perl Io Perl6 Maple Ruby Python Tcl Icon Awk FishShell Julia BourneShell PHP merd E Pliant YAML GNU-sed GNU-bc CoffeeScript", '//' => "BCPL Io C99 C++ C# F# Java Dylan Pike PHP JavaScript YCP Yorick Scilab Go", '--' => "Cecil Eiffel Sather Simula Haskell Ada Lua SQL92", ';' => "EmacsLisp Logo CommonLisp Scheme Rebol Assembler MUMPS", '%' => "Prolog Mercury TeX Erlang PostScript Oz Matlab", 'rem' => "Basic", "'" => "VisualBasic", '"' => "Vimscript", '\\' => "Forth", '!' => "Fortran90 Assembler", 'NB.' => 'J', 'C or * in column 1' => "Fortran", ], 'nestable' => [ '(* ... *)' => "OCaml Beta F# Mathematica Pascal Modula-3 SML", '%( ... %)' => "Matlab", '/* ... */' => "Oz Io Dylan ClassicREXX SQL99", '{ ... }' => "Pascal Rebol", '{- ... -}' => "Haskell", '#| ... |# (introduced in Scheme in R6RS)' => "CommonLisp Scheme", '#= ... =#' => "Julia", '#[ ... ]' => "Perl6", '#if 0 ... #endif' => "C", 'comment { ... }' => "Rebol", 'comment [ ... ]' => "Rebol", '[ ... ] (when unused)' => "Rebol", '--[[ ... ]]' => "Lua", ], 'non nestable' => [ '" ... "' => "Smalltalk", '/* ... */' => "C C++ C# Java B PL/I Pike CSS PHP JavaScript Mercury YCP Yorick GNU-bc Go", '' => "HTML XML", '( ... )' => "Forth", pre("###\n...\n###") => "CoffeeScript", ], ], 'documentation comment' => [ { MLANG => "C Tcl Forth ClassicREXX Mathematica Logo MUMPS Prolog Maple Go" }, 'until end of line' => [ '///' => "C# F# Java", '-- |' => "Haskell", '-- ^' => "Haskell", ], 'non nestable' => [ "/** ... */ (for C, it is not a standard convention, but it is the more widespread)" => "C C# Java JavaScript E PHP", "(** ... *)" => "F#", ], '' => [ '{-| ... -}' => "Haskell", '(** ... *)' => "OCaml", '/* DOCUMENT ... */' => "Yorick", 'indexing identifier: "...";' => "Eiffel", "someClass comment: '...'" => "Smalltalk", 'rebol [ Note: "..." ]' => "Rebol", 'func ["..." arg] ...' => "Rebol", pre('class X: """... """ def x(): """... """ ') . " (any string literal would work)" => "Python", '(define (f para1 para2) "..." ...)' => "Scheme", '(defun f (para1 para2) "..." ...)' => "EmacsLisp CommonLisp", pre('=pod ... =cut') . " (see also =head1, =head2, =over, etc)" => "Perl Perl6", pre('=begin ... =end') => "Ruby", pre('function MYFUNCTION %MYFUNCTION the very first comment line is displayed in the help table of contents % % the remaining lines are displayed when getting help for MYFUNCTION % ') => "Matlab", ], ], 'information about the current line and file' => [ { MLANG => "OCaml Io Haskell Forth Ada MUMPS CommonLisp Matlab Prolog Tcl" }, '__LINE__ __FILE__' => "C C++ Perl Pike PHP Ruby", '__LINE__ __SOURCE_FILE__' => "F#", '$?LINE $?FILE' => "Perl6", '__file__' => "Python", pre('(new System.Diagnostics.StackFrame(true)).GetFileLineNumber() (new System.Diagnostics.StackFrame(true)).GetFileName()') => 'C#', pre('Thread.currentThread().getStackTrace()[1].getLineNumber(); Thread.currentThread().getStackTrace()[1].getFileName();') => "Java", 'system/script/header/file (need "file: %script-header.r" in file header)' => "Rebol", 'SOURCELINE() / parse source OS . SOURCENAME' => "ClassicREXX", 'info frame 0' => "Tcl8.5", 'thisContext lineNumber / thisContext method source' => "Smalltalk", 'runtime.Caller(0)' => 'Go', ], 'tokens' => [ { ALL => 1 }, 'case-sensitivity (keywords, variable identifiers...)' => [ # see http://www.swiss.ai.mit.edu/~jaffer/r5rs_4.html#SEC14 for Scheme, Guile is an exception 'case-sensitive' => 'B C C++ C# F# Io Java Maple Mathematica Prolog JavaScript Lua Matlab Pike Perl Perl6 Python Ruby XML YAML Tcl Smalltalk BourneShell FishShell OCaml Haskell merd Awk Modula-3 Pliant Yorick CoffeeScript Go', 'case-insensitive' => "PL/I CSS Pascal Logo Rebol VisualBasic Eiffel Ada SGML HTML CommonLisp Forth Assembler ClassicREXX SQL92", 'case-sensitive: variables
case-insensitive: keywords, functions, constants...' => "PHP", 'case-sensitive: identifiers
case-insensitive: keywords' => "E", 'case-sensitive: identifiers
case-insensitive: commands' => "MUMPS", 'case-sensitive: upper case disallowed' => 'GNU-bc', ], 'what is the standard way for scrunching together multiple words' => [ { MLANG => 'MUMPS' }, # see http://dotnet.di.unipi.it/EcmaSpec/CSharp/cont25.html C.1.4 for C# # perl -ne '$l{$_} = 1 foreach /(\w*[a-z][_]\w*)/g; $m{$_} = 1 foreach /(\w*[a-z][A-Z]\w*)/g; END { print join(" ", keys %l), "\n", join(" ", keys %m), "\n" }' 'camelCase' => "JavaScript CoffeeScript", 'CamelCase or camelCase' => "Haskell Io Java JavaScript Tcl Smalltalk C# E Pascal Mathematica VisualBasic Go", 'underscores' => 'merd FishShell GNU-bc', 'dots' => "Logo", 'hyphens' => "Rebol EmacsLisp CommonLisp Scheme", 'underscores for functions / types, unclear for modules / constructors' => "OCaml", 'UPPER_CASE' => "BourneShell", 'lowercasenoseparator' => 'Matlab', 'underscores, UPPER_CASE for class names' => "Eiffel", 'CamelCase for classes, underscores for methods' => "Python", 'CamelCase for types, underscores for functions, variables, ...' => "Pliant", 'CamelCase for methods, types and modules, underscore for functions' => "F#", 'CamelCase for modules and classes, ALL_CAPS for constants, underscores for functions, variables, ...' => 'Ruby', 'CamelCase for modules and classes, ALLCAPS for macros, underscores for methods, constants and variables' => 'Pike', 'CamelCase for modules, ALL_CAPS for constants, unclear for functions / variables' => "Perl Perl6", 'CamelCase for variables, underscores for predicates' => 'Prolog', 'usually lowercase or underscores, ALL_CAPS for macros' => 'C', 'usually underscores' => "C++", 'Camel_Case' => "Ada", ], 'variable identifier regexp' => [ '[a-zA-Z][a-zA-Z0-9]*' => "PL/I Smalltalk FishShell Mathematica", "[a-zA-Z][_a-zA-Z0-9]*" => "Eiffel Matlab Vimscript", "[a-zA-Z](_?[a-zA-Z0-9])*" => 'Ada', "[_a-zA-Z][_a-zA-Z0-9]*" => 'B C C++ C# E Maple Python PHP Tcl Awk Go', '[_a-zA-Z0-9]+' => "BourneShell Perl Perl6", '[a-zA-Z0-9]+' => "FishShell", "[_a-zA-Z][_a-zA-Z0-9]* or '[^']*'" => "Pliant", '[_a-zA-Z$][_a-zA-Z0-9$]*' => "Java", '[$A-Za-z_\x7f-\uffff][$\w\x7f-\uffff]*' => "CoffeeScript JavaScript", '[a-zA-Z%][a-zA-Z0-9]*' => "MUMPS", "[_a-z][_a-zA-Z0-9]*" => 'Ruby', "[_a-z][_a-zA-Z0-9]*[!?']*" => 'merd', "[_a-z][_a-zA-Z0-9']*" => 'SML OCaml Haskell', "[_a-zA-Z][_a-zA-Z0-9']*" => 'F#', "[_A-Z][_a-zA-Z0-9]*" => 'Prolog Mercury', "[_a-zA-Z!$%&*/:<=>?^][_a-zA-Z!$%&*/:<=>?^0-9.+-]*" => "Scheme", # cooked from http://www.cs.indiana.edu/scheme-repository/R4RS/r4rs_9.html "[a-zA-Z!?@#$_][a-zA-Z0-9!?@#$_]*" => "ClassicREXX", q([_a-zA-Z?!.'+*&|=~-][_a-zA-Z0-9?!.'+*&|=~-]* or
[^0-9[](){}":;/][^ \n\t[](){}":;/]*) => "Rebol", '[a-z][a-z0-9_]*' => "GNU-bc", 'anything without a space and is not a number' => "CommonLisp Forth", ], 'function identifier regexp (if different from variable identifier regexp)' => [ { KIND => 'rare' }, "[_a-zA-Z][_a-zA-Z0-9]*[!?]?" => 'Ruby', "[_a-z][_a-zA-Z0-9]*" => 'Prolog Mercury', "[A-Z][_a-zA-Z0-9]* (for user defined functions only)" => 'Vimscript', '[^ \t\n\r\f]+' => "Tcl", '[^ \t\n\r\f/]+' => "FishShell", ], 'keyword regexp (if different from variable identifier regexp)' => [ { KIND => 'rare' }, '[A-Z]+' => "Modula-3", ], 'type regexp (if different from variable identifier regexp)' => [ { KIND => 'rare' }, "[_A-Z][_a-zA-Z0-9']*" => 'Haskell', "[_a-z][_a-zA-Z0-9']*" => 'OCaml Mercury', ], 'constant regexp (if different from variable identifier regexp)' => [ { KIND => 'rare' }, "[A-Z][_a-zA-Z0-9]*" => 'Ruby', "[_A-Z][_a-zA-Z0-9']*" => 'OCaml Haskell', "[_a-z][_a-zA-Z0-9']*" => 'Mercury', ], ], 'breaking lines (useful when end-of-line and/or indentation has a special meaning)' => [ { MLANG => "Pliant MUMPS Prolog GNU-sed" }, 'nothing needed' => 'Ada B C C++ C# D F# Haskell PHP Maple Mathematica Eiffel PostScript Rebol Java YCP JavaScript Pascal Perl Perl6 OCaml CommonLisp EmacsLisp Scheme SML Smalltalk XSLT Forth Oz Go', '\\' => "Awk Io C Python Ruby Tcl E FishShell BourneShell GNU-bc CoffeeScript", '_' => "VisualBasic", ',' => "ClassicREXX", '~' => "Logo", '...' => "Matlab", ], 'variable assignment or declaration' => [ 'assignment' => [ '=' => "B C C++ C# Io Mathematica Java Perl Perl6 Matlab Pike PHP Basic Erlang Icon Oz JavaScript Lua BourneShell Awk YCP ClassicREXX Yorick Go", ':=' => "BCPL Ada SML Cecil Pascal Mathematica Dylan Eiffel Maple Sather Modula-3 Simula Smalltalk E Pliant", '<-' => "OCaml F#", '_ (displayed <- with a special character)' => "Squeak", ':' => "BCPL Rebol", '-> (variable on the right)' => "Beta", 'def' => "PostScript", 'setq' => "EmacsLisp CommonLisp", 'setf' => "CommonLisp", 'set' => "Rebol CommonLisp FishShell", 'SET v=...' => "MUMPS", 'set!' => "Scheme", 'is' => "Prolog", 'make "v e' => "Logo", 'e v !' => "Forth", ], 'declaration' => [ '=' => "Haskell Prolog Mercury", '<-' => "Haskell", ':-' => "Prolog", ':=' => "Io", 'let v = e in' => "F# OCaml", 'let val v = e in' => "SML", 'let v = e (F#: with indentation)' => "F# BCPL Vimscript", 'def v := e / var v := e' => "E", 'my / our / local / use vars' => "Perl", 'my / our / temp' => "Perl6", 'define' => "Dylan Scheme", 'let let*' => "Scheme CommonLisp", 'letrec' => "Scheme", 'flet labels defun defmethod defvar defparameter defsetf ..' => "CommonLisp", 'local V1 = e V2 = e2 in ... end' => "Oz", 'global v1, v2' => "Python", 'global v1 v2' => "Matlab Scilab", ':@' => "Beta", 'NEW v' => "MUMPS", 'v: t' => "Ada Pascal Eiffel", 't v' => "C C++ C# Java", 'var v t' => "Go", '| v1 v2 |' => 'Smalltalk', 'auto v1, v2; extrn v3, v4;' => "B", 'auto' => "GNU-bc", 'var' => "JavaScript Pliant", 'gvar' => "Pliant", 'variable v (the variable behaves like a pointer)' => "Forth", 'e value v' => "Forth", 'Module[{x, y = v}, ... ]' => 'Mathematica', 'Block[{x, y = v}, ... ]' => 'Mathematica', 'With[{c1 = v1, c2 = v2, ... }, ...]' => 'Mathematica', '' => "XSLT", ], 'both' => [ '=' => "Python Ruby merd GNU-bc CoffeeScript", ':=' => "merd Go", 'set, variable' => "Tcl", ], ], 'grouping expressions' => [ { MLANG => 'EmacsLisp CommonLisp Scheme XSLT PostScript Forth' }, '( ... )' => "Beta BCPL D Io Julia Logo Mathematica Prolog B ClassicREXX Maple C C++ C# Matlab Scilab YCP Java Eiffel Rebol MUMPS MSH Pike Perl Perl6 Python Ruby Pascal Haskell OCaml F# Smalltalk SML merd E Tcl PHP JavaScript Lua Ada Awk Modula-3 Pliant XPath Oz SQL92 Yorick GNU-bc CoffeeScript Go Vimscript", '[ ... ]' => "Rebol", 'indentation' => "merd", '$ ...' => "Haskell", 'begin ... end' => "OCaml F# Ruby FishShell", 'space (cf horizontal layout)' => "merd", ], 'block (grouping statements, especially when statements are not expressions)' => [ { MLANG => 'OCaml Prolog Forth Rebol SML XSLT Mathematica CommonLisp Maple Oz PostScript' }, '{ ... }' => "Pike PHP JavaScript Awk BourneShell Tcl BCPL Yorick GNU-sed GNU-bc", '{ ... } (introduce scope)' => "B C C++ C# Java Perl Perl6 E Haskell Modula-3 YCP Go", '( ... ) (introduce scope)' => "BourneShell", '[ ... ] (Smalltalk: introduce scope)' => "Logo Smalltalk", '"..."' => "Tcl", 'begin ... end (introduce scope)' => "Pascal Ada", '(begin ...)' => 'Scheme', 'BEGIN ... END' => "Modula-3", 'do ... end' => "ClassicREXX", 'do ... end (introduce scope)' => "PL/I Lua", 'indentation' => "Python Pliant MUMPS F# CoffeeScript", 'indentation (introduce scope)' => "Haskell merd", 'foo ... end where foo in { if, do, ... }' => "Modula-2 Ruby", 'foo ... end where foo in { if, for, while, ... }' => "Matlab Scilab", 'foo ... end where foo in { if, loop, ... }' => "Eiffel", 'foo ... end foo where foo in { if, do, ... }' => "Fortran90 Ada", '(* ... *) (ascii representation, original uses a special charset)' => "BCPL", '(# ... #)' => "Beta", ], 'use a block as a return value (when statements are not expressions)' => [ { KIND => 'rare' }, 'valof' => "BCPL", 'do' => "Perl Perl6", "proc() .. end proc" => "Maple", ], 'equality / inequality' => [ 'shallow' => [ '== != ' => "B C C++ Io Java OCaml F# Pike Perl Perl6 Awk Yorick CoffeeScript Go", '= /=' => "Fortran90 Eiffel", '= <>' => "Pliant Forth Rebol Logo Maple Modula-2", '= # (in Modula-2, <> and # are synonyms)' => "Modula-2 Modula-3", "= !=" => "BourneShell FishShell", "== === != !== (=== and !== differ from == and != when the objects' type differ)" => "JavaScript PHP", "=== !==" => "PHP5 Perl6", '== ~=' => "Lua", '== ~~' => "Smalltalk", '== ~==' => "Dylan", "= '=" => "MUMPS", '= ~= neqv (ascii representation, original uses a special charset)' => "BCPL", 'f= f<>' => "Forth", 'is_equal (for objects)' => "Eiffel", 'eq ne' => "EmacsLisp PostScript", 'eq, eql' => "CommonLisp", 'eq? eqv?' => "Scheme", '.EQ. .NE.' => "Fortran", 'is / is not' => "Python", 'is / isnot' => 'Vimscript' ], 'deep' => [ '== !=' => "Awk C++ C# E Ruby Tcl merd Python YCP PHP5 Vimscript", '== <>' => "Python", '== /=' => "Haskell", '== \=' => "Oz", '== \==' => "ClassicREXX Prolog", '= /=' => "Ada", '= !=' => "XPath Maple", '= <>' => "VisualBasic OCaml F# Rebol SML Beta Pascal SQL92", '= ~=' => "Dylan Smalltalk", '== ~= eq ne isequal isequalwithequalnans' => "Matlab", '== ~= eq ne isequal' => "Scilab", '=@= \=@= / = \= / =:= =\= (normal / structural / unification / arithmetic)' => "Prolog", '=== =!= / == != (structural / mathematical)' => "Mathematica", '.eq' => "Logo", 'equal?' => "Scheme", 'equals' => "Java", 'equal' => "EmacsLisp CommonLisp Pike", 'equalp' => "CommonLisp", 'eqv' => "Perl6", 'deep_is_equal' => "Eiffel", 'isEqual' => "Objective-C", ], ], 'comparison' => [ { ALL => 1 }, '' => [ '< > <= >=' => "Ada Awk Io Beta Forth Maple Mathematica Logo B C C++ C# YCP E Matlab Scilab Java Pascal Rebol Smalltalk VisualBasic Scheme Pike Perl Perl6 merd Tcl Haskell Ruby SML OCaml F# PHP Eiffel JavaScript CoffeeScript EmacsLisp CommonLisp Dylan Lua Awk Modula-3 Python Pliant XPath ClassicREXX SQL92 Yorick Vimscript Go", '< > =< >=' => "Mercury Oz", "< > '> '<" => "MUMPS", '<< >> <<= >>= (deep comparison)' => "ClassicREXX", '@< / @=< / @> / @>=' => "Prolog", 'lt gt le ge' => "Perl Perl6 PostScript", '-lt -gt -le -ge' => "BourneShell FishShell MSH", '.LT. .GT. .LE. .GE.' => "Fortran", 'u< u> u<= u>=' => "Forth", 'f< f>' => "Forth", ], 'returns 3 values (i.e. inferior, equal or superior)' => [ { MLANG => 'B C C++ C# Ada Io Logo CommonLisp Awk Modula-3 Lua XSLT Rebol PostScript ClassicREXX Matlab' }, 'a <=> b' => "Ruby Perl Perl6 merd", 'cmp' => "Perl Perl6 Python", 'compare' => "OCaml Forth F# Haskell Prolog Mercury Pliant Smalltalk", 'strcmp' => "PHP C", 'three_way_comparison' => "Eiffel", 'string compare' => "Tcl", 'compareTo' => 'Java', 'strings.Compare()' => 'Go', ], 'returns 4 values (i.e. inferior, equal, superior or not comparable)' => [ { KIND => 'rare' }, 'compare' => "Pliant", 'compareTo' => 'E', ], 'min / max (binary or more)' => [ { MLANG => 'Ruby B C C# Awk XSLT Tcl Go' }, 'min / max' => "Io C++ Java Forth PHP5 Tcl8.5 Rebol Maple Lua Beta Prolog Pike Matlab Scilab Python Smalltalk E Eiffel merd CommonLisp Scheme OCaml F# Haskell Dylan Pliant SQL92 Yorick", 'min minstr / max maxstr (in List::Util)' => "Perl", 'Min / Max' => "Oz Mathematica", 'MIN / MAX' => "Modula-3 ClassicREXX", 'measure-object -min / measure-object -max' => "MSH", 'fmin / fmax' => "Forth", "Integer'min / Integer'max" => "Ada", ], ], 'runtime evaluation' => [ { KIND => 'dynamic', MLANG => "XSLT" }, 'eval' => "Perl Perl6 Ruby Python BourneShell FishShell Scheme EmacsLisp Tcl Matlab PHP JavaScript CommonLisp YCP", "CoffeeScript.eval (just 'eval' evaluates JavaScript)" => "CoffeeScript", 'exec' => "Python", 'evstr / execstr' => "Scilab", 'dostring' => "Lua", 'doString' => "Io", 'evaluate' => "Forth", 'Compiler evaluate:' => "Smalltalk", 'runtime_compile / compile + execute' => "Pliant", 'Compiler.evalExpression or Compiler.parseOzVirtualString' => "Oz", 'compile_string' => "Pike", 'interpret' => "ClassicREXX", 'ToExpression' => "Mathematica", 'run' => "Logo", 'XECUTE' => "MUMPS", 'do / reduce / compose / load' => "Rebol", '[...]' => "Tcl", '=.. (Univ operator)' => "Prolog", ], 'manual memory allocation' => [ { ALL => 1, KIND => 'rare' }, 'allocation' => [ 'malloc' => "C", 'allocate throw' => "Forth", 'new' => "Ada", ], 'deallocation' => [ 'free' => "C", 'free throw' => "Forth", ], ], 'force garbage collection' => [ { MLANG => 'Ada B C C++ Forth Tcl CommonLisp Mathematica Pascal XSLT ClassicREXX MUMPS Matlab FishShell', }, 'doGC' => "Beta", 'GC.start' => "Ruby", 'gc' => "Logo Pike Maple", 'System.gc()' => "Java", 'System.gcDo' => "Oz", 'System.GC.Collect()' => "C# F#", 'gc.collect()' => "Python", 'gc_collect_cycles (starting with PHP 5.3)' => 'PHP5', 'full_collect' => "Eiffel", 'garbage_collect' => "Mercury Prolog", 'collectgarbage' => "Lua", 'Collector collect' => "Io", 'VM.garbageCollect()' => "JavaScript", 'Gc.full_major()' => "OCaml", 'Smalltalk garbageCollect' => "Smalltalk", 'System.Mem.performGC' => 'Haskell', 'incremental garbage collection => not needed' => "Perl Perl6", 'recycle' => "Rebol", 'interp.gc()' => 'E', '(ext:gc)' => "CommonLisp", 'runtime.GC()' => "Go", ], ], 'Functions' => [ 'function call' => [ { ALL => 1 }, '' => [ 'f(a,b,...)' => "Awk B C C++ C# Io CSS Maple Java YCP Matlab Erlang Pike Perl Perl6 Mercury merd Eiffel Python Ruby Pascal E PHP JavaScript CoffeeScript Dylan Lua Ada Awk Modula-3 XPath Prolog Yorick Go", 'f a b ...' => "SML Haskell Logo F# OCaml Rebol Matlab Tcl Pliant BourneShell FishShell MSH", 'f(a,b,...f) or f[a,b,...] depending on the version' => "BCPL", '(f a b ...) (apply f l) ' => "Scheme EmacsLisp CommonLisp", '(funcall f a b ...)' => "EmacsLisp CommonLisp", '{f a b}' => "Oz", '[apply f a b]' => "Tcl8.5", 'f[a,b,...]' => "Mathematica", 'f[a,b,...] or f.call(a,b,...)' => "Ruby", '&$f(a,b,...) or $f->(a,b,...)' => "Perl", '$f.(a,b,...)' => "Perl6", 'f a, b, ...' => "Perl CoffeeScript", 'f, a, b, ... (procedure call)' => "Yorick", 'v = f(a, b, ...) or call f a, b, ...' => "ClassicREXX", 'a b ... f' => "PostScript Forth", # 'a f' => 'Smalltalk', # 'a f: b g: ... (the function is "f: g:")' => "Smalltalk", "(a,b,...)->&f or (a,b,...)->f" => "Beta", 'f:a (in Pliant, special sugar for only one parameter)' => 'FL', 'f@a (only for one parameter)' => "Mathematica", 'a // f (only for one parameter)' => "Mathematica", 'a ~ f ~ b (only for two parameters)' => "Mathematica", '.. [ f, A, B, ...]' => "Prolog", pre(' ') => "XSLT", ], 'with no parameter' => [ 'f' => "Ada Eiffel Io Pascal Forth PostScript Logo Matlab Rebol Ruby Perl MSH Perl6 Mercury Haskell Tcl Pliant BourneShell Prolog Yorick", # Haskell egs: monads 'f()' => "Awk PHP Pike Maple Erlang Python C C++ C# YCP Java E Lua Perl JavaScript CoffeeScript merd OCaml F# SML Go", '(f)' => "Scheme EmacsLisp CommonLisp", '(funcall f)' => "EmacsLisp CommonLisp", '{f}' => "Oz", 'f[]' => "Mathematica", 'f[] or f.call' => "Ruby", '&$f or $f->()' => "Perl", '$f.()' => "Perl6", 'v = f()' => "ClassicREXX", 'call f' => "ClassicREXX Fortran", 'f value (f is a block)' => "Smalltalk", '/' => "XSLT", ], ], 'partial application (in the examples below, a normal call is "f(a,b)")' => [ { KIND => 'functional', ALL => 1, MLANG => "Smalltalk Io Maple Mathematica CommonLisp Scheme Erlang Matlab" }, 'give the first argument' => [ 'f a' => "SML Haskell OCaml F#", 'f(a)' => "Mercury", 'f(a,)' => "merd", '&f.assuming(var_name => a)' => "Perl6", 'functools.partial(f, a) (Python >= 2.5)' => "Python", 'interp alias {} f_a {} f a' => "Tcl", ], 'give the second argument' => [ { MLANG => 'SML Haskell OCaml F#' }, 'f(,b)' => "merd", '&f.assuming(b => b)' => "Perl6", 'flip f b (it does not scale to 3rd argument)' => "Haskell", ], 'give the first argument to operator ">"' => [ '(a >)' => "Haskell merd", '(>) a' => "OCaml F#", ], 'give the second argument to operator ">"' => [ { MLANG => "OCaml F#" }, '(> a)' => "Haskell merd", ], ], 'function definition' => [ '' => [ 'sub f { ... }' => "Perl Perl6", 'sub f($para1, $para2, ...) { ... }' => "Perl6", 'def f(para1, para2, ...): ...' => "Python", 'def f(para1, para2, ...) ... end' => "Ruby", 'def f(para1, para2, ...) ... { ... }' => "E", 'f para1 para2 = ...' => "Haskell", 'let f para1 para2 = ...' => "OCaml F#", 'f(para1, para2, ...) = valof $( ... $)' => "BCPL", 'f(para1, para2, ...) = ...' => "merd", 'f[para1_, para2_, ...] := ... para1 ...' => "Mathematica", 'f ... or f: para1 ...' => "Smalltalk", 'f: func [para1 para2 ...] ...' => "Rebol", '/f { ... } def' => "PostScript", 'f := (para1, para2, ...) -> ...' => "Maple", 'f := method(para1, para2, ..., code)' => "Io", 'func f(a, b, c...) { ... }' => "Yorick", 'typ0 f(typ1 para1, typ2 para2, ...) { ... }' => "C C++ C# Pike YCP", 'function f(para1, para2) { ... }' => "Awk JavaScript PHP5", 'function f(para1, para2) ... code ... end' => "Lua", 'function f; ...; end' => "FishShell", 'function f { ... }' => "KornShell", 'function f { param(para1, [typ2]para2, ...) ... }' => "MSH", '(define (f para1 para2) ...)' => "Scheme", '(defun f (para1 para2) ...)' => "EmacsLisp CommonLisp", 'fun { F Para1 Para2 } ... end' => "Oz", 'fun f para1 para2 = ...' => 'SML', 'proc f {para1 para2} { ... }' => "Tcl", pre('function retval = f(para1, para2) retval = ...') => "Matlab Scilab", pre(':- func f(typ1, typ2, ...) = typ0. f(Para1, Para2, ...) = ...') => "Mercury", pre('function f(para1 : type1; para2 : typ2; ...) return retval is begin ... end f;') => "Ada", pre('function f para1 para2 -> retval arg typ1 para1; arg typ2 para2; arg rettyp retval; ...') => "Pliant", pre('function f(para1 : typ1, para2 : typ2, ...) : retval; var retval : typ0; begin ... end') => 'Pascal', pre('f (para1 : typ1; para2, para3 : typ2; ...) : rettyp is do ... end') => "Eiffel", pre(' ... ') => "XSLT", 'Function f(para1, para2) ... End Function' => "VisualBasic", ': f ... ;' => "Forth", 'f() { ... }' => 'BourneShell KornShell', pre('f : procedure ... return retval') => "ClassicREXX", pre('to f :para1 :para2 ... end') => "Logo", 'func f(para1 typ1, para2 typ2, ...) (typ3, ...) { ... }' => "Go", ], 'procedures' => [ pre('procedure f(para1 : typ1; para2, para3 : typ2); begin ... end') => 'Pascal', pre('f (para1 : typ1; para2, para3 : typ2; ...) is do ... end') => "Eiffel", pre('procedure f(para1 : typ1; para2 : MODE type2; ...) is begin ... end f; MODE ::= | OUT | IN OUT') => "Ada", 'void f(typ1 para1, typ2 para2, ...) { ... }' => "C C++ C# Pike", 'let f(para1, para2, ...) be $( ... $)' => "BCPL", 'proc { F Para1 Para2 } ... end' => "Oz", 'f := proc(para1, para2, ...) ... end proc' => "Maple", 'Sub f(para1, para2) ... End Sub' => "VisualBasic", pre('function f(para1, para2) ...') => "Matlab Scilab", pre('f : procedure ... return') => "ClassicREXX", 'func f(para1 typ1, para2 typ2, ...) { ... }' => "Go", ], 'variable number of arguments' => [ 'one can use overloading on different number of arguments' => "C++ Java", 'sub f { ... @_ }' => 'Perl', 'sub f; ... $argv; end' => 'FishShell', 'f() { ... $@ }' => "BourneShell", 'f := ... ## &' => "Mathematica", 'f[params___] := ... params ...' => "Mathematica", pre('function f(varargin) for i=1:nargin ...(varargin{i}) end') => 'Matlab', pre('function f(varargin) for e=varargin ...(e) end') => 'Scilab', '(args...) -> ...' => 'CoffeeScript', '(lambda x ...) or (lambda (x . y) ...)' => 'Scheme', 'f(args ...typ0) (only final parameter may be variadic and accepts ' . 'zero or more arguments)' => "Go", ], 'predicates' => [ 'f(Para1, Para2, ....) :- ... .' => "Prolog", ], ], 'anonymous function' => [ { KIND => 'has_lambda' }, 'sub { my ($a, $b) = @_; ... }' => "Perl", '{ my ($a, $b) = @_; ... } (when callee has special "&" prototype)' => "Perl", '{ ... } (arguments are in the stack' => "PostScript", '[ ... ]' => "Logo", '{ param(para1, [typ2]para2, ...) ... }' => "MSH", "{|a, b| ... } (this is a block, not precisely a function, but it's alike)" => "Ruby", '[:a :b| ... ]' => 'Smalltalk', '[list {a b} {...}]' => "Tcl8.5", 'lambda a, b: ...' => "Python", 'lambda(typ1 para1, typ2, para2, ...) { ... };' => "Pike", '(a, b) => ...' => "C#3 CoffeeScript", "(a, b) -> ..." => "Maple CoffeeScript", 'a, b -> ...' => "merd", '-> $a, $b { ... }' => "Perl6", '\a b -> ...' => "Haskell", ':noname ...' => "Forth", 'fn (a, b) => ...' => "SML", 'fun a b -> ...' => "OCaml F#", '(func(A, B) = C :- ...)' => "Mercury", 'function(a, b) { ... }' => "JavaScript PHP5", 'function(a, b) use (&$v1, $v2) { ... } (manual declaration of local variables wanted in the closure)' => "PHP5", 'function(a, b) ... end' => "Lua", 'Function[{a, b}, ....] (see also: #1 + #2 &)' => "Mathematica", 'fun(a, b) -> ... end' => "Erlang", 'fun {$ A B} ... end (also works for procedures: proc {$ A B} ... end)' => "Oz", 'func [a b ...] ...' => "Rebol", 'def _(para1, para2, ...) ... { ... }' => "E", 'proc {|a, b| ...}' => "Ruby", 'lambda {|a, b| ...}' => "Ruby", '(lambda (a b) ...)', "Scheme EmacsLisp CommonLisp", "inline('...x...y...') (x, y, z are the parameters)" => "Matlab", 'method(a, b, ...)' => "Io", 'method(a, b) ... end method (method is optional)' => "Dylan", "create_function('$a,$b','...')" => "PHP", 'delegate(ta a, tb b) { ... }' => "C#2", '[](ta a, tb b) { ... }' => "C++-0x", '[](ta a, tb b) -> typ { ... }' => "C++-0x", 'func(para1 typ1, ...) (typ2, ...) { ... }' => "Go", ], 'function return value' => [ { MLANG => 'Prolog PostScript' }, 'breaks the control flow' => ($::return_a_value = [ q(return (in Lua, "return xxx" can only appear before a block end. in Matlab, only in inline('...'))) => "Awk Io B BCPL CommonLisp C Maple C++ C# ClassicREXX FishShell Java E Pike YCP Perl Perl6 Ruby Rebol Python Tcl Ada PHP Pliant JavaScript CoffeeScript BourneShell Yorick Lua Matlab Go Vimscript", 'Return' => "VisualBasic Mathematica", 'RETURN' => "Modula-3", 'resultis ("return" is used when there is no value to return)' => "BCPL", 'return-from xxx' => "CommonLisp", '^' => "Smalltalk", 'Exit Function / Exit Sub' => "VisualBasic", 'exit' => "Forth", 'output' => "Logo", ]), 'function body is the result' => [ 'no syntax needed (in Matlab, only for anonymous function)' => "Maple Io Mathematica Haskell OCaml F# Erlang SML EmacsLisp Tcl Rebol CommonLisp Scheme Perl Perl6 Ruby Dylan Oz Matlab CoffeeScript", ], 'setting the result' => [ 'Result := val' => "Eiffel", ' = val' => "VisualBasic", ' := val' => "Pascal", ' = val;' => "Matlab Ada", ], ], 'function called when a function is not defined (in dynamic languages)' => [ { KIND => 'dynamic', MLANG => 'Logo Oz Forth Rebol ClassicREXX Matlab', }, # in Oz: the function call is postponed until the function gets defined. So the current thread will block, waiting for another thread to define the function. (mechanism of dataflow variables) 'AUTOLOAD' => "Perl", 'AUTOSCALAR, AUTOMETH, AUTOLOAD...' => "Perl6", '__autoload' => 'PHP5', '__getattr__' => "Python", 'method_missing' => "Ruby", 'doesNotUnderstand' => "Smalltalk", '__noSuchMethod__ (firefox)' => "JavaScript CoffeeScript", 'unknown' => "Tcl", 'no-applicable-method' => "CommonLisp", 'doesNotRecognizeSelector' => "Objective-C", 'TryInvokeMember (C#4, only for "dynamic" objects)' => "C#", 'match [name, args] { ... }' => "E", 'the predicate fail' => "Prolog", 'forward' => "Io", ], 'runtime inspecting the caller information' => [ { KIND => 'dynamic', MLANG => 'E Forth CommonLisp Logo' }, 'caller' => "Perl Perl6 Ruby", 'call' => "Io", 'inspect.stack()[1]' => "Python", 'backtrace' => "Pike", 'debug_backtrace' => "PHP5", "trace 'I'" => "ClassicREXX", "evalin('caller', ...)" => "Matlab", 'current_predicate' => "Prolog", 'thisContext sender' => "Smalltalk", 'where(2)' => "Maple", 'info level' => "Tcl", 'runtime.Caller(0)' => "Go", ], 'function composition' => [ { KIND => 'functional', MLANG => 'OCaml Io CommonLisp Smalltalk Matlab Logo', }, '.' => "Haskell", '~' => "merd", 'o' => "SML", '@' => "Maple", 'compose' => 'Dylan', 'Composition' => "Mathematica", '<<' => "F#", '>>' => "F#", ], 'identity function' => [ { KIND => 'functional', MLANG => 'OCaml F# Erlang Logo', }, 'id' => "Haskell", 'identity' => "CommonLisp", 'Identity' => "Mathematica", 'yourself' => "Smalltalk", ], ], 'Control Flow' => [ { MLANG => 'Haskell XSLT' }, 'sequence' => [ { MLANG => "Forth PostScript Oz" }, ',' => "C C++ Perl Matlab Scilab Pike JavaScript Prolog Go", '.' => "Smalltalk", ';' => "Awk Maple Mathematica Beta Io PL/I B C C++ C# Java Matlab YCP Pike Pascal Python Ruby Perl Perl6 OCaml F# SML merd Tcl E PHP JavaScript Ada BourneShell FishShell Haskell Modula-3 Pliant GNU-sed Go", ':' => "Maple", 'nothing, optionally ;' => "Lua ClassicREXX", 'space' => "Eiffel Rebol", 'end-of-line' => "Awk Ruby F# Io Python Lua merd Basic Tcl E Matlab Fortran Assembler JavaScript CoffeeScript BourneShell FishShell Haskell Pliant GNU-sed", '(begin ...)' => "Scheme", '(progn ...) (prog1 ...) (prog2 ...) ' => "EmacsLisp CommonLisp", '>>' => "Haskell", ], 'if_then' => [ { MLANG => "SML Prolog Haskell" }, 'if c then ...' => "OCaml F# Tcl merd Pascal CoffeeScript", 'if c then ... end' => "Ruby Eiffel Lua Oz", 'if c then ... end if' => "Ada Maple", 'if c then ... fi' => "Maple", 'if c; then ... fi' => "BourneShell", 'if (c) then ... end' => "Dylan", 'if c do ...' => "BCPL", 'IF c THEN ... END' => "Modula-2 Modula-3", 'if (c) ...' => "Awk B C C# C++ Java Pike PHP JavaScript YCP", 'if c: ...' => "Python", 'if c ...' => "Pliant Rebol Tcl", 'if (c): ... endif' => "PHP", 'if c {...}' => "Perl6 Go", 'if c [...]' => "Logo", 'if (c) {...}' => "Perl E Yorick", 'IF c ...' => "MUMPS", 'c -> ...' => 'FL', 'c ... if' => "PostScript", '... if c' => "Perl Ruby", 'c if b1 then' => "Forth", '(if c ...)' => "CommonLisp Scheme", '(when c ...)' => "EmacsLisp", 'c and ...' => "Perl Ruby", 'if(c, ...)' => "Io", 'If[c, ...]' => "Mathematica", 'if(c) then(...)' => "Io", 'c ifTrue(...)' => "Io", 'c ifTrue: ...' => "Smalltalk", '...' => "XSLT", 'if c ... endif' => 'Vimscript', 'If c Then ...' => "VisualBasic", pre('If c ... End If') => "VisualBasic", 'if c; ... end' => "Ruby", 'if c; ...; end' => "FishShell", 'if c, ..., end' => "Matlab", pre('if c ... end') => "Ruby Matlab", pre('if c then ; ... if c then ... if c then do ... end') => "ClassicREXX", 'c and ...' => 'Perl', 't label' => 'GNU-sed', pre('if c ...') => 'CoffeeScript', ], 'if_then_else' => [ 'if c then b1 else b2' => "SML OCaml F# Haskell merd CoffeeScript", 'if c then b1 else b2 end' => "Ruby Eiffel Lua", 'if c then b1 elsif c2 then b2 else b3 end if' => "Ada", 'if c then b1 elseif c2 then b2 else b3 end' => "Eiffel Oz", 'if (c) then b1 elseif (c2) then b2 else b3 end' => "Dylan", 'IF c THEN b1 ELSIF c2 THEN b2 ELSE b3 END' => "Modula-3", 'If c Then b1 ElseIf c2 Then b2 Else b3 End If' => "Modula-2", 'if (c) b1 else b2' => "Awk B C C# C++ Pike Java JavaScript YCP", 'if c b1 elsif c2 b2 b3' => "Tcl", 'if c then b1 elseif c2 then b2 else b3' => "Tcl", 'if c then begin b1 end else begin b2 end' => "Pascal", 'if c b1 eif c2 b2 else b3' => "Pliant", 'if c then b1 elif c2 then b2 else b3 end if' => "Maple", 'if c; then b1; elif c2; then b2; else b3; fi' => "BourneShell", 'if c; b1; else b2; end' => "FishShell", 'if c1, b1, elseif c2, b2, else, b3, end' => "Matlab", 'if (c) b1 elseif (c2) b2 else b3' => "PHP", 'if (c): b1 elseif (c2): b2 else: b3 endif' => "PHP", 'if (c) {b1} elsif (c2) {b2} else {b3}' => "Perl", 'if (c) {b1} else {b2}' => "E Yorick", '(if c b1 b2)' => "CommonLisp Scheme", '(if c then b1 else b2)' => "Mercury", '(c -> b1 ; c2 -> b2 ; b3)' => "Mercury", 'c -> b1 ; b2' => "FL", 'if(c, b1, b2)' => "Io", 'If[c, b1, b2]' => "Mathematica", 'if(c) then(b1) else(b2)' => "Io", 'c ifTrue: b1 ifFalse: b2' => "Smalltalk", 'ifelse c [b1] [b2]' => "Logo", 'shunt c b1 c2 b2 b3' => "Pliant", 'either c b1 b2 / if/else c b1 b2' => "Rebol", '(cond (c b1) (c2 b2) (t b3))' => "EmacsLisp CommonLisp", '(cond (c b1) (c2 b2) (else b3))' => "Scheme", 'Which[c, b1, c2, b2, True, b3]' => "Mathematica", 'c -> b1 ; c2 -> b2 ; b3' => "Prolog", 'case when c; b1 when c2; b2 else b3 end' => "Ruby", 'test c then b1 or b2' => "BCPL", 'e | c = b1 | c2 = b2 | otherwise = b3 (the result goes to "e")' => "Haskell", 'c b1 b2 ifelse' => "PostScript", 'c if b1 else b2 then' => "Forth", 'c ? b1 : b2' => "Awk B C C++ C# Java Perl Ruby PHP Tcl JavaScript YCP Yorick", 'c ?? b1 !! b2' => "Perl6", 'b1 if c else b2 (Python >= 2.5)' => "Python", '$SELECT(c:b1,c2:b2,1:b3)' => "MUMPS", 'c -> b1, b2' => "BCPL", '(if c then b1 else b2 fi)' => "Beta", pre(' b1 b2 b3 ') => "XSLT", 'if c1 ... elseif c2 ... else ... endif' => 'Vimscript', 'If c Then b1 Else b2' => "VisualBasic", pre('If c b1 Else b2 End If') => "VisualBasic", pre('if c: b1 elif c2: b2 else: b3') => "Python", pre('if c b1 elsif c2 b2 else b3 end') => "Ruby", pre('if c b1 elseif c2 b2 else b3 end') => "Matlab", pre('if c then ; b1 ; else ; b2 if c then b1 else b2 if c then do b1 ... end else do b2 ... end') => "ClassicREXX", pre('IF c ... ELSE ...') => "MUMPS", pre('if c b1 else if c2 b2 else b3') => "CoffeeScript", 'if c {b1} else if c2 {b2} else {b3}' => "Go", ], 'ifnot_then (unless)' => [ { KIND => 'rare' }, 'unless' => "EmacsLisp Perl CoffeeScript", 'ifFalse' => "Smalltalk", 'if(c) not then(...)' => "Io", ], 'multiple selection (switch)' => [ { MLANG => 'Awk Ruby Python Maple PostScript Lua Pliant Smalltalk XSLT' }, pre('switch (val) { case v1: ...; break; case v2: case v3: ...; break; default: ...; }') => "C C++ Pike Java PHP JavaScript", pre('switch val { case v1: ...; goto done; case v2: case v3: ...; goto done; } ...; done: ') => "B", pre('switch (val) { case v1: ...; break; case v2: case v3: ...; break; default: ...; break; }') . ' ("break"s are mandatory, even for "default"!)' => "C#", pre('switch (val) { match v1 { ... } match v2 { ... } match _ { ... } }') => "E", pre('switchon val case v1: ... case v2: ... default: ...') => "BCPL", pre("switch val case v1 ... case v2 v3 ... case '*' ... end") => "FishShell", pre('switch val case v1 ... case {v2,v3} ... otherwise ... end') => "Matlab", pre('case val of v1 : ...; v2, v3 : ... else ... end') => "Pascal", pre('switch val { v1 {...} v2 - v3 {...} default {...} }') => 'Tcl', pre('case val in v1) statement1 ;; v2|v3) statement23 ;; *) statement_else ;; esac') => "BourneShell", pre('(if val // v1 then ... // v2 then ... else ... if)') => "Beta", pre('match val with | v1 -> ... | v2 | v3 -> ... | _ -> ...') => "OCaml F#", pre('case val of v1 => ... | v2 => ... | _ => ...') => "SML", pre('CASE val OF v1 => ... | v2 => ... ELSE => ... END') => "Modula-3", pre('case val of v1 -> ... v2 -> ... _ -> ...') => "Haskell", pre('val case v1 of ... endof v2 of ... endof ... endcase') => "Forth", pre('val. v1 -> ... v2 -> ... _ -> ...') => "merd", pre('(case val ((v1) ...) ((v2) ...) (otherwise ...))') => "CommonLisp", pre('(case val ((v1) ...) ((v2) ...) (else ...))') => "Scheme", pre('case val is when v1 => ... when v2 | v3 => ... when others => ... end case;') => "Ada", pre('case val when v1; ... when v2, v3; ... else ... end') => "Ruby", pre('inspect val when v1 then statement1 when v2, v3 => statement23 else statement_else end') => "Eiffel", pre('select (val); when (v1) statement1; when (v2, v3) statement23; otherwise statement_else; end;') => "PL/I", pre('X = val, (X = v1, ... ; X = v2, ... ; ...)') => "Prolog Mercury", pre('my %case = ( v1 => sub { ... }, v2 => sub { ... }, ); if ($case{val}) { $case{val}->() } else { ... }') => "Perl", pre('use Switch; switch ($val) { case v1 { ... } case v2 { ... } else ... })') . ' (Perl >= 5.8.0)' => "Perl", pre('given $val { when v1 { ... } when v2 { ... } default { ... } }') => "Perl6", pre('Select val Case v1 ... Case v2, v3 ... Case Else ... End Select') => "VisualBasic", pre('switch (val) { v1 { ... } v2 { ... } default { ... } }') => "MSH", pre('switch val [ v1 [...] v2 [...] ] switch/default [ v1 [...] v2 [...] ][...]') => "Rebol", 'val caseOf: {[v1]->[...]. [v2]->[...]} otherwise: ...' => "Squeak", 'Switch[val, v1, ..., v2, ..., _, ...]' => "Mathematica", pre('select when v1 ... when v2 | v3 ... otherwise ... end') => "ClassicREXX", pre('CASE val WHEN v1 THEN ... WHEN v2 THEN ... ELSE ... END') => "SQL92", pre('switch val { case v1, v2, ...: ... fallthrough case v3: ... default: ... }') => "Go", ], 'loop' => [ { ALL => 1 }, 'forever loop' => [ { MLANG => 'Awk B Maple C C++ C# Tcl Scheme Java Prolog E Lua Matlab Pascal JavaScript Haskell Perl Python OCaml F# FishShell Smalltalk SML Tcl Eiffel Pliant' }, # Haskell would be: loop f = f >> loop f 'loop' => "Ruby merd PostScript Perl6 CoffeeScript", 'loop(...)' => "Io", 'loop ... end loop' => "Ada", 'LOOP ... END' => "Modula-3", '(loop do ...)' => "CommonLisp", "cycle (# do ... #) " => "Beta", 'repeat' => "Squeak", 'begin ... again' => "Forth", 'forever' => "Rebol Logo", pre('Do ... Loop') => "VisualBasic", pre('do forever ... end') => "ClassicREXX", 'for {}' => "Go", ], 'while condition do something' => [ { MLANG => 'Prolog Scheme' }, 'while (c) ...' => "Awk B C C++ C# Java E Pike Perl Ruby PHP JavaScript YCP Yorick", 'while c ...' => "Tcl Perl6 CoffeeScript", 'while c loop ... end loop' => "Ada", 'while c do ...' => "BCPL SML Pascal", 'while c do ... done' => "OCaml F#", 'while c do ... end do' => "Maple", 'while c do ... end' => "Lua", 'WHILE c DO ... END' => "Modula-3", 'while c: ...' => "Python", 'while c; do ...; done' => "BourneShell", 'while c; ...; end' => "FishShell", 'while c, ..., end' => "Matlab", 'while [c][...]' => "Rebol", 'while c [...]' => "Logo", 'while(c, ...)' => "Io", 'While[c, ...]' => "Mathematica", 'do.while [...] c' => "Logo", 'c whileTrue: ...' => "Smalltalk", '(loop while c do ...)' => "CommonLisp", 'loop (# while ::< (# do c -> value #) do ... #) ' => "Beta", 'begin c while ... repeat' => "Forth", 'from until not c loop ... end' => "Eiffel", pre(q(while c ...)), => "Pliant", pre(q(while c do ...)), => "F#", pre('Do While c ... Loop') => "VisualBasic", 'while c ... endwhile' => 'Vimscript', pre('do while c ... end') => "ClassicREXX", 'for c {...}' => "Go", ], 'do something until condition' => [ { MLANG => 'Python Maple Scheme Io OCaml F# SML Eiffel Matlab Pliant Smalltalk Tcl Go' }, 'do ... until c' => "Perl6", 'do {...} until c' => "Perl", 'do ... while (!c) ' => "C C++ C# Java Awk Pike JavaScript Yorick", 'begin ... end until c' => "Ruby", 'begin ... c until' => "Forth", 'REPEAT ... UNTIL c' => "Modula-3", 'loop (# until ::< (# do c -> value #) do ... #) ' => "Beta", 'loop ... exit when c; end loop' => "Ada", '(loop do ... until c)' => "CommonLisp", '... repeatuntil c' => "BCPL", 'repeat ... until c' => "Lua Pascal", 'repeat ... until (c) ' => "YCP", 'repeat, ..., c' => "Prolog", 'until [... c]' => "Rebol", 'until c [...]' => "Logo", 'do.while [...] c' => "Logo", 'While[...; c]' => "Mathematica", '[...] whileFalse: [c]' => "Smalltalk", pre('Do ... Loop Until c') => "VisualBasic", ], 'for each value in a numeric range, 1 increment (see also the entries about ranges)' => [ { MLANG => 'SML Eiffel Prolog' }, 'for (int i = 1; i <= 10; i++) ...' => "C C# C++", 'for (i = 1; i <= 10; i++) ...' => "Awk JavaScript", 'for ($i = 1; $i <= 10; $i++) ...' => "PHP", 'foreach my $i (1 .. 10) { ... }' => "Perl", 'foreach ($i in 1..10) { ... }' => "MSH", 'for (1 .. 10) -> $i { ... }' => "Perl6", 'for i = 1:10, ..., end' => "Matlab", 'for i = 1, 10 do ... end' => "Lua", 'for i := 1 to 10 do ...' => "Pascal", 'for i = 1 to 10 do ... done' => "OCaml F#", 'For i = 1 To 10 ... Next' => "VisualBasic", 'for i in 1 .. 10 loop ... end loop' => "Ada", 'for i in 1 .. 10 do ... done' => "F#", 'for i in [1..10] ...' => "CoffeeScript", 'for i in xrange(1, 11)' => "Python", 'for i in (seq 10); ...; end' => "FishShell", # 'for i in `seq 1 10`; do ...; done' => "BourneShell", seq is non standard 'FOR I=1:1:10 ...' => "MUMPS", 'for i from 1 to 10 do ... end do' => "Maple", 'for [i 1 10 +1] [...]' => "Logo", 'for {set i 1} {$i <= 10} {incr i} {...}' => "Tcl", '1 1 10 ... for' => "PostScript", '11 1 do ... loop' => "Forth", '(1..10).each {|i| ... }' => "Ruby", '1.upto(10) {|i| ... }' => "Ruby", '1 to(10) foreach(...)' => "Io", '1 to: 10 do: [...]' => "Smalltalk", '(loop for i from 1 to 10 do ...)' => "CommonLisp", 'do label i = 1, 10' => "Fortran", 'Do[..., {i, 1, 10}] (1 is optional in this example, since min is 1 by default)' => 'Mathematica', pre('do i = 1 for 10 ... end') => "ClassicREXX", 'for i := 1; i <= 10; i++ {...}' => "Go", ], 'for each value in a numeric range, 1 decrement' => [ { MLANG => 'SML Eiffel Prolog' }, 'for X := 10 downto 1 do ...' => "Pascal", 'for i = 10 downto 1 do ... done' => "OCaml F#", 'for i in reverse 1 .. 10 loop ... end loop' => "Ada", 'for i in 10 .. -1 .. 1 do ... done' => "F#", 'for (int i = 10; i >= 1; i--) ...' => "C C# C++", 'for (my $i = 10; $i >= 1; $i--) { ... }' => "Perl", 'loop (my $i = 10; $i >= 1; $i--) { ... }' => "Perl6", 'for (i = 10; i >= 1; i--) ...' => "Awk JavaScript", 'for ($i = 10; $i >= 1; $i--) ...' => "PHP", 'from i := 10 until i < 1 loop ... i := i - 1 end' => "Eiffel", 'for i = 10:-1:1, ..., end' => "Matlab", 'for i = 10, 1, -1 do ... end' => "Lua", 'For i = 10 To 1 Step -1 ... Next' => "VisualBasic", 'for i in xrange(10, 0, -1)' => "Python", 'for i in `seq 10 -1 1`; do ...; done' => "BourneShell", 'for i in (seq 10 -1 1); ...; end' => "FishShell", 'for i from 10 to 1 by -1 do ... end do' => "Maple", 'for [i 1 10 -1] [...]' => "Logo", 'FOR I=10:-1:1 ...' => "MUMPS", 'for {set i 10} {$i >= 1} {incr i -1} {...}' => "Tcl", '10 -1 1 ... for' => "PostScript", '1 10 do ... -1 +loop' => "Forth", '1 to: 10 by: -1 do: [...]' => "Smalltalk", '10 to(1) foreach(...)' => "Io", '10.downto(1) {|i| ... }' => "Ruby", '(loop for i from 1 to 10 by -1 do ...)' => "CommonLisp", 'do label i = 10, 1, -1' => "Fortran", 'Do[..., {i, 10, 1, -1}]' => 'Mathematica', pre('do i = 10 to 1 by -1 ... end') => "ClassicREXX", 'for i in [10..1] ...' => "CoffeeScript", 'for i := 10; i >= 1; i-- {...}' => "Go", ], 'for each value in a numeric range, free increment' => [ { MLANG => 'SML OCaml Eiffel Prolog' }, 'for (int i = 1; i <= 10; i += 2) ...' => "C C# C++ Pike", 'for (i = 1; i <= 10; i += 2) ...' => "Awk JavaScript", 'for ($i = 1; $i <= 10; $i += 2) ...' => "PHP", 'for (my $i = 1; $i <= 10; $i += 2) { ... }' => "Perl", 'loop (my $i = 1; $i <= 10; $i += 2) { ... }' => "Perl6", 'from i := 1 until i > 10 loop ... i := i + 2 end' => "Eiffel", 'for i = 1:3:10, ..., end' => "Matlab", 'for i = 1, 10, 2 do ... end' => "Lua", 'For i = 1 To 10 Step 2 ... Next' => "VisualBasic", 'for i in 1 .. 2 .. 10 do ... done' => "F#", 'for i in xrange(1, 11, 2)' => "Python", # 'for ((x = 1; x <= 10; x += 2)); do ...; done' => "BourneShell", it must be bash 'for i in (seq 1 2 10); ...; end' => "FishShell", 'for i from 1 to 10 by 2 do ... end do' => "Maple", 'for [i 1 10 2] [...]' => "Logo", 'FOR I=1:2:10 ...' => "MUMPS", 'for {set i 0} {$i <= 10} {incr i 2} {...}' => "Tcl", '1 2 10 ... for' => "PostScript", '11 1 do ... 2 +loop' => "Forth", '1 to: 10 by: 2 do: [...]' => "Smalltalk", '(1..10).step(2) {|i| ... }' => "Ruby", '1 to (9,2) foreach(...)' => "Io", '(loop for i from 1 to 10 by 2 do ...)' => "CommonLisp", 'do label i = 1, 10, 2' => "Fortran", 'Do[..., {i, 1, 10, 2}]' => 'Mathematica', pre('do i = 1 to 10 by 2 ... end') => "ClassicREXX", 'for i in [1..10] by 2 ...' => "CoffeeScript", 'for i := 1; i <= 10; i += 2 {...}' => "Go", ], 'for "a la C" (while + initialisation)' => [ { MLANG => 'Ada B Pascal Maple Python Prolog Rebol Matlab OCaml F# Smalltalk SML CommonLisp Ruby Pliant ClassicREXX FishShell' }, 'for' => "Awk C C++ C# Java Perl Pike Tcl Mathematica PHP MSH JavaScript Yorick Go", 'loop' => "Perl6", 'for ((x = 0; x < 10; x++)); do ...; done' => "BourneShell", 'from init_code until c loop ... incr_statement end' => "Eiffel", '(loop with VAR = INITIAL-VALUE ... while CONDITION finally INCREMENT ...)' => 'CommonLisp', # 'for var in range loop exp end loop' => "Ada", ], ], 'breaking control flow' => [ { ALL => 1, MLANG => "OCaml Forth F# SML Beta Prolog PostScript Eiffel Oz", }, 'returning a value' => $::return_a_value, 'goto (unconditional jump)' => [ { MLANG => 'Awk Tcl Prolog Ruby Maple merd Beta E Matlab Python Lua PostScript Smalltalk Java Pliant JavaScript FishShell' }, 'goto' => "BCPL B C C++ C# Perl PHP5 Basic Logo MUMPS Pascal Fortran Cobol Ada Yorick Go", 'Goto' => "Mathematica", 'go throw' => "CommonLisp", 'signal' => "ClassicREXX", 'b' => 'GNU-sed', 'b, bra, jmp' => 'Assembler', ], 'continue / break' => [ { MLANG => 'B Prolog Smalltalk' }, 'continue / break' => "Awk C Tcl Io C++ C# Java E Matlab Pike JavaScript CoffeeScript Python PHP YCP Yorick FishShell Go", 'Continue / Break' => "Mathematica",, 'next / last' => "Perl Perl6", 'next / break (in Ruby, see also catch/throw)' => "Maple Ruby", '/ break' => "BCPL Lua", '/ break/return' => "Rebol", '/ exit' => "Ada PostScript", '/ stop' => "Logo", "restart / leave" => "Beta Pliant", '/ Exit Do, Exit For' => "VisualBasic", '/ return-from xxx or return' => "CommonLisp", 'iterate / leave' => "ClassicREXX", '/ leave' => "Forth", ], 'redo / retry' => [ { KIND => 'rare' }, 'redo/' => "Perl Perl6", 'redo / retry' => "Ruby Io", ], ], 'exception' => [ { ALL => 1, MLANG => 'Awk B C XSLT Pascal FishShell' }, 'throwing' => [ { MLANG => 'Scheme' }, 'raise' => "Python SML OCaml F# Scheme-SRFI34 merd Ruby Eiffel Ada", 'RAISE' => "Modula-3", 'raise ... end' => "Oz", 'Exception raise' => "Io", 'throw' => "C# C++ Java Prolog PHP5 Pike Logo Forth E Erlang Rebol JavaScript CoffeeScript Haskell", 'Throw' => "Mathematica", 'throw/name' => "Rebol", 'die' => "Perl Perl6", 'return -code' => "Tcl", 'error' => "EmacsLisp Maple CommonLisp Dylan Matlab Lua Pliant Lua Yorick", 'signal' => "CommonLisp Dylan Smalltalk", 'signal predefined_condition_name' => "ClassicREXX", 'cerror warn' => "CommonLisp", '[NSException raise:name ...]' => "Objective-C", 'panic(v)' => "Go", ], 'catching' => [ { MLANG => 'Scheme' }, 'try: a except exn: ...' => "Python", 'try a with exn -> ...' => "OCaml F#", 'try a catch (exn) ...' => "C++ C# Java JavaScript", pre('try a ... catch exn ...') => "CoffeeScript", 'try { ... } catch(t $v) { ... }' => 'PHP5', 'try a catch exn then ... end' => "Oz", 'try a catch exn: ... end try' => "Maple", 'try(a) ; catch(...)' => "Io", 'try { a CATCH exn { ... } }' => "Perl6", 'TRY a EXCEPT exn => ... END' => "Modula-3", 'a handle exn => ...' => "SML", 'a on: exception_name do: [:exn | ...]' => "Smalltalk", 'ifCurtailed' => "Smalltalk", 'rescue' => "Eiffel Ruby", 'eval {a}; if ($@) ...' => "Perl", 'exception when exception_name =>' => "Ada", 'catch a (\exn -> ...) ' => "Haskell", 'catch' => "Erlang Prolog Forth Logo Rebol Tcl", 'Catch' => "Mathematica", 'catch/name' => "Rebol", 'catch(...) or catch { ... };' => "Pike", 'if (catch(exn)) { ... } a' => "Yorick", 'pcall' => "Lua", 'with-exception-handler or guard' => "Scheme-SRFI34", 'block a exception(exn) ... end' => "Dylan", '?, shy, safe' => "Pliant", 'handler-bind handler-case ignore-errors' => "CommonLisp", 'NS_DURING a NS_HANDLER ... NS_ENDHANDLER' => "Objective-C", pre('try a catch ... end') => "Matlab", pre('signal on predefined_condition_name ... predefined_condition_name : ... ') => "ClassicREXX", 'recover()' => "Go", ], 'cleanup: code executed before leaving' => [ { KIND => 'rare' }, 'ensure' => "Smalltalk Ruby", # ensure is there in Eiffel but is meant for postconditions, and is turned down when optimising 'finally' => "C# F# Java Maple Python", 'FINALLY' => "Modula-3", 'unwind-protect' => "EmacsLisp CommonLisp", 'cleanup' => "Dylan", 'dynamic-wind' => "Scheme", ], 'retrying: after catching an exception, tell the snippet to be re-run' => [ { KIND => 'rare' }, 'retry' => "Eiffel Smalltalk Ruby", 'restart' => "Dylan", ], 'resume execution where the exception took place' => [ { KIND => 'rare' }, 'resume' => "Smalltalk", ], ], 'call-with-current-continuation' => [ { KIND => 'rare' }, 'call-with-current-continuation (often provided in the abbreviated form call/cc)' => 'Scheme', 'callcc' => 'Ruby SML-NJ', ], ], 'Types' => [ { KIND => 'typed' }, 'declaration' => [ { MLANG => 'Smalltalk' }, 'typedef t n' => "C C++ Pike", 'type n is t' => "Ada", 'type n ...' => "Pliant", 'type n = t' => "OCaml F# Haskell SML Pascal", 'TYPE n = t' => 'Modula-3', 'using n = ...' => "C#", 'data n = t' => "Haskell", 'datatype n = t' => "SML", 'newtype n = t' => "Haskell", 'n = t' => "merd Python", 'n : t ' => "Beta", "(deftype n () 't)" => "CommonLisp", 'type n t' => "Go", ], # datatype declaration # # Haskell: data T = C1 t u ... | C2 v ... # newtype T = C1 t u ... # SML: datatype T = C1 of t u ... | C2 of v ... 'annotation (or variable declaration)' => [ { MLANG => 'Smalltalk' }, ':' => "SML Pascal OCaml F# Eiffel E Ada Modula-3", '::' => "Haskell Mercury Dylan", '!!' => "merd", 't v' => "C C++ C# Java Pike Pliant Perl6 YCP", '(declare (t v))' => "CommonLisp", 'v :@ t' => "Beta", '_t (matches an expression of type t)' => "Mathematica", 'var n t' => "Go", ], 'cast' => [ { MLANG => "Smalltalk SML" }, 'upcast' => [ '(t) e' => "C C++ C# Java PHP", 't(e)' => "Pascal Ada", '[t] e' => "Pike", 'static_cast(e)' => "C++", 'e :> t' => "OCaml", 'e : t'=> "F#", 'upcast e' => "F#", 'CAST(e as t)' => "SQL92", 'typecast(e,t)' => "Matlab", '(t)(e)' => "Go", ], 'downcast (need runtime checking)' => [ '(t) e' => "Java", 't(e)' => "Ada", 'e : t' => "E", '[t] e' => "Pike", 'dynamic_cast(e)' => "C++", 'e as t' => "C#", 'e :?> t' => "F#", 'downcast e (type is infered)' => "F#", 'v ?= e (expression "e" is cast to the type of "v")' => "Eiffel", 'NARROW(e, t)' => "Modula-3", 'typecast(e,t)' => "Matlab", ], 'computed conversion (calls an internal or a user-defined function)' => [ '(t) e' => "C++ Pike", '[t] e' => "MSH", 't(e)' => "Python C++ Matlab", 't e' => "F#", 'e : t' => "E", 'e :: t' => "Haskell", #- eg: 11111111111111111111 :: Int is allowed even if overflow 'cast e t' => "Pliant", '... cast t' => "Pliant", 'make t e / to t e' => "Rebol", ], ], 'mutability, constness' => [ { ALL => 1, MLANG => "Smalltalk Eiffel" }, 'type of a mutable value' => [ 'mutability is the default' => "C C++ Java Matlab C# Go", 'val x: T' => "Pascal", 'T ref' => "SML OCaml F#", 'STRef a T' => "Haskell", 'in out T (for parameters)' => "Ada", ], 'type of a constant value' => [ { MLANG => "C C# Matlab" }, 'const T' => "C99 C++", 'constant T' => "Ada", 'const x: T' => "Pascal", 'constness is the default' => "SML OCaml F# Haskell", 'const e t' => "Go", ], 'special cases' => [ { KIND => 'rare' }, '"readonly" fields (quite bad: only the reference is non-mutable whereas the object is still mutable)' => "C#", '"final" fields, parameters, local variables (quite bad: only the reference is non-mutable whereas the object is still mutable)' => "Java", ], ], ], 'Object Oriented & Reflexivity' => [ { KIND => 'OO', MLANG => 'Tcl Mathematica', }, 'method invocation' => [ { ALL => 1 }, '' => [ 'object.method(para)' => "C++ C# F# Java Ada E MSH Python Perl6 Beta Cecil Delphi-Kylix Eiffel Sather Modula-3 Ruby VisualBasic Icon merd JavaScript CoffeeScript", 'object#method para' => "OCaml", 'object:method(para)' => "Lua", 'object method(para)' => "Io", 'object method para' => "Tcl Pliant", 'object method: para1 method_continuation: para2' => "Smalltalk", 'object <- method(para) (eventual send)' => 'E', '[ object method: para ]' => "Objective-C", 'object->method(para)' => "Pike Perl PHP C++", 'object["method"](para)' => "Pike", 'object/method para' => "Rebol", 'method object para' => "Haskell Mercury", '(method object para)' => "CommonLisp", 'method(object, para)' => "Dylan Ada Matlab", 'para->method' => "Beta", '(send object method para)' => "MzScheme", ], 'with no parameter' => [ 'object.method' => "merd Ruby Ada Eiffel F# Perl6", 'object.property (properties are something alike attributes, but really are methods)' => "C#", 'object.method()' => "C# C++ Java E Python JavaScript CoffeeScript", 'object#method' => "OCaml", 'object:method' => "Pliant", 'object->method' => 'Perl', 'object->method()' => "Pike PHP5", 'object/method' => "Rebol", 'object["method"]()' => "Pike", 'object method' => "Smalltalk Io", '[ object method ]' => "Objective-C", 'method object' => "Haskell Mercury", '(method object)' => "CommonLisp", 'method(object)' => "Dylan Ada Matlab", '(send object method)' => "MzScheme", ], ], 'object creation' => [ { MLANG => 'Io' }, 'new' => "Simula PHP Pliant", 'new class_name(...)' => "C++ C# F# Java Perl JavaScript CoffeeScript VisualBasic PHP", 'new class_name ...' => "OCaml CoffeeScript", 'class_name.new(...)' => "Ruby Perl6", 'class_name new' => "Smalltalk", 'class_name(...)' => "Pike Python F# Matlab", 'class_name v(...)' => "C++", 'v : class_name' => "Ada", 'class_name.Create' => "Delphi-Kylix", '!class_name!constructor_name(...)' => "Eiffel", '&' => "Beta", 'make-object' => "MzScheme", '(make-instance class_name ...)' => "CommonLisp", '[class_name alloc]' => "Objective-C", 'make class_name! ...' => "Rebol", 'def object_name { ... }' => "E", ], 'object cloning' => [ { MLANG => 'E CommonLisp' }, 'o.clone' => "Perl6", 'o.clone (one level depth)' => "Ruby Eiffel", 'o.deep_clone' => "Eiffel", 'o.clone()' => "Java", 'o.Clone()' => "C#", 'clone $o' => "PHP5", 'o clone' => "Io", 'clone / copy or deepCopy' => "Smalltalk", 'Storable::dclone' => "Perl", '[o copy]' => "Objective-C", 'copy.copy(o) (general deep copy function)' => "Python", 'purecopy' => "EmacsLisp", '{< >} or Oo.copy o' => "OCaml", 'o2 = o (object cloning is the default, uses the copy constructor in C++)' => "C++ PHP Matlab", '$o2 = $o' => "PHP", 'o2.all := o.all' => "Ada", 'make o []' => "Rebol", "o_ : T'Class := o (or simply o_ := o for non-polymorphic objects)" => "Ada", ], "manually call an object's destructor" => [ { MLANG => 'OCaml Tcl Io Eiffel E Ada CommonLisp Smalltalk Matlab Ruby Java' }, 'delete' => "C++ JavaScript", 'destroy' => "Pike", 'DESTROY' => "Perl", 'dealloc' => "Objective-C", 'Dispose' => "C# F#", 'del, __del__' => "Python", '__destruct' => 'PHP5', 'Requires instantiation of Ada.Unchecked_Deallocation' => "Ada", ], 'class declaration' => [ { MLANG => "Perl Io E" }, 'class' => "C# C++ Java Perl6 Matlab Pike Ruby Python OCaml Haskell PHP MzScheme CoffeeScript", 'class c inherit p1 p2 ... feature decl decl ... end' => "Eiffel", 'defclass defstruct' => "CommonLisp", 'subclass' => 'Smalltalk', 'struct' => 'C++', 'type' => "Pliant", "type c is tagged record ... end record (c'Class is the class rooted in c)" => 'Ada', '@interface c { ... } ... @end' => "Objective-C", ':' => "Beta", 'type c() = class ... end' => "F#", pre('type c() = ...') => "F#", ], 'testing class membership' => [ { MLANG => 'OCaml Io' }, 'isa' => "Perl Matlab", 'is_a? kind_of?' => "Ruby", 'o.meta.isa' => "Perl6", 'isKindOf (see also isMemberOf)' => "Smalltalk", 'isKindOfClass' => "Objective-C", 'dynamic_cast' => "C++", 'instanceof' => "Java JavaScript CoffeeScript PHP5", 'isinstance' => "Python", 'in' => "Ada", 'is' => "C#", 'is_a' => "PHP", ':?' => "F#", 'Program.inherits or Program.implements' => "Pike", 'entry_type' => "Pliant", 'typep' => "CommonLisp", 'ISTYPE' => 'Modula-3', 'object## < classname##' => "Beta", 'type.accepts(object) / object =~ v : type' => "E", 'var ?= val (assignment attempt)' => "Eiffel", ], 'get the type/class corresponding to an object/instance/value' => [ { KIND => 'reflexive' }, 'class' => "Ruby Smalltalk Matlab Objective-C", '__class__' => "Python", 'getClass' => "Java", 'get_class' => 'PHP', 'GetType' => "F#", 'typeid' => "C++", 'typeof' => "C# JavaScript CoffeeScript", 'type-of' => "CommonLisp", 'type' => "Io", 'ref' => "Perl", 'generator' => "Eiffel", 'meta' => "Perl6", 'object_program' => "Pike", 'getAllegedType' => "E", ], 'methods available' => [ { KIND => 'reflexive', MLANG => "Perl CommonLisp Pliant" }, 'methods' => "Ruby Matlab", 'get_class_methods' => "PHP", 'getMethods' => "Java", 'get-member' => "MSH", 'indices' => "Pike", 'o.meta.getmethods' => "Perl6", 'dir' => "Python", 'slotNames' => "Io", 'o.GetType().GetMethods()' => "F#", 'o class selectors / o class allSelectors' => "Smalltalk", 'o.__getAllegedType().getMessageTypes()' => "E", ], 'inheritance' => [ "child :< parent " => "Beta", "class child : parent" => "C# C++", 'class child < parent end' => "Ruby", 'class child is parent { ... }' => "Perl6", "class child extends parent" => "Java CoffeeScript PHP5", "class child(parent):" => "Python", 'class child inherit parent end' => "Eiffel", 'parent subclass: child' => "Smalltalk", 'make parent ...' => "Rebol", 'inherit' => "Pike OCaml", 'def child extends makeSuperObject(parent, ...) { ... }' => "E", 'type child is new parent with record ... end record' => "Ada", pre('type child = inherit parent ...') => "F#", '(defclass child (parent) ...)' => "CommonLisp", '@interface child : parent { ... } ... @end' => "Objective-C", '@ISA = qw(parent1 parent2)' => "Perl", 'clone , setProtos, setProto, prependProto, appendProto' => "Io", 'instance Parent Child where ...' => "Haskell", ], 'has the method' => [ { KIND => 'reflexive dynamic' }, 'can' => "Perl Perl6", 'respond_to?' => "Ruby", 'respondsTo' => "E Smalltalk", 'respondsToSelector' => "Objective-C", 'hasattr(obj, "meth") (see also callable(obj.meth) for unbound methods)' => "Python", 'object->method' => "Pike", "all [in object 'method function? get in object 'method]" => "Rebol", 'find-method' => "CommonLisp", 'ismethod' => "Matlab", 'hasSlot' => "Io", 'try obj.GetType().GetMethod("meth") with ...' => "F#", 'obj.meth? instanceof Function' => 'CoffeeScript', 'method_exists' => 'PHP5', ], 'current instance' => [ { MLANG => 'OCaml' }, # OCaml can access current instance by binding it to a name 'this' => "C++ C# Java JavaScript CoffeeScript Pike PHP Beta", 'THIS' => "Simula", 'self' => "Smalltalk Io Rebol Ruby Objective-C", 'object_name if defined as: def object_name { ... }' => "E", 'Current' => 'Eiffel', 'first parameter (in Python, usually called self)' => "Perl Python Matlab Pliant", 'the object variable' => "F#", 'dispatching parameter' => "Ada CommonLisp", 'Me' => "VisualBasic", '.' => "Perl6", ], 'accessing parent method' => [ { MLANG => 'Python C++ OCaml' }, 'super' => "Java E Smalltalk Ruby Objective-C CoffeeScript", 'super(Class, self).meth(args)' => "Python", 'base' => "C#", 'resend' => "Io", 'Precursor' => "Eiffel", '$o.SUPER::method(...)' => "Perl6", '$o->SUPER::method(...)' => "Perl", 'method(parent(dispatching-parameter))' => "Ada", 'parent(dispatching-parameter).method' => "Ada", 'parent::method' => 'PHP5', 'call-next-method' => "CommonLisp", pre('type foo2 = inherit foo as parent ... member ... = ... parent.meth') => "F#", ], 'accessing child method' => [ { KIND => 'rare' }, "inner" => "Beta", ], ], 'Package, Module' => [ { MLANG => 'C Awk Forth Eiffel Pliant EmacsLisp Logo Smalltalk ClassicREXX JavaScript CoffeeScript' }, # For JavaScript (and CoffeeScript), it depends on the host environment 'package scope' => [ '.' => "C# Java F# Python Ruby Modula-3 SML OCaml Pascal E Ada Haskell Squeak CoffeeScript Go", ':' => "XML", '::' => "C++ Ruby Perl merd Tcl YCP Squeak", ': :: (":" is for external symbols only, recommended)' => "CommonLisp", ':-' => "Maple", "'" => "Perl", '`' => "Mathematica", '__' => "Mercury", '/' => "Matlab", ], # many info taken from http://www.cs.odu.edu/~zeil/cs355/Lectures/3modoop/modules_summary.pdf 'declare' => [ '' => [ 'package p;' => "Perl Java", 'namespace p { ... }' => "C++ C#", 'namespace p ...' => "F#", 'namespace P;' => 'PHP5', 'namespace eval p ...' => "Tcl", 'module p where ...' => "Haskell", 'module P ... end' => "Ruby", 'module P = struct ... end' => "OCaml", '{ module "p"; ... }' => "YCP", ':- module(p)' => "Prolog", 'p = module() ... end module' => "Maple", "(defpackage p ...)" => "CommonLisp", 'automatically done based on the file name' => "Python OCaml Tcl8.5", 'package declare (directory name is package name)' => "Matlab", 'Begin["p`"] ... End[]' => "Mathematica", 'BeginPackage["p`"] ... EndPackage[]' => "Mathematica", ' ... ' => "XML", pre('package p is -- Declare public package members here private -- Declare private package members here end p; package body p is ... -- Define package implementation here end p;') => "Ada", 'package p' => "Go", ], 'selective export' => [ 'module p (name1, name2, ...) where ...' => "Haskell", '@ISA = qw(Exporter); @EXPORT = qw(name1 name2 ...);' => "Perl", 'package p is ... end; package body p is ... end;' => "Ada", 'p = module() export name1, name2, ...; ... end module' => "Maple", "(export 'name1 'name2)" => "CommonLisp", 'attached to each name (public, private...) ' => "Java Pike", 'namespace export name1' => "Tcl", pre('namespace p val name1 : type1 ...') => "F#", 'append_features' => "Ruby", pre(q(module type PType = sig val name1 : type1 ... end module P : PType = struct ... end)) => "OCaml", 'all files in package directory are exported. files in /private sub-directory are not exported, but can be used by the package itself' => "Matlab", '__all__ = [ ... ]' => "Python", 'Identifier is only exported if the first character of its name is an ' . 'Unicode upper case letter; and the identifier is declared in the package ' . 'block or it is a field name or method name. No other identifiers are ' . 'exported' => "Go", ], ], 'import' => [ 'everything into current namespace' => [ 'use p (if names are exported using @EXPORT)' => "Perl", 'uses p' => "Pascal", 'using p' => "C#", 'using namespace p;' => "C++", "(use-package 'p)" => "CommonLisp", 'open p' => "OCaml F#", 'import' => "Pike", 'import p' => "Haskell", 'IMPORT p;' => "Modula-2", 'import p.*' => "Java", 'import "p"' => "YCP", 'from p import *' => "Python", 'with p; use p;' => "Ada", 'namespace import p *' => "Tcl", 'inherit c export {NONE} all end' => "Eiffel", 'include or even extend' => "Ruby", 'do' => "Rebol", 'addpath' => "Matlab", '. p' => "BourneShell", 'source p' => "BourneShell", 'builtin -f /path/to/lib.so' => 'KornShell', '<< p`' => "Mathematica", 'Get["p`"]' => "Mathematica", 'Needs["p`"]' => "Mathematica", 'use P1\P;' => 'PHP5', 'use P1\P as Q;' => 'PHP5', ], 'selectively' => [ 'import p (name1, name2, ...) ' => "Haskell", 'import p.name1; import p.name2' => "Java", "(import '(p:name1 p:name2))" => "CommonLisp", 'use p qw(name1 name2 ...)' => "Perl", 'from p import name1, name2, ...' => "Python", 'FROM p IMPORT name1, name2, ...;' => "Modula-2", 'namespace import p name1' => "Tcl", 'using p::name1; using p::name2; ...' => "C++", 'with p; use type p.type1; ...' => "Ada", 'with(p[name1, name2,])' => "Maple", 'def name := ' => "E", ':- use_module(name1, name2, ...)' => "Prolog", ], 'package (ie. load the package)' => [ 'import p' => "Python", 'use p; (if names are not exported or are exported using @EXPORT_OK)' => "Perl", 'require p' => "Perl", 'require "p"' => "Ruby", 'require, "p"' => "Yorick", "(require 'p) (deprecated in ANSI Common Lisp, but used in ASDF)" => "CommonLisp", 'with p;' => "Ada", 'with(p)' => "Maple", 'package require p' => "Tcl", 'automatically done (using a correspondance from the package name to the file name)' => "OCaml Java", 'import "p"' => "Go", ], ], ], 'Strings' => [ { MLANG => "Forth" }, 'type name' => [ { KIND => 'typed' }, 'char[]' => "C", 'char const[]' => "C++", 'string' => "C++ C# F# Maple SML OCaml Pike Pascal YCP PHP Vimscript Go", 'string!' => "Rebol", 'String' => "C# merd Ruby Haskell Java JavaScript CoffeeScript VisualBasic Smalltalk Ada", 'STRING' => "Eiffel", 'str' => "Python YAML", 'Str' => "Perl6 Pliant", 'NSString *' => "Objective-C", 'CHAR, VARCHAR(size)' => 'SQL92', 'Sequence' => "Io", ], 'character type name' => [ { KIND => 'typed', MLANG => "Maple Pike Io Pliant VisualBasic PHP" }, 'char' => "C C++ C# F# OCaml SML", 'char!' => "Rebol", 'Char' => "merd Haskell Perl6", 'Character' => "Smalltalk Ada", 'CHARACTER' => "Eiffel", 'rune' => "Go", ], 'character "z"' => [ { MLANG => "Awk Tcl Lua Perl Perl6 Python Io JavaScript CoffeeScript Prolog PHP" }, "'z'" => "B C C++ C# F# E OCaml Matlab Haskell Pike Pascal Eiffel Ada ClassicREXX Go", '"z"' => "Maple merd BourneShell ClassicREXX", '"z' => "Logo", '$z' => "Smalltalk", '#\z' => "Scheme CommonLisp", '#"z"' => "Rebol SML", '&z' => "Oz", '?z' => "Ruby EmacsLisp", 'char z, [char] z (inside a function)' => "Forth", ], 'strings' => [ { ALL => 1 }, 'with no interpolation of variables' => [ "'...'" => "Perl Perl6 CSS XPath YAML Python Matlab Ruby PHP Lua JavaScript CoffeeScript Pascal Smalltalk BourneShell FishShell Beta Prolog ClassicREXX SQL92 Vimscript", '"..."' => "C C++ C# F# CSS Io Maple Mathematica XPath Java YCP YAML E Prolog Rebol Pike Python MUMPS EmacsLisp Scheme CommonLisp OCaml Ada Haskell SML Eiffel JavaScript Dylan Lua Awk Modula-3 Pliant FL Oz ClassicREXX Go", '"...' => "Logo", q('''...''') => "Python", q("""...""") => "Python Io", '[[ ... ]]' => "Lua", 'R"[ ... ]"' => "C++-0x", "<<'MARK' ... MARK" => "BourneShell Perl Ruby", "<<<'MARK' ... MARK (since PHP 5.3)" => "PHP5", '{...{...}...}' => "Tcl", '(...)' => "PostScript", 'q(...(...)...), q[...], q{...}, q<...>, q/.../' => "Perl Perl6", '%q(...(...)...), %q[...], %q{...}, %q<...>, %q/.../' => "Ruby", 'q(...(...)...)' => "merd", '@"...""..."' => "C#", 's"..."' => "Forth", '@"..."' => "Objective-C", ], 'with interpolation of variables' => [ { MLANG => "SML Haskell Smalltalk CommonLisp Beta Maple Logo Prolog C C# C++ ClassicREXX Eiffel Go" }, '... (no spaces)' => "Tcl", '"... $v ..."' => "Perl Perl6 Tcl PHP BourneShell FishShell", '"... {v} ..."' => "merd", '"... #{v} ..." "... #$v ..." "... #@v ..." "... #@@v ..."' => "Ruby CoffeeScript", '< "BourneShell Perl", '< "Ruby", '<< "PHP", 'qq(...(... $v ...)...), qq[...], qq{...}, qq<...>, qq/.../' => "Perl Perl6", '%Q(...(... #{v} ...)...), %Q[...], %Q{...}, %Q<...>, %Q/.../' => "Ruby", 'qq(...(... {v} ...)...) ' => "merd", '"... #{v} ..." interpolate' => "Io", '"... %(v)s ..." % vars()' => "Python", ], 'end-of-line (without writing the real CR or LF character)' => [ { MLANG => "ClassicREXX Matlab Logo" }, '\n' => "Tcl", '"\n"' => "C C++ C# Perl PHP Io Perl6 Maple Mathematica Lua Haskell OCaml Python Ruby YCP Pike Java JavaScript CoffeeScript Yorick FishShell Go", '"*n"' => "B BCPL", '"%N"' => "Eiffel", '"^/"' => "Rebol", '"~%" (when using format)' => "CommonLisp", '"[lf]"' => "Pliant", 'vb_nl' => "VisualBasic", ' (need expandMacros)' => "Smalltalk", ], ], 'multi-line' => [ { MLANG => "C C++ Eiffel Prolog" }, 'all strings allow multi-line strings' => "E Maple F# Mathematica Smalltalk Perl PHP Io Perl6 OCaml Ruby Scheme Pascal CommonLisp EmacsLisp YCP FishShell BourneShell", '"...", {...}' => "Tcl", '@"..."' => "C#", q('''...''', """...""") => "Python", '[[ ... ]]' => "Lua", '{...}' => "Rebol", pre(q("...\n" "...\n")) => "C", pre(q(... "...\n\\ \\...\n")) => "Haskell", pre(q("...", "...")) => "ClassicREXX", pre(q("...%N% %...%N")) => "Eiffel", '""" ... """' => 'CoffeeScript', '`...`' => "Go", ], 'convert something to a string (see also string interpolation)' => [ { MLANG => 'Awk B C C++ Beta Prolog OCaml Logo SML BourneShell ClassicREXX' }, #- everything is a string in BourneShell 'show' => "Haskell", 'to_s, to_str, inspect, String()' => "Ruby", 'to_string' => "merd Pliant", 'tostring' => "Lua YCP", 'toString' => "Java JavaScript CoffeeScript", 'ToString' => "C# F# Mathematica", 'String' => "JavaScript CoffeeScript", 'perl' => "Perl6", 'Dumper' => "Perl", '"" . e' => "Perl", '"" ~ e' => "Perl6", '"" + e' => "Java E JavaScript CoffeeScript", 'string' => "Pliant Vimscript", 'str, `e`, repr' => "Python", 'out' => "Eiffel", 'cvs' => "PostScript", "T'Image(e) (where T is the type of the value)" => "Ada", 'asString' => "Smalltalk Io", 'printString' => "Smalltalk", 'as(, e)' => "Dylan", '(string) e' => "Pike PHP", 'convert(e,string)' => "Maple", "(coerce e 'string)" => "CommonLisp", 'prin1-to-string' => "EmacsLisp", 'to string! / to-string / to ""' => "Rebol", 'description' => "Objective-C", 'pr1' => "Yorick", 'unneeded, all values are strings' => 'Tcl', 'string(e)' => "Go", ], 'serialize (marshalling)' => [ { MLANG => 'C C++ Prolog Logo Tcl Go' }, 'export-clixml' => "MSH", 'serialize' => "PHP Io", 'Marshal.to_string' => "OCaml", 'Marshal.dump' => "Ruby", 'Data.Binary.encode' => "Haskell", 'BinaryFormatter.Serialize' => "F#", 'storeBinaryOn' => "Smalltalk", 'Storable::store' => "Perl", 'pickle.dump (see also cPickle)' => "Python", '(with-standard-io-syntax (write obj stream))' => "CommonLisp", "T'Output (where T is the type of the value)" => "Ada", ], 'unserialize (un-marshalling)' => [ { MLANG => 'C C++ Prolog Logo Tcl Go' }, 'import-clixml' => "MSH", 'unserialize' => "PHP", 'Marshal.from_string' => "OCaml", 'Marshal.load' => "Ruby", 'Data.Binary.decode' => "Haskell", 'BinaryFormatter.Deserialize' => "F#", 'readBinaryFrom' => "Smalltalk", 'pickle.load' => "Python", '(with-standard-io-syntax (read obj stream))' => "CommonLisp", 'Storable::store' => "Perl", 'doString' => "Io", "T'Input (where T is the type of the value)" => "Ada", ], 'sprintf-like' => [ { MLANG => 'B Ada Io Haskell SML Eiffel JavaScript CoffeeScript Scheme Smalltalk ClassicREXX' }, 'sprintf' => "Awk Maple C C++ F# Pike Matlab Perl Perl6 Ruby OCaml merd PHP", 'printf' => "Haskell", '%' => "Python Ruby", 'format' => "Tcl Java Lua", 'format (but not using the C-like %-syntax)' => "Scheme-SRFI28 CommonLisp Erlang", 'Format' => "C# F#", "putFormat" => "Beta", 'stringWithFormat' => "Objective-C", 'expandMacrosWith (but not using the C-like %-syntax)' => "Smalltalk", 'Storable::retrieve' => "Perl", 'fmt.Sprintf' => "Go", ], 'simple print' => [ 'on strings' => [ 'puts' => "C Tcl Dylan", 'print' => "Awk Java Maple merd Basic SML PHP", 'write' => "Pascal Pike JavaScript Yorick", 'putStr' => "Haskell", 'print_string' => "OCaml F#", 'console' => "Pliant", 'writeln' => "Pascal JavaScript", 'write-string' => "CommonLisp", 'putStrLn' => "Haskell", 'Put_Line' => "Ada", 'display' => "Cobol", 'message' => "EmacsLisp", 'put_string' => "Eiffel", 'show' => "Smalltalk", 'print_endline (adding an end-of-line)' => "OCaml", 'println (adding an end-of-line)' => "Java merd", 'put_chars' => "Erlang", 'echo (in BourneShell, adding an end-of-line)' => "PHP BourneShell FishShell", 'type' => "Forth", "putText" => "Beta", 'say' => "ClassicREXX", 'p or i' => 'GNU-sed', 'fmt.Print' => "Go", 'echom' => 'Vimscript' ], 'on simple objects' => [ { MLANG => "Beta"}, 'print' => "Perl Perl6", 'say (adding an end-of-line)' => "Perl6", 'puts (adding an end-of-line)' => "Tcl", 'puts -nonewline' => "Tcl", ], 'on any objects' => [ 'print' => "Ruby Io Logo Lua", 'print (adding an end-of-line)' => "Python Haskell Rebol Dylan", 'Print' => "Mathematica", 'print e,' => "Python", 'println (adding an end-of-line)' => "Io", 'prin' => "Rebol", 'Put' => "Ada", 'p (adding an end-of-line)' => "Ruby", 'puts (adding an end-of-line unless already newline-terminated)' => "Ruby", 'display' => "Scheme", 'write' => "Prolog Io Scheme CommonLisp", 'writeln (adding an end-of-line)' => "Io", 'print' => "CommonLisp", 'printOn' => "Smalltalk", 'princ prin1' => "CommonLisp EmacsLisp", 'print_any' => "F#", 'WriteLine' => "C# F#", 'nothing - just remove ";" at the end of the expression, and it will print it' => "Matlab", 'disp' => "Matlab", ], 'printf-like' => [ 'printf' => "C C++ F# Haskell KornShell Maple Matlab Perl Ruby OCaml merd Awk PHP", 'write' => "Pike", 'WriteLine' => "C#", 'putFormat' => "Beta", 'format (but not using the C-like %-syntax)' => "CommonLisp Prolog", 'fmt.Printf' => "Go", ], ], 'string equality & inequality' => [ 'eq ne' => "Perl Perl6 Tcl", 'strcmp' => "C Matlab", '== !=(Vimscript: whether or not == and != are case-sensitive depends on user settings.)' => "Pike JavaScript CoffeeScript Go Vimscript", '==? !=? (Always case insensitive)' => 'Vimscript', '==# !=# (Always case sensitive)' => 'Vimscript', '== !==' => 'PHP', '== ~=' => "Lua", '= \=' => "Prolog", 'isEqualToString (faster than isEqual)' => "Objective-C", # below are deep equality/inequality entries '== !=' => "Awk C++ C# E Io Ruby merd Python YCP", '== <>' => "Python", '== /=' => "Haskell", '== \=' => "Oz", '= !=' => "XPath BourneShell FishShell Maple", '= /=' => "Ada", '= \=' => "ClassicREXX", '= <>' => "OCaml F# VisualBasic SML Beta Pliant", '= ~=' => "Dylan Smalltalk", '== \== or = <> \=' => "ClassicREXX", '=== =!= / == != (structural / mathematical)' => "Mathematica", '== ~=' => "Matlab", 'equal?' => "Ruby Scheme", 'equals' => "Java", 'equal, equalp' => "CommonLisp", 'is_equal' => "Eiffel", 'isEqual' => "Objective-C", ], 'string size' => [ 'length' => "Awk C++ F# Maple Perl Prolog Ruby Haskell PostScript Matlab CommonLisp OCaml Java JavaScript CoffeeScript Beta Eiffel Objective-C", 'LENGTH' => "ClassicREXX", "'Length" => "Ada", 'length?' => "Rebol", 'size' => "C++ Ruby Io YCP SML Smalltalk E", 'Length' => "C# F# Modula-3 Pascal Oz", 'len' => "Python Pliant VisualBasic Go Vimscript", 'strlen' => "C PHP Vimscript", 'string length' => "Tcl", 'string-length' => "Scheme XPath", 'StringLength' => "Mathematica", 'sizeof' => "Pike", 'count' => "Eiffel Logo", 'bytes chars' => "Perl6", 'CHARACTER_LENGTH' => "SQL92", 'atom_length' => "Prolog", 'wc -c' => "FishShell", '#' => "Lua", '${#v}' => "BourneShell", 'dup (the string is represented on the stack as (addr len))' => "Forth", ], 'string concatenation' => [ '+' => "Ruby Pike Python YCP Java C++ C# F# merd Pascal E Eiffel JavaScript CoffeeScript Pliant MSH Go", '.' => "Perl PHP Vimscript", '..' => "Io Lua", ',' => "Smalltalk", '~' => "Perl6 D", '&' => "Ada Modula-3 VisualBasic", '^' => "SML OCaml F#", '_' => "MUMPS", '||' => "PL/I Cecil Icon Maple ClassicREXX SQL92", '++' => "Haskell", '$a$b' => "Tcl BourneShell FishShell", 'concatenate' => "Dylan CommonLisp", 'string-append' => "Scheme", 'StringJoin' => "Mathematica", 'cat' => "Maple", 'Cat' => "Modula-3", 'strcat' => "C", 'concat' => "XPath", "append" => "Beta Rebol Prolog", 'stringByAppendingString' => "Objective-C", ' ' => "Awk ClassicREXX", '[string1 string2]' => "Matlab", 'word' => "Logo", ], 'duplicate n times' => [ { MLANG => 'C C++ C# Java CommonLisp Prolog Logo VisualBasic JavaScript CoffeeScript Haskell Eiffel Beta OCaml SML Smalltalk' }, # Haskell is "concat (replicate n str)" '*' => "Ruby Pike Python E Ada", 'x' => "Perl Perl6", 'times' => "merd", 'repeat' => "Pliant", 'repeated' => "Io", 'str_repeat' => "PHP", 'string repeat' => "Tcl", 'strrep' => "Lua", 'repmat' => "Matlab", 'insert/dup' => "Rebol", 'COPIES' => "ClassicREXX", 'cat(s$n)' => "Maple", 'concat $ replicate' => "Haskell", 'strings.Repeat' => "Go", ], 'upper / lower case character' => [ 'upcase / downcase' => "Ruby EmacsLisp", 'uc / lc' => "Perl Perl6", 'upper / lower (in Lua >= 5.0)' => "Python Pliant Matlab Lua", 'toUpper / toLower' => "Haskell", 'to_upper / to_lower' => "Eiffel", 'To_Upper / To_Lower' => "Ada", 'toUpperCase / toLowerCase' => "Java E JavaScript CoffeeScript", 'upper_case / lower_case' => "Pike", 'uppercase / lowercase' => "OCaml F# Logo", 'strupper / strlower' => "Lua", 'strtoupper / strtolower' => "PHP", 'ToUpper / ToLower' => "Oz C# F#", 'toupper / tolower' => 'Awk C C++', 'string toupper / string tolower' => "Tcl", 'asLowercase / asUppercase' => "Smalltalk Io", "upCase / lowCase" => "Beta", 'uppercase form / lowercase form' => "Rebol", 'char-upcase / char-downcase' => "CommonLisp Scheme", 'char_type(C_, to_upper(C)), char_type(C_, to_lower(C))' => "Prolog", '\U / \L / \C' => "GNU-sed", 'unicode.ToUpper / unicode.ToLower' => "Go", ], 'uppercase / lowercase / capitalized string' => [ { MLANG => 'C C++ Haskell' }, # Haskell is "map toUpper / map toLower" 'upcase / downcase' => "Ruby EmacsLisp", 'upper / lower' => "SQL92 Matlab", 'upper / lower / capitalize' => "Python", 'uppercase/lowercase' => "OCaml F# Rebol Logo", 'upcase_atom/downcase_atom' => "Prolog", 'toUpperCase / toLowerCase' => "Java E JavaScript CoffeeScript", 'ToUpperCase / ToLowerCase' => "Mathematica", 'ToUpper / ToLower' => "C# F#", 'to_upper / to_lower' => "Eiffel Ada", 'toupper / tolower' => 'Awk YCP', 'uc / lc' => "Perl Perl6", 'UpperCase / LowerCase' => "Pascal", 'StringTools[UpperCase] / StringTools[LowerCase] / StringTools[Capitalize]' => "Maple", 'uppercaseString / lowercaseString / capitalizedString' => "Objective-C", 'UCase / LCase' => "VisualBasic", 'strtoupper / strtolower' => "PHP Yorick", 'strupper / strlower' => "Lua", 'string toupper / string tolower / string totitle' => "Tcl", 'string-upcase / string-downcase' => "CommonLisp Scheme", 'asLowercase / asUppercase / asUppercaseFirst' => "Smalltalk", 'asLowercase / asUppercase / makeFirstCharacterUppercase' => "Io", 'upcase_atom / downcase_atom' => "Prolog", "makeLC / makeUC" => "Beta", 'parse upper var in_var out_var / parse lower var in_var out_var' => "ClassicREXX", 'strings.ToUpper / strings.ToLower / strings.Title' => "Go", ], 'ascii to character' => [ { MLANG => "Eiffel" }, 'chr' => "Ruby Perl Perl6 F# Python SML OCaml Haskell Pascal PHP", 'chr$' => "VisualBasic", 'char' => "Matlab", 'format %c $c' => "Tcl", 'toChar' => "E", 'strchar' => "Lua", 'from_integer' => "Eiffel", 'fromCharCode' => "JavaScript CoffeeScript", 'FromCharacterCode' => "Mathematica", 'character' => "Pliant", 'Character value: c' => "Smalltalk", 'asCharacter' => "Io", 'code-char' => "CommonLisp", 'integer->char' => "Scheme", "'Val" => "Ada", '(char) c' => 'C C++ C# Java', 'to char! / to-char' => "Rebol", 'X2C, D2C' => "ClassicREXX", '$CHAR(s)' => "MUMPS", 'char_code' => "Prolog", 'ascii' => "Logo", 'StringTools[Char]' => "Maple", 'utf8.DecodeRuneInString(s)' => "Go", ], 'character to ascii' => [ 'ord' => "Perl Perl6 F# Python Haskell SML Pascal PHP", 'asc' => "VisualBasic", 'getNumericValue' => "Java", 'charCodeAt' => "JavaScript CoffeeScript", 'asciiValue' => "Smalltalk", 'code' => "OCaml Eiffel", 'char-code' => "CommonLisp", 'char->integer' => "Scheme", 's[0]' => "Ruby", 's 0 get' => "PostScript", 's at(0)' => "Io", 'scan $s %c' => "Tcl", 'strbyte' => "Lua", 'toInteger' => "E", "'Pos" => "Ada", 'number' => "Pliant", '(int) c' => "C C++ C# Java", 'to integer! / to-integer' => "Rebol", 'ToCharacterCode' => "Mathematica", 'C2X, C2D' => "ClassicREXX", '$ASCII(s)' => "MUMPS", '(done automatically when applying mathematical operations on char, such as +)' => "Matlab", 'char' => "Logo", 'char_code' => "Prolog", 'StringTools[Ord]' => "Maple", 'string(c)' => "Go", ], 'accessing n-th character' => [ { MLANG => 'Perl Perl6 ClassicREXX VisualBasic Yorick' }, 's[n]' => "Maple C C++ C# E Pike Python PHP Ruby Go Vimscript", 's(n)' => "Ada Matlab", 's:n' => "Pliant", 's.[n]' => "OCaml F#", 's !! n' => "Haskell", 's @ n' => "Eiffel", 's/:n' => "Rebol", 'string index s n' => "Tcl", 'sub' => "SML", 'char, aref, schar, svref' => "CommonLisp", 'GetChar' => "Modula-3", 's at(n)' => "Io", 'at (in C++, is range-checked whereas a[i] is not)' => "C++ Smalltalk", 'aref' => "CommonLisp", 'char(s, i)' => "B", 'charAt' => "Java JavaScript CoffeeScript", 'characterAtIndex' => "Objective-C", "n -> s.inxGet" => "Beta", 'string-ref' => "Scheme", 'StringTake[s, {n}]' => "Mathematica", '$EXTRACT(s, n)' => "MUMPS", 'item' => "Logo", 'over n chars + c@' => "Forth", 's/.{n}(.).*/\1/' => 'GNU-sed', ], 'extract a substring' => [ { MLANG => "Haskell Logo" }, # Haskell is "take len (drop n s)" 's[n..m]' => "Pike Maple Ruby CoffeeScript", 's.[n..m]' => "F#", 's(n..m)' => "Ada", 's(n:m)' => "Matlab", 's(n,m+1)' => "E", 's[n:m+1]' => "Python Go Vimscript", 's[n,len]' => "Ruby", 's n len' => "Pliant", 'strndup(s + n, len)' => "C", 'substring' => "Java Scheme YCP SML Eiffel XPath", 'Substring' => "C#", 'substr' => "Perl Perl6 C++ PHP", 'SUBSTR' => "ClassicREXX", 'sub' => "OCaml F# Lua", 'SUB' => "Modula-3", 'subseq' => "CommonLisp", 'slice' => "JavaScript CoffeeScript Io", 'mid$' => "JavaScript", 'string range' => "Tcl", 'StringTake[s, {n, m}]' => "Mathematica", 'strpart(s, n, m)' => "Yorick", 'copy/part at s n len' => "Rebol", 'copy/part at s n at s m' => "Rebol", 's copyFrom: n to: m' => "Smalltalk", "(n,m)->s.sub" => "Beta", '[s substringWithRange:NSMakeRange(n, len)]' => "Objective-C", 'SUBSTRING(s FROM n len)' => "SQL92", '$EXTRACT(s, n, m)' => "MUMPS", 'sub_string / sub_atom' => "Prolog", '(take len . drop n) s' => "Haskell", 'over n chars + len' => "Forth", 's/.{n}(.{len}).*/\1/' => 'GNU-sed', ], 'locate a substring' => [ { MLANG => "OCaml" }, # index in C is BSD only 'index' => "Ruby Perl Ada Perl6 Python", 'indexOf' => "JavaScript CoffeeScript Java", 'IndexOf' => "C# F#", 'indexOfString' => "Smalltalk", 'startOf' => "E", 'search' => "Pike CommonLisp PostScript", 'StringTools[Search]' => "Maple", 'StringPosition' => "Mathematica", 'strstr strchr' => "C", 'find' => "C++ Rebol YCP Logo Python Lua", 'findSeq' => "Io", 'findSubstring' => "Haskell", 'strfind' => "Matlab Yorick", 'strpos' => 'PHP', '$FIND' => "MUMPS", 'index_non_blank / find_token' => "Ada", 'substring_index' => "Eiffel", 'rangeOfString' => "Objective-C", 'POS' => "ClassicREXX", 'POSITION(needle IN s)' => "SQL92", 'sub_string / sub_atom' => "Prolog", 'string first' => "Tcl", 'strings.Index' => "Go", ], 'locate a substring (starting at the end)' => [ { MLANG => "Prolog Haskell Io" }, # rindex in C is BSD only 'rindex' => "Ruby Perl Perl6 OCaml Python", 'rfind' => "C++ Python", 'find/last' => "Rebol", 'strrchr' => "C", 'index(Going => Backward)' => "Ada", 'lastStartOf' => "E", 'lastIndexOf' => "JavaScript CoffeeScript Java", 'last_index_of (ESI dialect)' => "Eiffel", 'LastIndexOf' => "C# F#", 'lastIndexOfString' => "Smalltalk", 'string last' => "Tcl", '(search substring string :from-end t)' => "CommonLisp", '[string rangeOfString:substring options:NSBackwardsSearch]' => "Objective-C", 'LASTPOS' => "ClassicREXX", 't=strfind(s,p), t(end)' => "Matlab", 'strrpos' => 'PHP', 'StringTools[SearchAll](s,p)[-1]' => "Maple", 'strings.LastIndex' => "Go", ], ], 'Booleans' => [ 'type name' => [ { KIND => 'typed', MLANG => 'C Pike' }, 'Bool' => "Perl6 Haskell Pliant", 'bool' => "C# F# C++ C99 SML OCaml PHP Python YAML Go", 'Boolean' => "Smalltalk Lua Pascal VisualBasic Ada", 'boolean' => "Java CommonLisp YCP Maple PHP JavaScript CoffeeScript", 'BOOLEAN' => "Eiffel", 'logic!' => "Rebol", 'logical' => "Matlab", ], 'false value' => [ 'false' => "C99 C++ BCPL C# F# OCaml Io Logo SML Pascal YCP Smalltalk PostScript Java E Ada Beta Pliant FL Oz Tcl Maple JavaScript CoffeeScript Rebol Matlab BourneShell PHP Ruby Lua Forth YAML Go", 'False' => "VisualBasic Python Haskell merd Eiffel Mathematica", 'FALSE' => "Modula-3 SQL92", 'false()' => "XPath", '#f' => "Dylan Scheme", 'n' => "YAML", 'nil' => "EmacsLisp CommonLisp Io Lua Ruby", 'no' => "Tcl YAML CoffeeScript", 'No' => "Prolog", 'none' => "Rebol", 'None' => "Python", 'null' => "JavaScript CoffeeScript", 'NULL' => "C99 C++ C PHP", 'off' => "Tcl YAML CoffeeScript", 'undef' => "Perl Perl6", 'undefined' => "JavaScript CoffeeScript", 'fail' => "Prolog", 'FAIL' => "Maple", 'array containing at least one false value' => "Matlab", 'exit status different from 0' => "BourneShell", '0 (beware of 0.0 which is true in Pike!)' => "B VisualBasic C99 C++ Tcl Python JavaScript CoffeeScript ClassicREXX MUMPS Awk Perl Perl6 Matlab XPath C PHP Pike Forth Yorick", '0.0' => "Matlab PHP Perl", 'NaN' => "JavaScript CoffeeScript XPath", '""' => "Python JavaScript CoffeeScript Awk Perl Perl6 XPath PHP", '"0"' => "Awk Perl PHP Perl6", "''" => "Matlab Perl CoffeeScript", q('\0') => "C99 C++ C", '()' => "Python Perl Perl6", '[]' => "Python Matlab", '{}' => "Python Matlab", 'array()' => "PHP", ], 'true value' => [ 'TRUE' => "Modula-3 SQL92", 'True' => "Haskell merd Eiffel VisualBasic Python Mathematica", 'true' => "BCPL C++ C# F# OCaml Io Maple SML Pascal Logo Ruby Smalltalk PostScript Java E Ada PHP Beta Pliant FL Oz YCP Tcl BourneShell YAML Prolog Forth Rebol JavaScript CoffeeScript Go", 'true()' => "XPath", 't' => "EmacsLisp CommonLisp", '#t' => "Scheme Dylan", 'y' => "YAML", 'yes' => "Tcl YAML CoffeeScript", 'Yes' => "Prolog", 'on' => "Tcl YAML CoffeeScript", 'exit status 0' => "BourneShell", 'anything not false' => "Awk Perl Perl6 B C C++ Pike Matlab Ruby MUMPS XPath EmacsLisp CommonLisp Python Scheme Dylan Rebol Yorick", '1' => "ClassicREXX MUMPS", 'non zero number' => "Tcl", 'non-zero-numbers' => "VisualBasic", '-1' => "Forth", ], 'logical not' => [ '!' => "Awk B C C++ C# E Java Pike Perl Perl6 Ruby YCP Tcl PHP Mathematica JavaScript CoffeeScript Yorick Go Vimscript", 'not (Smalltalk: postfix operator)' => "OCaml F# Logo SML Rebol Io Maple Pascal PostScript Ruby Scheme Haskell Perl Perl6 XPath Python Smalltalk merd Eiffel Lua EmacsLisp CommonLisp Ada Beta Pliant Prolog CoffeeScript", 'Not' => "Oz VisualBasic", 'NOT' => "Modula-3", '~' => "PL/I BCPL Dylan Matlab", '^' => "PL/I", "'" => "MUMPS", "\\" => "ClassicREXX", "=0" => "Forth", ], 'logical or / and' => [ { MLANG => "Forth" }, 'short circuit' => [ '|| / &&' => "Awk C C++ C# F# Java Matlab Mathematica Pike Perl Perl6 YCP Ruby OCaml Haskell merd Tcl E PHP JavaScript CoffeeScript Yorick Vimscript Go", '| / &' => "B BCPL Dylan", 'or / and' => "Perl Perl6 Logo Io Ruby Python Modula-2 PHP Smalltalk EmacsLisp CommonLisp Scheme Lua Pliant CoffeeScript", 'OR / AND' => "Modula-3", 'or / & (in Modula-2, "&" and "and" are synonyms)' => "Modula-2", 'any / all' => "Rebol", 'orelse / andalso' => "SML", 'orelse / andthen' => "Oz", 'or else / and then' => "Ada Eiffel", '; / ,' => "Prolog", '& / !' => "MUMPS", ], 'non short circuit (always evaluates both arguments)' => [ '| / &' => "C# Java Smalltalk ClassicREXX Matlab", 'or / and' => "Maple Pascal PostScript Rebol SML Ada Eiffel Beta XPath", 'Or / And (in Oz, simple functions, not operators)' => "VisualBasic Oz", '\/ / /\ (ascii representation, original uses a special charset)' => "BCPL", '?| / ' => "Perl6", ], ], ], 'Bags and Lists' => [ { MLANG => "C Cobol Fortran Pascal Basic Ada BourneShell ClassicREXX" }, 'type name' => [ { KIND => 'typed' }, 'seq' => "YAML", 'a list' => "SML F# OCaml", '[a]' => 'Haskell', 'a[]' => "C#", 'list' => "Python Maple", 'List' => "Pliant Io Mathematica", 'Array or List' => "Perl6", 'ARRAY or LINKED_LIST' => "Eiffel", 'Array or OrderedCollection' => "Smalltalk", 'ARRAY' => 'Perl', 'array' => 'PHP', 'cell' => "Matlab", 'vector' => "C++", 'Containers.Vectors.Vector or Ada.Containers.Doubly_Linked_Lists.List' => "Ada", '[]a' => "Go", ], 'list concatenation' => [ { MLANG => 'C++ Forth' }, # C++ has the typical OO disease, it does everything in-place '+' => "Ruby Eiffel Pike Python merd E PHP Vimscript", ',' => "Smalltalk Maple Matlab Perl", '@' => "SML OCaml F#", '~' => 'D', '&' => "Ada", '++' => "Haskell", '|||' => "Icon", 'array_merge' => "PHP", 'merge' => "YCP", 'concat' => "Tcl JavaScript CoffeeScript", 'concatenate' => "Dylan", 'nconc' => "EmacsLisp CommonLisp", "append" => "Beta Rebol Prolog Scheme EmacsLisp CommonLisp Go", 'Append' => "Oz", 'appendSeq' => "Io", 'arrayByAddingObjectsFromArray' => "Objective-C", 'sentence' => "Logo", 'Join' => "Mathematica", ], 'list flattening' => [ { MLANG => 'Perl Matlab Logo Python C++ Forth Smalltalk JavaScript CoffeeScript Go' }, 'one level depth' => [ 'concat' => "F# Haskell Mercury SML", 'flatten' => "F# OCaml merd YCP Io Prolog", 'Flatten' => "Oz", 'eval concat' => "Tcl", 'ListTools[FlattenOnce]' => "Maple", '{*}$l' => "Tcl8.5", '"$l"' => "FishShell", ], 'recursive' => [ 'flatten' => "Pike Ruby", 'ListTools[Flatten]' => "Maple", 'Flatten' => "Mathematica", ], ], 'list constructor' => [ { MLANG => "Beta" }, '[ a, b, c ] (new in PHP 5.4)' => "Haskell Maple Ruby Python Matlab YCP JavaScript CoffeeScript SML YAML Perl Perl6 Prolog merd PostScript E PHP5 Vimscript", '( a, b, c )' => "Perl Perl6", '{ a, b, c } (restricted to initialisation of a local variable in C and C++)' => "Lua C C++ Mathematica", "#(a, b, c)" => "Dylan", '#(a b c) (a b c must be constants)' => "Smalltalk", '{ a. b. c }' => "Squeak", '[ a ; b ; c ]' => "F# OCaml", '[ a b c ]' => "Rebol Oz Logo", '({ a, b, c })' => "Pike", "'(a b c)" => "EmacsLisp CommonLisp Scheme", '<< a, b, c >>' => "Eiffel", 'list(a, b, c)' => "Io", 'list' => "Tcl Dylan EmacsLisp CommonLisp Scheme", 'array(a, b, c)' => "PHP", 'new t[] { a, b, c }' => 'C#', 'new[] { a, b, c }' => 'C#3', 'new List { a, b, c}' => "C#3", 'Array(a, b, c) (beware, if you give only one integer argument, it is the size!)' => "JavaScript", '[NSArray arrayWithObjects:a, b, c, nil]' => "Objective-C", 'set l a b c' => "FishShell", pre(' - a - b - c') => "YAML", '[]t{a, b, c}' => "Go", ], 'list/array indexing' => [ { MLANG => "Beta" }, # eiffeil favors a.put(v, i) for write access 'a[i]' => "B C C++ C# Java Pike BourneShell KornShell FishShell Maple Ruby Python merd Pascal E PHP Perl Perl6 Dylan Lua JavaScript CoffeeScript Modula-3 MSH Vimscript Go", 'a*[i] or a!i or a*(i) depending on the version' => "BCPL", 'a[[i]]' => "Mathematica", 'a[i]:default' => "YCP", 'a(i)' => "Ada Matlab", 'a:i' => "Pliant", 'a/:i' => "Rebol", 'a.(i)' => "F# OCaml", 'a.[i]' => "F#", 'a !! i' => "Haskell Mercury", 'a @ i' => "Eiffel", 'a i get (for write access: a i o put)' => "PostScript", 'a at(i)' => "Io", 'at (in C++, it is range-checked whereas a[i] is not. in Smalltalk, for write access: a :at i :put o)' => "C++ Smalltalk", 'lindex' => "Tcl", 'nth' => "OCaml EmacsLisp CommonLisp", 'Nth' => "Oz", 'aref' => "EmacsLisp CommonLisp", 'nth0 / nth1' => "Prolog", 'list-ref / vector-ref' => "Scheme", 'element' => "Dylan", 'slice' => "Ruby", 'node[i]' => "XPath", 'objectAtIndex' => "Objective-C", 'item' => "Logo", 'a i cells + @ (for write access: o a i cells + !' => "Forth", ], 'adding an element at the beginning (list cons)' => [ { MLANG => 'Python Forth Objective-C Tcl FishShell Go' }, 'return the new list (no side-effect)' => [ ':' => "Haskell merd", '::' => "SML OCaml F#", '|' => "Oz", '[ e | l ]' => "Prolog Erlang", '[e l[]]' => "Maple", '[e l]' => "Matlab", 'cons' => "EmacsLisp CommonLisp Scheme", 'pair' => "Dylan", 'fput' => "Logo", 'Prepend' => "Mathematica Ada", ], 'side-effect' => [ { MLANG => "Beta Maple Forth" }, # Beta: (obj, list.head) -> list.insertBefore 'unshift' => "Perl Perl6 Ruby JavaScript CoffeeScript", 'prepend' => "YCP", 'push_front' => "C++", 'addFirst' => "Smalltalk", 'insert' => "Rebol", 'put_first' => "Eiffel", 'push' => "CommonLisp Io", 'array_unshift' => "PHP", 'PrependTo' => "Mathematica", ], ], 'adding an element at index' => [ { MLANG => 'C++ Eiffel Forth OCaml Haskell Logo Prolog Matlab Maple Go' }, 'return the new list (no side-effect)' => [ 'linsert l i e' => "Tcl", 'Insert' => "Mathematica Ada", ], 'side-effect' => [ {}, '[a insertObject:e atIndex:i]' => "Objective-C", 'a.insert(i, e)' => "Ruby Python", 'a insertAt(e, i)' => "Io", 'a add: e beforeIndex: i / a add: e afterIndex: i' => "Smalltalk", 'splice(@a, $i, 0, $e)' => "Perl", ], ], 'adding an element at the end' => [ { MLANG => 'CommonLisp Forth Tcl Haskell Beta Prolog Maple OCaml SML FishShell' }, 'return the new list (no side-effect)' => [ '[l e]' => "Matlab", 'push' => "merd", 'arrayByAddingObject' => "Objective-C", 'lput' => "Logo", 'linsert l end e' => "Tcl", 'Append' => "Mathematica Ada", ], 'side-effect' => [ 'push' => "Perl Perl6 Ruby JavaScript CoffeeScript", 'push_back' => "C++", 'append' => "Python Pliant Rebol Io Go", 'AppendTo' => "Mathematica", 'lappend' => "Tcl", '+=' => "Pliant", 'add' => "Java Smalltalk YCP", 'put_last' => "Eiffel", 'array_push' => "PHP", 'addObject' => "Objective-C", ], ], 'first element' => [ { MLANG => "Beta Tcl Forth Perl Python Ruby JavaScript CoffeeScript Maple Matlab FishShell Go" }, '' => [ 'head' => "Haskell", 'Head' => "F#", 'hd' => "F# OCaml", 'car' => "Scheme EmacsLisp CommonLisp", 'first' => "Eiffel Pliant Rebol Smalltalk Io Logo", 'First (see also Head)' => "Mathematica", 'First_Element' => "Ada", ], 'iterator' => [ 'head' => "Beta", 'begin' => "C++", 'First' => "Ada", ], ], 'all but the first element' => [ { MLANG => 'Perl C++ Ruby Forth JavaScript CoffeeScript Maple Io Eiffel' }, 'tail' => "Haskell", 'Tail' => "F#", 'tl' => "OCaml F#", 'cdr' => "Scheme EmacsLisp CommonLisp", 'Rest' => "Mathematica", 'butfirst' => "Logo", 'allButFirst' => "Smalltalk", 'l[1:]' => 'Python Go', 'a(2:end)' => "Matlab", 'L = [_|ButFirst]' => "Prolog", 'lrange l 1 end' => "Tcl", ], 'last element' => [ { MLANG => 'C++ OCaml JavaScript CoffeeScript Forth Maple' }, '' => [ 'last' => "Eiffel Rebol Io Logo Haskell Prolog Pliant Smalltalk E Scheme", 'Last' => "Oz Mathematica", 'lastObject' => "Objective-C", 'a[-1]' => "Python Perl Pike Ruby", 'a(end)' => "Matlab", 'node[last()]' => "XPath", '(car (last l))' => "CommonLisp EmacsLisp", 'lindex l end' => "Tcl", 'Last_Element' => "Ada", 'l[len(l)-1:]' => "Go", ], 'iterator' => [ 'Last' => "Ada", ], ], 'all but the last element' => [ { KIND => 'rare', MLANG => 'Perl C++ Ruby JavaScript CoffeeScript Maple Io Eiffel' }, 'Most' => "Mathematica", ], 'get the first element and remove it' => [ { MLANG => 'Haskell Forth Matlab Tcl Python C++ OCaml Maple Eiffel Go' }, 'shift' => "Perl Perl6 Ruby JavaScript CoffeeScript", 'shift!' => "merd", 'pop' => "CommonLisp Logo", 'removeFirst' => "Smalltalk Io", 'array_shift' => "PHP", ], 'get the last element and remove it' => [ { MLANG => 'Haskell Forth C++ OCaml Tcl Maple Eiffel Matlab Go' }, 'pop' => "E Perl Perl6 Ruby Python Io JavaScript CoffeeScript", 'pop!' => "merd", 'array_pop' => "PHP", 'removeLast' => "Smalltalk Io", 'dequeue' => 'Logo', ], 'for each element do something' => [ { MLANG => "XSLT Matlab" }, # could be KIND has_lambda, but many languages has special cases for this 'each' => "Ruby merd Pliant", 'for v in l ...' => "Ruby E Maple CoffeeScript", 'for v in l: ...' => "Python", 'for v in l; do ...; done' => "BourneShell", 'for v in l do ...' => "F#", 'for v in l; ...; end' => "FishShell", 'for (v in l) ...' => "Awk Dylan", 'for (var v in l) { ... }' => "JavaScript", 'For Each v in l ... Next' => "VisualBasic", 'for v in range loop .. end loop' => "Ada", 'for' => "Perl", 'foreach' => "Perl Pike Rebol Logo Tcl Lua PHP", 'foreach (t v in l) ...' => "C#", 'foreach (v in l) ...' => "C#3", 'foreach ($v in l) ...' => "MSH", 'foreach(t v, l, { ... })' => "YCP", 'l foreach(v, ...)' => "Io", 'for_each' => "C++", 'for-each' => "Scheme", 'forall' => "PostScript Prolog", 'ForAll' => "Oz", 'iter' => "OCaml F#", 'do' => "Smalltalk", 'do_all' => "Eiffel", 'app' => "SML", 'mapc' => "EmacsLisp", 'mapM_' => "Haskell", 'Scan' => "Mathematica", '(dolist (v l) ...) (loop for v in l do ...) mapc' => "CommonLisp", "list.iterate (# do current ... #) " => "Beta", 'l.Iterate(...)' => "F#", 'Iterate' => "Ada", 'for i, v := range l {...}' => "Go", ], 'transform a list (or bag) in another one' => [ { KIND => 'has_lambda' }, 'map' => "Perl F# Pike Io Maple Ruby SML OCaml Haskell Mercury Scheme Python merd Dylan", 'Map' => "Oz F# Mathematica", 'mapcar' => "EmacsLisp CommonLisp", 'maplist' => "YCP Prolog", 'sublist' => "Prolog", 'map / map.se' => "Logo", 'for-each' => "XSLT", 'foreach or selected' => "MSH", 'collect' => "Ruby Smalltalk", 'transform' => "C++", 'array_map' => "PHP", '/@' => 'Mathematica', '[ f x | x <- l ] (list comprehension)' => "Haskell", '[ f(x) for x in l ] (list comprehension)' => "Python", 'magical: sin(x) computes sin on each element' => "Matlab", ], 'transform two lists in parallel' => [ { KIND => 'has_lambda', MLANG => "Perl Ruby" }, 'map2' => "OCaml F#", 'zipWith' => "Haskell", 'Zip' => "Maple Oz", 'map' => "Scheme Python Dylan Logo", 'map.se' => "Logo", 'mapcar' => "CommonLisp", 'maplist2' => "Prolog", 'l1 with: l2 collect: ...' => "Smalltalk", 'transform' => "C++", 'ListPair.map' => "SML", 'magical: a binary function or operator is appliied on each element' => "Matlab", ], 'find an element' => [ { KIND => 'has_lambda', MLANG => "Perl Scheme" }, 'find' => "C++ F# CommonLisp Ruby Rebol SML OCaml Haskell Scheme-SRFI1 merd YCP", 'Find' => "Ada", 'find_if' => "C++", 'find-if' => "CommonLisp", 'first (in List::Util)' => "Perl", 'detect' => "Ruby Smalltalk", 'search' => "Pike", 'ListTools[Search]' => "Maple", 'lsearch -exact' => "Tcl", 'index' => "Python", 'indexOf' => "Io", 'indexOfObject, indexOfObjectIdenticalTo' => "Objective-C", 'find(a == 3)' => "Matlab", 'Position' => "Mathematica", ], 'keep elements' => [ { KIND => 'has_lambda', MLANG => 'Scheme Tcl', }, 'matching' => [ 'find_all' => "Ruby F# OCaml", 'filter' => "Pike OCaml F# SML Haskell Mercury Scheme-SRFI1 Python merd YCP", 'filter!' => "Scheme-SRFI1", 'Filter' => "Oz", 'grep' => "Perl Perl6", 'where' => "MSH", 'select' => "Ruby Maple Smalltalk Io", 'Select / Case' => "Mathematica", 'selectInPlace' => "Io", 'remove-if-not delete-if-not' => "CommonLisp", # 'remove-each' => "Rebol", # unpure 'choose' => "Dylan", 'array_filter' => 'PHP5', '[ x | x <- l, p x ] (list comprehension)' => "Haskell", '[ x for x in l if p(x) ] (list comprehension)' => "Python", 'a(a == 3)' => "Matlab", ], 'non matching' => [ 'remove-if delete-if' => "CommonLisp", 'reject' => "Ruby", ], ], 'partition a list: elements matching, elements non matching' => [ { KIND => 'functional', MLANG => 'Smalltalk Scheme Matlab' }, 'partition' => "OCaml F# Ruby SML Haskell Scheme-SRFI1 merd", 'partition!' => "Scheme-SRFI1", 'Partition' => "Oz", ], 'split a list' => [ { KIND => 'functional', MLANG => 'Smalltalk Scheme Matlab' }, 'in 2 based on a predicate' => [ 'break' => "Haskell", 'span' => "Haskell", ], 'into sublists delimited by elements matching a predicate' => [ 'split-sequence (not in standard)' => "CommonLisp", 'ListTools[Split]' => "Maple", ], 'into a list of lists of same value' => [ 'group' => "Haskell", 'Split' => "Mathematica", ], 'into sublists based on a predicate' => [ 'groupBy' => "Haskell", 'Split' => "Mathematica", ], ], 'is an element in the list' => [ { MLANG => "C++ Forth Perl Maple Go" }, 'member?' => "Ruby merd Dylan", 'include?' => "Ruby", 'mem' => "F# OCaml", 'member' => "CommonLisp Prolog Scheme", 'Member' => "Oz", 'MemberQ' => "Mathematica", 'memq memv' => "Scheme", 'memberp / member?' => "Logo", 'contains' => "E YCP Io", 'containsObject' => "Objective-C", 'in' => "Tcl8.5 Python JavaScript CoffeeScript SQL92", 'in_array' => "PHP", 'includes' => "Smalltalk", 'elem' => "Haskell Mercury", 'has' => "Eiffel", 'has_value' => "Pike", 'ismember' => "Matlab", '/elt/' => 'GNU-sed', ], 'is the predicate true for an element' => [ { KIND => 'has_lambda', MLANG => "Perl Scheme" }, 'any (Python >= 2.5)' => "Haskell Mercury Matlab Scheme-SRFI1 Python", 'any?' => "Ruby Dylan", 'anySatisfy' => "Smalltalk", 'exists' => "F# OCaml SML", 'exists?' => "merd", 'some' => "CommonLisp", 'Some' => "Oz", 'ormap' => "Maple", 'detect' => "Io", ], 'is the predicate true for every element' => [ { KIND => 'has_lambda', MLANG => "Perl Io Scheme" }, 'all (Python >= 2.5)' => "Haskell SML Mercury Python", 'All' => "Oz", 'all?' => "Ruby merd", 'allSatisfy' => "Smalltalk", 'every' => "Scheme-SRFI1 CommonLisp", 'every?' => "Dylan", 'for_all' => "F# OCaml", 'andmap' => "Maple", ], 'smallest / biggest element' => # accepting n-ary functions if a "*" tupling function exists [ { MLANG => 'OCaml Tcl Forth Logo JavaScript Go' }, 'min / max' => "Eiffel Maple Perl6 PHP5 Pike Io Matlab Ruby Scheme Prolog Python CommonLisp Smalltalk Java", 'Min / Max' => "Mathematica", 'minimum / maximum' => "Haskell Mercury merd", 'minimum-of / maximum-of' => "Rebol", 'min minstr / max maxstr (in List::Util)' => "Perl", 'min_element / max_element' => "C++", ], 'join a list of strings in a string using a glue string' => [ { MLANG => "Eiffel Forth Logo" }, 'join(s, l)' => "PHP Perl Perl6", 'String.Join(s, l)' => "C#", 's.join(l)' => "Python", 'l.join(s)' => "Ruby JavaScript CoffeeScript Perl6", 'l asStringWith: s' => "Smalltalk", 'join l s' => "Tcl", 'implode(s, l)' => "PHP", 'ListTools[Join]' => "Maple", 'rjoin' => "E", 'join' => "Io", 'concat' => "F# OCaml", 'strcat' => "Matlab", 'concat_atom' => "Prolog", 'l * s' => "Pike Ruby", "(mapconcat 'identity l s)" => "EmacsLisp", 'componentsJoinedByString' => "Objective-C", 'intercalate' => "Haskell", 'StringJoin @@ Riffle[l, s]' => "Mathematica", 'strings.Join' => "Go", ], 'list size' => [ 'size' => "Ruby merd E Io Matlab Scilab Dylan Java C++ YCP Pliant Smalltalk", 'sizeof' => "Pike", 'length' => "C# F# Ruby Matlab SML Haskell Mercury OCaml Scheme PostScript Java JavaScript CoffeeScript EmacsLisp CommonLisp Prolog", 'Length' => "Oz F# Mathematica Ada", 'length?' => "Rebol", 'len' => "Python Vimscript", 'llength' => "Tcl", '$LENGTH' => "MUMPS", 'elems' => "Perl6", 'getn' => "Lua", 'count' => "PHP Eiffel XPath Objective-C SQL92 FishShell", 'numel' => "Matlab", 'scalar @l' => "Perl", 'nops' => "Maple", '#' => "Lua", 'len(l)' => "Go", ], 'iterate with index' => [ { MLANG => 'Haskell Tcl Maple Forth Logo Matlab Prolog Perl C++ OCaml Smalltalk JavaScript' }, # Haskell is "zipWith (\i v -> expr) [1..] l" 'each_with_index' => "Ruby merd", 'enumerate(l)' => "Python", 'foreach($l as $i => $v)' => "PHP", 'a foreach(i, e, ...)' => "Io", 'for i => v in l' => "E", 'for (v in l, i from 0) ... end' => "Dylan", 'forAllInd' => "Oz", 'foreachi' => "Lua", 'foreach(l; typ0 i; typ1 v) { ... }' => "Pike", 'withIndexDo' => "Squeak", 'iteri' => "F# OCaml", 'IterateIndexed' => "F#", 'MapIndexed' => "Mathematica", '(loop for v in l as i upfrom 0 do ...)' => "CommonLisp", 'for v,i in l ...' => 'CoffeeScript', 'for i, v := range l {...}' => "Go", ], 'remove duplicates' => [ { MLANG => "Perl Python Forth OCaml Smalltalk JavaScript CoffeeScript Scheme Go" }, 'uniq' => "Ruby Perl6 Pike merd", 'uniq!' => "Ruby", 'uniq2' => "Pike", 'unique (in C++, it is done in place)' => "Rebol Matlab Io C++", 'nub' => "Haskell", 'array_unique' => "PHP", 'ListTools[MakeUnique]' => "Maple", 'delete-duplicates' => "Scheme-SRFI1 CommonLisp", 'delete-duplicates!' => "Scheme-SRFI1", 'remove-duplicates' => "Dylan CommonLisp", 'lsort -unique' => "Tcl", 'toset' => "YCP", 'distinct' => "SQL92", 'set' => "Python", 'Union' => "Mathematica", ], 'sort' => [ { MLANG => 'Logo Forth Go' }, 'sort (in Scheme, not standard, but nearly standard)' => "Eiffel Io Pike F# Prolog Matlab Maple Rebol Ruby C++ C# OCaml XSLT Haskell Java JavaScript CoffeeScript CommonLisp Python Perl Perl6 merd E PHP Lua YCP Scheme", 'sort!' => "Ruby", 'sorted' => "Python", 'Sort' => "Oz Mathematica", 'sort_by' => 'merd Ruby', 'sortBy' => "Haskell Smalltalk Io", 'order by' => "SQL92", 'lsort' => "Tcl", 'asort' => "Awk", 'sort-object' => "MSH", 'sortedArrayUsingSelector, sortUsingSelector' => "Objective-C", 'predsort / keysort / mergesort' => "Prolog", ], 'reverse' => [ { MLANG => 'Tcl Forth Go' }, 'reverse' => "Pike Rebol Io Logo Ruby Haskell Prolog Perl Perl6 Java JavaScript CoffeeScript Mercury Scheme Python merd Dylan EmacsLisp CommonLisp C++", 'Reverse' => "C# Oz Mathematica", 'reversed' => "Smalltalk Python", 'reverse_copy' => "C++", 'rev' => "OCaml F# SML", 'Reverse_Elements' => "Ada", 'lreverse' => 'Tcl8.5', 'array_reverse' => "PHP", 'ListTools[Reverse]' => "Maple", 'fliplr flipud...' => "Matlab", 'l[::-1]' => "Python", ], 'list of couples from 2 lists' => [ { KIND => 'functional', MLANG => 'Smalltalk Io Scheme' }, 'combine' => "OCaml F#", 'zip' => "Haskell Maple F# SML Scheme-SRFI1 Ruby Python Perl6 merd", 'pairlis (the result is not guaranteed to be the same as the order in the input)' => "CommonLisp", 'transpose' => "Ruby", 'Transpose' => "Mathematica", '[a b]' => "Matlab", ], '2 lists from a list of couples' => [ { KIND => 'functional', MLANG => 'Smalltalk CommonLisp Scheme' }, 'split' => "OCaml F#", 'unzip' => "Haskell F# SML merd", 'unzip2' => "Scheme-SRFI1", 'transpose' => "Ruby", 'Transpose' => "Mathematica", 'zip(*l)' => "Python", 'a(1,:), a(2,:)' => "Matlab", ], 'lookup an element in a association list' => [ { KIND => 'functional', MLANG => 'Smalltalk Io' }, 'lookup' => "Haskell", 'assoc' => "Ruby F# OCaml CommonLisp EmacsLisp Scheme", 'assq' => "EmacsLisp Scheme", 'assv' => "Scheme", 'get_assoc' => "Prolog", 'select' => "Rebol", 'a.(e)' => "Matlab", 'a[e]' => "Maple", 'gprop' => "Logo", '/.' => "Mathematica", ], 'list out of a bag' => [ { KIND => 'rare' }, 'to_a' => "Ruby", 'toArray' => "Java", 'asArray' => "Smalltalk", 'to_list' => "merd", 'list' => "Python", 'map-as(, bag)' => "Dylan", '[a.(:)]' => "Matlab", 'array get' => "Tcl", ], 'f(... f(f(init, e1), e2) ..., en)' => [ { KIND => 'has_lambda', MLANG => "Perl Scheme Matlab" }, 'foldl' => "Haskell Maple SML Mercury merd", 'FoldL' => "Oz", 'fold_left' => "OCaml", 'fold' => "F# Scheme-SRFI1", 'Fold' => "Mathematica", 'reduce (in Perl, in List::Util)' => "Pike Io Python CommonLisp Dylan Perl Perl6", 'inject' => "Ruby", 'inject into' => 'Smalltalk', ], 'f(e1, f(e2, ... f(en, init) ...))' => [ { KIND => 'functional', MLANG => 'Smalltalk Scheme' }, 'foldr' => "Haskell Maple SML Mercury merd", 'FoldR' => "Oz", 'fold-right' => "Scheme-SRFI1", 'fold_right' => "OCaml", 'foldBack' => "F#", 'rreduce' => "Pike", "(reduce f '(e1 e2 ... en) :from-right t :initial-value init)" => "CommonLisp", 'reverseReduce' => "Io", ], ], 'Various Data Types' => [ 'tuple type' => [ { KIND => 'typed', MLANG => 'C C++ C# Maple PHP Eiffel Pascal Java Smalltalk JavaScript CoffeeScript Ada Go' }, 'typ1 * ... * typn' => "SML F# OCaml", '(typ1, ..., typn)' => "Haskell", 'typ1, ..., typn' => "merd", 'tuple' => "Python", 'tuple!' => "Rebol", 'Tuple[Typ1, Typ2, Typ3]' => "E", 'tuple< typ1, ..., typn >' => "C++-0x", ], 'tuple constructor' => [ { MLANG => 'C C++ C# Eiffel Tcl Java JavaScript PHP CoffeeScript ClassicREXX FishShell Forth Go' }, 'a, b, c' => "OCaml F# Ruby Python Lua merd", '( a, b, c )' => "SML Haskell Prolog Ada Perl C++-0x", '{ a. b. c }' => 'Smalltalk', '{ a, b, c }' => 'Matlab', '[ a, b, c ]' => "E", 'a . b . c' => "Rebol", '(cons a b)' => "CommonLisp", ], 'computable tuple (these are a kind of immutable lists playing a special role in parameter passing)' => [ { ALL => 1, KIND => 'dynamic', MLANG => "ClassicREXX Logo Io Tcl FishShell Forth" }, # tagged "dynamic" because in statically typed languages, this needs staged evaluation (like macros) 'empty tuple' => [ # () in MLs has no characteristic of a tuple, so not put here '()' => "Python merd Perl Perl6", '[]' => "Ruby", '{}' => "Matlab Smalltalk", '#()' => "Smalltalk", 'Nothing' => "Prolog", ], '1-uple' => [ 'a or [a]' => "Ruby", 'a,' => "Python Perl6", 'tuple([a])' => "Python", '(a)' => "Perl", # Perl's lists are a kind of tuple. There is a distinction between ("foo") x 4 and "foo" x 4 '((a))' => "merd", '{a}' => 'Smalltalk', ], 'using a tuple for a function call' => [ { MLANG => 'Smalltalk' }, 't' => "merd Perl", '*t' => "Ruby Python", 't{:}' => "Matlab", 'f @@ t' => "Mathematica", 'L =.. [ F | Args ], call(L)' => "Prolog", ], ], 'reference (pointer)' => [ { ALL => 1, MLANG => 'Ruby Io Python Tcl CommonLisp Matlab Scheme Smalltalk Eiffel Java ClassicREXX JavaScript CoffeeScript' }, 'creation' => [ '&' => "B C C++ C# Go", '\\' => "Perl", 'AddressOf' => "VisualBasic", 'addr (Borland extension in Pascal)' => "Pascal", '@ (Borland extension in Pascal)' => "Pascal", 'lv' => "BCPL", 'ref' => "C# F# SML OCaml", 'newSTRef' => "Haskell", 'NewCell' => "Oz", 'variable' => "Forth", "'access" => "Ada", ":> :>>" => "Pliant", "''" => "Maple", ], 'dereference' => [ '* (prefix)' => "B C C++ C# Go", '$ @ % & (prefix)' => "Perl", '->[...] ->{...} ->(...) (postfix)' => "Perl", '-> (infix)' => "C C++", '^ (postfix)' => "Modula-3 Pascal", '! (prefix)' => "OCaml F# SML", 'rv' => "BCPL", 'readSTRef' => "Haskell", 'Access' => "Oz", '.[all]' => "Ada", '@' => "Forth", 'eval' => "Maple", '(reg)' => 'Assembler', ], "assigning (when dereferencing doesn't give a lvalue)" => [ { KIND => 'rare' }, 'writeSTRef' => "Haskell", 'Assign' => "Oz", ':=' => "OCaml F# SML", '!' => "Forth", ], ], 'optional value' => [ { ALL => 1, MLANG => "ClassicREXX Prolog Go" }, 'null value' => [ '0 (optional value is only for pointers)' => 'C++ Forth', '0 nullptr (optional value is only for pointers)' => 'C++-0x', 'NULL' => 'C SQL92 Maple', 'nil' => "Ruby EmacsLisp Io CommonLisp Smalltalk Lua Objective-C", 'null' => "C# JavaScript CoffeeScript Java", 'Null (only for "access" types in Ada)' => "Ada Mathematica", 'undef' => "Perl", 'None' => "Python F# OCaml", 'NONE' => "SML", 'Nothing' => "Haskell", 'Void' => "Eiffel", '#f ()' => "EmacsLisp", '(empty) / ~ / null' => "YAML", ], 'value' => [ 'v' => "Ada C# Eiffel Java Perl JavaScript CoffeeScript Smalltalk Python Perl Ruby EmacsLisp CommonLisp Lua Scheme", '*v (optional value is only for pointers)' => "C C++", 'Just v' => "Haskell", 'Some v' => "OCaml F#", 'SOME v' => "SML", ], 'type name' => [ { KIND => 'functional typed', MLANG => "Smalltalk" }, 'option' => "SML F# OCaml", 'Maybe' => "Haskell", ], 'null coalescing' => [ 'COALESCE' => 'SQL92', '?:' => 'PHP', '||' => 'Perl Ruby JavaScript', '// (introduced in Perl 5.10)' => 'Perl', '??' => 'C#', 'if(a, b)' => "VisualBasic", 'or' => 'Python Scheme', ], ], 'record' => [ { ALL => 1, MLANG => "Perl Prolog Logo ClassicREXX" }, 'type declaration' => [ { KIND => 'typed' }, 'struct { typ1 n1; typ2 n2; ... }' => 'C C++', 'type typ = { n1 : typ1; n2 : typ2 }' => "OCaml SML", 'data Typ = N0 { n1, n2 :: typ1, n3 :: typ3, ... }' => "Haskell", pre("type Typ is record N1 : Typ1; N2 : Typ2 := default_val; ... end record;") => 'Ada', 'type typ struct{ n1 typ1; n2 typ2; }' => "Go", ], 'selector' => [ '.' => "C C++ C# F# Ruby OCaml Matlab Ada Beta Pascal Python E Eiffel Java Modula-2 Modula-3 JavaScript CoffeeScript Lua Oz Go", '::' => "XPath", '%' => "Fortran90", "' (attribute selector)" => "Ada", '^' => "Mercury", 'r { field }' => "merd", 'r:field' => "Pliant", 'field r' => "Haskell", '->' => "C C++", 'r[field]' => "Maple", 'r["field"]' => "JavaScript", '#field r' => "SML", 'normal function call' => "Haskell CommonLisp Dylan Smalltalk Io", ], ], 'union type declaration' => [ { KIND => 'typed', MLANG => 'Go' }, 'union { typ1 n1; typ2 n2; ... }' => 'C C++', 'data Typ = N1 typ1 | N2 typ2 | ...' => "Haskell", 'type typ = N1 of typ1 | N2 of typ2 | ...' => "OCaml", 'datatype typ = N1 of typ1 | N2 of typ2 | ...' => "SML", pre("type Typ (Choice : Discrete_Type) is record case Choice is when Choice_1 => N1 : Typ1; ... when Choice_2 | Choice_3 => ... when others => ... end case; end record;") => "Ada", ], 'enumerated type declaration' => [ { KIND => 'typed', MLANG => 'Go' }, 'enum typ { n1; n2; ... } (Java: introduced in 1.5)' => 'C C++ C# Java', pre('Enum typ n1 n2 End Enum') => "VisualBasic", '(n1, n2, ...)' => "Pascal", 'type typ is (n1, n2, ...)' => "Ada", 'data Typ = N1 | N2 | ...' => "Haskell", 'type typ = N1 | N2 | ...' => "OCaml", 'datatype typ = N1 | N2 | ...' => "SML", ], 'dictionary' => [ { ALL => 1, MLANG => 'C Ada Logo Smalltalk ClassicREXX Prolog Tcl' }, 'type name' => [ { KIND => 'typed' }, 'map' => "YAML Go", 'Map' => "Io F#", 'std::map' => 'C++', 'dict' => "Python", 'Dictionary' => "Pliant Smalltalk", 'dictionary' => 'Vimscript', 'Hash' => "Perl6 Ruby", 'HASH' => 'Perl', 'HASH_TABLE' => "Eiffel", 'HashTable' => "Java", 'Hashtbl' => "F#", 'Hashtbl.t' => "OCaml", 'struct' => "Matlab", 'table' => "Maple", 'array' => 'PHP', 'Data.Map, Data.HashTable' => "Haskell", 'Containers.Ordered_Maps.Map' => "Ada", ], 'constructor' => [ { MLANG => 'C++ C# OCaml Java Io' }, '[ a => b, c => d ]' => "E", 'array( a => b, c => d )' => "PHP", '{ a => b, c => d }' => "Ruby Perl Perl6", '{ a, b, c, d }' => "Ruby Perl", '{ a: b, c: d }' => "Python JavaScript CoffeeScript YAML Vimscript", '{ a: b; c: d }' => "CSS", '$[ a: b, c: d ]' => "YCP", '{ a->b. c->d }' => "Squeak", '{ a = b, c = d }' => "Lua", '@{ a = b; c = d }' => "MSH", '([ a:b, c:d ])' => "Pike", '([a]=b [c]=d)' => 'KornShell', '<< a b c d >>' => "PostScript", "struct(a, b, c, d)" => "Matlab", 'Hash[ a, b, c, d ]' => "Ruby", 'Map.of_list [a, b; c, d]' => "F#", 'Hashtbl.of_list [a, b; c, d]' => "F#", 'table([a=b, c=d])' => "Maple", 'define table foo a => b; c => d end' => "Dylan", 'dict create a b c d' => "Tcl8.5", 'new t { {a, b}, {c, d} }' => "C#", 'fromList' => "Haskell", '[NSDictionary dictionaryWithObjectsAndKeys:b, a, d, c, nil]' => "Objective-C", pre(' a: b c: d') => "YAML", 'map[typ0]typ1{ a: b, c: d }' => "Go", ], 'access' => [ 'read/write' => [ 'h[k]' => "Awk Maple Ruby Python E PHP MSH Dylan Lua JavaScript CoffeeScript C++ C# Go Vimscript", '$h{k}' => "Perl", '%h{k} or %h' => "Perl6", 'h(k)' => "Tcl", 'h.[k]' => "F#", 'h.k' => "Lua JavaScript CoffeeScript Matlab", 'h:k' => "Pliant", 'h["k"] or h->k' => "Pike", '(gethash k h)' => "CommonLisp", ], 'read' => [ 'h k get' => "PostScript", 'find' => "F# OCaml", 'fetch' => "Ruby", 'get' => "Java", 'dict get' => "Tcl8.5", 'at' => "Smalltalk Io", 'h@k or h.at(k)' => "Eiffel", 'h[k]:default' => "YCP", '${h[k]}' => 'KornShell', 'h.get(k, returned_value_when_k_unfound)' => "Python", 'objectForKey' => "Objective-C", 'lookup' => "Haskell", 'Element' => "Ada", ], 'write' => [ 'h k o put' => 'PostScript', 'put' => "Eiffel Java", 'add, replace' => "F# OCaml", 'store' => "Ruby", 'dict set' => "Tcl8.5", 'h[k]' => "YCP KornShell", 'atPut' => "Io", 'h at: k put: o' => "Smalltalk", '[h setObject:o forKey:k]' => "Objective-C", 'insert' => "Haskell", 'Replace_Element' => "Ada", ], ], 'has the key ?' => [ { MLANG => "Maple CommonLisp Objective-C" }, 'exists $h{k}' => "Perl", 'exists' => "Pliant Perl6", 'dict exists' => "Tcl8.5", 'has' => "Eiffel", 'haskey' => "YCP", 'hasKey' => "Io", 'has_key' => "Python Vimscript", 'has_key?, include?, key?, member?' => "Ruby", 'Contains' => "F# C# Ada", 'containsKey' => "Java", 'includesKey' => "Smalltalk", 'k in h' => "Python JavaScript CoffeeScript", 'k not in h' => "Python", 'in' => "Awk", 'mem' => "F# OCaml", 'member' => "Haskell", 'isfield' => "Matlab", 'find (returns an iterator)' => "C++", 'h[k]' => "Pike", '(gethash k h)' => "CommonLisp", 'maps' => "E", 'known' => "PostScript", 'isset(h[k]), array_key_exists(k, h)' => "PHP", 'v, exists := h[k]' => "Go", ], 'remove by key' => [ 'delete $h{k}' => "Perl", 'del h[k]' => "Python", 'unset(h[k])' => "PHP", 'remove' => "Eiffel Java F# OCaml YCP", 'Remove' => "C# F#", 'dict remove' => "Tcl8.5", 'removeAt' => "Io", 'removeKey' => "E Smalltalk", 'remhash' => "CommonLisp", 'delete' => "Ruby Haskell JavaScript CoffeeScript Perl6", 'Delete' => "Ada", 'erase' => "C++", 'm_delete' => "Pike", 'removeObjectForKey' => "Objective-C", 'undef' => "PostScript", 'rmfield' => "Matlab", 'delete(h, k)' => "Go", ], 'list of keys' => [ { MLANG => 'C++ OCaml F# CommonLisp Go' }, 'keys' => 'Perl Io Perl6 Maple Python MSH Ruby Smalltalk Haskell', 'dict keys' => "Tcl8.5", 'keySet' => "Java", 'allKeys' => "Objective-C", 'AllKeys' => "C#", 'indices' => "Pike", 'current_keys' => "Eiffel", 'getKeys' => "E", 'array_keys' => "PHP", 'fieldnames' => "Matlab", 'findall(Key, item(Key, _), Keys)' => 'Prolog', '${!h[@]}' => 'KornShell', ], 'list of values' => [ { MLANG => 'C# C++ F# OCaml CommonLisp Go' }, 'values' => "Perl Io Perl6 Java Pike Python Ruby Smalltalk", 'dict values' => "Tcl8.5", 'getValues' => "E", 'content' => "Eiffel", 'array_values' => "PHP", 'struct2cell' => "Matlab", 'entries' => "Maple", 'elems' => "Haskell", '${h[@]}' => 'KornShell', ], 'merge' => [ { MLANG => 'OCaml Go' }, 'merge (right-bias)' => "Ruby", 'array_merge (right-bias)' => "PHP", 'union (left-bias)' => "Haskell", 'update (right-bias)' => "Ruby Python", 'putAll (right-bias)' => "Java", 'insert (left-bias)' => "C++", '(%h1, %h2) (right-bias)' => "Perl", ], ], 'range' => [ { MLANG => 'C C++ Maple Forth OCaml Java ClassicREXX Eiffel' }, 'inclusive .. inclusive' => [ 'a .. b' => "Ruby Perl Pascal merd E Ada MSH", 'a:b' => "Matlab", '[ a .. b ]' => "F# Haskell CoffeeScript", 'to' => "Smalltalk Io", 'seq a b / jot - a b (jot on BSD)' => "BourneShell FishShell", '{a..b}' => 'KornShell', 'range' => "PHP", 'range(from: a, to: b, by: step)' => "Dylan", 'Range' => "Mathematica", 'Range with' => "Io", 'List.number A B Step' => "Oz", 'numlist / between' => "Prolog", 'iseq' => "Logo", 'k, v := range h' => "Go", ], 'inclusive .. exclusive' => [ 'a ... b' => "Ruby CoffeeScript", 'a ..! b' => "E", 'range' => "Python", ], ], ], 'Mathematics' => [ 'type name' => [ { KIND => 'typed' }, 'integers' => [ 'short, int, long' => "C C#", 'int' => "YAML SML OCaml PHP", 'Int' => "Perl6", 'Int, uInt, Int8, Int16...' => "Pliant", 'int, long (long is a big integer)' => "Python", 'integer' => "Maple PHP", 'INTEGER, INT, SMALLINT' => "SQL92", 'INTEGER, INTEGER_8, NATURAL_8...' => "Eiffel", 'int8, uint8, int16, uint16, ...64' => "Matlab Go", 'int8_t, uint8_t, int16_t, uint16_t, ...64' => "C99", 'int, int8, uint8, int16, uint16, int32, uint32, int64, uint64, bigint, bignum' => "F#", 'Int, Integer, Int8, Int16, Int32, Int64' => "Haskell", 'Integer, FixNum, BigNum' => 'Ruby', 'Integer, SmallInteger, LargeInteger' => "Smalltalk", 'Integer' => "Mathematica", "type T is range Low...High;" => "Ada", 'number' => 'Vimscript' ], 'floating point' => [ 'float, double, long double' => "C", 'float, double' => "C#", 'float' => "YAML SML OCaml Maple PHP Vimscript", 'Float' => "Ruby", 'float, float32' => "F#", 'Float, Float32, Float64' => "Pliant", 'NUMERIC, DECIMAL, DOUBLE PRECISION' => "SQL92", 'Rat' => "Perl6", 'DOUBLE, REAL' => "Eiffel", 'single, double' => "Matlab", 'Float, Double, Ratio' => "Haskell", 'Float, Double, Fraction, FixedPoint' => "Smalltalk", 'float, decimal.Decimal' => "Python", 'Real, Rational' => "Mathematica", 'Number' => "Io", 'type T is digits N range Low..High;' => "Ada", 'type T is delta S digits N range Low..High; (fixed point)' => "Ada", 'float32, float64' => "Go", ], ], 'numbers syntax' => [ { ALL => 1 }, 'integers' => [ '1000' => 'Awk Io C++ Forth F# B PHP Maple Mathematica Prolog Logo Rebol C C# Haskell E Java JavaScript CoffeeScript Pascal Pliant Pike Python BourneShell Tcl Scheme Smalltalk Perl Perl6 Ruby Eiffel OCaml merd Oz SQL92 Yorick Go', '1000, 1000.' => 'CommonLisp EmacsLisp', '1000, 1000., 1000.0' => 'Awk Matlab', "1000, '1000'D" => "ClassicREXX", '1000, 1E3' => 'Ada', ], 'integers in base 2, octal and hexadecimal' => [ { MLANG => "Matlab Prolog Logo" }, '0b1, 07, 0xf (0b1 new in PHP 5.4)' => 'Ruby Pike Perl PHP5 Oz CoffeeScript', '0b1, 0o7, 0xf' => 'OCaml F# Perl6', '07, 0xf' => "C C++ Python Tcl Awk JavaScript", '0xf' => "C# E Io Yorick Go", '07' => "B", '0o7, 0xf' => "Haskell", '1b' => "Eiffel", '2#1#, 8#7#, 16#f#' => "Ada", '2#{1}, #{F}' => "Rebol", '#b1, #o7, #xf' => "CommonLisp EmacsLisp Scheme", '2^^1, 8^^7, 16^^f' => "Mathematica", '2r1, 8r7, 16rf' => "Smalltalk", '#2r1, #8r7, #16rf' => "CommonLisp EmacsLisp", '1b, Fh' => "Pliant", "'1'B, 'F'X" => "ClassicREXX", "B'1', X'F'" => "SQL92", '$f' => "Forth", ], 'integer thousand-separator' => [ { KIND => "rare" }, '1_000, 10_00, 100_0' => 'E Perl Perl6 Ruby Eiffel OCaml Ada', "1'000, 10'00, 100'0" => 'Rebol', '1_000' => 'merd', ], 'floating point' => [ { MLANG => 'BourneShell' }, '1000., 1E3' => 'C C++ E Logo F# Maple OCaml Java Python Scheme Tcl JavaScript CoffeeScript ClassicREXX SQL92 Go', '1000., 1E3, 1,0' => 'Rebol', '1000., 1.E3' => 'Oz Eiffel', '1000.0, 1E3' => 'C# Pike Ruby PHP Prolog CommonLisp EmacsLisp Smalltalk', '1000.0, 1.0E3' => 'Haskell Ada', '1000, 1000.0, 1E3 (integers are decimals)' => 'Awk Perl Perl6 merd', '1000., 1*^3, 1000`' => "Mathematica", '1000e, 1e3' => "Forth", ], ], 'addition / subtraction / multiplication / division' => [ '+ / - / * / /' => "Io C C++ D Vimscript Java Eiffel PHP Maple C# F# Forth Logo Perl Perl6 Matlab MUMPS Python Pliant Ruby BourneShell merd Tcl Haskell Scheme CommonLisp EmacsLisp Smalltalk ClassicREXX SQL92 Prolog Yorick JavaScript CoffeeScript Go", '+ / - / * or nothing / /' => "Mathematica", '+ +. / - -. / * *. / / /. (with mathematical priorities)' => "OCaml", 'sum / difference / product / quotient' => "Logo", 'add / sub / mul / idiv div' => "PostScript", 'f+ / f- / f* / f/' => "Forth", ], 'exponentiation (power)' => [ { MLANG => 'Pascal Forth' }, '**' => 'PL/I Perl Perl6 F# Io Tcl8.5 Rebol Ruby Python OCaml E Ada merd Fortran Prolog ClassicREXX', '^' => 'Eiffel Awk Dylan Lua Matlab Mathematica Pliant Yorick', '* (APL uses a real multiplication sign for multiplication from a special character set)' => 'APL', '**, ^' => 'Maple', '^^' => 'D', '**, ^ and ^^ (for each various types)' => 'Haskell', 'f**' => "Forth", 'pow' => 'C C++ Pike Python SML Tcl Java PHP JavaScript CoffeeScript', 'Pow' => "C# Oz", 'power' => 'Delphi-Kylix Logo Rebol', 'exp' => "PostScript", 'expt' => "EmacsLisp CommonLisp Scheme", 'raisedTo' => "Smalltalk", 'math.Pow' => "Go", ], 'negation' => [ '-' => "B D Vimscript Io BCPL PHP Awk Maple Logo C++ C C# F# E Java Matlab Mathematica Rebol Pike MUMPS Pliant Haskell Python BourneShell Tcl Scheme Smalltalk Perl Perl6 Ruby Eiffel merd EmacsLisp CommonLisp JavaScript CoffeeScript Ada Prolog ClassicREXX Yorick Go", '- -.' => "OCaml", '~' => "SML Oz", 'neg' => "PostScript", 'negate' => "Rebol Forth", 'fnegate' => "Forth", 'minus' => "Logo", ], 'random' => [ { ALL => 1 }, 'random number' => [ 'rand' => 'C Perl Perl6 Maple Ruby Matlab PHP Tcl', 'random' => "Prolog Logo Python CommonLisp Yorick", '$RANDOM' => "MUMPS", 'randomR' => "Haskell", 'Random (from instances of Ada.Numerics.Float_Random or Ada.Numerics.Discrete_Random)' => "Ada", 'Random.int' => "OCaml", 'Random, RandomReal, RandomInteger' => "Mathematica", 'Random value' => "Io", 'Random new nextInteger' => "Smalltalk", pre('r: RANDOM create r.make r.start r.item') => "Eiffel", pre('Random ran = new Random(); ran.Next(...);') => "C#", pre('let r = System.Random() r.Next()') => "F#", 'mt_rand' => 'PHP', 'rand.Read ("math/rand" is pseudo random whereas "crypto/rand" is ' . 'cryptographically random)' => "Go", ], 'seed the pseudo random generator' => [ { MLANG => "Prolog" }, 'srand' => 'C Perl Perl6 PHP Ruby Tcl', 'set_seed' => "Eiffel", 'random.seed' => "Python", 'Random setSeed' => "Io", 'Random.init, Random.self_init' => "OCaml", "rand('state',...)" => "Matlab", 'rerandom' => "Logo", 'RandomTools[MersenneTwister][SetState]' => "Maple", 'Random new setSeed' => "Smalltalk", 'SeedRandom' => "Mathematica", 'mkStdGen' => "Haskell", 'make-random-state' => "CommonLisp", 'Reset' => "Ada", 'rand.Seed (only applies to "math/rand")' => "Go", ], ], 'operator priorities and associativities' => [ { MLANG => 'Forth PostScript Scheme CommonLisp EmacsLisp' }, 'addition vs multiplication' => [ 'mathematical' => "C C++ F# Maple PHP Mathematica Io Java C# Eiffel Perl Perl6 Python Ruby BourneShell merd Matlab Tcl Haskell ClassicREXX Yorick Go", 'same priorities' => "Smalltalk MUMPS", ], 'exponentiation vs negation (is -3^2 equal to 9 or -9)' => [ { MLANG => 'C C++ MUMPS Go' }, 'mathematical' => "Perl Perl6 Maple Mathematica Io Eiffel Ruby Python Haskell Matlab ClassicREXX", 'negation first' => "OCaml F#", ], ], 'square root / e-exponential / absolute value' => [ 'sqrt / exp / abs' => 'C C++ Eiffel Maple Io F# Prolog Python Ruby Smalltalk SML Perl Perl6 Pascal Tcl Java E PHP JavaScript CoffeeScript Lua Ada Haskell OCaml EmacsLisp CommonLisp Scheme Yorick', 'sqrt realsqrt / exp / abs' => "Matlab", 'sqrt / exp /' => "Awk Logo", 'Sqrt / Exp / Abs' => 'C# Oz Mathematica', 'sqrt / / abs' => "PostScript", 'Sqrt / / ABS' => "Modula-3", '/ exp / abs' => "Pliant", 'sqrt / /' => "Pike", 'square-root / exp / abs or absolute' => "Rebol", 'Sqrt / Exp / ABS' => "ClassicREXX", 'sqrt,isqrt / exp / abs' => "Tcl8.5", 'fsqrt / fexp / abs,fabs' => "Forth", 'math.Sqrt' => "Go", ], 'trigonometry' => [ { ALL => 1 }, 'basic' => [ # perl's tan is in Math::Trig 'sin / cos / tan' => "C C++ Pike Maple Io F# Prolog Ruby Matlab Python Smalltalk SML Pascal Perl Perl6 Tcl Java E PHP JavaScript CoffeeScript EmacsLisp CommonLisp Scheme Lua Ada Haskell OCaml Pliant Yorick", 'Sin / Cos / Tan' => "C# Oz ClassicREXX Mathematica", 'sin / cos /' => "Awk PostScript", 'sine / cosine / tangent' => "Eiffel Rebol", 'radsin / radcos / radtan' => "Logo", 'fsin / fcos / ftan' => "Forth", 'math.Sin / math.Cos / math.Tan' => "Go", ], 'inverse' => [ # perl's are in Math::Trig, JavaScript are in Math 'asin / acos / atan (Ruby >= 1.7)' => "C C++ F# Io Haskell Pike Tcl Prolog Pliant CommonLisp Scheme Python OCaml Perl Perl6 Ruby JavaScript CoffeeScript Ada Matlab Yorick", 'Asin / Acos / Atan' => "C# Oz", 'ASin / ACos / ATan' => "ClassicREXX", 'arcsin / arccos / arctan' => "Maple", 'arcSin / arcCos / arcTan' => "Smalltalk", 'ArcSin / ArcCos / ArcTan' => "Mathematica", 'arcsine / arccosine / arctangent' => "Rebol", 'arc_sine / arc_cosine / arc_tangent' => "Eiffel", ' / / atan' => "PostScript", ' / / radarctan' => "Logo", 'fasin / facos / fatan' => "Forth", 'math.Asin / math.Acos / math.Atan' => "Go", ], ], 'logarithm' => [ { ALL => 1 }, 'base e' => [ 'ln' => "Pascal Maple Delphi-Kylix Logo PostScript SML Smalltalk", 'log' => "C C++ Eiffel Perl Maple Prolog Io Perl6 Ruby Python Tcl PHP Lua F# OCaml Pliant Matlab Awk Pike Java E JavaScript CoffeeScript EmacsLisp Scheme CommonLisp Yorick", 'Log' => "C# ClassicREXX Oz Ada Mathematica", 'log 10' => "Haskell", 'log-e' => "Rebol", 'fln' => "Forth", 'math.Log' => "Go", ], 'base 10' => [ 'log10' => "C C++ Eiffel Perl Prolog Perl6 Io Ruby Python Tcl PHP Lua F# OCaml Pliant Matlab Delphi-Kylix Logo Yorick", 'Log10' => "C# ClassicREXX", 'log' => "PostScript SML", 'log: 10' => "Smalltalk", 'log-10' => "Rebol", 'log[10]' => "Maple", 'Log[10, val]' => "Mathematica", 'logBase 10' => "Haskell", 'Log(X => val, Base => 10.0)' => "Ada", '(log x 10) ' => "CommonLisp", 'flog' => "Forth", 'math.Log10' => "Go", ], 'base 2' => [ { KIND => 'rare' }, 'log2' => "Matlab", 'log-10 / log-2' => "Rebol", 'Log(X => val, Base => 2.0)' => "Ada", 'log(val, 2)' => "Python", 'Log[2, val]' => "Mathematica", 'frexp' => "C", 'math.Log2' => "Go", ], ], 'euclidean division (both quotient and modulo)' => [ { KIND => 'rare' }, 'divmod' => "Ruby Python", 'divMod' => "Haskell", # and quotRem 'div ldiv lldiv' => "C", 'IntInf.quotrem' => "SML", 'floor' => "Dylan CommonLisp", '/mod' => "Forth", 'Div (method on big.Int)' => "Go", ], 'modulo' => [ 'modulo of -3 / 2 is 1' => [ '%' => "Ruby Pike Python Tcl Perl Perl6 ClassicREXX", '%%' => "E", '\\\\' => "Smalltalk", 'mod' => "SML EmacsLisp CommonLisp Matlab Ada Haskell Prolog", 'Mod' => "Mathematica", 'MOD' => "Modula-3", 'modulo' => "Ruby Dylan Logo", 'rem' => "Prolog", ], 'modulo of -3 / 2 is -1' => [ '%' => "Awk B C C++ C# F# Java Io E PHP JavaScript CoffeeScript Pliant Yorick Go", '#' => "MUMPS", 'mod' => "Pascal PostScript Forth Prolog Lua F# OCaml XPath Oz", 'remainder' => "Ruby Scheme Logo", 'rem' => "BCPL Ada Haskell Smalltalk Matlab", '//' => "Rebol ClassicREXX", '\\\\' => "Eiffel", ], ], 'truncate / round / floor / ceil' => [ 'trunc / round / floor / ceil' => "C C++ Maple Matlab", 'truncate / round / floor / ceiling' => "CommonLisp Haskell Scheme PostScript Prolog Perl6", 'int / round / floor / ceil' => "Pike JavaScript CoffeeScript Python", 'int / round / /' => "Logo", 'to_i, Integer() / round / floor / ceil' => "Ruby", 'TRUNC / FORMAT / Floor / Ceil' => "ClassicREXX", "Float'Truncation / Float'Rounding / Float'Floor / Float'Ceiling (replace Float with whatever type you are using)" => "Ada", '/ round / floor / ceil' => "SML Tcl Java E PHP Lua Io", '/ Round / Floor / Ceiling' => "C#", '/ Round / Floor / Ceil' => "Oz", '/ round / floor / ceiling' => "PostScript Dylan EmacsLisp XPath", '/ ROUND / FLOOR / CEILING' => "Modula-3", '/ rounded / floor / ceiling' => "Smalltalk Eiffel", 'int / / floor / ceil' => "Perl F#", 'int_of_float / / floor / ceil' => "OCaml F#", ' / / floor / ceil' => "Lua Yorick", 'IntegerPart / Round / Floor / Ceiling' => "Mathematica", ' / Rounding / Floor / Ceiling' => "Ada", 'to-integer / / /' => "Rebol", '/ fround / /' => "Forth", 'math.Trunc / / math.Floor / math.Ceil' => "Go", ], 'bitwise operators' => [ 'and / or / xor' => [ '& / | / ^' => "C C++ C# PHP Tcl E Eiffel Pike Ruby Python Perl Java JavaScript CoffeeScript Go", '& / | / ~' => "Yorick", '& / |' => "YCP", '+& / +| / +^' => "Perl6", '.&. / .|. / xor (in module Data.Bits)' => "Haskell", '&&& / ||| / ^^^' => "F#", 'and / or / xor' => "Rebol PostScript Forth Ada", 'land / lor / lxor' => "F# OCaml", 'logand / logior / logxor (see also bit-and / bit-or / bit-xor)' => "CommonLisp", 'bitand / bitor / bitxor' => "Matlab Logo", 'BITAND / BITOR / BITXOR' => "ClassicREXX", 'BitAnd / BitOr / BitXor' => "Mathematica", 'bitAnd / bitOr / bitXor' => "Smalltalk", 'bitwiseAnd / bitwiseOr / bitwiseXor' => "Io", '/\ / \/ / xor' => "Prolog", ], 'bitwise inversion' => [ '~' => "C C++ C# Pike PHP Ruby Tcl Python Perl Java JavaScript CoffeeScript YCP SML", '~~~' => "F#", 'not' => 'Eiffel PostScript Ada', 'lnot' => "F# OCaml", 'lognot (see also bit-not)' => "CommonLisp", 'bitnot' => "Eiffel Logo", 'BitNot' => "Mathematica", 'complement' => "Rebol Haskell", 'bitcmp' => "Matlab", 'bitInvert' => "Smalltalk", 'bitwiseComplement' => "Io", 'invert' => "Forth", '\\' => "Prolog", ], 'left shift / right shift / unsigned right shift' => [ { MLANG => "Mathematica" }, '<< / >> / >>>' => "Java JavaScript CoffeeScript", '<< / >>' => "C C++ C# Pike PHP Tcl Prolog Ruby Python Perl YCP Go", '<<< / >>>' => "F#", '|<< / |>>' => "Eiffel", 'lsl / lsr or asr' => "F# OCaml", 'bitshift' => "PostScript Matlab", 'bitShift' => "Smalltalk", 'ashift lshift' => "Logo", 'lshift / rshift' => "Forth", 'shiftL / / shiftR' => "Haskell", 'shiftLeft / shiftRight' => "Io", 'Shift_Left / Shift_Right / Shift_Right_Arithmetic / Rotate_Left / Rotate_Right' => "Ada", '(ash x positive-integer) / (ash x negative-integer) / ' => "CommonLisp", ], ], ], 'Threads' => [ { KIND => 'rare' }, 'thread definition' => [ 'class class_name(threading.Thread) {[override run method] }' => "Python", 'task task_name is [entry entry_name[(parameter ...)]...] end task_name' => "Ada", 'task type task_type_name is [entry entry_name[(parameter ...)]...] end task_type_name' => "Ada", 'class class_name extends Thread {[override run method] }' => "Java", 'thread ...' => "Pliant", pre(q(parallel [threads nb_threads] [mini mini_threshold] [maxi maxi_threshold] [active] ... task parallel_instructions [post sequential_instructions] ...)) => "Pliant", '[NSThread detachNewThreadSelector:mainFunction toTarget:target withObject:obj]' => "Objective-C", ], 'thread creation' => [ 'object t=Thread.Thread(f)' => "Pike", 'set t [thread create {code}]' => "Tcl", 'Thread createThread(...)' => "Io", ], 'thread object creation' => [ 'MyTask : task_type_name;' => "Ada", 'class_name MyThread = new class_name()' => "Java", 'p := [ ... ] newProcess.' => "Smalltalk", 'p := [ ... ] fork. (equivalent to newProcess + resume)' => "Smalltalk", ], 'starting / stopping threads' => [ 'start() / stop() ("stop" is now deprecated)' => "Java", 'resume / suspend / terminate' => "Smalltalk", 'Tasks are started when created / call Stop entry or "abort task-object-name"' => "Ada", 'thread send $t {script}' => "Tcl", ], 'passing data directly between threads' => [ 'call an entry with parameters' => "Ada", 'call any public method' => "Java", 'common variables are copied at thread creation, in abscence of a "share" statement' => "Pliant", 'use messages, parameters or shared variables (a thread is created from a block, which is a closure on the variables as seen by the block)' => "Smalltalk", ], 'terminating thread communication due to a time-out' => [ 'select task_entry_call; or delay timeout_limit; end select;' => "Ada", ], 'Thread Synchronization' => [ 'Defining a Synchronized Shared Resource' => [ 'thread::mutex' => "Tcl", pre('protected Object_Name is [entry entry_name(Parameter : [in out] is type [...]); procedure procedure_name(Parameter : [in out] is type [...]); function function_name return type; private shared data declaration end Object_Name;') => "Ada", 'synchronize (this){ ... }' => "Java", 'SharedQueue, Semaphore critical: [...], Future, LazyValue' => "Smalltalk", ], 'Synchronized Writing to a shared resource' => [ 'Object_Name.Entry_Name(Parms)
Object_Name.Procedure_Name(Parms)' => "Ada", 'Object_Name.SetMethod(Parms)' => "Java", ], 'Synchronized Reading of a Shared Resource' => [ 'Object_Name.Function_Name' => "Ada", 'Object_Name.GetMethod()' => "Java", ], 'Monitor Syntax' => [ { MLANG => 'Java' }, 'Objectg_Name.Entry_Name(Parms)' => "Ada", ], ], 'Joining Another Thread' => [ 'Suspending a thread until another thread completes' => [ 'Call task entry serviced just before task termination' => "Ada", 'OtherThread.join()' => "Java Python", ], 'Suspending a Thread Until Another Thread Establishes An Internal State' => [ { MLANG => 'Java',}, 'Call a task entry on the other thread' => "Ada", ], ], 'Thread Prioritization' => [ 'Selecting a Prioritization Model' => [ { MLANG => 'Java' }, 'pragma Locking_Policy(Ceiling_Locking);' => "Ada", ], 'Establishing a base thread priority' => [ { MLANG => 'Java' }, 'pragma Priority(expression);' => "Ada", ], 'Changing Thead Priority' => [ 'Set_Priority(Priority_Value);' => "Ada", 'setPriority(newPriority);' => "Java", 'p priority: n' => "Smalltalk", ], ], 'Thread-safe sharing of data without synchronization' => [ 'Ensuring access is atomic' => [ { MLANG => 'Java' }, 'pragma Atomic(Object_Name);' => "Ada", ], 'Ensuring access is always via a local copy of the shared data' => [ { MLANG => 'Java' }, 'pragma Volatile(Object_Name);' => "Ada", ], ], ], ]; sub merge_options { my ($h1, $h2) = @_; $h1->{MLANG} = join(' ', grep {$_} $h1->{MLANG}, $h2->{MLANG}); $h1->{KIND} = join(' ', grep {$_} $h1->{KIND}, $h2->{KIND}); $h1->{ALL} ||= $h2->{ALL}; } # normalize, using annotations to know missing entries sub normalize { my ($all_raw) = @_; my (@all, %missing); foreach (group_by2(@$all_raw)) { my ($category, $l) = @$_; push @all, [ $category, my $l_cat = [] ]; my %options; if (ref $l->[0]) { merge_options(\%options, shift @$l); } foreach (group_by2(@$l)) { my ($label, $l) = @$_; push @$l_cat, [ $label, my $l_label = [] ]; my %options = %options; if (ref $l->[0] eq 'HASH') { merge_options(\%options, shift @$l); } # if no subcat, fake one if (ref $l->[1] ne 'ARRAY') { @$l = ('' => [ @$l ]); } my @g = map { my ($subcat, $l) = @$_; my %options = %options; if (ref $l->[0] eq 'HASH') { my $h = shift @$l; $h->{KIND} && !$options{ALL} and die "KIND not accepted here\n"; merge_options(\%options, $h); } my @subcats = ref $l->[1] eq 'ARRAY' ? map { [ "$subcat: $_->[0]", normalize_entries($_->[1]) ] } group_by2(@$l) : [ "$subcat" => normalize_entries($l) ]; push @$l_label, @subcats; my @provided_langs = map { split(" ", $_->[1]) } map { @{$_->[1]} } @subcats; push @provided_langs, split(' ', $options{MLANG}) if $options{MLANG}; my @wanted_langs = @langs; if ($options{KIND}) { @wanted_langs = intersection(\@wanted_langs, $kinds{$_}) foreach split(' ', $options{KIND}); } [ $subcat => \@provided_langs, \@wanted_langs ]; } group_by2(@$l); if (!$options{ALL}) { @g = [ '' => [ map { @{$_->[1]} } @g ], $g[0][2] ]; } foreach (@g) { my ($subcat, $provided_langs, $wanted_langs) = @$_; my $provided_langs_ = [ map { $_, @{$rev_hierarchy{$_} || []} } @$provided_langs ]; push @{$missing{$_}{$category}}, $label . ($subcat && " ($subcat)") foreach difference2($wanted_langs, $provided_langs_); } } } # @various don't have missing things delete @missing{@various}; \@all, \%missing; } my $global_comment_count; sub normalize_entries { my ($l) = @_; [ map { my ($name, $langs) = @$_; if (my ($n, $comment) = $name =~ m/(.*) \s+ \( ( [^)]+ (?: \( [^)]* \) )* [^)]* ) \)$/sx) { $name = $n; [ $n, $langs, $comment, ++$global_comment_count ]; } else { $name =~ s/\s+$//; [ $name, $langs ]; } } group_by2(@$l) ]; } sub per_langs { my ($all) = @_; my %per_langs; foreach (@$all) { my ($category, $l) = @$_; foreach (@$l) { my ($label, $l) = @$_; foreach (@$l) { my ($subcat, $l) = @$_; foreach (@$l) { my ($name, $langs, $comment) = @$_; push @{$per_langs{$_}{$category}{$label . ($subcat && " ($subcat)")}}, [ $name, $comment ] foreach split(" ", $langs); } } } } \%per_langs; } sub empty_comments { [ {}, 0 ]; } sub may_add_comment_and_quote { my ($comments, $name, $comment) = @_; my $more = ''; if ($comment) { my $nb = $comments->[0]{$comment} ||= ++$comments->[1]; $more = qq(($nb)); } html_quote($name) . $more; } sub proximity { my ($all) = @_; my %proximity; my %count; foreach (@$all) { my ($_category, $l) = @$_; foreach (@$l) { my ($_label, $l) = @$_; foreach (@$l) { my ($_subcat, $l) = @$_; foreach (@$l) { my ($_name, $langs) = @$_; foreach my $a (split(' ', $langs)) { $count{$a}++; foreach my $b (split(' ', $langs)) { $proximity{$a}{$b}++ if $a ne $b; } } } } } } \%proximity, \%count; } generate_all(); sub generate_all { $\ = "\n"; unlink "syntax-across-languages.html"; system("rm -rf syntax-across-languages"); system("rm -rf syntax-across-languages-per-language"); mkdir "syntax-across-languages"; mkdir "syntax-across-languages-per-language"; my ($all, $missing) = normalize($all_raw); generate_main_page($all); my $per_langs = per_langs($all); my @langs_ = sort { lc $a cmp lc $b } keys %$per_langs; print STDERR "unused lang $_" foreach difference2(\@langs, \@langs_); print STDERR "non described lang $_" foreach difference2(\@langs_, \@langs); generate_category_descriptions(); generate_what_is_missing(\@langs_, $missing); generate_proximity($all, \@langs_); generate_per_language_index(\@langs_); generate_per_language_file($all, $_, $per_langs, $missing) foreach @langs_; } sub generate_main_page { my ($all) = @_; my $all_comments = empty_comments(); open(my $LONG, ">syntax-across-languages.html") or die ''; open(my $SHORT, ">syntax-across-languages/index.html") or die ''; chmod 0444, "syntax-across-languages.html"; my $print_both = sub { print $LONG @_; print $SHORT @_ }; print $LONG intro(' (One Big Page)', ''); print $SHORT intro('', "../"); print $LONG qq(

Light Version

); print $LONG qq(Same content split into multiple html files); print $SHORT qq(

One Big Page

); print $SHORT qq(Same content in one big page); $print_both->("

Categories

"); $print_both->("
    "); my $cache = mangle_category_init(); foreach (@$all) { my ($category, $l) = @$_; my $mangled_category = mangle_category($category, '', $cache); print $LONG qq(
  • $category); print $SHORT qq(
  • $category); $print_both->("
      "); foreach (@$l) { my ($label, $l) = @$_; $label = simplify_category($label); my $s = mangle_category($label, $mangled_category, $cache); print $LONG qq(
    • $label); print $SHORT qq(
    • $label); } $print_both->("
    "); } $print_both->("
"); foreach (@$all) { my ($category, $l) = @$_; my $mangled_category = mangle_category($category, ''); open(my $CAT, "> syntax-across-languages/$mangled_category.html") or die; print $CAT "syntax across languages per category"; my $cat_comments = empty_comments(); my $print_both = sub { print $LONG @_; print $CAT @_ }; $print_both->(qq(

$category

)); $print_both->("
    "); foreach (@$l) { my ($label, $l) = @$_; my $s = mangle_category($label, $mangled_category); $print_both->(qq(
  • $label

    )); foreach (@$l) { my ($subcat, $l) = @$_; table($l, $category, $label, $subcat, $LONG, $all_comments); table($l, $category, $label, $subcat, $CAT, $cat_comments); } } $print_both->("

"); print $CAT comments_text($cat_comments); print $CAT end('../'); } print $LONG comments_text($all_comments); $print_both->(similar_pages()); $print_both->(credits()); print $LONG end(''); print $SHORT end('../'); } sub table { my ($l, $category, $label, $subcat, $F, $comments) = @_; print $F $subcat; print $F ""; my $i = 0; foreach (@$l) { my ($name, $langs, $comment) = @$_; my $name_ = may_add_comment_and_quote($comments, $name, $comment); my @langs = sort { lc $a cmp lc $b } split(" ", $langs); print $F ""; $i++; } print $F "
$name_", html_quote(join(", ", @langs)), "

"; } sub generate_per_language_index { my ($all_langs) = @_; open(my $F, ">syntax-across-languages-per-language/index.html") or die ''; print $F "syntax across languages per language"; print $F "

    "; printf $F qq(
  • %s\n), url_quote($_), html_quote($_) foreach @$all_langs; print $F "
"; print $F credits(); print $F end('../'); } sub generate_per_language_file { my ($all, $lang, $per_langs, $missing) = @_; my $comments = empty_comments(); open(my $F, ">syntax-across-languages-per-language/" . file_quote($lang) . ".html") or die "bad lang $lang\n"; print $F "syntax in ", html_quote($lang)," "; print $F q(

The "Unknown:"s below indicate that an entry is incomplete.

  • either the entry exist in the language, and please tell.
  • either the entry doesn't exist in the language, and please tell so. The entry will be marked as such and won't appear as missing anymore.
); printf $F qq(
); foreach my $prev (@{$hierarchy{$lang} || []}) { printf $F qq(

See the various entries for %s

\n), url_quote($prev), html_quote($prev); } print $F "

    "; if (my @has_kinds = grep { member($lang, @{$kinds{$_}} ) } keys %kind_descriptions) { my %l; @l{@has_kinds} = (); foreach (keys %kind_dependencies) { exists $l{$kind_dependencies{$_}} and delete $l{$_}; } print $F qq(
  • Category: ), join(", ", map { $kind_descriptions{$_}} sort keys %l), "

    "; } foreach my $category (map { $_->[0] } @$all) { my $l = $per_langs->{$lang}{$category}; my $misses = $missing->{$lang}{$category}; $l || $misses or next; my $mangled_category = mangle_category($category, ''); print $F qq(

  • $category

    ); if ($l) { print $F ""; foreach my $label (sort keys %$l) { my $label_ = html_quote($label); my @names_ = map { may_add_comment_and_quote($comments, @$_) } @{$l->{$label}}; print $F "" foreach @names_; } print $F "
    $_$label_

    "; } if ($misses) { print $F "Unknown:

    ", join("
    ", @$misses); print $F "
    "; } } print $F "
"; print $F comments_text($comments); print $F end('../'); } sub generate_category_descriptions { open(my $F, ">syntax-across-languages-per-language/categories.html") or die ''; print $F "language categories"; print $F qq(Programming languages are categorized. The goal is to tag the various entries as belonging to some categories, so that the number of "Unknown:"s is reduced. For example, the "object creation" entry only means something in the category "Object Oriented".

); print $F "

    "; print $F "
  • $_" foreach values %kind_descriptions; print $F "
"; print $F "

"; print $F "Note that:"; print $F "

    "; while (my ($k, $v) = each %kind_dependencies) { print $F qq(
  • "$kind_descriptions{$v}" automatically implies "$kind_descriptions{$k}"); } print $F "
"; print $F end('../'); } sub generate_what_is_missing { my ($all_langs, $missing) = @_; open(my $F, ">syntax-across-languages-per-language/what-is-missing.html") or die ''; print $F "Missing's in syntax across languages"; print $F ""; foreach (@$all_langs) { my $nb = map { @$_ } values %{$missing->{$_} || {}}; my $nb_text = sprintf("", boundit(8 * $nb), boundit(0xff - 3 * ($nb - 16))) . ($nb == 0 ? 'all done' : "$nb Missings") . ""; printf $F qq(\n), url_quote($_), html_quote($_), $nb_text; } print $F "
%s%s
"; print $F end('../'); } sub generate_proximity { my ($all, $all_langs) = @_; my ($proximity, $count) = proximity($all); open(my $F, ">syntax-across-languages/proximity.html") or die ''; print $F "Proximity between languages"; print $F ""; foreach my $lang (@$all_langs) { my $h = $proximity->{$lang}; my @l = sort { $b->[1] <=> $a->[1] } map { [ $_, $h->{$_} / ($count->{$lang} + $count->{$_}) * 2 ]; } grep { $_ ne $lang && min($count->{$lang}, $count->{$_}) > 10 } keys %$h; @l = grep { $_->[1] > 0.25 } @l or next; my $nb_text = join(' ', map { my $nb = boundit(0xff - ($_->[1] * 1.6 - 0.2) * 0xff); sprintf("%s (%d/%d)", $nb, $nb, $nb, $_->[0], $h->{$_->[0]}, $count->{$_->[0]}); } @l); printf $F qq(\n), url_quote($lang), html_quote($lang), $count->{$lang}, $nb_text; } print $F "
%s (%d)%s
"; print $F end('../'); } sub comments_text { my ($comments) = @_; my %c = reverse %{$comments->[0]} or return ''; join("\n", "

Remarks

", "
    ", (map { qq(
  • ($_) ) . html_quote($c{$_}) } (1 .. keys %c)), "
"); } sub similar_pages { <<'EOF';

Similar Pages

References

EOF } sub credits { <<'EOF';

Credits

  • Yoann 'Pad' Padioleau (Haskell additions, Beta, various fixes)
  • Jakub Travnik (Pascal, Delphi-Kylix)
  • Robert Feldt (Ruby additions)
  • Pascal Terjan (PHP)
  • Carlos 'angus' (PostScript)
  • Axel Kittenberger (various)
  • Guido van Rossum (block vs scoping)
  • Jeffrey Hobbs (Tcl)
  • Mark-Jason Dominus (SML, various)
  • Ash Searle (Java, PHP, JavaScript)
  • Mark S. Miller (E)
  • Pete Jinks (various)
  • Steve Tolkin (various)
  • Franck Arnaud (Eiffel)
  • Tom Murphy (SML)
  • Guy Steele (Fortran, and many various)
  • Carl Gay (Dylan, CommonLisp)
  • Jay nop@nop.com (Lua)
  • Philippe Lhoste (Lua, JavaScript)
  • Jim Rogers (Ada, Java, Threads section)
  • Ketil Z. Malde (Haskell)
  • Mark Carroll (Modula-3)
  • Keith Wansbrough (Haskell and a few SML)
  • Remi Vanicat (OCaml)
  • Matthieu Villeneuve (CommonLisp)
  • Joachim Durchholz (Eiffel)
  • Walter Vannini (C, "breaking lines" idea)
  • Peter Lewerin (Tcl)
  • Patrice Ossona de Mendez (Pliant)
  • Bert Freudenberg (Smalltalk & Squeak additions corrections)
  • Dennis Haney (Perl, C#)
  • Fergus Henderson (Mercury)
  • Ralph Becket (Mercury)
  • Bill Thornton (Java)
  • Nik Crabtree (C#)
  • Neal Holtz (Python)
  • Donald Chai (Python)
  • Fred Spiessens (Oz)
  • Martin Nilsson (Pike)
  • Theodore Eastman (VisualBasic)
  • George Herson (Eiffel)
  • Lee Denison (Tcl)
  • Anton Rolls (Rebol)
  • Pedro (Lua)
  • Nathan Sharfi (C99, C#, C++)
  • Dirk Gerrits (Common Lisp, Scheme, Emacs Lisp)
  • Tabitha Arrowny (Ruby, Python, Perl, ...)
  • Péter Varga (BourneShell, Common Lisp, ...)
  • Ian Henderson (Objective C)
  • Anthony Borla (Classic REXX, Prolog, Logo)
  • Paul McJones (Modula-3 fixes)
  • Uwe Kolb (Smalltalk fixes)
  • Ciaran McNulty (PHP)
  • David B. Nagle (Yorick)
  • Michael Schaufelberger (Eiffel)
  • Samuel Charron (Erlang)
  • Kyle Ross (OCaml)
  • Damien Krotkine (Ruby)
  • Guillaume Cottenceau (Java)
  • David.Whitten (MUMPS)
  • Phil Howard (various)
  • Andrzej Zawadzki (Ruby)
  • Stuart Brady (VisualBasic)
  • Joris Gillis (Maple)
  • Garrett Wollman (Ruby, BourneShell, C...)
  • Claus Gittinger (Smalltalk)
  • Bobby 'nneonneo' Xiao (Python)
  • Michael Schlenker (Tcl)
  • Alex Vondrak (Python)
  • Daniel Laberge (Pascal)
  • Daniel Wagner (Haskell)
  • Bob Bane (Common Lisp)
  • Alan Hogan (Java)
  • Steve Davison (C)
  • Konstantin Yegupov (PHP, Python...)
  • Noé Rubinstein (Io, CoffeeScript)
  • Florentin Millour (Yorick)
  • Axel Liljencrantz (FishShell)
  • Sanghyeon Seo (Lua)
  • Szabolcs Horvát (Mathematica)
  • Laurent Le Brun (F#, GNU-sed)
  • Julien Hall (Smalltalk)
  • Ian Osgood (Forth)
  • Dmitry A. Kazakov (Ada)
  • Peter Hermann (Ada)
  • Ian Jackson (Tcl, Perl, C, Assembler...)
  • Steve Breese
  • Nils M Holm (Scheme, ...)
  • Stas Malyshev (PHP5)
  • Adam Woodbeck (Go)
EOF } sub intro { my ($title_suffix, $ref) = @_; < syntax across languages$title_suffix

Introduction

What's this about?

  • Language Designers:

    Looking for operator or function names? Well have a look at the following and remember using existing one may ease the transition :)

  • Language Users:

    You know one language and want to find the corresponding operator or function in another language

  • Language lovers:

    Want to know the various ways people invented for commenting/assigning/...?

This is of course incomplete. I welcome contributions!

You may also have a look at this information sorted by languages. EOF } sub end { my ($rel) = @_; sprintf(<< 'EOF', $rel) . "\n";

Pixel
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.0 Generic License.
Generated from syntax-across-languages.html.pl EOF } sub pre { "
" . html_quote($_[0]) . "
"; } sub group_by2 { my @l; local $::i; for ($::i = 0; $::i < @_ ; $::i += 2) { push @l, [ $_[$::i], $_[$::i+1] ]; } @l; } sub html_quote { local $_ = $_[0]; s/CommonLisp/Common Lisp/; s/EmacsLisp/Emacs Lisp/; s/VisualBasic/Visual Basic/; s/ClassicREXX/Classic REXX/; if (!//) { s//>/g; s/<br>/
/g; # put back
} $_; } sub file_quote { local $_ = $_[0]; s|/|_|g; $_; } sub url_quote { local $_ = $_[0]; s/#/%23/g; file_quote($_); } sub simplify_category { my ($s) = @_; $s =~ s!(.*?)!$1!g; $s; } sub mangle_category_init { { '' => 1 }; } sub mangle_category { my ($s, $have, $seen) = @_; $s = simplify_category($s); $s = 'power' if $s eq 'exponentiation (power)'; my @l = map { ucfirst } grep { !/^(the|a)$/i } split(/[^a-z0-9]+/i, $s); my $nb = @l == 1 ? 5 : @l == 2 ? 4 : @l < 6 ? 3 : 1; length($_) > 4 and s/[aeiouy]//ig foreach @l; my $s_ = $have . join('', map { substr($_, 0, $nb) } @l); if ($seen) { $seen->{$s_} and die "name conflict @l for $s_ ($have$s vs $seen->{$s_})\n"; $seen->{$s_} = $s; } $s_; } sub member { my $e = shift; foreach (@_) { $e eq $_ and return 1 } 0 } sub uniq { my %l; $l{$_} = 1 foreach @_; grep { delete $l{$_} } @_ } sub difference2 { my %l; @l{@{$_[1]}} = (); grep { !exists $l{$_} } @{$_[0]} } sub intersection { my (%l, @m); @l{@{shift @_}} = (); foreach (@_) { @m = grep { exists $l{$_} } @$_; %l = (); @l{@m} = (); } keys %l } sub boundit { $_[0] < 0 ? 0 : $_[0] > 0xff ? 0xff : $_[0] } sub min { my $n = shift; $_ < $n and $n = $_ foreach @_; $n } sub if_ { my $b = shift; $b or return (); wantarray || @_ <= 1 or die("if_ called in scalar context with more than one argument " . join(":", caller())); wantarray ? @_ : $_[0]; } # Lua about dictionary contructors # # Given keys k1 and k2, and values v1 and v2, the general lua dictionary # constructor is: # # {[k1]=v1, [k2]=v2} # # To retrieve the value associated with key k1: # # a[k1] # # So if k1 and k2 are the strings "foo" and "bar", this is written: # # {["foo"]=v1, ["bar"]=v2} # # and # # a["foo"] # # Across languages that I use, it seems that the majority of dictionary # constructors, and most dictionary accessors, are through constant # strings. Lua's shorthand for the above is: # # {foo=v1, bar=v2} # # and # # a.foo # # which are friendlier to type and read. So I misunderstood what your # form was asking for when I said Lua's dictionary constructor was # merely {a=b, c=d}. # CommonLisp todo # - control flow: CASE, ECASE, TYPECASE, PROG1,... # - loops: DO, DO* and LOOP (*very* powerful), DOLIST, DOTIMES. # - breaking control flow: RETURN, RETURN-FROM # - exceptions: THROW, CATCH # # - strings: all the items under "missing" are not missing (except the # repetition). Look at PRINT, PRINC, PRIN1, FORMAT, LENGTH, SUBSEQ, AREF, # CHAR-CODE, CODE-CHAR, UPPER-CASE-P and others, CHAR-UPCASE and others, # STRING-UPCASE and others, misc functions on strings. # # - lists: same as above. # # - various data types: tuples can be represented by any kind of sequence, # or by structures.