규칙 8.18

A function whose parameter has a function type, written out (f: (x: f32) => f32) or through a type alias of one, takes a function: a function declared at the top of the file or of a namespace, a method, a static method, a constructor, a field that holds a function (Rule 8.16) and a local function (Rule 8.17). It is compiled once for each set of functions its calls hand it, as a generic function is once for each set of type arguments (Rule 8.9), and in each copy a call of the parameter calls the function handed over (apply_sq, apply_run_f, Swarm_each_sq, run_twice_run_f). A call hands a function over by its name (a module function, a local function, or a parameter of function type of the function the call is in) or as an arrow function or a function expression written in the call, which is a local function of the calling body (Rule 8.17) and takes its parameter types, and its return type where it writes none, from the parameter’s type. What the function handed over captures, the copy takes as parameters too and passes on, by reference where the function writes it. A variable the copy and a function handed over both reach is passed once, as TypeScript has it once: a variable a local function and the function it is handed both capture, and the object a method is called on when a function handed over captures that very variable (this, or a local named as the object), which the copy then takes as its object, by reference where the caller may write it (Rule 8.10). A function handed over takes the parameter’s types and returns its type, or any type where the parameter’s returns void, whose value is not used; an arrow function may leave parameters off at the end, as TypeScript allows, and one whose body is an expression and whose type returns void runs the expression as a statement. Inside the function that takes it, a parameter of function type may only be called or handed on to another such parameter. A fold’s function (any(xs, (x) => x > k), zip(xs, ys, (a, b) => a * b)) is handed over the same way, its types read off the arrays, and an arrow function whose return type nothing gives returns what its body does. An array’s method (xs.map(f), xs.forEach(f), xs.some(p), xs.every(p), xs.reduce(f, init), surface §63) takes a function the same way, a function the file declares taking as few of the arguments as it declares: each call is a call of a function of the module made once for each array type and function handed over (array_map_sq), a counted loop over the indices (Rule 7.5) that hands the function the element, its index as an i32 and the array, and for reduce the running value first, which has the type of the function’s first parameter where that is written and of the value to start from otherwise. The loop reads the array as it goes: a module variable, a module constant or a binding in place, the variable a function handed over captures through the one reference both use, and any other array by value, an index on the way to it read once. Of an array’s methods, one Array.prototype has beyond those five, map on an array with no size, whose value would be an array with none, reduce with no value to start from on an array with no size, which may be empty, a second argument to any but reduce (thisArg), and a function a method passes an array with no size to must be refused. A function type anywhere else (a return, a field, a variable), a parameter of function type on a setter or an entry point, an argument that would choose a function at run time (c ? f : g), a function whose copies would never end (one that hands itself a function it builds anew each time), and a call on a field or an element of a variable that a function handed over reaches, where one of the two may write it, which would be two references into one variable, must be refused.