Skip to main content

Type Guards

Flow lets you define functions whose return expression encodes some type predicate over a parameter param. This predicate is annotated in place of a return type annotation as param is PredicateType. It declares that if the function returns true then param is of type PredicateType.

The syntax for a function like this is:

function predicate(param: InputType): param is PredicateType {
return <some_expression>;
}

The type of this function can also be written in terms of a type guard annotation:

type PredicateFunc = (param: InputType) => param is PredicateType;

Basic Usage

Let's see a simple example where we define a type guard function and then use it to refine some values.

Defining a type guard function

1type A = { type: "A"; data: string };2type B = { type: "B"; data: number };3type AorB = A | B;4
5function isA(value: AorB): value is A {6  return value.type === "A";7}

We have defined a data type AorB that is a disjoint union of two types A and B that each have a property type used as tag.

We have also written a user defined type guard function isA defined over objects of type AorB. This function returns true when the value of of the type property of its input is "A". Using the definitions of A and B, Flow can prove that when the value of type is "A" then the type of value will be A.

Using a type guard function to refine values

Functions that have a declared type guard can be used to refine values in conditionals. In the example above, we can use isA to refine a variable of type AorB to just A:

1type A = { type: "A"; data: string };2type B = { type: "B"; data: number };3type AorB = A | B;4
5function isA(value: AorB): value is A {6  return value.type === "A";7}8
9function test(x: AorB) {10  if (isA(x)) {11    // `x` has now been refined to type A.12    // We can assign it variables of type A ...13    const y: A = x;14    // ...and access A's properties through `x`15    const stringData: string = x.data;16
17    // As a sanity check, the following assignment to B will error18    const error: B = x;
19 }20}
18:22-18:22: Cannot assign `x` to `error` because string [1] is incompatible with number [2] in property `data`. [incompatible-type]
18:22-18:22: Cannot assign `x` to `error` because string literal `A` [1] is incompatible with string literal `B` [2] in property `type`. [incompatible-type]

In the then-branch of the conditional if (isA(x)), x will have the type A.

One-sided Type Guards

Note: This feature is available as of v0.237.0 when option one_sided_type_guards=true is set in the flowconfig.

In some cases we may want to declare that a type guard function only refines the then-branch of a conditional. Consider for example the function

1function isPositive(n: ?number): boolean {2  return n != null && n > 0;3}

If we declared n is number as the type guard of this function then in the following code:

declare n: ?number;
if (isPositive(n)) {
// n is number here
} else {
// n would be null | void here
}

we would be able to establish that n is null | void in the else-branch. This is not true, however, since n could just be a non-negative number.

One-sided type guards, which we annotate as implies param is PredicateType, let us specify that a predicate narrows the type in only the positive case. For example,

1function isPositive(n: ?number): implies n is number {2  return n != null && n > 0;3}

Now, we'll get the following behavior

declare n: ?number;
if (isPositive(n)) {
// n is number here
} else {
// n is still ?number
}

Refine with Array.filter

Flow recognizes when you call filter on an array of type Array<T> with a callback function that holds a type guard with type (value: T) => value is S. It will use this to produce an output array of type Array<S>. Note that S needs to be a subtype of the type of the array element T.

For example

1type Success = $ReadOnly<{type: 'success', value: 23}>;2type Error = $ReadOnly<{type: 'error', error: string}>;3
4type Response =5  | Success6  | Error7
8function filterSuccess(response: Array<Response>): Array<Success> {9  return response.filter(10    (response): response is Success => response.type === 'success'11  );12}13
14function filterError1(response: Array<Response>): Array<Error> {15  const result = response.filter(16    (response): response is Success => response.type === 'success'17  );18  // The following is expected to error19  return result;
20}21 22function filterError2(response: Array<Response>): Array<Error> {23 const result = response.filter(24 // The following is expected to error25 (response): response is Error => response.type === 'success'
26 );27 return result;28}
19:10-19:15: Cannot return `result` because property `error` is missing in object type [1] but exists in object type [2] in array element. [prop-missing]
19:10-19:15: Cannot return `result` because property `value` is missing in object type [1] but exists in object type [2] in array element. [prop-missing]
19:10-19:15: Cannot return `result` because string literal `success` [1] is incompatible with string literal `error` [2] in property `type` of array element. [incompatible-return]
25:17-25:33: Inconsistent type guard declaration because property `error` is missing in object type [1] but exists in object type [2]. The type of `response` [3] refined with the predicate encoded in return expression `response.type === 'success'` [4] needs to be compatible with the guard type `Error` [2]. See 1. in https://flow.org/en/docs/types/type-guards/#toc-consistency-checks-of-type-guard-functions. [prop-missing]
25:17-25:33: Inconsistent type guard declaration because string literal `success` [1] is incompatible with string literal `error` [2] in property `type`. The type of `response` [3] refined with the predicate encoded in return expression `response.type === 'success'` [4] needs to be compatible with the guard type `Error` [5]. See 1. in https://flow.org/en/docs/types/type-guards/#toc-consistency-checks-of-type-guard-functions. [incompatible-type-guard]
25:29-25:33: Inconsistent type guard declaration because property `value` is missing in object type [1] but exists in object type [2]. The type of `response` [3] refined with the predicate encoded in return expression `response.type === 'success'` [4] needs to be compatible with the guard type `Error` [1]. See 1. in https://flow.org/en/docs/types/type-guards/#toc-consistency-checks-of-type-guard-functions. [prop-missing]
25:17-25:33: Inconsistent type guard declaration. The negation of the predicate encoded in return expression `response.type === 'success'` [1] needs to completely refine away the guard type `Error` [2]. Consider using a one-sided type-guard (`implies x is T`). See 2. in https://flow.org/en/docs/types/type-guards/#toc-consistency-checks-of-type-guard-functions. [incompatible-type-guard]

In filterError1, filtering produces Array<Success> that is not compatible with the expected return type Array<Error>.

In filterError2, the predicate response.type === 'success' is used to refine Responses to Successs, not Errors.

Defining Type Guard Functions

To ensure that refinement with type guard functions is sound, Flow runs a number of checks associated with these functions.

Predicate parameter is a regular parameter to the function

In a type guard annotation of the form parameter is Type, parameter needs to belong to the current function's parameter list.

1function missing(param: mixed): prop is number {
2 return typeof param === "number";3}
1:33-1:36: Cannot find type guard parameter `prop` [1] in the parameters of this function (type). [function-predicate]

It cannot be a parameter bound in a destructuring pattern, or a rest paramter:

1function destructuring({prop}: {prop: mixed}): prop is number {
2 return typeof prop === "number";3}
1:48-1:51: A type guard parameter `prop` [1] cannot reference pattern parameter `prop` [2]. [function-predicate]
1function rest(...value: Array<mixed>): value is Array<mixed> {
2 return Array.isArray(value);3}
1:40-1:44: A type guard parameter `value` [1] cannot reference rest parameter `value` [2]. [function-predicate]

Predicate type is consistent with the parameter type

The type guard Type needs to be compatible with the type of the parameter. In other words, given a definition

function isT(x: ParamType): x is Type {
return ...
}

Flow will check that Type is a subtype of ParamType. So the following will be an error:

1function isNumber(x: string): x is number {
2 return typeof x === "number";3}
1:36-1:41: Cannot use number [1] as type prediate for parameter `x` because number [1] is incompatible with string [2]. A user defined type guard needs to be compatible with its parameter's type. [incompatible-type-guard]

Type guard function returns boolean

A type guard function needs to return a boolean expression. The following are invalid declarations:

1function isNumberNoReturn(x: string): x is string {}
1:39-1:49: Cannot declare a type predicate [1] for function [2] because boolean [1] is incompatible with implicitly-returned undefined. [incompatible-return]
1function nonMaybe<V: {...}>(x: ?V): x is V {2  return x;
3}
2:10-2:10: Cannot return `x` because null or undefined [1] is incompatible with boolean [2]. [incompatible-return]
2:10-2:10: Cannot return `x` because object type [1] is incompatible with boolean [2]. [incompatible-return]

A correct version of nonMaybe would be

1function nonMaybe<V: {...}>(x: ?V): x is V {2  return !!x;3}

Predicate type is consistent with refined type

In addition to the above checks, Flow also ensures that the declared type guard is consistent with the check happening in the body of the function. To establish this it needs to guarantee two things:

  1. The type of the refined parameter at the return location after the predicate of the return expression has been applied is a subtype of the guard type. For example, the following definitions are correct:
1function numOrStr(x: mixed): x is number | string {2  return (typeof x === "number" || typeof x === "string");3}4
5function numOrStrWithException(x: mixed): x is number | string {
6 if (typeof x === "number") {7 return true;8 } else {9 if (typeof x === "string") {10 return true;11 } else {12 throw new Error("");13 }14 }15}
5:43-5:62: Inconsistent type guard declaration. The negation of the predicate encoded in return expression `true` [1] needs to completely refine away the guard type union type [2]. Consider using a one-sided type-guard (`implies x is T`). See 2. in https://flow.org/en/docs/types/type-guards/#toc-consistency-checks-of-type-guard-functions. [incompatible-type-guard]
5:43-5:62: Inconsistent type guard declaration. The negation of the predicate encoded in return expression `true` [1] needs to completely refine away the guard type union type [2]. Consider using a one-sided type-guard (`implies x is T`). See 2. in https://flow.org/en/docs/types/type-guards/#toc-consistency-checks-of-type-guard-functions. [incompatible-type-guard]

But in the following Flow will raise errors:

1function numOrStrError(x: mixed): x is number | string {
2 return (typeof x === "number" || typeof x === "boolean");3}
1:35-1:54: Inconsistent type guard declaration because: [incompatible-type-guard] Either boolean [1] is incompatible with number [2]. Or boolean [1] is incompatible with string [3]. The type of `x` [4] refined with the predicate encoded in return expression `((typeof x) === "number") || ((typeof x) === "boolean")` [5] needs to be compatible with the guard type union type [6]. See 1. in https://flow.org/en/docs/types/type-guards/#toc-consistency-checks-of-type-guard-functions.
1:35-1:54: Inconsistent type guard declaration. The negation of the predicate encoded in return expression `((typeof x) === "number") || ((typeof x) === "boolean")` [1] needs to completely refine away the guard type union type [2]. Consider using a one-sided type-guard (`implies x is T`). See 2. in https://flow.org/en/docs/types/type-guards/#toc-consistency-checks-of-type-guard-functions. [incompatible-type-guard]
  1. Type guard functions can be used to refine the else-branch of conditionals. For example,
1function isNumber(x: mixed): x is number {2  return typeof x === "number";3}4
5declare var value: number | string;6if (isNumber(value)) {7  value as number; // okay8} else {9  value as string; // also okay10}

Therefore, the inverse form of the first requirement also needs to hold. Specifically, if we negate the predicate encoded in the function, and use it to refine the input, then the result must not overlap with the type guard at all. This condition is equivalent to checking that the type guard refined with the negation of the function predicate is a subtype of empty. For example the following raises an error:

1function isPosNum(x: mixed): x is number {
2 return typeof x === 'number' && x > 0;3}
1:30-1:40: Inconsistent type guard declaration. The negation of the predicate encoded in return expression `((typeof x) === 'number') && (x > 0)` [1] needs to completely refine away the guard type number [2]. Consider using a one-sided type-guard (`implies x is T`). See 2. in https://flow.org/en/docs/types/type-guards/#toc-consistency-checks-of-type-guard-functions. [incompatible-type-guard]

This is because the negation of the predicate of isPosNum is "x is not a number or x<=0". This predicate is equivalent to the empty predicate and does not refine the input type it is applied to.

If you're seeing errors related to this check, consider using a one-sided type guard (write implies x is T). Ones-sided type guards do not require this check, since they do not refine the else-branch of conditionals.

Note: This check only happens when one_sided_type_guards=true is set in the flowconfig.

  1. The parameter that is refined cannot be reassigned in the body of the type guard function. Therefore the following are errors:
1function isNumberError1(x: mixed): x is number {2  x = 1;3  return typeof x === "number";
4}
3:10-3:30: Cannot use type guard parameter `x` [1] because at this return point it is written to in [2]. [function-predicate]
1function isNumberError2(x: mixed): x is number {
2 function foo() {3 x = 1;4 }5 foo();6 return typeof x === "number";7}
1:36-1:36: Cannot use type guard parameter `x`, because `x` [1] is reassigned in [2]. [function-predicate]

Adoption

To use type guards, you need to upgrade your infrastructure so that it supports the syntax:

  • flow and flow-parser: 0.209.1. Between v0.209.1 to v0.211.1, you need to explicitly enable it in your .flowconfig, under the [options] heading, add type_guards=true. One-sided type guards are available as of version 0.237.0 with the option one_sided_type_guards=true.
  • prettier: 3
  • babel with babel-plugin-syntax-hermes-parser. See our Babel guide for setup instructions.
  • eslint with hermes-eslint. See our ESLint guide for setup instructions.