Functions

• function call

  f(a,b,...)	Ada, Awk, Awk, B, C, C#, C++, Dylan, E, Eiffel, Erlang, Java, JavaScript, Lua, Maple, Matlab, Mercury, merd, Modula-3, Pascal, Perl, Perl6, PHP, Pike, Prolog, Python, Ruby, XPath, YCP, Yorick
  f a b ...	Haskell, Logo, Matlab, MSH, OCaml, Pliant, Rebol, sh, SML, Tcl
  f(a,b,...f) or f[a,b,...] depending on the version	BCPL
  (f a b ...) (apply f l)	Scheme
  (f a b ...) (apply f l) (funcall f a b ...)	Common Lisp, Emacs Lisp
  {f a b}	Oz
  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, ... (18)	Yorick
  v = f(a, b, ...) or call f a, b, ...	Classic REXX
  a b ... f	Forth, PostScript
  a f	Smalltalk
  a f: b g: ... (19)	Smalltalk
  (a,b,...)->&f or (a,b,...)->f	Beta
  f:a	FL
  f:a (20)	Pliant
  .. [ 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, Eiffel, Haskell, Logo, Matlab, Mercury, MSH, Pascal, Perl, Perl6, Pliant, PostScript, Prolog, Rebol, Ruby, sh, Tcl
  f()	Awk, C, C#, C++, E, Erlang, Java, JavaScript, Lua, Maple, Perl, Pike, Python, YCP
  f() (21)	merd, OCaml, SML
  (f)	Scheme
  (f) (funcall f)	Common Lisp, Emacs Lisp
  {f}	Oz
  f[] or f.call	Ruby
  &$f or $f->()	Perl
  $f.()	Perl6
  v = f() or call f	Classic REXX
  f value (22)	Smalltalk
  <xsl:call-template name="f">/	XSLT
  call f	Fortran

• partial application (in the examples below, a normal call is "f(a,b)")

  give the first argument

  f a	Haskell, OCaml, SML
  f(a)	Mercury
  f(a,)	merd
  &f.assuming(var_name => a)	Perl6
  functools.partial(f, a)	Python

  give the second argument

  f(,b)	merd
  &f.assuming(b => b)	Perl6

  give the first argument to operator ">"

  (a >)	Haskell, merd
  (>) a	OCaml

  give the second argument to operator ">"

  (> 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(para1, para2, ...) = valof $( ... $)	BCPL
  f(para1, para2, ...) = ...	merd
  f ... or f: para1 ...	Smalltalk
  f: func [para1 para2 ...] ...	Rebol
  /f { ... } def	PostScript
  f := (para1, para2, ...) -> ...	Maple
  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 { param(para1, [typ2]para2, ...) ... }	MSH
  (define (f para1 para2) ...)	Scheme
  (defun f (para1 para2) ...)	Common Lisp, Emacs Lisp
  fun { F Para1 Para2 } ... end	Oz
  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() { ... }	sh
  f : procedure ... return retval	Classic REXX
  to f :para1 :para2 ... end	Logo

  procedures

  procedure f(para1 : typ1, para2 : 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

  predicates

  f(Para1, Para2, ....) :- ... .

  Prolog

• anonymous function

  sub { my ($a, $b) = @_; ... }	Perl
  { my ($a, $b) = @_; ... } (23)	Perl
  { ... } (arguments are in the stack	PostScript
  [ ... ]	Logo
  { param(para1, [typ2]para2, ...) ... }	MSH
  {|a, b| ... } (24)	Ruby
  [:a :b| ... ]	Smalltalk
  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 -> ...	OCaml
  (func(A, B) = C :- ...)	Mercury
  function(a, b) ...	JavaScript
  function(a, b) ... end	Lua
  fun(a, b) -> ... end	Erlang
  fun {$ A B} ... end (25)	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...') (26)	Matlab
  method(a, b) ... end method (27)	Dylan
  create_function(',','...')	PHP
  delegate(ta a, tb b) { ... }	C#2

• function return value

  breaks the control flow

  return	Ada, Awk, B, C, C#, C++, Classic REXX, E, Java, JavaScript, Maple, Perl, Perl6, PHP, Pike, Pliant, Python, Rebol, Ruby, sh, Tcl, YCP, Yorick
  return (28)	Lua
  return (29)	Matlab
  Return	Visual Basic
  RETURN	Modula-3
  resultis / return (30)	BCPL
  return from xxx / return	Common Lisp
  ^	Smalltalk
  Exit Function / Exit Sub	Visual Basic
  output	Logo

  function body is the result

  no syntax needed	Common Lisp, Dylan, Emacs Lisp, Erlang, Haskell, Maple, OCaml, Oz, Perl, Perl6, Rebol, Ruby, Scheme, SML
  no syntax needed (31)	Matlab

  setting the result

  Result := val	Eiffel
  <function name> = val	Visual Basic
  <function name> := val	Pascal
  <retvar name> = val;	Matlab

• function called when a function is not defined (in dynamic languages)

  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

• runtime inspecting the caller information

  caller	Perl, Perl6, Ruby
  inspect.stack()[1]	Python
  backtrace	Pike
  trace 'I'	Classic REXX
  evalin('caller', expression)	Matlab
  current_predicate	Prolog
  where(2)	Maple

• function composition

  .	Haskell
  ~	merd
  o	SML
  @	Maple
  compose	Dylan

• identity function

  id	Haskell
  identity	Common Lisp
  yourself	Smalltalk

Remarks

• (1) for C, it is not a standard convention, but it is the more widespread
• (2) any string literal would work
• (3) see also =head1, =head2, =over, etc
• (4) need "file: %script-header.r" in file header
• (5) displayed <- with a special character
• (6) variable on the right
• (7) the variable behaves like a pointer
• (8) cf horizontal layout
• (9) introduce scope
• (10) ascii representation, original uses a special charset
• (11) <> and # are synonyms
• (12) === and !== differ from == and != when the objects' type differ
• (13) for objects
• (14) normal / structural / unification / arithmetic
• (15) deep comparison
• (16) in List::Util
• (17) Univ operator
• (18) procedure call
• (19) the function is "f: g:"
• (20) special sugar for only one parameter
• (21) there really is a parameter which is the empty tuple
• (22) f is a block
• (23) when callee has special "&" prototype
• (24) this is a block, not precisely a function, but it's alike
• (25) also works for procedures: proc {$ A B} ... end
• (26) x, y, z are the parameters
• (27) method is optional
• (28) in Lua, "return xxx" can only appear before a block end
• (29) only in inline('...')
• (30) "return" is used when there is no value to return
• (31) only for anonymous function