Point-free JavaScript: write a function runner

Question

In this programming-puzzle, your goal is to write the following function in JavaScript, using (essentially) point-free (tacit) programming:

(f) => void(f())

Your submission should be an expression which returns a function which behaves like the above (taking a function as an argument and calling it, and returning undefined), without writing a function definition (defined objectively below). You must instead achieve the behavior by combining existing functions (e.g., Function.prototype.apply).

Any JS is valid, with the exception of the following:

• Function definitions using the function keyword, arrow function syntax, or object/class method syntax
• Function definitions using new Function or the Function constructor
• Evaluation of code using eval (directly or indirectly)
• Relying on browser-only functionality or import/filesystem/OS/FFI libraries in Node.js

If this is not possible, a proof of its impossibility is also a valid submission. Solutions will be scored by byte count; smallest solution is best.

Answer 1

Why I believe this is impossible (as stated)

There aren't very many JS builtins that call a function, and even fewer that call one with arbitrary arguments. The ones that I've found are the string methods replace and replaceAll, the array methods every, filter, find, findIndex, findLast, findLastIndex, flatMap, forEach, map, reduce, reduceRight, and some; the the function methods apply and call; the global functions Reflect.apply, setTimeout, setInterval, the Promise constructor and (browser only) requestAnimationFrame and addEventListener, and also some weird stuff like RegExp[@@replace].

All the array methods are useless, as they all call functions with the signature f(item, index, array).

There are a few that call the function but can't return undefined. String#replace (along with String#replaceAll and RegExp[@@replace]) almost work with ''.replace.bind('', /(?:)/g), but returns the function's result stringified. setTimeout ignores the function's return value, but returns a uid for that particular call (ditto with setInterval).

Likewise, the function methods apply and call return the return value of whatever function they're called with. Reflect.construct can be used to trigger the Promise constructor, but requires the arguments passed to the constructor function to be placed in an array.

Event listeners are somewhat promising, taking a function and returning undefined, but there's no way to create an object which has an event occur on it every time the function is called. window.addEventListener.bind(window, 'click') (browser only) does work to call a function every time a click is called though.

As calling the expression with the input function has to be the last operation performed on the expression, I don't think there's any way to transform whatever non-undefined value is returned into undefined. And since there's no built-in function capable of both instantly calling the function a single time without arguments and returning undefined, I don't think this challenge is possible.

---

(old answer, calls with nonempty args) 17 bytes

[].find.bind([,])

Try it online!

I'm pretty sure this is optimal -3 bytes thanks to Neil.

Calls the function on an array [,], passing undefined to it. If the function's return value is truthy, the undefined is returned; if it's falsy the find call fails and returns undefined.

Answer 2

JavaScript (Node.js), 74 65 bytes

[].forEach.bind([{[Symbol.split]:(c=Map.call).bind(c)}],''.split)

Attempt This Online!

Answer 3

It looks like a loophole in the function definition restriction, but you can still define a setter:

({set s(f){f()}}).__lookupSetter__('s')

__lookupSetter__ is non-standard and deprecated, but shorter than

Object.getOwnPropertyDescriptor({set s(f){f()}},'s').set