Looking for operator or function names? Well have a look at the following and remember using existing one may ease the transition :)
You know one language and want to find the corresponding operator or function in another language
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.
until end of line
| # | Awk, BourneShell, E, FishShell, Icon, Io, Maple, merd, Perl, Perl6, PHP, Pliant, Python, Ruby, Tcl, YAML |
| // | BCPL, C#, C++, C99, Dylan, F#, Io, Java, JavaScript, PHP, Pike, YCP, Yorick |
| -- | Ada, Cecil, Eiffel, Haskell, Lua, Sather, Simula, SQL92 |
| ; | Assembler, Common Lisp, Emacs Lisp, Logo, MUMPS, Rebol, Scheme |
| % | Erlang, Matlab, Mercury, Oz, PostScript, Prolog, TeX |
| rem | Basic |
| ' | Visual Basic |
| \ | Forth |
| ! | Assembler, Fortran90 |
| NB. | J |
| C or * in column 1 | Fortran |
nestable
| (* ... *) | Beta, F#, Mathematica, Modula-3, OCaml, Pascal, SML |
| %( ... %) | Matlab |
| /* ... */ | Classic REXX, Dylan, Io, Oz, SQL99 |
| { ... } | Pascal, Rebol |
| {- ... -} | Haskell |
| #| ... |# | Common Lisp |
| #[ ... ] | Perl6 |
| #if 0 ... #endif | C |
| comment { ... } | Rebol |
| comment [ ... ] | Rebol |
| [ ... ](1) | Rebol |
| --[[ ... ]] | Lua |
non nestable
| " ... " | Smalltalk |
| /* ... */ | B, C, C#, C++, CSS, Java, JavaScript, Mercury, PHP, Pike, PL/I, YCP, Yorick |
| <!-- ... --> | HTML, XML |
| ( ... ) | Forth |
until end of line
| /// | C#, F#, Java |
| -- | | Haskell |
| -- ^ | Haskell |
non nestable
| /** ... */(2) | C, C#, E, Java, PHP |
| (** ... *) | F# |
| {-| ... -} | Haskell |
| (** ... *) | OCaml |
| /* DOCUMENT ... */ | Yorick |
| indexing identifier: "..."; | Eiffel |
| someClass comment: '...' | Smalltalk |
| rebol [ Note: "..." ] | Rebol |
| func ["..." arg] ... | Rebol |
class X: """... """ def x(): """... """(3) | Python |
| (define (f para1 para2) "..." ...) | Scheme |
| (defun f (para1 para2) "..." ...) | Common Lisp, Emacs Lisp |
=pod ... =cut(4) | Perl, Perl6 |
=begin ... =end | Ruby |
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 |
| __LINE__ __FILE__ | C, C++, Perl, PHP, Pike, Ruby |
| __LINE__ __SOURCE_FILE__ | F# |
| $?LINE $?FILE | Perl6 |
| inspect.stack()[0][2] inspect.stack()[0][1] | Python |
(new System.Diagnostics.StackFrame(true)).GetFileLineNumber() (new System.Diagnostics.StackFrame(true)).GetFileName() | C# |
| system/script/header/file(5) | Rebol |
| SOURCELINE() / parse source OS . SOURCENAME | Classic REXX |
| info frame 0 | Tcl8.5 |
| thisContext lineNumber / thisContext method source | Smalltalk |
case-sensitivity (keywords, variable identifiers...)
| case-sensitive | Awk, B, BourneShell, C, C#, C++, F#, FishShell, Haskell, Io, Java, JavaScript, Lua, Maple, Mathematica, Matlab, merd, Modula-3, OCaml, Perl, Perl6, Pike, Pliant, Prolog, Python, Ruby, Smalltalk, Tcl, XML, YAML, Yorick |
| case-insensitive | Ada, Assembler, Classic REXX, Common Lisp, CSS, Eiffel, Forth, HTML, Logo, Pascal, PL/I, Rebol, Scheme, SGML, SQL92, Visual Basic |
| case-sensitive: variables case-insensitive: keywords, functions, constants... | PHP |
| case-sensitive: identifiers case-insensitive: keywords | E |
| case-sensitive: identifiers case-insensitive: commands | MUMPS |
what is the standard way for scrunching together multiple words
| camelCase | JavaScript |
| CamelCase or camelCase | C#, E, Haskell, Io, Java, JavaScript, Mathematica, Pascal, Smalltalk, Tcl, Visual Basic |
| underscores | FishShell, merd |
| dots | Logo |
| hyphens | Common Lisp, Emacs Lisp, Rebol |
| underscores for functions, unclear for modules / types / 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]* | FishShell, Mathematica, PL/I, Smalltalk |
| [a-zA-Z][_a-zA-Z0-9]* | Eiffel, Matlab |
| [a-zA-Z](_?[a-zA-Z0-9])* | Ada |
| [_a-zA-Z][_a-zA-Z0-9]* | Awk, B, C, C#, C++, E, Maple, PHP, Python, Tcl |
| [_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, 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']* | Haskell, OCaml, SML |
| [_a-zA-Z][_a-zA-Z0-9']* | F# |
| [_A-Z][_a-zA-Z0-9]* | Mercury, Prolog |
| [_a-zA-Z!0&*/:<=>?^][_a-zA-Z!0&*/:<=>?^0-9.+-]* | Scheme |
| [a-zA-Z!?@#][a-zA-Z0-9!?@#]* | Classic REXX |
| [_a-zA-Z?!.'+*&|=~-][_a-zA-Z0-9?!.'+*&|=~-]* or
[^0-9[](){}":;/][^ \n\t[](){}":;/]* | Rebol |
| anything without a space and is not a number | Common Lisp, Forth |
function identifier regexp (if different from variable identifier regexp)
| [_a-zA-Z][_a-zA-Z0-9]*[!?]? | Ruby |
| [_a-z][_a-zA-Z0-9]* | Mercury, Prolog |
| [^ \t\n\r\f]+ | Tcl |
| [^ \t\n\r\f/]+ | FishShell |
keyword regexp (if different from variable identifier regexp)
| [A-Z]+ | Modula-3 |
type regexp (if different from variable identifier regexp)
| [_A-Z][_a-zA-Z0-9']* | Haskell |
| [_a-z][_a-zA-Z0-9']* | Mercury, OCaml |
constant regexp (if different from variable identifier regexp)
| [A-Z][_a-zA-Z0-9]* | Ruby |
| [_A-Z][_a-zA-Z0-9']* | Haskell, OCaml |
| [_a-z][_a-zA-Z0-9']* | Mercury |
| nothing needed | Ada, B, C, C#, C++, Common Lisp, Eiffel, Emacs Lisp, F#, Forth, Haskell, Java, JavaScript, Maple, Mathematica, OCaml, Oz, Pascal, Perl, Perl6, PostScript, Rebol, Scheme, Smalltalk, SML, XSLT, YCP |
| \ | Awk, BourneShell, C, E, FishShell, Io, Python, Ruby, Tcl |
| _ | Visual Basic |
| , | Classic REXX |
| ~ | Logo |
| ... | Matlab |
assignment
| = | Awk, B, Basic, BourneShell, C, C#, C++, Classic REXX, Erlang, Icon, Io, Java, JavaScript, Lua, Mathematica, Matlab, Oz, Perl, Perl6, PHP, Pike, YCP, Yorick |
| := | Ada, BCPL, Cecil, Dylan, E, Eiffel, Maple, Mathematica, Modula-3, Pascal, Pliant, Sather, Simula, Smalltalk, SML |
| <- | F#, OCaml |
| _(6) | Squeak |
| : | BCPL, Rebol |
| ->(7) | Beta |
| def | PostScript |
| setq | Common Lisp, Emacs Lisp |
| setf | Common Lisp |
| set | Common Lisp, FishShell, Rebol |
| SET v=... | MUMPS |
| set! | Scheme |
| is | Prolog |
| make "v e | Logo |
declaration
| = | Haskell, Mercury, Prolog |
| <- | Haskell |
| :- | Prolog |
| := | Io |
| let v = e in | F#, OCaml |
| let val v = e in | SML |
| let v = e(8) | BCPL, F# |
| def v := e / var v := e | E |
| my / our / local / use vars | Perl |
| my / our / temp | Perl6 |
| define | Dylan, Scheme |
| let let* | Common Lisp, Scheme |
| letrec fluid-let | Scheme |
| flet labels defun defmethod defvar defparameter defsetf .. | Common Lisp |
| local V1 = e V2 = e2 in ... end | Oz |
| global v1, v2 | Python |
| global v1 v2 | Matlab |
| :@ | Beta |
| NEW v | MUMPS |
| v: t | Ada, Eiffel, Pascal |
| t v | C, C#, C++, Java |
| | v1 v2 | | Smalltalk |
| auto v1, v2; extrn v3, v4; | B |
| var | JavaScript, Pliant |
| gvar | Pliant |
| variable v(9) | Forth |
| Module[{x, y = v}, ... ] | Mathematica |
| Block[{x, y = v}, ... ] | Mathematica |
| With[{c1 = v1, c2 = v2, ... }, ...] | Mathematica |
| <xsl:variable name="v" select="e"/> | XSLT |
both
| = | merd, Python, Ruby |
| := | merd |
| set, variable | Tcl |
| ( ... ) | Ada, Awk, B, BCPL, Beta, C, C#, C++, Classic REXX, E, Eiffel, F#, Haskell, Io, Java, JavaScript, Logo, Lua, Maple, Mathematica, Matlab, merd, Modula-3, MSH, MUMPS, OCaml, Oz, Pascal, Perl, Perl6, PHP, Pike, Pliant, Prolog, Python, Rebol, Ruby, Smalltalk, SML, SQL92, Tcl, XPath, YCP, Yorick |
| [ ... ] | Rebol |
| indentation | merd |
| $ ... | Haskell |
| begin ... end | F#, FishShell, OCaml, Ruby |
| space(10) | merd |
| { ... } | Awk, BourneShell, JavaScript, PHP, Pike, Tcl, Yorick |
| { ... }(11) | B, C, C#, C++, E, Haskell, Java, Modula-3, Perl, Perl6, YCP |
| ( ... )(11) | BourneShell |
| [ ... ](12) | Logo, Smalltalk |
| "..." | Tcl |
| begin ... end(11) | Ada, Pascal |
| BEGIN ... END | Modula-3 |
| do ... end | Classic REXX |
| do ... end(11) | Lua, PL/I |
| indentation | F#, MUMPS, Pliant, Python |
| indentation(11) | Haskell, merd |
| foo ... end where foo in { if, do, ... } | Modula-2, Ruby |
| foo ... end where foo in { if, for, while, ... } | Matlab |
| foo ... end where foo in { if, loop, ... } | Eiffel |
| foo ... end foo where foo in { if, do, ... } | Ada, Fortran90 |
| (* ... *)(13) | BCPL |
| (# ... #) | Beta |
| valof | BCPL |
| do | Perl, Perl6 |
| proc() .. end proc | Maple |
shallow
| == != | Awk, B, C, C++, F#, Io, Java, OCaml, Perl, Perl6, Pike, Yorick |
| = /= | Eiffel, Fortran90 |
| = <> | Logo, Maple, Modula-2, Pliant, Rebol |
| = #(14) | Modula-2, Modula-3 |
| = != | BourneShell, FishShell |
| == === != !==(15) | JavaScript, PHP |
| === !== | PHP5 |
| == ~= | Lua |
| == ~~ | Smalltalk |
| == ~== | Dylan |
| = '= | MUMPS |
| = ~= neqv(13) | BCPL |
| is_equal(16) | Eiffel |
| equal? | Scheme |
| eq ne | Emacs Lisp, PostScript |
| eq, eql | Common Lisp |
| eq? eqv? | Scheme |
| .EQ. .NE. | Fortran |
| is / is not | Python |
deep
| == != | Awk, C#, C++, E, merd, PHP5, Python, Ruby, Tcl, YCP |
| == <> | Python |
| == /= | Haskell |
| == \= | Oz |
| == \== | Classic REXX, Prolog |
| = /= | Ada |
| = != | Maple, XPath |
| = <> | Beta, F#, OCaml, Pascal, Rebol, SML, SQL92, Visual Basic |
| = ~= | Dylan, Smalltalk |
| == ~= eq ne isequal isequalwithequalnans | Matlab |
| =@= \=@= / = \= / =:= =\=(17) | Prolog |
| === =!= / == !=(18) | Mathematica |
| .eq | Logo |
| equal? | Scheme |
| equals | Java |
| equal | Common Lisp, Emacs Lisp, Pike |
| equalp | Common Lisp |
| deep_is_equal | Eiffel |
| isEqual | Objective-C |
| < > <= >= | Ada, Awk, Awk, B, Beta, C, C#, C++, Classic REXX, Common Lisp, Dylan, E, Eiffel, Emacs Lisp, F#, Haskell, Io, Java, JavaScript, Logo, Lua, Maple, Mathematica, Matlab, merd, Modula-3, OCaml, Pascal, Perl, Perl6, PHP, Pike, Pliant, Python, Rebol, Ruby, Scheme, Smalltalk, SML, SQL92, Tcl, Visual Basic, XPath, YCP, Yorick |
| < > =< >= | Mercury, Oz |
| < > '> '< | MUMPS |
| << >> <<= >>=(19) | Classic REXX |
| @< / @=< / @> / @>= | Prolog |
| lt gt le ge | Perl, Perl6, PostScript |
| -lt -gt -le -ge | BourneShell, FishShell, MSH |
| .LT. .GT. .LE. .GE. | Fortran |
returns 3 values (i.e. inferior, equal or superior)
| a <=> b | merd, Perl, Perl6, Ruby |
| cmp | Perl, Perl6, Python |
| compare | F#, Haskell, Mercury, OCaml, Pliant, Prolog, Smalltalk |
| strcmp | C, PHP |
| three_way_comparison | Eiffel |
| string compare | Tcl |
| compareTo | Java |
returns 4 values (i.e. inferior, equal, superior or not comparable)
| compare | Pliant |
| compareTo | E |
min / max (binary or more)
| min / max | Ada, Beta, C++, Common Lisp, Dylan, E, Eiffel, F#, Haskell, Io, Java, Lua, Maple, Matlab, merd, OCaml, Pike, Pliant, Prolog, Python, Rebol, Scheme, Smalltalk, SQL92, Tcl8.5, Yorick |
| min minstr / max maxstr(20) | Perl |
| Min / Max | Mathematica, Oz |
| MIN / MAX | Classic REXX, Modula-3 |
| measure-object -min / measure-object -max | MSH |
| eval | BourneShell, Common Lisp, Emacs Lisp, FishShell, JavaScript, Matlab, Perl, Perl6, PHP, Python, Ruby, Scheme, Tcl, YCP |
| exec | Python |
| dostring | Lua |
| doString | Io |
| Compiler evaluate: | Smalltalk |
| runtime_compile / compile + execute | Pliant |
| Compiler.evalExpression or Compiler.parseOzVirtualString | Oz |
| compile_string | Pike |
| interpret | Classic REXX |
| ToExpression | Mathematica |
| run | Logo |
| XECUTE | MUMPS |
| do / reduce / compose / load | Rebol |
| [...] | Tcl |
| =..(21) | Prolog |
| doGC | Beta |
| GC.start | Ruby |
| gc | Logo, Maple, Pike |
| System.gc() | Java |
| System.gcDo | Oz |
| System.GC.Collect() | C#, F# |
| gc.collect() | Python |
| 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) | Common Lisp |
| f(a,b,...) | Ada, Awk, Awk, B, C, C#, C++, CSS, Dylan, E, Eiffel, Erlang, Io, Java, JavaScript, Lua, Maple, Matlab, Mercury, merd, Modula-3, Pascal, Perl, Perl6, PHP, Pike, Prolog, Python, Ruby, XPath, YCP, Yorick |
| f a b ... | BourneShell, F#, FishShell, Haskell, Logo, Matlab, MSH, OCaml, Pliant, Rebol, SML, Tcl |
| f(a,b,...f) or f[a,b,...] depending on the version | BCPL |
| (f a b ...) (apply f l) | Common Lisp, Emacs Lisp, Scheme |
| (funcall f a b ...) | Common Lisp, Emacs Lisp |
| {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 |
| f, a, b, ...(22) | Yorick |
| v = f(a, b, ...) or call f a, b, ... | Classic REXX |
| a b ... f | Forth, PostScript |
| (a,b,...)->&f or (a,b,...)->f | Beta |
| f:a(23) | FL |
| f@a(24) | Mathematica |
| a // f(24) | Mathematica |
| a ~ f ~ b(25) | Mathematica |
| .. [ f, A, B, ...] | Prolog |
<xsl:call-template name="f">
<xsl:with-param name="a" select=a/>
<xsl:with-param name="b" select=b/>
</xsl:call-template> | XSLT |
with no parameter
| f | Ada, BourneShell, Eiffel, Haskell, Io, Logo, Matlab, Mercury, MSH, Pascal, Perl, Perl6, Pliant, PostScript, Prolog, Rebol, Ruby, Tcl, Yorick |
| f() | Awk, C, C#, C++, E, Erlang, F#, Java, JavaScript, Lua, Maple, merd, OCaml, Perl, PHP, Pike, Python, SML, YCP |
| (f) | Common Lisp, Emacs Lisp, Scheme |
| (funcall f) | Common Lisp, Emacs Lisp |
| {f} | Oz |
| f[] | Mathematica |
| f[] or f.call | Ruby |
| &$f or $f->() | Perl |
| $f.() | Perl6 |
| v = f() | Classic REXX |
| call f | Classic REXX, Fortran |
| f value(26) | Smalltalk |
| <xsl:call-template name="f">/ | XSLT |
give the first argument
| f a | F#, Haskell, OCaml, SML |
| f(a) | Mercury |
| f(a,) | merd |
| &f.assuming(var_name => a) | Perl6 |
| functools.partial(f, a)(27) | Python |
| interp alias {} f_a {} f a | Tcl |
give the second argument
| f(,b) | merd |
| &f.assuming(b => b) | Perl6 |
| flip f b(28) | Haskell |
give the first argument to operator ">"
| (a >) | Haskell, merd |
| (>) a | F#, OCaml |
give the second argument to operator ">"
| (> a) | Haskell, merd |
| 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 = ... | F#, OCaml |
| 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 |
| 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) ...) | Common Lisp, Emacs Lisp |
| fun { F Para1 Para2 } ... end | Oz |
| fun f para1 para2 = ... | SML |
| proc f {para1 para2} { ... } | Tcl |
function retval = f(para1, para2) retval = ... | Matlab |
:- func f(typ1, typ2, ...) = typ0. f(Para1, Para2, ...) = ... | Mercury |
function f(para1 : type1; para2 : typ2; ...) return retval is begin ... end f; | Ada |
function f para1 para2 -> retval arg typ1 para1; arg typ2 para2; arg rettyp retval; ... | Pliant |
function f(para1 : typ1, para2 : typ2, ...) : retval; var retval : typ0; begin ... end | Pascal |
f (para1 : typ1; para2, para3 : typ2; ...) : rettyp is do ... end | Eiffel |
<xsl:template name="f">
<xsl:param name="para1"/>
<xsl:param name="para2"/>
...
</xsl:template> | XSLT |
| Function f(para1, para2) ... End Function | Visual Basic |
| : f ... ; | Forth |
| f() { ... } | BourneShell, KornShell |
f : procedure ... return retval | Classic REXX |
to f :para1 :para2 ... end | Logo |
procedures
procedure f(para1 : typ1; para2, para3 : typ2); begin ... end | Pascal |
f (para1 : typ1; para2, para3 : typ2; ...) is do ... end | Eiffel |
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 | Visual Basic |
function f(para1, para2) ... | Matlab |
f : procedure ... return | Classic REXX |
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 |
function f(varargin)
for i=1:nargin
...(varargin{i})
end | Matlab |
predicates
| f(Para1, Para2, ....) :- ... . | Prolog |
| sub { my ($a, $b) = @_; ... } | Perl |
| { my ($a, $b) = @_; ... }(29) | Perl |
| { ... } (arguments are in the stack | PostScript |
| [ ... ] | Logo |
| { param(para1, [typ2]para2, ...) ... } | MSH |
| {|a, b| ... }(30) | Ruby |
| [:a :b| ... ] | Smalltalk |
| [list {a b} {...}] | Tcl8.5 |
| lambda a, b: ... | Python |
| lambda(typ1 para1, typ2, para2, ...) { ... }; | Pike |
| (a, b) => ... | C#3 |
| (a, b) -> ... | Maple |
| a, b -> ... | merd |
| -> $a, $b { ... } | Perl6 |
| \a b -> ... | Haskell |
| fn (a, b) => ... | SML |
| fun a b -> ... | F#, OCaml |
| (func(A, B) = C :- ...) | Mercury |
| function(a, b) ... | JavaScript |
| function(a, b) ... end | Lua |
| Function[{a, b}, ....](31) | Mathematica |
| fun(a, b) -> ... end | Erlang |
| fun {$ A B} ... end(32) | Oz |
| func [a b ...] ... | Rebol |
| def _(para1, para2, ...) ... { ... } | E |
| proc {|a, b| ...} | Ruby |
| lambda {|a, b| ...} | Ruby |
| (lambda (a b) ...) | Common Lisp, Emacs Lisp, Scheme |
| inline('...x...y...')(33) | Matlab |
| method(a, b, ...) | Io |
| method(a, b) ... end method(34) | Dylan |
| create_function(',','...') | PHP |
| delegate(ta a, tb b) { ... } | C#2 |
| [](ta a, tb b) { ... } | C++-0x |
| [](ta a, tb b) -> typ { ... } | C++-0x |
breaks the control flow
| return(35) | Ada, Awk, B, BCPL, BourneShell, C, C#, C++, Classic REXX, Common Lisp, E, FishShell, Io, Java, JavaScript, Lua, Maple, Matlab, Perl, Perl6, PHP, Pike, Pliant, Python, Rebol, Ruby, Tcl, YCP, Yorick |
| Return | Mathematica, Visual Basic |
| RETURN | Modula-3 |
| resultis(36) | BCPL |
| return from xxx | Common Lisp |
| ^ | Smalltalk |
| Exit Function / Exit Sub | Visual Basic |
| output | Logo |
function body is the result
| no syntax needed(37) | Common Lisp, Dylan, Emacs Lisp, Erlang, F#, Haskell, Io, Maple, Mathematica, Matlab, OCaml, Oz, Perl, Perl6, Rebol, Ruby, Scheme, SML, Tcl |
setting the result
| Result := val | Eiffel |
| <function name> = val | Visual Basic |
| <function name> := val | Pascal |
| <retvar name> = val; | Matlab |
| AUTOLOAD | Perl |
| AUTOSCALAR, AUTOMETH, AUTOLOAD... | Perl6 |
| __getattr__ | Python |
| method_missing | Ruby |
| doesNotUnderstand | Smalltalk |
| unknown | Tcl |
| no-applicable-method | Common Lisp |
| doesNotRecognizeSelector | Objective-C |
| match [name, args] { ... } | E |
| the predicate fail | Prolog |
| forward | Io |
| caller | Perl, Perl6, Ruby |
| call | Io |
| inspect.stack()[1] | Python |
| backtrace | Pike |
| trace 'I' | Classic REXX |
| evalin('caller', ...) | Matlab |
| current_predicate | Prolog |
| thisContext sender | Smalltalk |
| where(2) | Maple |
| info level | Tcl |
| . | Haskell |
| ~ | merd |
| o | SML |
| @ | Maple |
| compose | Dylan |
| Composition | Mathematica |
| << | F# |
| >> | F# |
| id | Haskell |
| identity | Common Lisp |
| Identity | Mathematica |
| yourself | Smalltalk |
| , | C, C++, JavaScript, Matlab, Perl, Pike, Prolog |
| . | Smalltalk |
| ; | Ada, Awk, B, Beta, BourneShell, C, C#, C++, E, F#, FishShell, Haskell, Io, Java, JavaScript, Maple, Mathematica, Matlab, merd, Modula-3, OCaml, Pascal, Perl, Perl6, PHP, Pike, PL/I, Pliant, Python, Ruby, SML, Tcl, YCP |
| : | Maple |
| nothing, optionally ; | Classic REXX, Lua |
| space | Eiffel, Rebol |
| end-of-line | Assembler, Awk, Basic, BourneShell, E, F#, FishShell, Fortran, Haskell, Io, JavaScript, Lua, Matlab, merd, Pliant, Python, Ruby, Tcl |
| (begin ...) | Scheme |
| (progn ...) (prog1 ...) (prog2 ...) | Common Lisp, Emacs Lisp |
| >> | Haskell |
| if c then ... | F#, merd, OCaml, Pascal, Tcl |
| if c then ... end | Eiffel, Lua, Oz, Ruby |
| if c then ... end if | Ada, Maple |
| if c then ... fi | BourneShell, Maple |
| 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, JavaScript, PHP, Pike, YCP |
| if c: ... | Python |
| if c ... | Pliant, Rebol, Tcl |
| if (c): ... endif | PHP |
| if c {...} | Perl6 |
| if c [...] | Logo |
| if (c) {...} | E, Perl, Yorick |
| IF c ... | MUMPS |
| c -> ... | FL |
| c ... if | PostScript |
| ... if c | Perl, Ruby |
| c if b1 then | Forth |
| (if c ...) | Common Lisp, Scheme |
| (when c ...) | Emacs Lisp |
| c and ... | Perl, Ruby |
| if(c, ...) | Io |
| If[c, ...] | Mathematica |
| if(c) then(...) | Io |
| c ifTrue(...) | Io |
| c ifTrue: ... | Smalltalk |
| <xsl:if test="c">...</xsl:if> | XSLT |
| If c Then ... | Visual Basic |
If c ... End If | Visual Basic |
| if c; ... end | Ruby |
| if c; ...; end | FishShell |
| if c, ..., end | Matlab |
if c ... end | Matlab, Ruby |
if c then ; ... if c then ... if c then do ... end | Classic REXX |
| if c then b1 else b2 | F#, Haskell, merd, OCaml, SML |
| if c then b1 else b2 end | Eiffel, Lua, Ruby |
| 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++, Java, JavaScript, Pike, YCP |
| if c b1 elsif c2 b2 b3 | Tcl |
| if c then b1 elsif 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) | Common Lisp, 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)) | Common Lisp, Emacs Lisp |
| (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(38) | Haskell |
| c b1 b2 ifelse | PostScript |
| c if b1 else b2 then | Forth |
| c ? b1 : b2 | Awk, B, C, C#, C++, Java, JavaScript, Perl, PHP, Ruby, YCP, Yorick |
| c ?? b1 !! b2 | Perl6 |
| b1 if c else b2(27) | Python |
| $SELECT(c:b1,c2:b2,1:b3) | MUMPS |
| c -> b1, b2 | BCPL |
| (if c then b1 else b2 fi) | Beta |
<xsl:choose>
<xsl:when test="c"> b1 </xsl:when>
<xsl:when test="c2"> b2 </xsl:when>
<xsl:otherwise> b3 </xsl:otherwise>
</xsl:choose> | XSLT |
| If c Then b1 Else b2 | Visual Basic |
If c b1 Else b2 End If | Visual Basic |
if c: b1 elif c2: b2 else: b3 | Python |
if c b1 elsif c2 b2 else b3 end | Ruby |
if c b1 elseif c2 b2 else b3 end | Matlab |
if c then ; b1 ; else ; b2 if c then b1 else b2 if c then do b1 ... end else do b2 ... end | Classic REXX |
IF c ... ELSE ... | MUMPS |
| unless | Emacs Lisp, Perl |
| ifFalse | Smalltalk |
| if(c) not then(...) | Io |
switch (val) {
case v1: ...; break;
case v2: case v3: ...; break;
default: ...;
} | C, C++, Java, JavaScript, PHP, Pike |
switch val {
case v1: ...; goto done;
case v2: case v3: ...; goto done;
}
...;
done:
| B |
switch (val) {
case v1: ...; break;
case v2: case v3: ...; break;
default: ...; break;
}(39) | C# |
switch (val) {
match v1 { ... }
match v2 { ... }
match _ { ... }
} | E |
switchon val case v1: ... case v2: ... default: ... | BCPL |
switch val
case v1
...
case v2 v3
...
case '*'
...
end | FishShell |
switch val
case v1
...
case {v2,v3}
...
otherwise
...
end | Matlab |
case val of v1 : ...; v2, v3 : ... else ... end | Pascal |
switch val {
v1 {...}
v2 - v3 {...}
default {...}
} | Tcl |
case val in v1) statement1 ;; v2|v3) statement23 ;; *) statement_else ;; esac | BourneShell |
(if val
// v1 then ...
// v2 then ...
else ...
if) | Beta |
match val with | v1 -> ... | v2 | v3 -> ... | _ -> ... | F#, OCaml |
case val of v1 => ... | v2 => ... | _ => ... | SML |
CASE val OF v1 => ... | v2 => ... ELSE => ... END | Modula-3 |
case val of v1 -> ... v2 -> ... _ -> ... | Haskell |
val. v1 -> ... v2 -> ... _ -> ... | merd |
(case val ((v1) ...) ((v2) ...) (otherwise ...)) | Common Lisp |
(case val ((v1) ...) ((v2) ...) (else ...)) | Scheme |
case val is when v1 => ... when v2 | v3 => ... when others => ... end case; | Ada |
case val when v1; ... when v2, v3; ... else ... end | Ruby |
inspect val when v1 then statement1 when v2, v3 => statement23 else statement_else end | Eiffel |
select (val); when (v1) statement1; when (v2, v3) statement23; otherwise statement_else; end; | PL/I |
X = val, (X = v1, ... ; X = v2, ... ; ...) | Mercury, Prolog |
my %case = (
v1 => sub { ... },
v2 => sub { ... },
);
if ($case{val}) { $case{val}->() } else { ... } | Perl |
use Switch;
switch ($val) {
case v1 { ... }
case v2 { ... }
else ...
})(40) | Perl |
given $val {
when v1 { ... }
when v2 { ... }
default { ... }
} | Perl6 |
Select val
Case v1
...
Case v2, v3
...
Case Else
...
End Select | Visual Basic |
switch (val) {
v1 { ... }
v2 { ... }
default { ... }
} | MSH |
switch val [
v1 [...]
v2 [...]
]
switch/default [
v1 [...]
v2 [...]
][...] | Rebol |
| val caseOf: {[v1]->[...]. [v2]->[...]} otherwise: ... | Squeak |
| Switch[val, v1, ..., v2, ..., _, ...] | Mathematica |
select when v1 ... when v2 | v3 ... otherwise ... end | Classic REXX |
CASE val
WHEN v1 THEN ...
WHEN v2 THEN ...
ELSE ...
END | SQL92 |
forever loop
| loop | merd, Perl6, PostScript, Ruby |
| loop(...) | Io |
| loop ... end loop | Ada |
| LOOP ... END | Modula-3 |
| (loop do ...) | Common Lisp |
| cycle (# do ... #) | Beta |
| repeat | Squeak |
| forever | Logo, Rebol |
Do
...
Loop | Visual Basic |
do forever ... end | Classic REXX |
while condition do something
| while (c) ... | Awk, B, C, C#, C++, E, Java, JavaScript, Perl, PHP, Pike, Ruby, YCP, Yorick |
| while c ... | Perl6, Tcl |
| while c loop ... end loop | Ada |
| while c do ... | BCPL, Pascal, SML |
| while c do ... done | F#, OCaml |
| 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 ...) | Common Lisp |
| loop (# while ::< (# do c -> value #) do ... #) | Beta |
| begin c while ... repeat | Forth |
| from until not c loop ... end | Eiffel |
while c
... | Pliant |
while c do
... | F# |
Do While c
...
Loop | Visual Basic |
do while c ... end | Classic REXX |
do something until condition
| do ... until c | Perl6 |
| do {...} until c | Perl |
| do ... while (!c) | Awk, C, C#, C++, Java, JavaScript, Pike, Yorick |
| begin ... end until c | Ruby |
| REPEAT ... UNTIL c | Modula-3 |
| loop (# until ::< (# do c -> value #) do ... #) | Beta |
| loop ... exit when c end loop | Ada |
| (loop do ... until c) | Common Lisp |
| ... 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 |
Do ... Loop Until c | Visual Basic |
for each value in a numeric range, 1 increment (see also the entries about ranges)
| 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 | F#, OCaml |
| For i = 1 To 10 ... Next | Visual Basic |
| for i in 1 .. 10 loop ... end loop | Ada |
| for i in 1 .. 10 do ... done | F# |
| for i in xrange(1, 11) | Python |
| for i in (seq 10); ...; end | FishShell |
| 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 |
| (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 ...) | Common Lisp |
| Do[..., {i, 1, 10}](41) | Mathematica |
do i = 1 for 10 ... end | Classic REXX |
for each value in a numeric range, 1 decrement
| for X := 10 downto 1 do ... | Pascal |
| for i = 10 downto 1 do ... done | F#, OCaml |
| 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 = 1; i <= 10; i--) ... | Awk, JavaScript |
| for ($i = 1; $i <= 10; $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 | Visual Basic |
| 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 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 ...) | Common Lisp |
| Do[..., {i, 10, 1, -1}] | Mathematica |
do i = 10 to 1 by -1 ... end | Classic REXX |
for each value in a numeric range, free increment
| 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 | Visual Basic |
| for i in 1 .. 2 .. 10 do ... done | F# |
| for i in xrange(1, 11, 2) | Python |
| 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 |
| 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 ...) | Common Lisp |
| Do[..., {i, 1, 10, 2}] | Mathematica |
do i = 1 to 10 by 2 ... end | Classic REXX |
for "a la C" (while + initialisation)
| for | Awk, C, C#, C++, Java, JavaScript, Mathematica, MSH, Perl, PHP, Pike, Tcl, Yorick |
| loop | Perl6 |
| for ((x = 0; x < 10; x++)); do ...; done | BourneShell |
| from init_code until c loop ... incr_statement end | Eiffel |
returning a value
| return(35) | Ada, Awk, B, BCPL, BourneShell, C, C#, C++, Classic REXX, Common Lisp, E, FishShell, Io, Java, JavaScript, Lua, Maple, Matlab, Perl, Perl6, PHP, Pike, Pliant, Python, Rebol, Ruby, Tcl, YCP, Yorick |
| Return | Mathematica, Visual Basic |
| RETURN | Modula-3 |
| resultis(36) | BCPL |
| return from xxx | Common Lisp |
| ^ | Smalltalk |
| Exit Function / Exit Sub | Visual Basic |
| output | Logo |
goto (unconditional jump)
| goto | Ada, B, Basic, BCPL, C, C#, C++, Cobol, Fortran, Logo, MUMPS, Pascal, Perl, Yorick |
| Goto | Mathematica |
| go throw | Common Lisp |
| signal | Classic REXX |
continue / break
| continue / break | Awk, C, C#, C++, E, FishShell, Io, Java, JavaScript, Matlab, PHP, Pike, Python, Tcl, YCP, Yorick |
| Continue / Break | Mathematica |
| next / last | Perl, Perl6 |
| next / break(42) | Maple, Ruby |
| / break | BCPL, Lua |
| / break/return | Rebol |
| / exit | Ada, PostScript |
| / stop | Logo |
| restart / leave | Beta, Pliant |
| / Exit Do, Exit For | Visual Basic |
| / return from xxx or return | Common Lisp |
| iterate / leave | Classic REXX |
redo / retry
| redo/ | Perl, Perl6 |
| redo / retry | Io, Ruby |
throwing
| raise | Ada, Eiffel, F#, merd, OCaml, Python, Ruby, Scheme-SRFI34, SML |
| RAISE | Modula-3 |
| raise ... end | Oz |
| Exception raise | Io |
| throw | C#, C++, E, Erlang, Haskell, Java, JavaScript, Logo, Pike, Prolog, Rebol |
| Throw | Mathematica |
| throw/name | Rebol |
| throw new exception | PHP5 |
| die | Perl, Perl6 |
| return -code | Tcl |
| error | Common Lisp, Dylan, Emacs Lisp, Lua, Lua, Maple, Matlab, Pliant, Yorick |
| signal | Common Lisp, Dylan, Smalltalk |
| signal predefined_condition_name | Classic REXX |
| cerror warn | Common Lisp |
| [NSException raise:name ...] | Objective-C |
catching
| try: a except exn: ... | Python |
| try a with exn -> ... | F#, OCaml |
| try a catch (exn) ... | C#, C++, Java, JavaScript, 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, Logo, Prolog, 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 | Common Lisp |
| NS_DURING a NS_HANDLER ... NS_ENDHANDLER | Objective-C |
try a catch ... end | Matlab |
signal on predefined_condition_name ... predefined_condition_name : ... | Classic REXX |
cleanup: code executed before leaving
| ensure | Ruby, Smalltalk |
| finally | C#, F#, Java, Maple, Python |
| FINALLY | Modula-3 |
| unwind-protect | Common Lisp, Emacs Lisp |
| cleanup | Dylan |
| dynamic-wind | Scheme |
retrying: after catching an exception, tell the snippet to be re-run
| retry | Eiffel, Ruby, Smalltalk |
| restart | Dylan |
resume execution where the exception took place
| resume | Smalltalk |
| call-with-current-continuation(43) | Scheme |
| callcc | Ruby, SML-NJ |
| typedef t n | C, C++, Pike |
| type n is t | Ada |
| type n ... | Pliant |
| type n = t | F#, Haskell, OCaml, Pascal, SML |
| 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) | Common Lisp |
| : | Ada, E, Eiffel, F#, Modula-3, OCaml, Pascal, SML |
| :: | Dylan, Haskell, Mercury |
| !! | merd |
| t v | C, C#, C++, Java, Perl6, Pike, Pliant, YCP |
| (declare (t v)) | Common Lisp |
| v :@ t | Beta |
| typeset | BourneShell |
| _t(44) | Mathematica |
upcast
| (t) e | C, C#, C++, Java, PHP |
| t(e) | Ada, Pascal |
| [t] e | Pike |
| static_cast<t>(e) | C++ |
| e :> t | OCaml |
| e : t | F# |
| upcast e | F# |
| CAST(e as t) | SQL92 |
| typecast(e,t) | Matlab |
downcast (need runtime checking)
| (t) e | Java |
| t(e) | Ada |
| e : t | E |
| [t] e | Pike |
| dynamic_cast<t>(e) | C++ |
| e as t | C# |
| e :?> t | F# |
| downcast e(45) | F# |
| v ?= e(46) | 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) | C++, Matlab, Python |
| t e | F# |
| e : t | E |
| e :: t | Haskell |
| cast e t | Pliant |
| ... cast t | Pliant |
| make t e / to t e | Rebol |
type of a mutable value
| mutability is the default | Ada, C, C#, C++, Java, Matlab |
| val x: T | Pascal |
| T ref | F#, OCaml, SML |
| STRef a T | Haskell |
type of a constant value
| const T | C++, C99 |
| constant T | Ada |
| const x: T | Pascal |
| constness is the default | F#, Haskell, OCaml, SML |
special cases
| "readonly" fields(47) | C# |
| "final" fields, parameters, local variables(47) | Java |
| object.method(para) | Beta, C#, C++, Cecil, Delphi-Kylix, E, Eiffel, F#, Icon, Java, JavaScript, merd, Modula-3, MSH, Perl6, Python, Ruby, Sather, Visual Basic |
| object#method para | OCaml |
| object:method(para) | Lua |
| object method(para) | Io |
| object method para | Pliant, Tcl |
| object method: para1 method_continuation: para2 | Smalltalk |
| object <- method(para)(48) | E |
| [ object method: para ] | Objective-C |
| object->method(para) | C++, Perl, PHP, Pike |
| object["method"](para) | Pike |
| object/method para | Rebol |
| method object para | Haskell, Mercury |
| (method object para) | Common Lisp |
| method(object, para) | Ada, Dylan, Matlab |
| para->method | Beta |
| (send object method para) | MzScheme |
with no parameter
| object.method | Eiffel, F#, merd, Perl6, Ruby |
| object.property(49) | C# |
| object.method() | C#, C++, E, Java, JavaScript, Python |
| object#method | OCaml |
| object:method | Pliant |
| object->method | Perl |
| object->method() | Pike |
| object/method | Rebol |
| object["method"]() | Pike |
| object method | Io, Smalltalk |
| [ object method ] | Objective-C |
| method object | Haskell, Mercury |
| (method object) | Common Lisp |
| method(object) | Ada, Dylan, Matlab |
| (send object method) | MzScheme |
| new | Ada, PHP, Pliant, Simula |
| new class_name(...) | C#, C++, F#, Java, JavaScript, Perl, PHP, Visual Basic |
| new class_name ... | OCaml |
| class_name.new(...) | Perl6, Ruby |
| class_name new | Smalltalk |
| class_name(...) | F#, Matlab, Pike, Python |
| class_name v(...) | C++ |
| class_name.Create | Delphi-Kylix |
| !class_name!constructor_name(...) | Eiffel |
| & | Beta |
| make-object | MzScheme |
| (make-instance class_name ...) | Common Lisp |
| [class_name alloc] | Objective-C |
| make class_name! ... | Rebol |
| def object_name { ... } | E |
| o.clone | Perl6 |
| o.clone(50) | Eiffel, Ruby |
| 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)(51) | Python |
| purecopy | Emacs Lisp |
| {< >} or Oo.copy o | OCaml |
| o2 = o(52) | C++, Matlab, PHP |
| $o2 = $o | PHP |
| o2.all := o.all | Ada |
| make o [] | Rebol |
| delete | C++, JavaScript |
| destroy | Pike |
| DESTROY | Perl |
| dealloc | Objective-C |
| Dispose | C#, F# |
| del, __del__ | Python |
| Requires instantiation of Ada.Unchecked_Deallocation | Ada |
| class | C#, C++, Haskell, Java, Matlab, MzScheme, OCaml, Perl6, PHP, Pike, Python, Ruby |
| class c inherit p1 p2 ... feature decl decl ... end | Eiffel |
| defclass defstruct | Common Lisp |
| subclass | Smalltalk |
| type | Pliant |
| type c is tagged record ... end record | Ada |
| @interface c { ... } ... @end | Objective-C |
| : | Beta |
| type c() = class ... end | F# |
type c() = ... | F# |
| isa | Matlab, Perl |
| is_a? kind_of? | Ruby |
| o.meta.isa | Perl6 |
| isKindOf(53) | Smalltalk |
| isKindOfClass | Objective-C |
| dynamic_cast | C++ |
| instanceof | Java, JavaScript |
| isinstance | Python |
| in | Ada |
| is | C# |
| is_a | PHP |
| :? | F# |
| Program.inherits or Program.implements | Pike |
| entry_type | Pliant |
| typep | Common Lisp |
| ISTYPE | Modula-3 |
| object## < classname## | Beta |
| type.accepts(object) / object =~ v : type | E |
| var ?= val(54) | Eiffel |
| class | Matlab, Objective-C, Ruby, Smalltalk |
| __class__ | Python |
| getClass | Java |
| GetType | F# |
| typeid | C++ |
| typeof | C#, JavaScript |
| type-of | Common Lisp |
| type | Io |
| ref | Perl |
| generator | Eiffel |
| meta | Perl6 |
| object_program | Pike |
| getAllegedType | E |
| methods | Matlab, Ruby |
| 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 |
| child :< parent | Beta |
| class child : parent | C#, C++ |
| class child < parent end | Ruby |
| class child is parent { ... } | Perl6 |
| class child extends parent | Java |
| class child(parent): | Python |
| class child inherit parent end | Eiffel |
| parent subclass: child | Smalltalk |
| make parent ... | Rebol |
| inherit | OCaml, Pike |
| def child extends makeSuperObject(parent, ...) { ... } | E |
| type child is new parent with record ... end record | Ada |
type child = inherit parent ... | F# |
| (defclass child (parent) ...) | Common Lisp |
| @interface child : parent { ... } ... @end | Objective-C |
| @ISA = qw(parent1 parent2) | Perl |
| clone , setProtos, setProto, prependProto, appendProto | Io |
| instance Parent Child where ... | Haskell |
| can | Perl, Perl6 |
| respond_to? | Ruby |
| respondsTo | E, Smalltalk |
| respondsToSelector | Objective-C |
| hasattr(obj, "meth")(55) | Python |
| object->method | Pike |
| all [in object 'method function? get in object 'method] | Rebol |
| find-method | Common Lisp |
| ismethod | Matlab |
| hasSlot | Io |
| try obj.GetType().GetMethod("meth") with ... | F# |
| this | Beta, C#, C++, Java, JavaScript, PHP, Pike |
| THIS | Simula |
| self | Io, Objective-C, Rebol, Ruby, Smalltalk |
| object_name if defined as: def object_name { ... } | E |
| Current | Eiffel |
| first parameter(56) | Matlab, Perl, Pliant, Python |
| the object variable | F# |
| dispatching parameter | Ada, Common Lisp |
| Me | Visual Basic |
| . | Perl6 |
| super | E, Java, Objective-C, Ruby, Smalltalk |
| 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 |
| call-next-method | Common Lisp |
type foo2 = inherit foo as parent ... member ... = ... parent.meth | F# |
| inner | Beta |
| . | Ada, C#, E, F#, Haskell, Java, Modula-3, OCaml, Pascal, Python, Ruby, SML, Squeak |
| : | XML |
| :: | C++, merd, Perl, Ruby, Squeak, Tcl, YCP |
| : ::(57) | Common Lisp |
| :- | Maple |
| ' | Perl |
| ` | Mathematica |
| __ | Mercury |
| / | Matlab |
| package p; | Java, Perl |
| namespace p { ... } | C#, C++ |
| namespace p ... | F# |
| 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 ...) | Common Lisp |
| automatically done based on the file name | OCaml, Python, Tcl8.5 |
| package provide p 1.0 | Tcl |
| package declare(58) | Matlab |
| Begin["p`"] ... End[] | Mathematica |
| BeginPackage["p`"] ... EndPackage[] | Mathematica |
| <node xmlns="namespace"> ... </node> | XML |
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 |
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) | Common Lisp |
| attached to each name (public, private...) | Java, Pike |
| namespace export name1 | Tcl |
namespace p val name1 : type1 ... | F# |
| append_features | Ruby |
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 |
everything into current namespace
| use p(59) | Perl |
| uses p | Pascal |
| using p | C# |
| using namespace p; | C++ |
| (use-package 'p) | Common Lisp |
| open p | F#, OCaml |
| 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 |
selectively
| import p (name1, name2, ...) | Haskell |
| import p.name1; import p.name2 | Java |
| (import '(p:name1 p:name2)) | Common Lisp |
| 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 := <import:p.name> | E |
| :- use_module(name1, name2, ...) | Prolog |
package (ie. load the package)
| import p | Python |
| use p;(60) | Perl |
| require p | Perl |
| require "p" | Ruby |
| require, "p" | Yorick |
| (require 'p)(61) | Common Lisp |
| with p; | Ada |
| with(p) | Maple |
| package require p | Tcl |
| automatically done(62) | Java, OCaml |
| char[] | C |
| char const[] | C++ |
| string | C#, C++, F#, Maple, OCaml, Pascal, Pike, SML, YCP |
| string! | Rebol |
| String | Ada, C#, Haskell, Java, JavaScript, merd, Ruby, Smalltalk, Visual Basic |
| STRING | Eiffel |
| str | Python, YAML |
| Str | Perl6, Pliant |
| NSString * | Objective-C |
| CHAR, VARCHAR(size) | SQL92 |
| Sequence | Io |
| char | C, C#, C++, F#, OCaml, SML |
| char! | Rebol |
| Char | Haskell, merd, Perl6 |
| Character | Ada, Smalltalk |
| CHARACTER | Eiffel |
| 'z' | Ada, B, C, C#, C++, Classic REXX, E, Eiffel, F#, Haskell, Matlab, OCaml, Pascal, Pike |
| "z" | BourneShell, Classic REXX, Maple, merd |
| "z | Logo |
| $z | Smalltalk |
| #\z | Common Lisp, Scheme |
| #"z" | Rebol, SML |
| &z | Oz |
| ?z | Emacs Lisp, Ruby |
with no interpolation of variables
| '...' | Beta, BourneShell, Classic REXX, CSS, FishShell, JavaScript, Lua, Matlab, Pascal, Perl, Perl6, PHP, Prolog, Python, Ruby, Smalltalk, SQL92, XPath, YAML |
| "..." | Ada, Awk, C, C#, C++, Classic REXX, Common Lisp, CSS, Dylan, E, Eiffel, Emacs Lisp, F#, FL, Haskell, Io, Java, JavaScript, Lua, Maple, Mathematica, Modula-3, MUMPS, OCaml, Oz, Pike, Pliant, Prolog, Python, Rebol, Scheme, SML, XPath, YAML, YCP |
| "... | Logo |
| '''...''' | Python |
| """...""" | Io, Python |
| [[ ... ]] | Lua |
| R"[ ... ]" | C++-0x |
| <<'MARK' ... MARK | BourneShell, Perl, Ruby |
| {...{...}...} | Tcl |
| (...) | PostScript |
| q(...(...)...), q[...], q{...}, q<...>, q/.../ | Perl, Perl6 |
| %q(...(...)...), %q[...], %q{...}, %q<...>, %q/.../ | Ruby |
| q(...(...)...) | merd |
| @"...""..." | C# |
| @"..." | Objective-C |
with interpolation of variables
| ...(63) | Tcl |
| "... $v ..." | BourneShell, FishShell, Perl, Perl6, PHP, Tcl |
| "... {v} ..." | merd |
| "... #{v} ..." "... #$v ..." "... #@v ..." "... #@@v ..." | Ruby |
| <<MARK ... $v ... MARK | BourneShell, Perl |
| <<MARK ... #{v} ... MARK | Ruby |
| <<<MARK ... $v ... MARK | PHP |
| [ subst {...{... $v ...}...} ] | Tcl |
| 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)
| \n | Tcl |
| "\n" | C, C#, C++, FishShell, Haskell, Io, Java, JavaScript, Lua, Maple, Mathematica, OCaml, Perl, Perl6, Pike, Python, Ruby, YCP, Yorick |
| "*n" | B, BCPL |
| "%N" | Eiffel |
| "^/" | Rebol |
| "~%"(64) | Common Lisp |
| "[lf]" | Pliant |
| vb_nl | Visual Basic |
| <N>(65) | Smalltalk |
| all strings allow multi-line strings | Common Lisp, E, Emacs Lisp, F#, FishShell, Io, Maple, Mathematica, OCaml, Pascal, Perl, Perl6, Ruby, Scheme, Smalltalk, YCP |
| "...", {...} | Tcl |
| @"..." | C# |
| '''...''', """...""" | Python |
| [[ ... ]] | Lua |
| {...} | Rebol |
"...\n" "...\n" | C |
... "...\n\
\...\n" | Haskell |
"...", "..." | Classic REXX |
"...%N% %...%N" | Eiffel |
| show | Haskell |
| to_s, to_str, inspect, String() | Ruby |
| to_string | merd, Pliant |
| tostring | Lua, YCP |
| toString | Java, JavaScript |
| ToString | C#, F#, Mathematica |
| String | JavaScript |
| perl | Perl6 |
| Dumper | Perl |
| "" . e | Perl |
| "" ~ e | Perl6 |
| "" + e | E, Java, JavaScript |
| string | Pliant |
| str, `e`, repr | Python |
| out | Eiffel |
| cvs | PostScript |
| 'Image | Ada |
| asString | Io, Smalltalk |
| printString | Smalltalk |
| as(<string>, e) | Dylan |
| (string) e | Pike |
| convert(e,string) | Maple |
| (coerce e 'string) | Common Lisp |
| prin1-to-string | Emacs Lisp |
| to string! / to-string / to "" | Rebol |
| description | Objective-C |
| pr1 | Yorick |
| export-clixml | MSH |
| serialize | Io, PHP |
| Marshal.to_string | OCaml |
| Marshal.dump | Ruby |
| Data.Binary.encode | Haskell |
| BinaryFormatter.Serialize | F# |
| storeBinaryOn | Smalltalk |
| Storable::store | Perl |
| pickle.dump(66) | Python |
| (with-standard-io-syntax (write obj stream)) | Common Lisp |
| 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)) | Common Lisp |
| Storable::store | Perl |
| doString | Io |
| sprintf | Awk, C, C++, F#, Maple, Matlab, merd, OCaml, Perl, Perl6, PHP, Pike, Ruby |
| printf | Haskell |
| % | Python, Ruby |
| format | Java, Lua, Tcl |
| format(67) | Common Lisp, Erlang, Scheme-SRFI28 |
| Format | C#, F# |
| putFormat | Beta |
| stringWithFormat | Objective-C |
| expandMacrosWith(67) | Smalltalk |
| Storable::retrieve | Perl |
on strings
| puts | C, Dylan |
| Awk, Basic, Java, Maple, merd, PHP, SML | |
| write | JavaScript, Pascal, Pike, Yorick |
| putStr | Haskell |
| print_string | F#, OCaml |
| console | Pliant |
| writeln | JavaScript, Pascal |
| write-string | Common Lisp |
| putStrLn | Haskell |
| Put_Line | Ada |
| display | Cobol |
| message | Emacs Lisp |
| put_string | Eiffel |
| show | Smalltalk |
| print_endline(68) | OCaml |
| println(68) | Java, merd |
| put_chars | Erlang |
| echo(69) | BourneShell, FishShell, PHP |
| emit | Forth |
| putText | Beta |
| say | Classic REXX |
on simple objects
| Perl, Perl6 | |
| say(68) | Perl6 |
| puts(68) | Tcl |
| puts -nonewline | Tcl |
on any objects
| Io, Logo, Lua, Ruby | |
| print(68) | Dylan, Haskell, Python, Rebol |
| Mathematica | |
| print e, | Python |
| println(68) | Io |
| prin | Rebol |
| Put | Ada |
| p(68) | Ruby |
| puts(70) | Ruby |
| display | Scheme |
| write | Common Lisp, Io, Prolog, Scheme |
| writeln(68) | Io |
| Common Lisp | |
| printOn | Smalltalk |
| princ prin1 | Common Lisp, Emacs Lisp |
| 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 | Awk, C, C++, F#, Haskell, KornShell, Maple, Matlab, merd, OCaml, Perl, PHP, Ruby |
| write | Pike |
| WriteLine | C# |
| putFormat | Beta |
| format(67) | Common Lisp, Prolog |
| eq ne | Perl, Perl6, Tcl |
| strcmp | C, Matlab |
| == != | JavaScript, Pike |
| == ~= | Lua |
| = \= | Prolog |
| isEqualToString(71) | Objective-C |
| == != | Awk, C#, C++, E, Io, merd, Python, Ruby, YCP |
| == <> | Python |
| == /= | Haskell |
| == \= | Oz |
| = != | BourneShell, FishShell, Maple, XPath |
| = /= | Ada |
| = \= | Classic REXX |
| = <> | Beta, F#, OCaml, Pliant, SML, Visual Basic |
| = ~= | Dylan, Smalltalk |
| == \== or = <> \= | Classic REXX |
| === =!= / == !=(18) | Mathematica |
| == ~= | Matlab |
| equal? | Ruby, Scheme |
| equals | Java |
| equal, equalp | Common Lisp |
| is_equal | Eiffel |
| isEqual | Objective-C |
| length | Awk, Beta, C++, Common Lisp, Eiffel, F#, Haskell, Java, JavaScript, Maple, Matlab, Objective-C, OCaml, Perl, PostScript, Prolog, Ruby |
| LENGTH | Classic REXX |
| 'Length | Ada |
| length? | Rebol |
| size | C++, E, Io, Ruby, Smalltalk, SML, YCP |
| Length | C#, F#, Modula-3, Oz, Pascal |
| len | Pliant, Python, Visual Basic |
| strlen | C, PHP |
| 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 |
| + | C#, C++, E, Eiffel, F#, Java, JavaScript, merd, MSH, Pascal, Pike, Pliant, Python, Ruby, YCP |
| . | Perl, PHP |
| .. | Io, Lua |
| , | Smalltalk |
| ~ | Perl6 |
| & | Ada, Modula-3, Visual Basic |
| ^ | F#, OCaml, SML |
| _ | MUMPS |
| || | Cecil, Classic REXX, Icon, Maple, PL/I, SQL92 |
| ++ | Haskell |
| $a$b | BourneShell, FishShell, Tcl |
| concatenate | Common Lisp, Dylan |
| string-append | Scheme |
| StringJoin | Mathematica |
| cat | Maple |
| Cat | Modula-3 |
| strcat | C |
| concat | XPath |
| append | Beta, Prolog, Rebol |
| stringByAppendingString | Objective-C |
| Awk, Classic REXX | |
| [string1 string2] | Matlab |
| word | Logo |
| * | Ada, E, Pike, Python, Ruby |
| x | Perl, Perl6 |
| times | merd |
| repeat | Pliant |
| repeated | Io |
| str_repeat | PHP |
| string repeat | Tcl |
| strrep | Lua |
| repmat | Matlab |
| insert/dup | Rebol |
| COPIES | Classic REXX |
| cat(s$n) | Maple |
| concat $ replicate | Haskell |
| upcase / downcase | Emacs Lisp, Ruby |
| uc / lc | Perl, Perl6 |
| upper / lower(72) | Lua, Matlab, Pliant, Python |
| toUpper / toLower | Haskell |
| to_upper / to_lower | Eiffel |
| To_Upper / To_Lower | Ada |
| toUpperCase / toLowerCase | E, Java, JavaScript |
| upper_case / lower_case | Pike |
| uppercase / lowercase | F#, Logo, OCaml |
| strupper / strlower | Lua |
| ToUpper / ToLower | C#, F#, Oz |
| toupper / tolower | Awk, C, C++ |
| string toupper / string tolower | Tcl |
| asLowercase / asUppercase | Io, Smalltalk |
| upCase / lowCase | Beta |
| uppercase form / lowercase form | Rebol |
| char-upcase / char-downcase | Common Lisp, Scheme |
| char_type(C_, to_upper(C)), char_type(C_, to_lower(C)) | Prolog |
| upcase / downcase | Emacs Lisp, Ruby |
| upper / lower | Matlab, SQL92 |
| upper / lower / capitalize | Python |
| uppercase/lowercase | F#, Logo, OCaml, Rebol |
| upcase_atom/downcase_atom | Prolog |
| toUpperCase / toLowerCase | E, Java, JavaScript |
| ToUpperCase / ToLowerCase | Mathematica |
| ToUpper / ToLower | C#, F# |
| to_upper / to_lower | Ada, Eiffel |
| 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 | Visual Basic |
| strtoupper / strtolower | PHP, Yorick |
| strupper / strlower | Lua |
| string toupper / string tolower / string totitle | Tcl |
| string-upcase / string-downcase | Common Lisp, 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 | Classic REXX |
| chr | F#, Haskell, OCaml, Pascal, Perl, Perl6, PHP, Python, Ruby, SML |
| chr$ | Visual Basic |
| char | Matlab |
| format %c $c | Tcl |
| toChar | E |
| strchar | Lua |
| from_integer | Eiffel |
| fromCharCode | JavaScript |
| FromCharacterCode | Mathematica |
| character | Pliant |
| Character value: c | Smalltalk |
| asCharacter | Io |
| code-char | Common Lisp |
| integer->char | Scheme |
| 'Val | Ada |
| (char) c | C, C#, C++, Java |
| to char! / to-char | Rebol |
| X2C, D2C | Classic REXX |
| $CHAR(s) | MUMPS |
| char_code | Prolog |
| ascii | Logo |
| StringTools[Char] | Maple |
| ord | F#, Haskell, Pascal, Perl, Perl6, PHP, Python, SML |
| asc | Visual Basic |
| getNumericValue | Java |
| charCodeAt | JavaScript |
| asciiValue | Smalltalk |
| code | Eiffel, OCaml |
| char-code | Common Lisp |
| 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 | Classic REXX |
| $ASCII(s) | MUMPS |
| (done automatically when applying mathematical operations on char, such as +) | Matlab |
| char | Logo |
| char_code | Prolog |
| StringTools[Ord] | Maple |
| s[n] | C, C#, C++, E, Maple, PHP, Pike, Python, Ruby |
| s(n) | Ada, Matlab |
| s:n | Pliant |
| s.[n] | F#, OCaml |
| s !! n | Haskell |
| s @ n | Eiffel |
| s/:n | Rebol |
| string index s n | Tcl |
| sub | SML |
| char, aref, schar, svref | Common Lisp |
| GetChar | Modula-3 |
| s at(n) | Io |
| at(73) | C++, Smalltalk |
| aref | Common Lisp |
| char(s, i) | B |
| charAt | Java, JavaScript |
| characterAtIndex | Objective-C |
| n -> s.inxGet | Beta |
| string-ref | Scheme |
| StringTake[s, {n}] | Mathematica |
| $EXTRACT(s, n) | MUMPS |
| item | Logo |
| s[n..m] | Maple, Pike, Ruby |
| s.[n..m] | F# |
| s(n..m) | Ada |
| s(n:m) | Matlab |
| s(n,m+1) | E |
| s[n:m+1] | Python |
| s[n,len] | Ruby |
| s n len | Pliant |
| strndup(s + n, len) | C |
| substring | Eiffel, Java, Scheme, SML, XPath, YCP |
| Substring | C# |
| substr | C++, Perl, Perl6, PHP |
| SUBSTR | Classic REXX |
| sub | F#, Lua, OCaml |
| SUB | Modula-3 |
| subseq | Common Lisp |
| slice | Io, JavaScript |
| 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 |
| index | Ada, Perl, Perl6, Python, Ruby |
| indexOf | Java, JavaScript |
| IndexOf | C#, F# |
| indexOfString | Smalltalk |
| startOf | E |
| search | Common Lisp, Pike, PostScript |
| StringTools[Search] | Maple |
| StringPosition | Mathematica |
| strstr strchr | C |
| find | C++, Logo, Lua, Python, Rebol, YCP |
| findSeq | Io |
| findSubstring | Haskell |
| strfind | Matlab, Yorick |
| $FIND | MUMPS |
| index_non_blank / find_token | Ada |
| substring_index | Eiffel |
| rangeOfString | Objective-C |
| POS | Classic REXX |
| POSITION(needle IN s) | SQL92 |
| sub_string / sub_atom | Prolog |
| string first | Tcl |
| rindex | OCaml, Perl, Perl6, Python, Ruby |
| rfind | C++, Python |
| find/last | Rebol |
| strrchr | C |
| index(Going => Backward) |