Proposal: Predicate inferer

[emmbm]

Type description + examples

With typescript now supporting predicate inference for guard functions without the need for explicitly specifying a is clause, it could be interesting to provide a simple helper that allows to get the inferred predicate for any guard function.

Ex.:

function isValid(value: string | number | null | undefined | false) {
  return value != null && value !== false;
} // : value is string | number

type Valid = Predicate<typeof isValid> // string | number

Type source

export type Predicate<T> = T extends (x: any) => x is infer U ? U : never;

Search existing types and issues first

• I tried my best to look for it

Upvote & Fund

• We're using Polar.sh so you can upvote and help fund this issue.
• The funding will be given to active contributors.
• Thank you in advance for helping prioritize & fund our backlog.

[sindresorhus]

Sounds useful, but the name is slightly confusing. The type extracts the inferred guard type, but a name like Predicate makes it sound like it's for making predicates. Maybe something like GuardType or ExtractGuard?

[emmbm]

I agree Predicate is probably not the best naming, but I don't think derivatives of Guard sound right either since the guard is technically the check, not it's resulting assertion. Maybe GuardedType or just Guarded?

[fregante]

This type would be similar to ReturnType so maybe it should follow its naming.

[Emiyaaaaa]

Looks interesting, are there any use cases?

[emmbm]

@Emiyaaaaa rather than having to rely on manually maintaining consistency across explicit predicates and implementations, it allows to derive types from guard function implementations, the latter being less error-prone.

For example:

// Before

type Valid = string | number | null // Let's say a dev decided to add null to this union.

// When declared explicitly, the predicate can diverge from the actual implementation if not cautious.
function isValid(value: string | number | null | undefined | false): value is Valid {
  return value != null && value !== false;
}

// After

function isValid(value: string | number | null | undefined | false) {
  return value != null && value !== false;
}

type Valid = Predicate<typeof isValid> // This will always be up to date with the guard implementation.

Use cases include typing function params based on guard implementations or extracting type from data parsing functions without having to explicitly repeat types now adequately inferred by ts.

[Emiyaaaaa]

Sorry I actually want real usecases, and I have a doubt that this type depends on the real result of the execution of the function, this sounds a little strange for typescript.

[emmbm]

and I have a doubt that this type depends on the real result of the execution of the function, this sounds a little strange for typescript.

I'm not sure how to interpret this, it honestly reads either like a misinterpretation conflating runtime and compile time analysis, or an overlook of predicate inference being a major improvement brought by typescript 5.5 (microsoft/TypeScript#57465).

Either way, if you don't think this would be a valid addition, feel free to close the issue.