javascript - typescript 定义 - 嵌套函数

Question

如下所示，假设我们有:

1. 将多个任务组合在一起的函数r
2. 和一个返回类似when(cb).map(cb)
形状的函数 o

传递给 when 或 map 的每个回调都应始终采用这些 3 参数:S、A、C其中 S 和 C 在 r 中定义，A 在 o 中定义。

这里是 typescript playground 的链接这也显示了我得到的错误。

我的问题是:如何获得类型安全声明？

type Task<S, A, C> = <AA extends A>(s: S, a: AA, c: C) => any;
type Fn<S, A, C> = (s: S, a: A, c: C) => any;

const r = <S, C>() => ({
  tasks: (...tasks: Task<S, any, C>[]) => null,
});

const o = <T, A = { prop: T }>(type: T) => ({
  when: <S, C>(fp: Fn<S, A, C>) => ({
    map: <SS extends S, CC extends C>(fn: Fn<SS, A, CC>): Task<SS, A, CC> => (
      (s: SS, a: A, c: CC): any => (
        fp(s, a, c) ? fn(s, a, c) : s
      )
    ),
  }),
});

const result = r<2, 7>().tasks(
  o(44) // expect: cb(2, 44, 7)
    .when((s, a, c) => s + a.prop + c)
    .map((s, a, c) => s + a.prop + c),

  o(78) // expect: cb(2, 78, 7)
    .when((s, a, c) => s + a.prop + c)
    .map((s, a, c) => s + a.prop + c),

  // etc...
  // callback provided to `.map` is typesafe,
  // callback provided to `.when` is not,
);

如您所见，提供给 when 的回调不是类型安全的:Params S 和 C 丢失了。

Answer 1

嗯，除其他问题外，您似乎想要一些 contextual type inference该语言没有提供。以下是我推荐的输入方式:

type Fn<S, A, C> = (s: S, a: A, c: C) => any;

// allow tasks to be an array of Fn<S, any, C> 
const r = <S, C>() => ({
  tasks: <FF extends Fn<S, any, C>[]>(...tasks: FF) => null,
});
// it is concerning that S and C must be explicitly specified
// when calling r(); not sure how you will hook that up to runtime

// only make types generic if they need to be, 
// and declare close to their uses if you want them to be inferred
const o = <T>(type: T) => ({
  when: <S, C>(fp: Fn<S, { prop: T }, C>) => ({
    map: (fn: Fn<S, { prop: T }, C>) => (s: S, a: { prop: T }, c: C): any =>
      fp(s, a, c) ? fn(s, a, c) : s,
  }),
});

const result = r<2, 7>().tasks(
  o(44) // expect: db(2, 44, 7)
    // you need to annotate the s and c parameters in when().
    // The compiler does not try to infer S and C in o(44).when() contextually 
    // from the contextual parameter type of r<2.7>().tasks().
    .when((s: 2, a, c: 7) => s + a.prop + c)
    .map((s, a, c) => s + a.prop + c),

  o(78) // expect: db(2, 78, 7)        
    // alternatively you can specify S and C manually:
    .when<2, 7>((s, a, c) => s + a.prop + c)
    .map((s, a, c) => s + a.prop + c),
  // etc...
);

自从我处理此问题以来，您已经更改了定义，因此以下内容可能与您发布的内容不完全匹配。简而言之:

• 制作r().tasks()取 Fn<S, any, C> 的数组(可能是 tuple )值，所以第二个任务的 A 的事实与第一个不一样不会导致错误。

• 没有通用的 T还有一个通用的 A = {prop: T} .我猜 A并不意味着独立于 T而你正在尝试使用 default type parameter代表某种任务，但它并不是那样工作的。相反，只需使用 T然后替换 A 的所有实例与 {prop: T} .

• 只拥有您需要的泛型类型，并且尽可能靠近所需的推理位置。我搬家了S和 C至 o().when .

• 最后，来自 r<2.7>().tasks() 参数的上下文输入到 S 的值和 C在 o().when()不会发生。编译器可能甚至不会尝试这样做，因为推理必须在多个级别的函数调用中发生。处理这个问题的唯一方法似乎是重新指定 S和 C ，或者通过注释 s和 c传递给 o().when() 的回调参数，或调用 o().when<2,7>() .

希望这能帮助您指明正确的方向。祝你好运!