XQuery 4.0: An XML Query Language

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.

An inline function expression may have annotations. The only annotation defined in XQuery 4.0 for inline function expressions is the annotation %method, described in 4.5.6.1 Methods. It is a static error [err:XQST0125] if an inline function expression is annotated as %public or %private. An implementation can define annotations, in its own namespace, to support functionality beyond the scope of this specification.

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 Annotations andSequenceTypes 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: The annotations explicitly included in the inline function expression. .

• 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) )