Why does `new (() => {})()` throw a TypeError in JavaScript, and which other function forms are non-constructible in the same way?

## Callable and constructible are two different capabilities Every function object in JavaScript has an internal `[[Call]]` method - that is what makes it callable. Only *some* function objects also have `[[Construct]]`, and that is what `new` demands. When you write `new F()`, the engine checks for `[[Construct]]` first; if it is absent, evaluation stops with a `TypeError` such as `F is not a constructor`. An arrow function is deliberately built without `[[Construct]]`: ```js const arrow = () => {}; new arrow(); // TypeError: arrow is not a constructor ``` ## Why arrows in particular Arrow functions were designed as lightweight lambdas that do not carry their own `this` - they close over the surrounding one. A constructor's whole job is to receive a brand-new `this`, so the two designs are incompatible: there is no slot to put the new object in. Consistently, arrows also carry no `prototype` property: ```js const arrow = () => {}; function Point(x) { this.x = x; } 'prototype' in arrow; // false 'prototype' in Point; // true ``` That property exists only to be used as the `[[Prototype]]` of instances a constructor creates. No construction, no need for it. ## The full non-constructible list - **Arrow functions**, including async arrows. - **Concise (shorthand) methods** in object literals - `{ m() {} }` - and in class bodies, both prototype and `static` methods. - **Getters and setters** defined with `get` / `set`. - **Generator functions** (`function*`) and **async generators**. - **Async functions** (`async function`). - Most built-in functions that are not constructors, e.g. `Math.max` or `parseInt`. A nice detail: a generator function *does* have a `prototype` property - it is used as the prototype of the generator objects it returns - yet it is still not constructible. Async functions have no `prototype` property at all. So "has a prototype property" and "is a constructor" are correlated but not the same test. ## What is constructible - `function` declarations and `function` expressions, including named ones. - `class` declarations and expressions (which are *only* constructible - calling a class without `new` throws). - **Bound functions**, but only if the target is constructible: `Point.bind(null)` can be `new`ed and produces a `Point`; `arrow.bind(null)` cannot. ```js function Point(x) { this.x = x; } const Bound = Point.bind(null); new Bound(5).x; // 5 ``` ## The shorthand-method trap The most practical consequence is that object-literal shorthand is not a pure abbreviation: ```js const api = { Shorthand() {}, Assigned: function () {} }; new api.Assigned(); // fine new api.Shorthand(); // TypeError: api.Shorthand is not a constructor ``` They look interchangeable, and for ordinary calls they are, but only the assigned function expression carries `[[Construct]]`. Codemods and hand-refactors that "tidy up" object literals into shorthand have broken code that used one of those functions as a constructor. The mirror-image trap is converting a constructor to an arrow. `const User = (name) => { this.name = name; }` is not a slightly different constructor - it is not a constructor at all, and every `new User(...)` in the codebase now throws. ## How to check at runtime There is no direct `isConstructor` predicate. The idiomatic probe is to try constructing through `Reflect.construct` and catch: ```js function isConstructor(f) { try { Reflect.construct(function () {}, [], f); return true; } catch { return false; } } ``` This uses `f` as the *new target*, which requires it to be a constructor without actually running its body. In interviews it is enough to know the categories; the probe is a nice extra. ## What interviewers listen for The minimum is "arrow functions cannot be used with `new`". A stronger answer names the reason - no `[[Construct]]`, no own `this`, no `prototype` property - and extends the list to shorthand methods, generators and async functions, which is where the surprise actually costs people time.