In TypeScript, what does a method whose declared return type is `this is Foo` do at call sites, and when would you model a check that way instead of exporting a standalone `value is Foo` guard?

## The form A type predicate normally names a parameter: `function isString(v: unknown): v is string`. A method may instead name the receiver: ```ts class Draft { constructor(public title: string, public body?: string) {} isPublishable(): this is Draft & { body: string } { return this.body !== undefined; } } ``` The return type `this is T` says: this method returns a boolean, and a `true` result licenses the compiler to treat *the object the method was called on* as `T`. ## What it does at the call site ```ts const draft = new Draft("Title", "Body"); if (draft.isPublishable()) { draft.body.trim(); // body: string, not string | undefined } ``` The narrowing lands on the receiver expression, following the same rules as any other narrowing: it works on a reference the checker can track and it resets if the reference is reassigned. It also works on `this` itself: ```ts class Draft { // ... publish(): string { if (this.isPublishable()) { return this.body.toUpperCase(); // this narrowed inside the method } throw new Error("Draft has no body"); } } ``` Interfaces can declare the same signature, so a contract can require implementors to provide the narrowing check without dictating how it is computed. ## Two shapes it takes **Refinement by intersection.** The asserted type is the class itself intersected with a tighter view of some members — `this is Draft & { body: string }`. This is the workhorse form for objects with optional or nullable state: one method encodes "I am in the filled state" and every caller gets the tightened field. **Refinement to a subclass.** In a hierarchy, the base declares checks that assert subclass types: ```ts class FsNode { isDirectory(): this is Directory { return this instanceof Directory; } } class Directory extends FsNode { children: FsNode[] = []; } ``` Callers holding a `FsNode` can branch once and reach `children` without writing `instanceof` themselves or importing the subclass to do it. ## When to choose it over a free guard Ask who owns the state being tested. Choose `this is T` when the object owns it: the check is really a question about an instance's own lifecycle or variant, the instance is what callers already hold, and discoverability matters — autocomplete on the object surfaces `isPublishable()` where nobody would think to import a helper. It also keeps the invariant next to the fields it reasons about, so a change to the state representation updates the check in the same file. Choose a standalone `value is T` guard when the value comes from outside as plain data — a parsed payload, a message, a value typed `unknown` — because there is no instance whose class you control, and because a free function composes: it can be passed to `filter`, reused across shapes, and applied to values you did not construct. ## Costs worth naming in an interview The subclass form points the base class at its own subtypes, which inverts the usual dependency direction and can force a circular import; the intersection form avoids that and is usually the better default. The narrowing also depends on calling the method *on the reference*: pulling the method off the object (`const check = draft.isPublishable; if (check()) …`) loses both the narrowing and the `this` binding. And because objects are mutable, a narrowed receiver is only as good as the code between the check and the use — an intervening call that clears the field is not tracked. Finally, `this is T` is a different feature from a method that *returns* `this`. The latter is about fluent chaining and preserves the subclass type through a chain of calls; `this is T` returns a boolean and refines the receiver in a branch. Interviewers sometimes probe whether a candidate conflates the two.