TypeScript高阶函数实现重载疑问：签名相同时如何确定调用？

Great question! This is a common point of confusion when first diving into fp-ts, since it leverages TypeScript's powerful type inference system to make these generic functions feel seamless. Let's break down how TypeScript figures out the correct types for functions with the signature <A, B>(f: (a: A) => B).

1. The Basics of the Generic Signature #

First, let's unpack what <A, B>(f: (a: A) => B) means:

• <A, B> are type parameters — they're placeholders for any two types, making the function flexible enough to work with arbitrary input-output pairs.
• f: (a: A) => B is a function parameter that takes a value of type A and returns a value of type B.

This signature is intentionally generic because fp-ts is built around abstractions like functors, monads, and applicatives, which need to work across many different data types (like Option, Either, Array, etc.).

2. TypeScript's Contextual Inference in Action #

The magic happens with TypeScript's contextual type inference. When you use one of these fp-ts functions (like map on an Option), TypeScript uses the surrounding context to fill in the A and B type parameters automatically.

Let's use a concrete example with Option:

import { Option, some } from 'fp-ts/Option';

// Our function to pass in
const multiplyByThree = (n: number) => n * 3;

// An Option containing a number
const myNumber = some(7);

// Call map with multiplyByThree
const result = myNumber.map(multiplyByThree);

Here's how TypeScript infers the types:

• It first sees myNumber is of type Option<number>, so it knows the A type parameter for map is number.
• Next, it checks that multiplyByThree accepts a number (matching A) and returns a number — so B is inferred as number.
• Finally, it knows result must be Option<number>.

3. Chained Inference with fp-ts Pipelines #

fp-ts encourages using pipelines (via pipe or flow), and TypeScript's inference works seamlessly here too. It propagates types step-by-step through the chain:

import { pipe } from 'fp-ts/function';
import { Option } from 'fp-ts/Option';

const processed = pipe(
  some('fp-ts is cool'),
  (optStr) => optStr.map(str => str.length), // str is inferred as string; returns Option<number>
  (optNum) => optNum.map(num => num > 10)    // num is inferred as number; returns Option<boolean>
);

In this pipeline:

• The first step gives us an Option<string>, so TypeScript knows the map call expects a function that takes a string.
• The result of that first map is Option<number>, so the next map expects a function that takes a number.
• By the end, processed is correctly inferred as Option<boolean>.

4. Type Classes Add Constraints #

Under the hood, fp-ts uses type classes (like Functor, Monad) to define these generic functions. Type classes enforce that data types (like Option) implement specific methods, which gives TypeScript additional context to narrow down types.

For example, the Functor type class defines map as:

interface Functor<F> {
  readonly map: <A, B>(fa: F<A>, f: (a: A) => B) => F<B>;
}

When Option implements Functor, TypeScript knows that F<A> for Option is Option<A>, so it can reliably infer A and B based on the input Option<A> and the function f.

Wrap-Up #

To put it simply:

• The generic signature <A, B>(f: (a: A) => B) makes the function reusable across any type pair.
• TypeScript uses contextual inference (looking at where the function is called, like on an Option<number>) to figure out what A and B should be.
• fp-ts's type classes add structure that helps TypeScript make precise, safe type inferences without you having to manually specify types most of the time.

内容的提问来源于stack exchange，提问作者dagda1