TypeScript 提供(未指定)泛型类型作为泛型参数 [英] TypeScript provide (unspecified) generic type as generic argument

问题描述

我希望提供一个泛型类型作为类型参数而不首先将其解析为具体类型.换句话说，我正在寻找一种方法来指定从基类继承时可以使用的类型映射函数.

I'm looking to provide a generic type as a type argument without resolving it to a concrete type first. Put another way, I'm looking for a way to specify a type mapping function that I can use when inheriting from a base class.

示例(不正确)语法，希望比我能解释的更好:

Example (incorrect) syntax which hopefully explains better than I can:

abstract class RunIt<SomeMagicConverter> {
    // The return type for this function depends on the type of the
    // argument *and* on the way the implementation class was declared:
    run<T>(o: T): SomeMagicConverter<T> { // (syntax error)
        return this.handle(o); // (imagine this does something more interesting)
    }
    protected abstract handle<T>(o: T): SomeMagicConverter<T>; // (syntax error)
}

type MyMagicConverter<T> = TypeIWantToReturn<T>; // MyMagicConverter is generic
class MyRunIt extends RunIt<MyMagicConverter> { // but we don't specify T here
    // [...]
}
new MyRunIt().run(7); // call infers T is number, so returns TypeIWantToReturn<number>
new MyRunIt().run(''); // now T is string, so returns TypeIWantToReturn<string>

另外，我想限制这个，以便 SomeMagicConverter;extends SomeBase 是有保证的.即

Additionally, I want to restrict this so that SomeMagicConverter<T> extends SomeBase<T> is guaranteed. i.e.

abstract class RunIt<SomeMagicConverter extends SomeBase>

---

关于我希望如何使用它的更具体的例子，这里有一个用于 wrap-with-caching 的基本基类(不是我的实际用例，但演示了需求):

---

For a more concrete example of how I hope to use this, here's a basic base-class for a wrap-with-caching (not quite my actual use-case but demonstrates the need):

interface Wrapped<T> {
    contains(other: T): boolean;
}

abstract class Store {
    private readonly cached = new Map<any, any>();

    protected abstract applyWrap<T>(o: T): Wrapped<T>;

    wrap<T>(o: T): Wrapped<T> { // <-- this should return something more specific
        if (!this.cached.has(o)) {
            this.cached.set(o, this.applyWrap(o));
        }
        return this.cached.get(o);
    }
}

class Foo<T> implements Wrapped<T> {
    constructor(private readonly o: T) {}
    contains(other: T): boolean { return other === this.o; }
    extraFooFunc(): void {}
}

class FooWrapper extends Store {
    constructor() { super(); }
    protected applyWrap<T>(o: T): Foo<T> { return new Foo<T>(o); }
}

new FooWrapper().wrap(4).extraFooFunc(); // syntax error because extraFooFunc is not defined on Wrapped

显然我可以通过定义包装方法来解决这个问题，但我想避免在每个子类上都这样做:

Clearly I can work around this by defining wrapping methods, but I'd like to avoid having to do that on every child class:

class FooWrapper extends Store {
    // [...]
    wrap<T>(o: T): Foo<T> { return super.wrap(o) as Foo<T>; }
}

推荐答案

尚不支持通用通用参数(2021 年 3 月).请参阅 TypeScript 问题 和 类似的问题了解更多信息.

Generic generic parameters are not supported yet (March 2021). See TypeScript Issue and a similar SO question for more information.

但是，您所描述的内容可以使用索引访问来实现类型和映射类型:

However, what you describe can be implemented using Indexed Access Types and Mapped Types:

// Any Converter to be used with RunIt must be added to Converters
interface Converters<T> { }

// All Converters must implement this interface
interface ConverterBase<T> { length: number }

// Maps valid keys to themselves, invalid ones to `never`
type ValidKey<T, K extends keyof Converters<T>> =
    Converters<T>[K] extends ConverterBase<T> ? K : never;

// Contains all entries from Converters where the type extends ConverterBase
type ConstrainedConverters<T> = {
    [K in keyof Converters<T> as ValidKey<T, K>]: Converters<T>[K];
};

abstract class RunIt<K extends keyof ConstrainedConverters<void>> {
    run<T>(o: T): ConstrainedConverters<T>[K] {
        return this.handle(o);
    }
    protected abstract handle<T>(o: T): ConstrainedConverters<T>[K];
}

// Re-open Converters and add some Converters
interface Converters<T> { Id: T, Array: Array<T> }

class ArrayRunIt extends RunIt<'Array'> {
    protected handle<T>(o: T) { return [o]; }
}

// @ts-expect-error Type '"Id"' does not satisfy the constraint '"Array"'.(2344)
class IdRunIt extends RunIt<'Id'> {
    protected handle<T>(o: T) { return o; }
}

这篇关于TypeScript 提供(未指定)泛型类型作为泛型参数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！