XML Path Language (XPath) 4.0 WG Review Draft

4.5.6 Inline Function Expressions

[Definition: An inline function expression, when evaluated, creates an anonymous function defined directly in the inline function expression.] An inline function expression specifies the names and SequenceTypes of the parameters to the function, the SequenceType of the result, and the body of the function.

An inline function expression whose FunctionSignature is omitted is known as a focus function. Focus functions are described in 4.5.6.2 Focus Functions.

[Definition: An anonymous function is a function item with no name. Anonymous functions may be created, for example, by evaluating an inline function expression or by partial function application.]

The keywords function and fn are synonymous.

The syntax allows the names and types of the function argument to be declared, along with the type of the result:

function($x as xs:integer, $y as xs:integer) as xs:integer { $x + $y }

The types can be omitted, and the keyword can be abbreviated:

fn($x, $y) { $x + $y }

A zero-arity function can be written as, for example, fn() { current-date() }.

If a function parameter is declared using a name but no type, its default type is item()*. If the result type is omitted, its default result type is item()*.

The parameters of an inline function expression are considered to be variables whose scope is the function body. It is a static error [err:XQST0039] for an inline function expression to have more than one parameter with the same name.

The annotation keyword %method is described in 4.5.6.1 Methods.

The static context for the function body is inherited from the location of the inline function expression, with the exception of the static type of the context value which is initially absent^DM.

The variables in scope for the function body include all variables representing the function parameters, as well as all variables that are in scope for the inline function expression. If the annotation %method is present then an additional system-defined variable $this is added to the static context for the function body, as described in 4.5.6.1 Methods.

The result of an inline function expression is a single function item with the following properties (as defined in Section 7.1 Function Items^DM):

• name: Absent.

• identity: A new function identity distinct from the identity of any other function item.

  Note:

  See also 4.5.7 Function Identity.

• parameter names: The parameter names in the InlineFunctionExpr’s ParamList.

• signature: A FunctionType constructed from the SequenceTypes in the InlineFunctionExpr. An implementation which can determine a more specific signature (for example, through use of type analysis of the function’s body) is permitted to do so.

• annotations: If the keyword %method is present, then a list containing a single annotation whose name is a QName with local name "method" and namespace "http://www.w3.org/2012/xquery" and whose value is an empty sequence; otherwise an empty set..

• body: The FunctionBody of the InlineFunctionExpr.

• captured context: the static context is the static context of the inline function expression, with the exception of the static context value type which is absent^DM. The dynamic context has an absent focus, and a set of variable bindings comprising the variable values component of the dynamic context of the InlineFunctionExpr.

The following are examples of some inline function expressions:

• This example creates a function that takes no arguments and returns a sequence of the first 6 primes:

  function() as xs:integer+ { 2, 3, 5, 7, 11, 13 }

• This example creates a function that takes two xs:double arguments and returns their product:

  fn($a as xs:double, $b as xs:double) as xs:double { $a * $b }

• This example creates and invokes a function that captures the value of a local variable in its scope:

  let $incrementors := (
    for $x in 1 to 10
    return function($y) as xs:integer { $x + $y }
  )
  return $incrementors[2](4)

  The result of this expression is 6

let $rectangle := { 'height': 3,
                    'width': 4,
                    'area': %method fn() { $this?height * $this?width }
                  }

let $rectangle := { 'height': 3,
                    'width': 4,
                    'area': %method fn() { $this?height × $this?width }
                  }

let $rectangle1 := { 'x':3, 'y':4, 'area': %method fn() {$this?x * $this?y} }
let $rectangle2 := { 'x':5, 'y':5, 'area': $rectangle1?area }
return $rectangle2?area()

let $rectangle1 := { 'x':3, 'y':4, 'area': %method fn() {$this?x × $this?y} }
let $rectangle2 := { 'x':5, 'y':5, 'area': $rectangle1?area }
return $rectangle2?area()

let $area := %method fn() {$this?x * $this?y}                     
let $rectangle1 := { 'x':3, 'y':4, 'area': $area }
let $rectangle2 := { 'x':5, 'y':5, 'area': $area }
return $rectangle2?area()

let $area := %method fn() {$this?x × $this?y}                     
let $rectangle1 := { 'x':3, 'y':4, 'area': $area }
let $rectangle2 := { 'x':5, 'y':5, 'area': $area }
return $rectangle2?area()

                  
let $rectangle := { 'height': 3,
                    'width': 4,
                    'expand': %method fn($ratio) { 
                       { 'height': $this?height × $ratio,
                         'width': $this?width × $ratio,
                         'expand': map:get($this, 'expand') }
                  }
return 2 => $rectangle?expand()

let $area := %method fn() {$this?x * $this?y}                     
return $area( { 'x':3, 'y':4 } )

let $area := %method fn() {$this?x × $this?y}                     
return $area( { 'x':3, 'y':4 } )

let $area := %method fn() {$this?x × $this?y}                     
return { 'x':3, 'y':4 } => $area()

let $lib := {
   'product': %method fn($in as xs:double*) {
                        if (empty( $in ))
                        then 1
                        else head( $in ) * $this?product( tail($in) )
                      }
}
return $lib?product( (1.2, 1.3, 1.4) )

let $lib := {
   'product': %method fn($in as xs:double*) {
                        if (empty( $in ))
                        then 1
                        else head( $in ) × $this?product( tail($in) )
                      }
}
return $lib?product( (1.2, 1.3, 1.4) )