Call a function: Difference between revisions
Content added Content deleted
(XSLT) |
(jq) |
||
Line 644: | Line 644: | ||
var foo = [1, 2, 3]; |
var foo = [1, 2, 3]; |
||
mutate(foo) // foo is now [null, 2, 3], not 42</lang> |
mutate(foo) // foo is now [null, 2, 3], not 42</lang> |
||
=={{header|jq}}== |
|||
jq functions are pure functions that are somewhat unusual in two respects: |
|||
* They are like commands in modern operating systems, in that they are <tt>parameterized filters</tt> that can accept input from the previous command and provide output to the next command if there is one in the pipeline of commands. |
|||
* Functions can not only process a stream of inputs, one at a time, but each argument can also accept a stream of inputs. The outputs are then a Cartesian product of the various inputs. |
|||
In this section, we use the notation fn/N to refer to a function named "fn" with N formal parameters. |
|||
'''Calling a function that requires no arguments''' |
|||
0-arity jq functions are invoked simply by specifying their name. |
|||
* Example: . |
|||
(Yes, "." is a 0-arity jq function.) |
|||
'''Calling a function with a fixed number of arguments''' |
|||
The conventional syntax is used except that ";" is the parameter separator. "," is used to construct a stream of values. |
|||
* Example: range(0;100;2) |
|||
'''Calling a function with optional arguments''' |
|||
Recent versions of jq allow one to define functions with the same name but different arities, and therefore if both fn/1 and fn/2 are defined, we may say that fn requires one parameter but accepts 2. In all cases, the syntax for function invocation is the same. |
|||
* Example: range(0; 10) and range(0; 10; 2) |
|||
Since jq functions can accept JSON arrays and objects, there are other ways to simulate optional arguments. |
|||
'''Calling a function with a variable number of arguments''' |
|||
See above. |
|||
'''Calling a function with named arguments''' |
|||
This is not directly supported but can be simulated by defining the function to accept JSON objects. For example, if fn were such a function, |
|||
we might invoke fn like so: <tt>fn( {"required": 1, "optional" 2} )</tt>. |
|||
'''Using a function in statement context''' |
|||
The assignment to a local variable (e.g. <tt>(2*2) as $two<tt>) is similar to a statement context in that the expression as a whole does nothing to the flow of values from its input to its output. |
|||
'''Using a function in first-class context within an expression''' |
|||
jq functions cannot be assigned to variables but are otherwise "first-class" in that the composition of functions can be passed as arguments to other functions. No special syntax is required. |
|||
* Example: <tt>2 | recurse(. * .)</tt> # generate the sequence 2, 4, 16, 256, ... |
|||
'''Obtaining the return value of a function''' |
|||
The value (or stream of values) returned by a function is (or are) automatically available to the next function in the pipeline (e.g. sin | cos); the returned value(s) can also be assigned to a local variable (e.g. sin as $v). |
|||
'''Distinguishing built-in functions and user-defined functions''' |
|||
Currently there is no such distinction, but user-defined functions always have the conventional form, whereas some built-in functions have special syntax. |
|||
'''Distinguishing subroutines and functions''' |
|||
A jq function can be written so as never to return anything (either because it returns without generating a value or because it generates an infinite stream of values), but there is no distinctive marker associated with such functions. |
|||
'''Stating whether arguments are passed by value or by reference''' |
|||
Arguments are in effect passed by value. |
|||
'''Is partial application possible and how''' |
|||
See [[Currying#jq]]. |
|||
=={{header|LFE}}== |
=={{header|LFE}}== |