Standard Functions

• a Unicode codepoint, supplied as an integer,
• an HTML5 character reference name, or
• the backslash-escape sequence \t, \n, \r, \b or \f.

char(65), char(0x41), char(0b01000001)

char('xcirc')

string-join(('auml', 'ouml', 'uuml', 'szlig') ! char(.))

string-to-codepoints(char('\t'))

for $cp in string-to-codepoints($value)
return codepoints-to-string($cp)

characters('AB')

contains-token(('a', 'b c', 'd'), 'c')

string-join(1 to 3)

string-join(('one', 'two', 'three'), ', ')

• padding: string to pad with (default: ' '). It is repeated as often as required and cut to fit; it must not be empty.
• side: side on which the padding is added: end (default), start or both. With both, an odd padding character is appended at the end.

pad-string('abc', 6)

pad-string('abc', 6, { 'side': 'start' })

pad-string(42, 6, { 'padding': '0', 'side': 'start' })

pad-string('Chapter 1', 20, { 'padding': '.' })

pad-string('abcdef', 3)

graphemes("a" || char(0x308) || "b")

graphemes(char(0x1F476) || char(0x200D) || char(0x1F6D1))

graphemes(char('\r') || char('\n'))

collation({ 'language': 'de' })

collation({ 'language': 'de' })

for value $v in map:build(
  ('a', 'A', 'b'),
  collation-key(?, collation({ 'strength': 'primary' })),
  identity#1
)
return [ $v ]

[ "b" ]
[ ("a", "A") ]

replace('a1c', '\d', 'X')

replace('1aBc2', '[a-z]', 'X', 'i')

replace('1aBc2', '[a-z]', upper-case#1)

replace("Chapter 9", "[0-9]+", fn($match) { $match + 1 })

replace(
  "12°34′57″",
  "([0-9]+)°([0-9]+)′([0-9]+)″",
  fn($full-match, $groups) {
    message($full-match),
    ($groups[1] + $groups[2] ÷ 60 + $groups[3] ÷ 3600) || '°'
  }
)

tokenize('a b c')

tokenize('a, b,  c', ',\s*')

tokenize('a|b|c', '|', 'q')

matching-segments("The cat sat on the mat.", "\w+")?substring

matching-segments(
  "08-12-03",
  "^(\d+)\-(\d+)\-(\d+)$")?groups ! (?1?group, ?2?group, ?3?group
)

matching-segments("Chapter 5", "(Chapter|Appendix)(?=\s+([0-9]+))")?groups?2

matching-segments(
  "2026-06-25",
  "(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})"
)?groups?year?group

is-NaN(0e0 div 0)

is-NaN('NaN')

• number is a random double between 0 and 1
• next is a function that returns another random number generator
• permute is a function that returns a random permutation of its argument

let $rng := random-number-generator()
let $number := $rng?number                (: random number :)
let $next-rng := $rng?next()              (: new generator :)
let $next-number := $next-rng?number      (: another random number :)
let $permutation := $rng?permute(1 to 5)  (: random permutation of (1 to 5) :)
return ($number, $next-number, $permutation)

round(1.5)

round(15, -1)

round(9.9999, 1, 'floor')

divide-decimals(10, 3)

divide-decimals(10, 7, 3)

let $nodes := <xml>
  <node id='0'/>
  <node id='1' idref='0'/>
  <node id='2' idref='1'/>
  <node id='3' idref='1'/>
</xml>/node
return transitive-closure(
  head($nodes),
  fn($n) { $nodes[@idref = $n/@id] }
)

<node id='1' idref='0'/>,
<node id='2' idref='1'/>,
<node id='3' idref='1'/>

$nodes/self::node()
$nodes/.
$nodes union .
$nodes except ()

let $doc := <doc><b/><a/></doc>
return distinct-ordered-nodes(($doc/a, $doc/a, $doc/b))

in-scope-namespaces(<xsi:a/>)

{
  "xsi": "http://www.w3.org/2001/XMLSchema-instance",
  "xml": "http://www.w3.org/XML/1998/namespace"
}

siblings(<xml><a/><b/><c/></xml>/b)

let $xml := document { <xml><a/></xml> }
return path($xml/xml/a, { 'indexes': false() })

let $xml := document {
  <xml xmlns='URI'><a/></xml>
}
let $namespaces := in-scope-namespaces($xml/*)
return path($xml/*:xml/*:a, { 'namespaces': $namespaces })

Calling jtree($X) is equivalent to the path expression $X/.: maps and arrays that appear as the left-hand operand of / are wrapped implicitly, so an explicit call is rarely needed.

jtree([ "a", "b", "c" ])/*[1]

jtree([ "a", "b" ])/* =!> jkey()

let $array := [ 1, 4.5, "eight", 10 ]
return $array/jnode(*, xs:integer) =!> jkey()

let $map := { 'Mo': 'Monday', 'Tu': 'Tuesday', 'We': 'Wednesday' }
return $map/(Mo|We|Fr|Su) =!> jkey()

let $array := [ [ 4, 18 ], [ 30, 4, 22 ] ]
return $array/descendant::*[. > 25]/ancestor-or-self::* =!> jkey()

let $array := [ 1, 3, 4.5, 7, "eight", 10 ]
return $array/jnode(*, xs:integer) =!> jvalue()

let $map := { 'Mo': 'Monday', 'Tu': 'Tuesday', 'We': 'Wednesday' }
return $map/(Mo|We|Fr|Su) =!> jvalue()

let $input := {
  "a": [ 10, 20 ],
  "b": ([ 30, 40 ], [], 0, [ 50 ])
}
return $input/b/* ! [ jposition(), jkey(), jvalue() ]

[ 1, 1, 30 ]
[ 1, 2, 40 ]
[ 4, 1, 50 ]

build-dateTime({
  "year": 2026,
  "month": 4,
  "day": 8,
  "hours": 18,
  "minutes": 46,
  "seconds": 12,
  "timezone": xs:dayTimeDuration("PT2H")
})

civil-timezone(xs:dateTime('2001-01-01T11:11:11Z'))

civil-timezone(xs:dateTime('2001-07-01T11:11:11Z'))

let $dt := xs:dateTime('2024-07-01T01:01:01Z')
return adjust-dateTime-to-timezone($dt, civil-timezone($dt))

civil-timezone(xs:dateTime('2024-12-24T12:24:48'), 'Africa/Abidjan')

parts-of-dateTime(xs:dateTime('2026-04-08T18:46:12+02:00'))

unix-dateTime(0)

encode-for-uri('São Paulo?')

encode-for-uri('ABC123-~._ !"#<=>?')

decode-from-uri('S%C3%A3o%20Paulo%3F')

decode-from-uri('%00')

For a full description of behavior and the $options, see fn:parse-uri.

parse-uri("https://basex.org/download/")

{
  "uri": "https://basex.org/download/",
  "scheme": "https",
  "hierarchical": true(),
  "authority": "basex.org",
  "host": "basex.org",
  "path": "/download/",
  "path-segments": ("", "download", ""),
  "absolute": true()
}

For a full description of behavior and the $options, see fn:build-uri.

build-uri({
  "scheme": "https",
  "host": "docs.basex.org",
  "path": "/main"
})

atomic-equal(1, 1.0)

atomic-equal('a', xs:anyURI('a'))

atomic-equal(xs:double('NaN'), xs:double('NaN'))

atomic-equal(1, '1')

As BaseX is not schema-aware, all nodes have the same type annotations, and typed values are equal to string values. The options typed-values, type-annotations and type-variety are accepted and ignored.

deep-equal((), ())

deep-equal(1, 1.0)

deep-equal(
  <name sex='f' id='name1'>Sunita</name>,
  <name id="name1" sex="f">Sunita</name>
)

deep-equal((1, 2, 3), (3, 2, 1), { 'ordered': false() })

deep-equal('X', ' X ', { 'whitespace': 'normalize' })

deep-equal(sum#1, sum#2, {
  'items-equal': fn($a, $b) {
    if(($a, $b) instance of fn(*)*) {
      function-name($a) = function-name($b)
    }
  }
})

compare(1, 1.0)

compare(xs:double('NaN'), 0)

compare('a', 'A')

compare(
  'Strasse',
  'Straße',
  collation({ 'lang': 'de', 'strength': 'primary' })
)

compare(xs:hexBinary('41'), xs:base64Binary('QQ=='))

starts-with-subsequence(1 to 10, 1 to 3)

starts-with-subsequence(
  1 to 10,
  ('a', 'bb', 'ccc'),
  fn($a, $b) { $a = string-length($b) }
)

ends-with-subsequence(1 to 10, 8 to 10)

ends-with-subsequence(
  ('one', 'two', 'three'),
  ('t', 't'),
  starts-with#2
)

contains-subsequence(1 to 10, 4 to 6)

contains-subsequence(
  ('anna', 'berta', 'clara', 'dora'),
  ('CLARA', 'DORA'),
  fn($a, $b) { $a = lower-case($b) }
)

all-equal((1, 1.0, 1e0))

all-equal((1, '1'))

all-equal(())

all-different(1 to 5)

all-different(())

every(1 to 5)

every(1 to 5, fn { . > 3 })

every(())

some(-3 to 3)

some(1 to 5, fn { . > 3 })

some(())

index-where(
  (10, 11, 12, 14, 17, 21, 26),
  fn { . mod 2 = 0 }
)

index-where(
  (1, 8, 2, 7, 3),
  fn($item, $pos) { $item < 5 and $pos > 2 }
)

sort(reverse(1 to 3))

reverse(sort(1 to 3))

sort((-2, 1, 3), key := abs#1)

sort($employees, (), fn { @name, @age })

sort((1, 'a'))

sort-by((-2, 1, 3), { 'key': abs#1 })

sort-by(1 to 3, { 'order': 'descending' })

sort-with((1, 4, 6, 5, 3), compare#2)

sort-with(
  (1, -2, 5, 10, -12, 8),
  fn($a, $b) { abs($a) - abs($b) }
)

let $persons := <persons>
  <person name='Josipa' age='8'/>
  <person name='Jade' age='6'/>
  <person name='Jie' age='8'/>
</persons>
return sort-with($persons/person, (
  fn($a, $b) { compare($a/@age, $b/@age) },
  fn($a, $b) { compare($a/@name, $b/@name) }
))

<person name="Jade" age="6"/>,
<person name="Jie" age="8"/>,
<person name="Josipa" age="8"/>

foot(reverse(1 to 100))

trunk(reverse(1 to 4))

for $pos in $at
return $input[$pos]

items-at(reverse(1 to 5), 1)

items-at(('one', 'two'), (2, 1))

items-at(('a', 'b'), 0)

• If no start is specified, the sequence will start with the first item.
• If no end is specified, all remaining items are returned.
• If end is smaller than start, the items are returned in reverse order.
• If a negative start or end is specified, the counter starts from the end of the sequence.

slice(1 to 5, 3)

slice(1 to 5, 3, 4)

slice(1 to 10, -3)

slice(1 to 5, 4, 2)

slice(1 to 5, step := 2)

remove(1 to 3, 2)

remove(1 to 5, (5, 3, 1))

The function is equivalent to:

let $start := index-where($input, $from)[1]             otherwise (count($input) + 1)
let $end   := index-where($input, $to)[. ge $start][1]  otherwise (count($input) + 1)
return slice($input, $start, $end)

subsequence-where(1 to 5, fn { . >= 3 })

subsequence-where(1 to 5, fn { . >= 2 }, fn { . >= 4 })

let $drop-while := fn($input, $predicate) {
  subsequence-where($input, fn { not($predicate(.)) })
}
return $drop-while(1 to 5, fn { . <= 2 })

The function is equivalent to:

declare function take-while($input, $predicate, $pos := 1) {
  if(exists($input) and $predicate(head($input), $pos)) {
    head($input),
    take-while(tail($input), $predicate, $pos + 1)
  }
};

take-while((1, 5, 10, 20, 50, 100), fn { . <= 30 })

take-while(
  (1 to 100) ! random:integer(50),
  fn($item, $pos) { . >= 10 }
)

head($input), tail($input) ! ($separator, .)

(1 to 3)
=> insert-separator('|')
=> string-join()

insert-separator((<_>1</_>, <_>2</_>, <_>3</_>), '; ')

replicate('A', 3)

let $nodes := replicate(<node/>, 2)
return $nodes[1] is $nodes[2]

void(fetch:binary('http://my.rest.service'))

highest(8 to 12)

highest(98 to 102, key := string#1)

highest(1 to 7, (), fn { . idiv 3 })

lowest(8 to 12)

lowest(98 to 102, key := string#1)

lowest(1 to 7, (), fn { . idiv 3 })

for $group in $values
group by $value := $group
where count($group) > 1
return $value

duplicate-values((1, 2, 3, 1.0, 1e0))

duplicate-values(1 to 100)

let $ids := duplicate-values(//@id)
where exists($ids)
return error((), 'Duplicate IDs found: ' || string-join($ids, ', '))

partition((1 to 5), fn($seq) { count($seq) = 2 })

partition(
  ('Anita', 'Anne', 'Barbara', 'Catherine', 'Christine'), 
  fn($partition, $next) {
    substring(head($partition), 1, 1) ne substring($next, 1, 1)
  }
)

[ 'Anita', 'Anne' ],
[ 'Barbara' ],
[ 'Catherine', 'Christine' ]

Retrieves and parses an XML document from a given URI and returns a document-node() item.

Within $options, the following keys can be specified:

Additionally, these BaseX XML Parsing options are supported, using lower-case option names:

doc('example.xml')

<root>
   <a> </a>
</root>

doc('example.xml', { 'strip-space': true() })

doc('book.xml', { 'xinclude': true(), 'trusted': true() })

Checks if an XML document can be retrieved and parsed from a given URI. Returns true if fn:doc($source, $options) would return a document node, and false otherwise.

The recognized options are the same as for fn:doc.

doc-available('https://example.org/example.xml')

unparsed-binary('https://files.basex.org/releases/BaseX.jar')

parse-integer('7B', 16)

parse-integer('11111111', 2)

parse-integer(' -1_000_000 ')

parse-QName('xml:node') => namespace-uri-from-QName()

let $qname := parse-QName('Q{http://gotcha.org/works}fine')
return string-join((
  namespace-uri-from-QName($qname),
  local-name-from-QName($qname)
), ': ')

parse-ietf-date('28-Feb-1984 07:07:07')

parse-ietf-date('Wed, 01 Jun 2001 23:45:54 +02:00')

Parses a string as XML and returns a document-node() item.

If the $value is supplied as a binary (e.g., xs:base64Binary or xs:hexBinary), its encoding may be inferred from a byte order mark or an XML declaration. The input is then processed like a resource retrieved via fn:doc.

The recognized $options are the same as for fn:doc, with the following differences: the stable option does not apply; a base-uri can be supplied (defaulting to the static base URI of the function call); and xsd-validation does not support the values lax and type.

parse-xml('<Greeting>Hello, world!</Greeting>')

This function takes an XML fragment as a string or binary input and returns it as a document node.

If the $value is supplied as binary, its encoding is inferred as with fn:unparsed-text, and it is parsed as an external general parsed entity.

Within $options, the standard options are supported:

Additionally, this BaseX XML Parsing option is supported, using a lower-case option name:

parse-xml-fragment('<a/> <b/> <c/>')/node()

Assembles an XSD schema and returns a function that validates a document or element node against this schema. The returned function returns an empty sequence if the supplied node is empty. Otherwise, it returns a record with the field is-valid and, on demand, the validated node (typed-node) and details on the invalidities that were found (error-details).

The following $options are available:

As BaseX is not schema-aware, the returned node has no type annotations, and the options validation-mode (with the values lax and by-type), type and target-namespace are rejected with an error.

let $schema := <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
  <xs:element name='distance' type='xs:decimal'/>
</xs:schema>
let $validator := xsd-validator({ 'schema': $schema })
return (
  $validator(<distance>8.5</distance>)?is-valid,
  $validator(<distance>8.5km</distance>)?is-valid
)

1. as a map…

   { "method": "xml", "cdata-section-elements": "div" }

2. or (for backward compliance) as an element:

   <output:serialization-parameters>
     <output:method value='xml'/>
     <output:cdata-section-elements value='div'/>
   </output:serialization-parameters>

serialize(1 to 3)

serialize(<xml id='1'></xml>)

serialize(<html/>, { 'method': 'html', 'html-version': '5.0' })

serialize({ 1: "one" }, { 'method': 'json' })

format-integer(123, '0')

format-integer(12, 'w')

format-integer(21, 'Ww;o', 'de')

format-integer(65535, '16^xxxx')

format-integer(15, '2^xxxx')

format-number(123, '0')

format-number(1.23, '0,0##', 'de')

format-number(1234, "0.000,0", { 'format-name': 'de' })

format-number(1010, '0^0', { 'exponent-separator': '^' })

format-number(1984.42, '00.0e0')

expanded-QName(xs:QName('country'))

expanded-QName(QName('http://eat.org/lunch', 'cake'))

With our custom csv:parse function, additional conversion formats are available.

csv-to-arrays(
  string-join(('Name,City', 'Rossi,Rome', 'Da Silva,Rio de Janeiro'), char('\n'))
)

csv-to-arrays(
  string-join(('Product;Price', 'Laptop;1200', 'Mouse;25'), char('\n')),
  { 'separator': ';' }
)

• columns is a sequence of strings containing column names, if any
• column-index is a map from column names to (one-based) column positions
• rows is a sequence of arrays of strings representing the parsed rows of the CSV data
• get is a function that returns a field in the result that is identified by row and column. Its signature is function(xs:positiveInteger, (xs:positiveInteger | xs:string)) as xs:string? where the first argument is the (one-based) row number, and the second argument is the (one-based) column number or the column name.

For more details, and for the allowable options, see fn:parse-csv.

With our custom csv:parse function, additional conversion formats are available.

parse-csv(
  string-join(('Name,City', 'Rossi,Rome', 'Da Silva,Rio de Janeiro'), char('\n')),
  { 'header': true() }
)

{
  "columns": ("Name", "City"),
  "column-index": { "Name": 1, "City": 2},
  "rows": ([ "Rossi", "Rome" ], [ "Da Silva", "Rio de Janeiro" ]),
  "get": (anonymous-function)#2
}

parse-csv(
  string-join(('Laptop;1200', 'Mouse;25', 'Keyboard;45'), char('\n')),
  { 'separator': ';', 'header': ('Product', 'Price') }
)

{
  "columns": ("Product", "Price"),
  "column-index": { "Product": 1, "Price": 2},
  "rows": ([ "Laptop", "1200" ], [ "Mouse", "25" ], [ "Keyboard", "45" ]),
  "get": (anonymous-function)#2
}

The result is equivalent to reading the CSV file as binary using unparsed-binary and parsing the content with parse-csv. If the $source is the empty sequence, the function returns the empty sequence.

For more details and allowable options, see fn:csv-doc.

With our custom csv:doc function, additional conversion formats are available.

csv-doc('input.csv', { 'header': true() })

{
  "columns": ("Name", "Age"),
  "column-index": { "Name": 1, "Age": 2 },
  "rows": ([ "Alice", "30" ], [ "Bob", "25" ]),
  "get": (anonymous-function)#2
}

• columns holds the column names in a sequence of column elements (only present if there are column names)
• rows holds a sequence of row elements representing the rows of the CSV data. Each row has field elements with the field values. Their column attribute indicates the column name, if any

With our custom csv:parse function, additional conversion formats are available.

csv-to-xml(
  string-join(('Laptop;1200', 'Mouse;25', 'Keyboard;45'), char('\n')),
  { 'separator': ';', 'header': ('Product', 'Price') }
)

<csv xmlns="http://www.w3.org/2005/xpath-functions">
  <columns>
    <column>Product</column>
    <column>Price</column>
  </columns>
  <rows>
    <row>
      <field column="Product">Laptop</field>
      <field column="Price">1200</field>
    </row>
    <row>
      <field column="Product">Mouse</field>
      <field column="Price">25</field>
    </row>
    <row>
      <field column="Product">Keyboard</field>
      <field column="Price">45</field>
    </row>
  </rows>
</csv>

With our custom html:parse function, additional conversion formats are available.

parse-html(
  '<!DOCTYPE html>' ||
  '<html><head><meta charset="UTF-8"></head><body>Hello, World!</body></html>'
)

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta charset="UTF-8"/>
  </head>
  <body>Hello, World!</body>
</html>

The returned result is a document node whose root element is <html>, conforming to the HTML structure parsed from the input. The result is equivalent to reading the file as binary with unparsed-binary and parsing it via parse-html.

For more details and allowable options, see fn:html-doc.

With our custom html:doc function, additional parsing features are available.

html-doc('https://basex.org/download')//@href[contains(., '.zip')]!string()

With our custom json:parse function, additional conversion formats are available.

parse-json('{ "name": "john" }')

parse-json('[ 1, 2, 4, 8, 16 ]')

With our custom json:doc function, additional conversion formats are available.

json-doc("http://ip.jsontest.com/")?id

With our custom json:parse function, additional conversion formats are available.

json-to-xml('{ "message": "world" }')

document {
  <map xmlns="http://www.w3.org/2005/xpath-functions">
    <string key="message">world</string>
  </map>
}

The resulting string can also be created with our custom json:serialize function.

<map xmlns="http://www.w3.org/2005/xpath-functions">
  <string key="message">world</string>
</map>
=> xml-to-json()

record(
  layout  as xs:string,
  child?  as xs:string?,
  type?   as enum('integer', 'decimal', 'double', 'boolean', 'string')
)

record(
  type  as enum('integer', 'decimal', 'double', 'boolean', 'string', 'skip')
)

element-to-map-plan(<a><b>3</b><b>4</b></a>)

{
  "a": {
    "layout": "list",
    "child": "b"
  },
  "b": {
    "layout": "simple",
    "type": "integer"
  }
}

element-to-map-plan((<a x="2">red</a>, <a x="3">blue</a>))

{
  "a": {
    "layout": "simple-plus"
  },
  "@x": {
    "type": "integer"
  }
}

let $plan := element-to-map-plan(
  <name><first>Jane</first><last>Smith</last></name>
)
return element-to-map(
  <name><first>John</first><last>Doe</last></name>,
  { 'plan': $plan }
)

{
  "name": {
    "first": "John",
    "last": "Doe"
  }
}

element-to-map(<foo>bar</foo>)

element-to-map(
  <name>
    <first>Jane</first>
    <last>Smith</last>
  </name>
)

element-to-map(
  <list>
    <item value='1'/>
    <item value='2'/>
  </list>,
  { 'attribute-marker': '' }
)

Loads an XQuery library module by its namespace URI and returns a map of its public functions and global variables.

Within $options, the following keys can be specified:

let $module := '
  module namespace m = "http://ex.org";
  declare %public function m:two() { 2 };'
let $functions := load-xquery-module(
  'http://ex.org',
  { 'content': $module }
)?functions
let $two := $functions(QName('http://ex.org', 'two'))?0
return $two()

let $uri := 'http://basex.org/modules/code'
let $functions := load-xquery-module(
  $uri,
  { 'location-hints': 'code.xqm' }
)?functions
let $run := $functions(QName($uri, 'run'))(0)
return $run()

Invokes an XSLT transformation and returns a map with a single entry: the key is the base output URI, or the string output; the value is the principal result document. See XSLT Functions for the processors that can be used.

The following $options are available:

The options enable-assertions, enable-messages, enable-trace and vendor-options are accepted and ignored. All other options of the specification (initial-template, initial-mode, static-params, template-params, the package-* options, etc.) cannot be assigned via the JAXP interface and are rejected with an error, as are the delivery format raw and requested properties other than xsl:version.

transform({
  'stylesheet-text': "<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
    version='1.0'><xsl:template match='/'><out><xsl:value-of
    select='//b'/></out></xsl:template></xsl:stylesheet>",
  'source-node': <a><b>89</b></a>
})?output

function-name(true#0)

function-name(fn { . + 1 })

function-arity(true#0)

function-arity(fn { . + 1 })

declare
  %public
  %rest:GET
  %rest:path('/')
  %perm:allow('all')
function local:index($n) {
  <html>Welcome!</html>
};
function-annotations(local:index#1)

{ #xq:public: () },
{ #rest:GET: () },
{ #rest:path: '/' },
{ #perm:allow: 'all' }

let $add := fn($a, $b) { $a * $b }
let $double := %local:deprecated fn($a) { $a + $a }
for $ann in ($add, $double) =!> function-annotations()
where map:keys($ann) = #local:deprecated
return 'Deprecated function found.'

function-identity({})

function-identity(abs#1)

declare function filter($input, $pred) {
  for-each(
    $input,
    fn($item) { if ($pred($item)) { $item } }
  )
};

An equivalent XQuery function is:

declare function filter(
  $input      as item()*,
  $predicate  as fn(item()) as xs:boolean?
) as item()* {
  $input[$predicate(.)]
};

filter(1 to 10, fn { . mod 2 eq 0 })

let $first-upper := fn($str) {
  let $first := substring($str, 1, 1)
  return $first eq upper-case($first)
}
return filter(('FooBar', 'foo', 'BAR'), $first-upper)

let $is-prime := fn($x) {
  $x gt 1 and (every $y in 2 to ($x - 1) satisfies $x mod $y != 0)
}
return filter(1 to 20, $is-prime)

An equivalent XQuery function is:

declare function for-each(
  $input   as item()*,
  $action  as fn(item()) as item()*
) as item()* {
  for $item in $input
  return $action($item)
}

for-each(1 to 10, math:pow(?, 2))

let $fs := (
  upper-case#1,
  substring(?, 4),
  string-length#1
)
return for-each($fs, fn($f) { $f('foobar') })

("one", "two", "three") => for-each(upper-case(?))

An equivalent function is:

declare function for-each-pair(
  $input1  as item()*,
  $input2  as item()*,
  $action  as fn(item(), item()) as item()*
) as item()* {
  for $pos in 1 to min((count($input1), count($input2)))
  return $action($input1[$pos], $input2[$pos])
};

for-each-pair(
  for-each(1 to 10, fn { . mod 2 }),
  replicate(1, 5),
  fn($a, $b) { $a + $b }
)

let $number-words := fn($str) {
  string-join(
    for-each-pair(
      1 to 1000000000,
      tokenize($str, ' +'),
      concat(?, ': ', ?)
    ),
    ', '
  )
}
return $number-words('how are you?')

let $is-sorted := fn($input) {
  every $b in
    for-each-pair(
      $input,
      tail($input),
      fn($a, $b) { $a <= $b }
    )
  satisfies $b
}
return (
  $is-sorted(1 to 10),
  $is-sorted((1, 2, 42, 4, 5))
)

1. $predicate is called with $input.
2. If the result is true, $action is called with $input, the result is adopted as new $input, and step 2 is repeated.
3. Otherwise, $input is returned.

while-do(2, fn { . <= 100 }, fn { . * . })

while-do(
  1,
  fn($num, $pos) { $pos <= 10 },
  fn($num, $pos) { $num * $pos }
)

let $input := (0 to 4, 6 to 10)
return while-do(
  0,
  fn($n) { $n = $input },
  fn($n) { $n + 1 }
)

let $input := 3936256
return while-do(
  $input,
  fn($result) { abs($result * $result - $input) >= 0.0000000001 },
  fn($guess) { ($guess + $input div $guess) div 2 }
) => round(5)

1. $action is called with $input and the result is adopted as new $input.
2. $predicate is called with $input. If the result is false, step 1 is repeated.
3. Otherwise, $input is returned.

do-until(
  (),
  fn($value, $pos) { $value, $pos * $pos },
  fn($value) { foot($value) > 50  }
)

do-until(
  (1, 0),
  fn($value) { $value[1] + $value[2], $value },
  fn($value) { avg($value) > 10 }
)

let $sort := sort(?, (), identity#1)
let $reverse-sort := sort(?, (), fn($x) { -$x })
return string-join((
  $sort((1, 5, 3, 2, 4)),
  '|',
  $reverse-sort((1, 5, 3, 2, 4))
))

map:for-each({ 1: 'one', 2: 'two' }, identity#1)

apply(concat#5, array { 1 to 5 })

apply(fn($a) { sum($a) }, [ 1 to 5 ])

apply(substring#3, [ "abc", 2 ])

let $char-at := partial-apply(substring#3, { 3: 1 })
return $char-at("abc", 2)

+ * - | || < <= = >= > != << >> is mod div idiv and or lt le eq ge gt ne to union intersect except otherwise

for-each-pair(1 to 3, 4  to 6, op('+'))

map:keys(map:filter(
  { 2: 1234, 3: 3, 4: 5678, 5: 5 },
  op('=')
))

$f($f($f($f($f(0, 1), 2), 3), 4), 5)

An equivalent XQuery function is:

declare function fold-left(
  $input   as item()*,
  $init    as item()*,
  $action  as fn(item()*, item()) as item()*
) as item()* {
  if (empty($input)) then $init
  else fold-left(
    tail($input),
    $action($init, head($input)),
    $action
  )
};

Note: Contrary to the official specification, the current position of the iteration can be retrieved via the third parameter of the higher-order function argument.

fold-left(1 to 5, 1, fn($result, $curr) { $result * $curr })

fold-left(1 to 5, '$seed',
  concat('$f(', ?, ', ', ?, ')')
)

let $from-digits := fold-left(?, 0,
  fn($n, $d) { 10 * $n + $d }
)
return (
  $from-digits(1 to 5),
  $from-digits((4, 2))
)

fold-left(
  1 to 10000000000,
  1,
  fn($n, $curr) { if($n > 100000) then $n else $n * $curr }
)

$f(1, $f(2, $f(3, $f(4, $f(5, 0)))))

Note that the order of the arguments of $fun are inverted compared to that in fn:fold-left:

declare function fold-right(
  $input   as item()*,
  $init    as item()*,
  $action  as fn(item(), item()*) as item()*
) as item()* {
  if (empty($input)) then $init
  else $action(
    head($input),
    fold-right(tail($input), $init, $action)
  )
};

Note: Contrary to the official specification, the current position of the iteration can be retrieved via the third parameter of the higher-order function argument.

fold-right(1 to 5, 1,
  fn($curr, $result) { $result * $curr }
)

fold-right(1 to 5, '$seed',
  concat('$f(', ?, ', ', ?, ')')
)

let $reverse := fold-right(?, (), fn($item, $rev) { $rev, $item })
return $reverse(1 to 5)

'Hello' => trace() => void()

• name: QName of the type
• is-simple: indicates whether it is a simple type
• base-type: function returning the annotation of the base type
• primitive-type: function returning the annotation of the primitive type
• variety: variety of the type (atomic, list, union or mixed)
• members: function returning the annotations of the member types
• simple-content-type: function returning the annotation of the simple content type
• matches: function testing whether an atomic value is an instance of the type
• constructor: function constructing a value of the type

atomic-type-annotation(1e0)?variety

atomic-type-annotation(xs:byte(1))?base-type()?name => string()

atomic-type-annotation(1)?matches(2)

atomic-type-annotation(xs:byte(1))?constructor('127') instance of xs:byte

node-type-annotation(<a/>)?name => string()

node-type-annotation(attribute id { 1 })?name => string()

node-type-annotation(<a/>)?variety

schema-type(xs:QName('xs:integer'))?variety

schema-type(xs:QName('xs:integer'))?base-type()?name => string()

schema-type(xs:QName('xs:positiveInteger'))?constructor('42')
    instance of xs:positiveInteger

empty(schema-type(xs:QName('unknown-type')))

type-of('Hello')

type-of(1 to 10)

type-of((1, 'a'))

type-of(())

string(hash(''))

string(hash('', 'SHA-1'))

hash('', 'CRC-32') => string()

hash('BaseX', 'CRC-32') => string()

seconds(0)

seconds(86_400.1)

current-time() + seconds(100)

• xpath-version: version of the supported XPath specification
• xsd-version: version of the supported XML Schema specification
• product-name: name of the product
• product-version: version of the product
• schema-aware: indicates whether schema-awareness is supported
• accepts-typed-data: indicates whether typed data is accepted
• supports-xinclude: indicates whether XInclude is supported
• supports-dtd: indicates whether DTDs are fully supported
• supports-invisible-xml: indicates whether Invisible XML is available
• supports-dynamic-xquery: indicates whether dynamic XQuery evaluation is supported
• supports-dynamic-xslt: indicates whether dynamic XSLT evaluation is supported

system-properties()?#product-name

system-properties()?#xpath-version

sort(map:keys(system-properties()) ! string())