In the project I was working on, I had to handle multiple resources (named here Resource1, Resource2, Resource3, … for simplicity). Each resource had its own associatedList component (Resource1List, Resource2List, …), each of which was pretty similar to the others in terms of implementation, as the resources themselves were quite the same outside of a few differences. Below, you can see the types of Resource1 and Resource2 :

So given these specs, I wanted to build a single ResourceList component to display items of a given resource. Its props would include an onItemClick callback function, which takes a variable of that resource type as an argument. Here’s the first type that I wrote for the props of the ResourceList component:

Now that the component is typed, the next step consists of trying to use it with one of our Resources. Here’s how ResourceList can be used for Resource1 for example:

1
import React from 'react';
2
import ResourceList from 'components/ResourceList';
3
import type { Resource1 } from 'core/types';
6
class Resource1List extends React.Component {
7
  onResource1Click = (item: Resource1) => {
8
    const { name, id } = item;
15
    return <ResourceList onItemClick={this.onResource1Click(item)} />;

This is the moment when I ran into the main problem. Given the way I typed this component, running Flow against the code in the example above outputs an error:

In the Resource types we declared above ( Resource1, Resource2 , …), you can see that the key of the “id” field of each Resource doesn’t match. Thus, whenever we will use this component and write an onItemClick function for a resource, Flow will give you an error telling us the properties of the other resources are missing.

To overcome this kind of situation, generics can be very practical. This is how we can end up typing this component and fix this issue:

• we can provide a generic BaseProps type which takes a generic type T

• use T inside BaseProps for ouronItemClick function which will take an item of type T as argument and thus be of type T => void

• declare Resource1Props , Resource2Props , etc, based on BaseProps

• write the type Props as an enum of Resource1Props, Resource2Props, etc.

The resulting code looks like this:

3
    onItemSelect = T => void,
6
type Resource1Props = BaseProps<Resource1>;
7
type Resource2Props = BaseProps<Resource2>;
9
type Props = Resource1Props | Resource2Props;

Running Flow with this type should output the following:

We have now typed our generic list component properly thanks to Flow. We can see that using generics not only brings flexibility to our type, but also will help in the future when we want to scale up the usage of this component, so it can be used with even more resources.