# AI solution for TypeScript puzzle on BFE.dev

40. implement UnionToIntersection<T>

```
type UnionToIntersection<T> =
(T extends unknown ? (arg: T) => void : never) extends (arg: infer I) => void ? I : never;
```

Explanation:

To implement `UnionToIntersection<T>`

, we first need to understand what intersection types are in TypeScript. Intersection types are formed by using the `&`

symbol between two or more types. It represents a type which has all the properties of the combined types.

Now, let's look at the type parameter `T`

of `UnionToIntersection<T>`

. It is a union of types, i.e., `T`

could be any of the types `{a: string}`

, `{b: string}`

, or `{c: string}`

.

To get the intersection of all these types, we can create a function that takes an argument of type `T`

. But since we want to return the intersection type and not just call the function, we need to wrap this function in an identity function that returns the same type as its argument.

`(T extends unknown ? (arg: T) => void : never)`

The above code creates an anonymous function that takes an argument of type `T`

and returns `void`

. The `extends unknown`

check is necessary to ensure that `T`

is assignable to a function argument. If `T`

is not assignable to a function argument, it means that it cannot be used to create intersection types.

Next, we use the conditional type syntax to check if the above function can be assigned to a function that takes any argument of type `infer I`

and returns `void`

. If yes, we return `I`

, which is the intersection of all the types in the union `T`

. Otherwise, we return `never`

.

`(T extends unknown ? (arg: T) => void : never) extends (arg: infer I) => void ? I : never;`

Thus, the complete implementation of `UnionToIntersection<T>`

is as given above.