Changes

|

* Doubles a numeric value until a maximum is reached:

hof:until(

function($output) { $output ge 1000 },

1

)

* Calculates the square-root of a number by iteratively improving an initial guess:

let $sqrt := function($input as xs:double) as xs:double {

hof:until(

}

return $sqrt(25)

* Returns {{Code|OK}}, as the predicate is evaluated first:

hof:until(

function($_) { true() },

'OK'

)

|}

| '''Summary'''

|This function is similar to [[Higher-Order Functions#fn:fold-left|fn:fold-left]], but it returns a list of successive reduced values from the left. It is equivalent to:

declare function hof:scan-left($seq, $acc, $f) {

if(empty($seq)) then $acc else (

)

};

|-

| '''Examples'''

|

* Returns triangular numbers:

hof:scan-left(1 to 10, 0, function($a, $b) { $a + $b })

|}

| '''Summary'''

|The function returns items of <code>$seq</code> as long as the predicate <code>$pred</code> is satisfied. It is equivalent to:

declare function hof:take-while($seq, $pred) {

if(empty($seq) or not($pred(head($seq)))) then () else (

)

};

|-

| '''Examples'''

|

* Computes at most 100 random integers, but stops if an integer is smaller than 10:

hof:take-while(

(1 to 100) ! random:integer(50),

function($x) { $x >= 10 }

)

|}

| '''Summary'''

|Returns the {{Code|$k}} items in {{Code|$seq}} that are greatest when sorted by the result of {{Code|$f}} applied to the item. The function is a much more efficient implementation of the following scheme:

(for $x in $seq

order by $sort-key($x) descending

return $x

)[position() <= $k]

|-

| '''Examples'''

* {{Code|hof:id(1 to 5)}} returns {{Code|1 2 3 4 5}}

* With higher-order functions:

let $sort := sort(?, (), hof:id#1)

let $reverse-sort := sort(?, (), function($x) { -$x })

$reverse-sort((1, 5, 3, 2, 4))

)

returns: <code>1 2 3 4 5 | 5 4 3 2 1</code>

|}

* {{Code|hof:const(42, 1337)}} returns {{Code|42}}.

* With higher-order functions:

let $zip-sum := function($f, $seq1, $seq2) {

sum(for-each-pair($seq1, $seq2, $f))

$sum-left((1, 1, 1, 1, 1), 1 to 5)

)

* Another use-case: When inserting a key into a map, {{Code|$f}} decides how to combine the new value with a possibly existing old one. {{Code|hof:const}} here means ignoring the old value, so that's normal insertion.

let $insert-with := function($f, $map, $k, $v) {

let $old := $map($k)

$ins($map, 'foo', 42)('foo')

)

returns {{Code|3 42}}

|}