处理展开的可变元组类型

Question

考虑以下代码：

interface Wrap<Value> {
  pick(): Value
}

class WrapConstant<Value> implements Wrap<Value> {
  constructor(public readonly a: Value) { }
  pick(): Value { return this.a }
}

type Unwrap<Wrapped> = { [P in keyof Wrapped]: Wrapped[P] extends Wrap<infer Value> ? Value : never }

class WrapTuple<Tuple extends Wrap<unknown>[], Value = Unwrap<Tuple>> implements Wrap<Value> {
  readonly ts: Tuple
  constructor(...t: Tuple) { this.ts = t }

  pick(): Value { return this.ts.map(a => a.pick()) }                // fails to type check
}

type T1 = Unwrap<[WrapConstant<number>, WrapConstant<string>]>       // [number, string]

new WrapTuple(new WrapConstant(1), new WrapConstant("hello")).pick() // [1, "hello"]

基本上我正在解开一个我知道遵循某种形状的元组（Wrap<Values> 的元组）。 WrapTuple 中的 pick() 函数应该保证返回相同形状的未包装类型（由 Unwrap<Tuple> 提供），尽管我在该行中遇到类型检查错误。问题：

1. 这是因为 Unwrap<Tuple> 不能保证由于条件类型推断而具有相同的形状吗？
2. 是否可以在不强制转换as unknown as Value 的情况下使其工作？

---

更新：正如 Linda 所说，映射元组不会产生元组。我尝试按照here的建议合并我自己的地图声明：

interface Array<T> {
  map<U>(callbackfn: (value: T, index: number, array: T[]) => U, 
         thisArg?: any): { [K in keyof this]: U }
}

但这仍然需要将map 断言为Value：

pick(): Value { return this.ts.map(a => a.pick()) as Value }

Answer 1

更新

这里是解决方法：

interface Wrap<Value> {
    pick(): Value
}

class WrapConstant<Value> implements Wrap<Value> {
    constructor(public readonly a: Value) { }
    pick(): Value { return this.a }
}

type Unwrap<Wrapped> = { [P in keyof Wrapped]: Wrapped[P] extends Wrap<infer Value> ? Value : never }

class WrapTuple<Tuple extends ReadonlyArray<Wrap<unknown>>> implements Wrap<unknown> {
    readonly ts: Tuple
    constructor(...ts: [...Tuple]) {
        this.ts = ts
    }

    pick(): Unwrap<[...Tuple]> // <-- added overload
    pick() {
        return this.ts.map(a => a.pick())
    }
}


const foo = new WrapTuple(new WrapConstant(1), new WrapConstant("hello")).pick() // [number, string]

Playground

看起来它在方法重载的情况下按预期工作

Here 你可以找到更多使用元组的解决方法。这是我的博客