TypeScript无法推导含至少1元素的递归元组类型？求解决方案

在TypeScript 5.0.4中，定义了如下类型与函数：

首先定义Parser接口和用于解析元组的类型工具：

interface Parser<T> {
    parse(str: string): T;
}
type UnwrapParserTuple<Ps extends readonly Parser<any>[]> =
    Ps extends readonly []
        ? []
    : Ps extends readonly [Parser<infer T1>, ...infer PsRest]
        ? (PsRest extends readonly Parser<any>[] ? [T1, ...UnwrapParserTuple<PsRest>] : never)
    : never;

接着定义一个保证至少传入1个Parser实例的函数：

function actionWithPrepended<P1 extends Parser<any>, const Ps extends readonly Parser<any>[]>(
    parser1: P1, ...parsers: Ps
) {
    let allValues: UnwrapParserTuple<[P1, ...Ps]>; // 假设该变量来自外部
    const value1 = allValues[0]; // 报错：Tuple type '[]' of length '0' has no element at index '0'
}

TypeScript禁止访问allValues[0]并抛出上述错误。若修改类型工具以支持数组类型：

type UnwrapParserArray<Ps extends readonly Parser<any>[]> =
    Ps extends readonly []
        ? []
    : Ps extends readonly [Parser<infer T1>, ...infer PsRest]
        ? (PsRest extends readonly Parser<any>[] ? [T1, ...UnwrapParserTuple<PsRest>] : never)
    : Ps extends readonly Parser<infer TAll>[]
        ? TAll[]
    : never;

此时可访问allValues，但它的类型会退化为unknown | unknown[]，失去精确的类型推导能力。

核心问题 #

为什么TypeScript无法推导出UnwrapParserTuple<[P1, ...Ps]>至少包含一个元素？该如何解决此问题？

原因分析 #

TypeScript无法完成推导的核心问题在于类型工具的分支逻辑与泛型约束的边界模糊：

• 函数参数结构parser1: P1, ...parsers: Ps确实保证了[P1, ...Ps]是非空的，但UnwrapParserTuple的泛型约束仅限定为readonly Parser<any>[]，这个约束包含了空数组的可能性。
• 类型工具的第一个分支直接对空数组返回[]，TypeScript会据此认为UnwrapParserTuple<[P1, ...Ps]>存在为空元组的可能，因此禁止访问索引0。

解决方案 #

方案一：优化类型工具的非空约束 #

修改UnwrapParserTuple的泛型约束，明确限定输入为非空元组，同时调整分支逻辑确保推导精确：

interface Parser<T> {
    parse(str: string): T;
}

// 限定输入为非空元组，递归解析每一项的返回类型
type UnwrapParserTuple<Ps extends readonly [Parser<any>, ...Parser<any>[]]> =
    Ps extends readonly [Parser<infer T1>, ...infer PsRest]
        ? PsRest extends readonly Parser<any>[] 
            ? [T1, ...(PsRest extends [] ? [] : UnwrapParserTuple<PsRest>)] 
            : never
        : never;

function actionWithPrepended<P1 extends Parser<any>, const Ps extends readonly Parser<any>[]>(
    parser1: P1, ...parsers: Ps
) {
    // 用Extract确保传入类型符合非空元组约束
    let allValues: UnwrapParserTuple<Extract<[P1, ...Ps], readonly [Parser<any>, ...Parser<any>[]]>>;
    const value1 = allValues[0]; // 无报错，类型正确推导为P1的解析结果
}

方案二：直接断言结果非空 #

在类型层面添加条件判断，排除结果为空元组的可能性：

interface Parser<T> {
    parse(str: string): T;
}

type UnwrapParserTuple<Ps extends readonly Parser<any>[]> =
    Ps extends readonly []
        ? []
    : Ps extends readonly [infer T1 extends Parser<any>, ...infer PsRest]
        ? [T1['parse'] extends (str: string) => infer R ? R : never, ...UnwrapParserTuple<PsRest>]
        : Ps extends readonly Parser<infer TAll>[]
            ? TAll[]
            : never;

function actionWithPrepended<P1 extends Parser<any>, const Ps extends readonly Parser<any>[]>(
    parser1: P1, ...parsers: Ps
) {
    // 通过条件类型断言结果非空
    let allValues: UnwrapParserTuple<[P1, ...Ps]> extends infer R 
        ? R extends [] ? never : R 
        : never;
    const value1 = allValues[0]; // 类型精确，无报错
}

方案三：简化推导逻辑，跳过递归 #

直接提取单个Parser的返回类型，组合成结果元组：

interface Parser<T> {
    parse(str: string): T;
}

// 提取单个Parser的返回类型
type ParserResult<P extends Parser<any>> = P extends Parser<infer T> ? T : never;

function actionWithPrepended<P1 extends Parser<any>, const Ps extends readonly Parser<any>[]>(
    parser1: P1, ...parsers: Ps
) {
    // 直接组合出非空的结果元组类型
    let allValues: [ParserResult<P1>, ...ParserResult<Ps[number]>[]];
    const value1 = allValues[0]; // 类型精确推导为P1的解析结果
}

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