Standard Functions

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

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

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

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

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

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

replace(
  "12°34′57″",
  "([0-9]+)°([0-9]+)′([0-9]+)″",
  action := 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')

string-join(1 to 3)

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

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

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

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

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)

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"
}

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

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

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

decode-from-uri('%00')

atomic-equal(1, 1.0)

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

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

atomic-equal(1, '1')

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)

every(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))

sort(1 to 3, orders := 'descending')

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

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

sort((1, 'a'))

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 start 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)
=> intersperse('|')
=> string-join()

intersperse((<_>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' ]

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

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

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

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

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

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

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

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

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)

{
  QName('http://www.w3.org/2012/xquery', 'public'): (),
  QName('http://exquery.org/ns/restxq', 'GET'): (),
  QName('http://exquery.org/ns/restxq', 'path'): '/',
  QName('http://basex.org/modules/perm', 'allow'): 'all'
}

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

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(count#1, [ 1, 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-where(
  { 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()*,
  $zero    as item()*,
  $action  as fn(item()*, item()) as item()*
) as item()* {
  if (empty($input)) then $zero
  else fold-left(
    tail($input),
    $action($zero, head($input)),
    $action
  )
};

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()*,
  $zero    as item()*,
  $action  as fn(item(), item()*) as item()*
) as item()* {
  if (empty($input)) then $zero
  else $action(
    head($input),
    fold-right(tail($input), $zero, $action)
  )
};

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

string(hash(''))

string(hash('', { 'algorithm': 'SHA-1' }))

hash('', { 'algorithm': 'CRC-32' }) => string()

hash('BaseX', { 'algorithm': 'CRC-32' }) => string()

seconds(0)

seconds(86_400.1)

current-time() + seconds(100)