In TypeScript, how do you type a value that is both callable and carries properties — for example a `log(message)` function that also has `log.level` and `log.reset()` — and why can't the `(message: string) => void` shorthand express it?

## Two ways to write one callable TypeScript has two syntaxes for "this can be called": ```ts type Shorthand = (message: string) => void; interface Member { (message: string): void; } ``` As *callables* these are the same type — `Shorthand` and `Member` are mutually assignable. The difference is structural: the shorthand is a self-contained type expression, while the member form lives inside a member list that can hold other members. ## The hybrid type That second property is the whole reason the member form exists. JavaScript functions are objects, so a library can perfectly well export something you call *and* read properties off: ```ts interface Logger { (message: string): void; level: number; reset(): void; } declare const log: Logger; log('starting'); // uses the call signature log.level = 2; // uses the property log.reset(); // uses the method member ``` All three lines type-check against a single type. This is how you model a callable configuration object, a memoised function that exposes `.cache`, a `parse` function that also offers `parse.strict(...)`, or a middleware factory that carries defaults. ## Why the shorthand cannot do it In a function type expression the return type extends as far to the right as the parser can take it. So the natural-looking attempt is silently a different type: ```ts type Wrong = (message: string) => void & { level: number }; // parses as: (message: string) => (void & { level: number }) ``` The property landed inside the *return type*, not on the function. To attach it to the callable you must parenthesise: ```ts type Right = ((message: string) => void) & { level: number }; ``` That intersection is equivalent to the member form for practical purposes, and it is what people usually write when the callable part is already a named type. Getting this precedence wrong is one of the most common self-inflicted TypeScript bugs — the code compiles, and every property access on the value then fails to resolve. ## Interfaces are not special here A frequent misconception is that only interfaces can be callable. Object type literals accept the same member syntax: ```ts type Logger = { (message: string): void; level: number; }; ``` The interface version differs in the ways interfaces always differ (they participate in declaration merging, they can be `extends`-ed by other interfaces), not in callability. ## Call signatures alongside other member kinds A member list can mix a call signature with ordinary properties, methods, optional members, `readonly` members and index signatures: ```ts interface Route { (path: string): string; readonly base: string; strict?: boolean; } ``` What you should *not* do is treat a hybrid type as a place to describe several different ways of calling the same function — a member list holding two or more call signatures is an overload list, which is a separate topic with its own resolution rules. A hybrid type is about the callable plus its data. ## Nothing exists at runtime The type is a description, not a constructor. Declaring `Logger` emits nothing; it does not create a function, does not attach `level` to anything, and does not verify at runtime that the property is there. That has a practical consequence: producing a value of a hybrid type takes real work in value space — typically `Object.assign(fn, { ...props })`, or assigning properties onto a function declaration so the compiler folds them into its inferred type. A bare arrow function will not satisfy `Logger`, and a type assertion that claims it does is a promise the compiler simply believes. ## Reading the type back out Once you have a hybrid value, `typeof value` in type position gives you the whole thing — callable plus properties — which is the cheapest way to keep a wrapper or a test double in sync with it. ## Interview framing Say the mechanism, not the vocabulary: "a call signature written as a member lets the same type also declare properties, which is how you type a function that carries state". Then note the precedence trap in the intersection spelling, and finish with the erasure point — the type describes the shape, and building a value that actually has that shape is a separate job.