Variables

A variable may be bound by a let clause in a FLWOR expression. The type of the variable is the same as the type of its defining expression. Here are some examples:

let $z := 1+2 return $z+$z has type xs:integer
let $z := 1e0+1.0 return $z+$z has type xs:double

In the first let expression, the expression 1+2 has type xs:integer; therefore, the variable $z also has type xs:integer, and the return expression is typed assuming that $z has type xs:integer. Similarly, in the second expression, variable $z has type xs:double. The static type system keeps track of the types of variables in the static environment; whenever a variable is bound, the static environment is extended by associating the variable with the computed type.

The type of a variable may also be declared explicitly. In this case, a static type error is raised if the type of the defining expression is not a subtype of the declared type. Here are some examples:

let $x as xs:integer := 1+2 return $x+$x has type xs:integer
let $x as xs:decimal := 1+2 return $x+$x has type xs:decimal

The second example is well typed, because xs:integer is a subtype of xs:decimal.

One type is a subtype of another if every value that matches the first type always matches the second type. In particular, whenever one type is derived from a second type by restriction, the first type is a subtype of the second. So xs:integer, for example, is a subtype of xs:decimal, and the type NewUser defined earlier is a subtype of the type User.

Subtyping does not include type promotion. So xs:integer is not a subtype of xs:double, even though it is beneath it in the promotion hierarchy.

let $x as xs:double := 1+2 return $x+$x is a static type error
					

One can specify promotion by including an explicit type coercion, with or without a type declaration.

let $x := xs:double(1+2) return $x+$x has type xs:double
let $x as xs:double := xs:double(1+2) return $x+$x has type xs:double

The type of an expression depends only on the type of its subexpressions. Thus, a static type error will be raised whenever the type of the defining expression is not a subtype of the declared type, even if the value belongs to the declared type. The let expression defining variable $y below is an example of such a static type error:

let $x as xs:decimal := 1,
    $y as xs:integer := $x+$x
return $y+$y               

Even though the value of $x is an integer at run-time, the type of $x is decimal for the purposes of static analysis.