Is there a way to create a named immediately invoked arrow function expression?

Question

I think one good way of self-documenting code (wikipedia page) is to have it enclosed in a named block.

For a long piece of code which is only used once and the purpose is not immediately obvious, instead of using comments, one could put it in a named IIFE¹ (different variations):

(function functionName() {
  // ...
})();

The function names the code, immediately invokes it and is locally scoped.

That seems good to me but for aesthetics reasons I would like to use an arrow function expression instead.

Unnamed "anonymous" IIAFE²:

(() => {
  // ...
})();

Is there a way to create a named IIAFE?

The following attempt throws a SyntaxError:

(const functionName = () => {
  // ...
})();

Uncaught SyntaxError: Unexpected token 'const'

---

¹ IIFE - immediately invoked function expression
² IIAFE - immediately invoked arrow function expression

Answer 1

To address the question of self-documenting the code, the solutions below using comments are probably more appropriate.

Solution 1:

{ // explanation of purpose of this block of code
  // locally scoped code
}

Solution 2:

(() => { // explanation
  // code
})();

Solution 3:

// explanation of code below
// code
// optional end of code mark

Solution 4:

(function functionName() {
  // code
})();

---

As to answer if it is possible to have a named IIAFE:

Without the const statement it declares a named IIAFE to the global scope:

(functionName = () => {
  // ...
})();

Which could be declared to the local scope this way:

let functionName;
(functionName = () => {
  // ...
})();

The following is not exactly immediately invoked but could be used:

const functionName = () => {
  // ...
};
functionName();

Enclosing it inside an anonymous IIAFE could be a workaround, though probably overcomplicated:

(() => {
  const functionName = () => {
    // ...
  };
  functionName();
})();