简单聊一聊柯里化和 TypeScript 泛型

这篇文章主要参考了[Learn Advanced TypeshScript](https://hackernoon.com/learn-advanced-typescript-4yl727e6), 加上自己查阅的一些资料和个人理解. 由于后半部分讲的是[Ramda](https://ramdajs.com/)里的 placeholder, 个人不太常用 Ramda 就暂时跳过了.

以及, 这篇文章写的比较虚, 很多地方可能没有完全理解, 见谅.

## 从柯里化讲起
柯里化定义简单来讲, 就是一个接受 n 个参数的函数, 转换成每次只接受一个参数的函数, 最多需要 n 次调用完. 实现如下

```javascript
function curry(callback) {
 return (...args) => {
 if (args.length < callback.length) {
 return curry(callback.bind(null, ...args))
 } else {
 return callback(...args)
 }
 }
}
```

两个点:

- `Function.prototype.bind`方法在每次绑定参数的时候会减少被绑定的函数(这里即`callback`)的`length`, `bind`几个参数, `Function.length`相应减少对应的数量. 传入的绑定参数依次以队列形式从左往右添加到`callback`. 另这里 mdn 我其实没查到相关说明, 去[ecma 手册](https://tc39.es/ecma262/#sec-function.prototype.bind)才找到的...

 ```javascript
 const foo = (arg1, arg2, arg3) => arg1 + arg2 - arg3
 const bar = foo.bind(null, 1)
 bar.bind(null, ...[2, 3])() // 0
 ```

- 递归调用. 递归调用需要一个终止条件, 这里终止条件为当`args.length >= callback.length`, 停止接受实参绑定, 调用该回调. 即由于`bind`, 每次`callback`都在不断接受需要的参数, 其`length`属性也不断减少, 并且最终会减少到 0, 那么当最后一次传递参数(比如现在`callback.length=1`), 传了 2 个(`args.length=2`), 那么第一个参数会被加入到回调函数中作为实参, 递归终止, 柯里化结束

测试一下:

```javascript
const test = (a, b, c, ...d) => true

curry(test)(1)(2)(3) // 严格按照定义, 无 rest 参数
curry(test)(1)(2)(3, 4, 5) // 严格按照定义, 怎么任意数量的 rest 参数
curry(test)(1)(2, 3, 4) // 非严格调用, 有 rest 参数
curry(test)(1, 2, 3) // 非严格调用, 无 rest 参数
```

可以看到, 我们可以遵循严格的柯里化, 一次传入一个参数进行调用, 也可以不遵守, 传入多个参数调用. 

这里需要注意一点: 允许`...d`在最后一次调用的时候传入无限个参数还能调用成功的原因是: `Function.length`并不把 rest 参数计算在内: [This number excludes the rest parameter and only includes parameters before the first one with a default value](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/length)

## 添加类型

### overload 重载

根据声明函数时的不同一般有两种方法进行函数重载:
- 普通函数声明
- `const` 声明(使用`type`或`interface`声明重载类型)

[第一种](https://www.typescriptlang.org/docs/handbook/functions.html#overloads):

```typescript
function foo(a: number): number
function foo(a: string): string
function foo(a: any) {
 return a
}
```

[第二种](https://www.typescriptlang.org/docs/handbook/interfaces.html#function-types):

```typescript
// 或者使用 type Foo = {...}
interface Foo {
 (a: number): number
 (a: string): string
}

const foo: Foo = (a: any) => {
 return a
}
```

### 重载定义类型
观察上面的`curry`代码可以发现, 由于存在递归调用, 返回值可能是一个函数(本身), 或者是最后的结果, 因此可以尝试使用重载, 如下:

```typescript
interface Curry<T extends any[], R> {
 (...args: T): Curry<T, R> 
 (...args: T): R 
}

function curry<T extends any[], R>(callback: Curry<T, R>): Curry<T, R> {
 return (...args: T) => {
 if (args.length < callback.length) {
 return curry(callback.bind(null, ...args))
 } else {
 return callback(...args)
 }
 }
}
```

很遗憾会出现如下类似错误:

```typescript
Type '(...args: T) => Curry<T, R> | Curry<any[], unknown>' is not assignable to type 'Curry<T, R>'...
```

查阅了一下, 发现一个类似的问题: [Generic curry function with TypeScript 3](https://stackoverflow.com/q/51859461/12733140). 

个人理解是, 这个柯里化函数如果使用上述定义的话, 每次返回的函数的类型都是`F<T, R>`, 然而实际上随着每次调用传入参数之后其参数类型应该是不同的. ts 目前还不能把剩余泛型参数(Generic rest parameters)分割成更小的元祖类型, 也就是[concatenate tuples](https://github.com/Microsoft/TypeScript/issues/26058)目前还不完善

解决方法一个是使用`heaps of overloads`, 也就是硬编码类型, 规定所有可能的情况, 也就是上述问题下的第二个[答案](https://stackoverflow.com/a/51861885/12733140)做法, 我自己尝试了一下, 大致如下:

```typescript
interface Curry1<T1, R> {
 (): Curry1<T1, R>
 (t1: T1): R
}

interface Curry2<T1, T2, R> {
 (): Curry2<T1, T2, R>
 (t1: T1): Curry1<T2, R>
 (t1: T1, t2: T2): R
}

interface Curry3<T1, T2, T3, R> {
 (): Curry3<T1, T2, T3, R>
 (t1: T1): Curry2<T2, T3, R>
 (t1: T1, t2: T2): Curry1<T3, R>
 (t1: T1, t2: T2, t3: T3): R
}
```

然后可以定义到`curry`函数上:

```typescript
function curry<T1, R>(fn: (t1: T1) => R): Curry1<T1, R>;
function curry<T1, T2, R>(fn: (t1: T1, t2: T2) => R): Curry2<T1, T2, R>;
function curry<T1, T2, T3, R>(fn: (t1: T1, t2: T2, t3: T3) => R): Curry3<T1, T2, T3, R>;
function curry(callback: any) {
 return (...args: any) => {
 if (args.length < callback.length) {
 return curry(callback.bind(null, ...args))
 } else {
 return callback(...args)
 }
 }
}
```

当然把上述重载抽成一个类型也是可以的, 如下:

```typescript
interface Curry {
 <T1, R>(fn: (t1: T1) => R): Curry1<T1, R>;
 <T1, T2, R>(fn: (t1: T1, t2: T2) => R): Curry2<T1, T2, R>;
 <T1, T2, T3, R>(fn: (t1: T1, t2: T2, t3: T3) => R): Curry3<T1, T2, T3, R>;
}

const curry: Curry = (callback: any) => {
 return (...args: any) => {
 if (args.length < callback.length) {
 return curry(callback.bind(null, ...args))
 } else {
 return callback(...args)
 }
 }
}
```

翻阅了一下`lodash`里面关于`curry`里的定义, 思路也是类似的, 唯一区别是里面用了一些占位符(placeholder), 这里不做深究: 

![curry_lodash](https://user-images.githubusercontent.com/36297538/77854746-a6213180-721e-11ea-855b-e6de47776646.png)

## 泛型
[ts2.8](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html)引入了一些新概念, 比如 conditional types(`T extends U ? X : Y`), `infer`, 一些[工具类型](https://www.typescriptlang.org/docs/handbook/utility-types.html)例如(`Parameters<T>`, `ReturnType<T>`), 其本质都是为了方便做泛型类型推导

泛型一个很明显的好处是可以在 run time 检查类型, 并且确定类型是一个具体的唯一的值, 比如拿官网的一个[泛型例子](https://www.typescriptlang.org/docs/handbook/generics.html#generic-constraints):

```typescript
function getProperty<T, K extends keyof T>(obj: T, key: K) {
 return obj[key];
}

const x = getProperty({ a: 1, b: 'b' }, 'a') // number
```

假设不使用泛型:

```typescript
function getProperty<T, K extends keyof T>(obj: T, key: keyof T) {
 return obj[key];
}

const x = getProperty({ a: 1, b: 'b' }, 'a') // string | number
```
可以看到推断出的类型是一个 union 类型, 并不精准

### 需求
假设不考虑具体代码实现, 仅仅想要实现这样一个`Curry`类型, 满足如下的类型推断:

- 能够满足一次只传入一个参数, 且有类型提示(推导)
- 能够满足一次传入多个参数, 且有类型提示(推导)
- 最后一次调用允许传入剩余参数(rest parameters), 且有类型提示(推导)

具体示例如下

```typescript
// 仅适用 declare 声明 curry 函数的类型, Curry 是需要最后实现的类型
declare function curry(f: (...args: P) => R): Curry<P, R>
// 需要被柯里化的函数
const toCurry = (a: string, b: number, c: boolean, d: ...args: string[]) => true
const curried = curry(toCurry)

curried('a')(1)(true, 'd', 'dd') // true
curried('a')(1)(2) // error
curried('a', 1)(true, 'd', 'dd') // true
curried('a')(1, true, 'd', 'dd') // true
curried('a')(1, true, 'd', 2) // error
```

### 基本概念
三个基本关键词: `type`, `extends`, `infer`
- `type`: 自定义类型, 可以想象成一个 **函数**, 等号左边可以接受输入(也就是泛型), 可以想象成这里泛型充当这个"函数"的参数, 等号右边是输出, 也就是最后会返回的类型, 比如类似这样

 ```typescript
 // 无泛型参数, 返回 string 和 number 的联合类型
 type Foo = string | number

 // 接受一个泛型参数 T, 返回类型为这个参数泛型本身
 type Self<T> = T

 const foo: Self<Foo> = 'foo'
 ```

- `extends`: 可以看成`js`中的`===`, 用于比较. 比如`type T0<T> = T extends U ? X : Y` 的意思是, 泛型`T`是否和`U`类型"相等", 如果相等的话`type T0`返回`X`类型, 否则返回`Y`类型
- `infer`: 可以理解成一个变量, 用来代表一些泛型, 后面有例子会讲到

### 泛型类型和泛型函数(generic type & generic function)

假设有以下两个类型:

```typescript
type Identical1<T> = (x: T) => T
type Identical2 = <T>(x: T) => T
```

第一个可以看做就是一个泛型类型(`generic type`), 接受一个`T`作为参数. 第二个可以看做是一个普通的泛型类型(`generic function`), 不接受任何泛型输入, 返回的就是一个泛型函数. 测试一下:

```typescript
const id1: Identical1<string> = (x) => x
const id2: Identical2 = (x) => x

id1('id') // string
id1(1) // error
id2('id') // string
id2(2) // number
```

具体想要更详细的参考可以去看这个[问题](https://stackoverflow.com/q/58770087/12733140)下的[回答](https://stackoverflow.com/a/58770968/12733140)

### 元祖类型

直接引用[官网](https://www.typescriptlang.org/docs/handbook/basic-types.html#tuple)的定义:
> Tuple types allow you to express an array with a fixed number of elements whose types are known, but need not be the same

```typescript
type tuple = ['a', number, string[]]

const t1: tuple = ['a', 1, ['b', 'c']]
const t2 = (...args: tuple) => true
t2('a', 42, []) // true
```

### 泛型基本类型推导

#### Params

定义: 以元组形式返回一个函数的参数:
```typescript
type Params<F extends (...args: any[]) => any> = 
 F extends ((...args: infer A) => any) ? A : never
```

理解: 接受一个参数`F`类型, 该类型满足`(...args: any[]) => any`的函数类型, 判断条件为`F`是否满足`((...args: infer A) => any)`, 满足返回`A`类型, 否则返回`never`类型

伪代码如下:
```javascript
const Params = (F) => {
 if (F === ((...args: infer A) => any)) {
 return A
 } else {
 return never
 }
}
```

测试一下:
```typescript
const fn = (name: string, age: number, single: boolean) => true
Params<typeof fn> // [string, number, boolean]
```

官方也有一样的实现: [Parameters](https://github.com/Microsoft/TypeScript/blob/v3.3.1/lib/lib.es5.d.ts#L1471-L1474)

不过注意, 这里虽然给`extends`后面的条件加上括号不是必须的, 但是建议加上, 遇到更加复杂的类型推导的时候也更容易看清, 后面会有具体例子说明这一点

#### Head

定义: 给定一个元祖类型, 返回该元祖里面的第一个类型

```typescript
type Head<T extends any[]> = 
 T extends [any, ...any[]] ? T[0] : never
```

测试一下:
```typescript
Head<[string, number, boolean]> // string
```

#### Tail

定义: 给定一个元祖类型, 返回该元祖类型里第一个类型之后的所有类型

```typescript
type Tail<T extends any[]> = 
 ((...args: T) => any) extends ((arg1: any, ...tail: infer A) => any) ? A : []
```

测试一下:
```typescript
Tail<[string, number, boolean]> => [number, boolean]
```

#### HasTail

定义: 给定一个元祖类型, 返回这个元祖类型是否能满足 Tail 类型(其类型数量是否 > 1)

```typescript
type HasTail<T extends any[]> = 
 T extends ([] | [any]) ? false : true
```

测试一下:
```typescript
HasTail<[1, 2, string]> // true
HasTail<Tail<Tail<[1, 2, string]>>> // false => [string]
```

上面三个类型和我们实现一个柯里化类型其实是有一定的关系的:
- `Head`: 比较经典的柯里化里面, 一个柯里化过后的函数每一次只接受一个参数, 因此`Head`类型可以帮助检查每次需要接受的一个参数是哪个
- `Tail`: 每次调用一次柯里化的函数, 正常讲一个参数就已经被消耗(consumed)掉了, 因此需要移入下一个参数, `Tail`类型可以帮助判断下一个所需要的参数类型是哪个
- `HasTail`: 回顾上面的柯里化函数实现, 无限递归是需要有一个终止条件的, 也就是所有需要给定的参数都被消耗完毕, `HasTail`正好用来判断这点

#### ObjectInferValue

定义: 给定一个对象和键, 返回该键下的值类型

```typescript
type ObjectInferValue<O, K> = 
 K extends keyof O ? O[K]: never
```

测试一下:
```typescript
ObjectInferValue<{ a: 1, b: '22' }, 'a'> // 1
```

#### ObjectInferKey

定义: 给定一个对象和值, 根据值得到所对应的键类型

```typescript
type ObjectInferKey<O, V> = 
 { [K in keyof O]: O[K] extends V ? K : never }[keyof O]
```

这里的推断思路是这样的: 先算出`{}[]`, 也就是对应的 `O[K`], 而 `O[k] extends V` 形成一个条件, 也就对这个结果进行再一步判断, 看是否和 `V` 相等, 相等返回推导结果是 `K`

伪代码大致为:
```javascript
const ObjectInferKey = (O, V) => {
 const K = keyof O
 if (O[K] === V) {
 return K
 }
 return never
}
```

测试一下:
```typescript
ObjectInferKey<{ a: 1, b: '22' }, '22'> // 'b'
```

#### FunctionInfer

定义: 给定一个函数, 返回该函数的参数和返回值

```typescript
type FunctionInfer<F> = 
 F extends (...args: infer A) => infer R ? [A, R] : never
```

测试一下:
```typescript
FunctionInfer<(a: number, b: string) => true> // [[number, string], true]
```

#### PromiseInfer

定义: 返回 promise 的类型

```typescript
type PromiseInfer = 
 P extends Promise<infer T> ? T : never
```

测试一下:
```typescript
const p = new Promise<string>()
PromiseInfer<typeof p> // string
```

#### ArrayInfer

定义: 返回一个数组里的类型

```typescript
type ArrayInfer<T extends any[]> = 
 T extends (infer U)[] ? U : never
```

测试一下:
```typescript
ArrayInfer<typeof arr> => string | number
ArrayInfer<(string | number)[]> => string | number
```

#### TupleInfer

定义: 给定一个元祖类型, 返回第一个类型以及后面元素的联合类型

```typescript
type TupleInfer<T> = 
 T extends [infer A, ...(infer B)[]] ? [A, B] : never
```

测试一下
```typescript
TupleInfer<[string, number, boolean]> => [string, number | boolean]
```

### 测试

可以自定义简单的类型测试函数/类型帮助我们进行测试

#### Equals

定义: 判断两个类型是否相等, 相等返回`true`, 否则返回`false`

```typescript
type Equals<X, Y> = 
 (<T>() => T extends X ? 1 : 2) extends 
 (<T>() => T extends Y ? 1 : 2) ? true : false;
```

使用方法如下:
```typescript
Equals<[true, false], [true, false]> // true
Equals<[true, false], [true, 1]> // false
```

#### assertType / assertNotType

两个函数分别用于做类型检测

```typescript
const assertType = <T extends true>() => {}
const assertNotType = <T extends false>() => {}
```

举个例子, 需要测试之前实现的`Head`类型:
```typescript
type test = Head<[string, number, boolean]>

assertType<Equals<test, string>>()
```

编译器不报错就说明没类型是正确的

### 柯里化类型 1

至此根据上面定义的一些工具类型已经可以写出比较基本的柯里化类型了

#### CurryV0

实现如下:
```typescript
type CurryV0 =
 (arg: Head) => HasTail extends true ? CurryV0<Tail, R> : R
```

解析: 这里接受两个参数, `P`(所需要接收的所有参数)和`R`(返回结果), 判断条件为`HasTail`是否和`true`相等, 相等返回输出`(arg: Head) => CurryV0<Tail, R>`这样的一个函数类型, 否则返回`(arg: Head) => R`的函数类型(也就是最后一次接受参数的形态)

伪代码解析一下:
```javascript
const CurryV0 = (P, R) => {
 if (HasTail === true) {
 return (arg: Head) => CurryV0<Tail, R>
 }
 return (arg: Head) => R
}
```

分析一下实现思路: 根据传统的柯里化定义, 每次只接受一个参数, 直到最后所有参数接收完毕返回结果. 那么`Head`即返回每次所需要的那个参数, 每次调用(传入参数)之后, `Tail`做切片处理, 帮助去除之前已经传入的参数, 返回还未被传入的参数列表.`HasTail`帮助判断是否还有参数等待被传入

测试一下:

**这里定义一下两种需要被柯里化的函数, 下面所有的测试均使用这两个函数:**
```typescript
// 无 ...rest 参数的
const curryCb1 = (a: string, b: number, c: boolean) => true
// 有 ...rest 参数的
const curryCb2 = (a: string, b: number, ...c: string[]) => true
```

定义`curry`函数, 这里使用`declare`仅指定类型, 不做具体实现, 该类型会在 run-time 被删除
```typescript
declare function curryV0(f: (...args: P) => R): CurryV0<P, R>
```

```typescript
const curriedCb = curryV0(curryCb1)
const curriedCb2 = curryV0(curryCb2)

const r1 = curriedCb('name')
const r2 = curriedCb('name')(1)
const r3 = curriedCb('name')(1)(true)

type test = typeof curriedCb
assertType<Equals<test, (arg: string) => CurryV0<[number, boolean], boolean>>>()
// 传统的只接受一个参数调用的都很完美
```

可以看到进行传统的一个参数的柯里化调用的时候很完美, 包括完整的类型推断

```typescript
// 无法进行剩余多参数调用
const r4 = curriedCb2('name')(1)('a', 'b') // error
// 无法进行合并参数调用
const r5 = curriedCb2('name', 1) // error
```

然而似乎并不接受非柯里化类型的多个参数调用, `...rest`也不支持

#### CurryV1

改进一下, 如下:
```typescript
type CurryV1 = 
 (arg: Head, ...rest: Tail<Partial>) => HasTail extends true 
 ? CurryV1<Tail, R> : R
```

这样一看, 似乎确实是支持非柯里化的多参数调用了, 测试一下:
```typescript
// 定义一下柯里函数
declare function curryV1(f: (...args: P) => R): CurryV1<P, R>

const curriedCb = curryV1(curryCb1)
const curriedCb2 = curryV1(curryCb2)

const r1 = curriedCb('name') // ok
const r2 = curriedCb('name', 1, true) // ok
const r3 = curriedCb('name', 1, true)(1, false) // should be error
```

可以发现, 尽管改进之后允许传入多个参数, 但是对于第三个测试用例在已经传入了`number`和`boolean`类型之后本应该返回`R`的, 似乎返回的类型还是一个函数类型, 且实质和仅传入了一个参数的效果是一样的

仔细看实现发现, 实际上还是使用了`Head`和`Tail`进行参数校验, 也就是说不管传入了多少参数, 由于我们使用`Head`强制要求传入了第一个参数, `Tail`永远只会抹除第一个传入的参数, 返回剩余的参数数组.

> Somehow, we are going to need to keep track of the arguments that are consumed at a time

#### CurryV2

继续改进, 如下:

```typescript
type CurryV2 = 
 <T extends any[]>(...args: T) => HasTail extends true
 ? CurryV2<Tail<T>, R> : R
```

这里不考虑使用`Head`了, 直接使用`T`来跟踪所有被传入的参数, `Tail<T>`确实是可以根据数量"正确"返回剩余所需要的参数的

但是这里有个问题, 使用了`any[]`实际上失去了所有的类型检查, 比如下面的测试:

```typescript
declare function curryV2(f: (...args: P) => R): CurryV2<P, R>

const curriedCb = curryV2(curryCb1)

const r1 = curriedCb(1) // should be error
```

显而易见, `curryCb1`要求的第一个参数应该是`string`类型, 但是传入`number`类型好像也不报错, 可以看一下具体的类型

```typescript
type test = typeof curriedCb
type test1 = typeof r1

assertType<Equals<test, <T extends any[]>(...args: T) => CurryV2<Tail<T>, boolean>>>()
assertType<Equals<test1, <T extends any[]>(...args: T) => boolean>>()
```

由于`any[]`的存在, 失去了类型检测. 因此目前来看还需要做更多

### 递归类型与其他泛型推导

根据之前的实践发现, 现在需要一些工具类型来帮助追踪已经传入的参数, 也就是说, 没错调用之后需要明确知道有哪些参数已经被传入进去(消耗掉的), 还有哪些参数等待被传入. 接下来的工具函数都是为了帮助做到这点

#### Last

定义: 返回元祖类型的最后一个元素

```typescript
type Last<T extends any[]> = { 0: Last<Tail<T>>, 1: Head<T> }[HasTail<T> extends true ? 0 : 1]
```

简单讲一讲推断思路: 最后返回的是 {}[], 也就是该对象的结果, 其中该对象的 `key` 需要判断, 判断条件是 `T` 中元素是否`> 2`, 是继续递归调用, 同时 `T` 使用 `Tail<T>` 进行数量缩减, 否则返回最后的元素

伪代码为:
```javascript
const Last = (T) => {
 const o = {
 0: Last<Tail<T>>,
 1: Head<T>
 }
 const k = HasTail<T> === true ? 0 : 1
 return o[k]
}
```

测试一下:
```typescript
Last<[1, 2, 3, 4]> // 4
```

#### Length

定义: 返回一个元祖类型的长度

```typescript
type Length<T extends any[]> = T['length']
```

测试一下:
```typescript
Length<[]> // 0
Length<any, any> // 2
```

#### Prepend

定义: 给定一个类型和一个元祖类型, 在该元祖类型的头部插入这个类型, 输出该新元祖类型

```typescript
type Prepend<E, T extends any[]> = 
 ((arg: E, ...args: T) => any) extends ((...args: infer U) => any) ? U : T
```

测试一下
```typescript
Prepend<string, []> // [string]
Prepend<number, [1, 2]> // [number, 1, 2]
```

#### Drop

定义: 给定一个数字 N, 一个元祖类型, 返回从索引从数字之后(包括)的所有类型

```typescript
type Drop<N extends number, T extends any[], I extends any[]=[]> = {
 0: Drop<N, Tail<T>, Prepend<any, I>>,
 1: T
}[Length extends N ? 1 : 0]
```

简单讲一讲推导思路: 给定一个 `I` 为空元祖, 每次 `Drop` 一次就往里面添加一个元素, 不断比较 `N` 和 `I` 的长度, 如果 `I` 的长度 `< N` 继续递归调用, 否则返回最终结果

测试一下:
```typescript
Drop<2, [0, 1, 2, 3]> // [2, 3]
```

#### Cast

定义: 检查 X 是否是 Y 类型, 如果满足保持 X 类型, 否则返回 Y 类型

```typescript
type Cast<X, Y> = X extends Y ? X : Y
```

测试一下:
```typescript
Cast<string, any> // string
Cast<string, string | number> // string
Cast<string, number> // number
```

### 柯里化类型 2

讲一讲如何追踪已经传入的参数的思路, 假设有如下两个类型`parameters`和`consumed`, 分别代表总的(一开始)需要的参数元祖类型和已经传入(consumed)的参数元祖类型:
```typescript
type parameters = [string, number, boolean, string[]]
type consumed = [string, number]
```

配合之前的工具类型可以轻松得到剩余需要的类型列表
```typescript
type toConsume = Drop<Length<consumed>, parameters> // [boolean, string[]]
```

#### CurryV3

根据上面的思路可以实现第三版:

```typescript
type CurryV3 =
 <T extends any[]>(...args: T) =>
 Length<Drop<Length<T>, P>> extends 0
 ? R : CurryV3<Drop<Length<T>, P>, R>
```

简单讲一下推导思路: 核心在于`Drop<Length<T>, P>`, 这个类型代表的就是剩余需要被传入的参数, 利用`Length`进行判断是否还存在参数等待被传入

然而实现的时候会存在错误:
```typescript
Type instantiation is excessively deep and possibly infinite.
```

这时需要使用之前提到的`Cast`帮助修复

#### CurryV4

```typescript
type CurryV4 =
 <T extends any[]>(...args: Cast<T, Partial>) =>
 Length<Drop<Length<T>, P> extends infer DT ? Cast<DT, any[]> : never> extends 0
 ? R
 : CurryV4<Drop<Length<T>, P> extends infer DT ? Cast<DT, any[]> : never, R> 
```

测试一下:
```typescript
declare function curryV4(f: (...args: P) => R): CurryV4<P, R>

const curriedCb = curryV4(curryCb1)

const r1 = curriedCb('name') // ok
const r2 = curriedCb('name', 1, true) // ok
```

似乎对于严格的单个参数柯里化调用和非严格的函数调用都没有问题. 然而, 假如尝试加入`...rest`参数

```typescript
const curriedCb2 = curryV4(curryCb2)
const r3 = curriedCb2('name', 1)('f')('a', 'aaa') // error
```

出现了两个问题:
- `curriedCb2('name', 1)('f')('a', 'aaa')`这样的调用方式其实是错误的, 正确方式应该是`curriedCb2('name', 1, 'f', 'a', 'aaa')`也就是`...rest`参数应该是随着最后一个参数一起传入完毕, 不应该返回出一个新的函数类型来接受`...rest`参数
- 永远也拿不到最后的`boolean`结果了

原因其实是这样, `Length`类型是无法推导出`...rest`的参数个数的, 毕竟他无法确切知道你需要传入的参数到底是有几个

```typescript
type restargs = [string, number, boolean, ...string[]]
type restargsLength = Length<restargs> // number
```

推导结果是`number`....其实是一个挺不错的结果了

#### CurryV5

```typescript
type CurryV5 =
 <T extends any[]>(...args: Cast<T, Partial>) =>
 Drop<Length<T>, P> extends [any, ...any[]]
 ? CurryV5<Drop<Length<T>, P> extends infer DT ? Cast<DT, any[]> : never, R>
 : R
```

这里使用`[any, ...any[]]`来进行判断是否是最后一次非`...rest`参数的传入, 同时配合`Cast`保证返回正确类型

测试一下:
```typescript
const curriedCb = curryV5(curryCb1)
const curriedCb2 = curryV5(curryCb2)

// 单个参数调用
const r1 = curriedCb('name')
// 多个参数调用
const r2 = curriedCb('name', 1, true)
// ...rest 参数调用
const r3 = curriedCb2('name', 1, 'aaa')
```

算是基本实现了功能

### 占位符(Placeholders)

个人不太熟悉`Ramda`, 不做深究, 不过`lodash`源码里面也提到了一些, 这里仅做一个简单了解

下面几种调用是等价的:
```typescript
f(1, 2, 3)
f(_, 2, 3)(1)
f(_, _, 3)(1)(2)
f(_, 2, _)(1, 3)
f(_, 2)(1)(3)
f(_, 2)(1, 3)
f(_, 2)(_, 3)(1)
```

这里的`_`就是作为一个占位符, 即 placeholder, 或叫作 gap

这块有兴趣还是建议去看作者[原文](https://hackernoon.com/learn-advanced-typescript-4yl727e6)

### 关于原文和源码

作者最后提到, 这篇文章其实是[ts-toolbelt](https://github.com/pirix-gh/ts-toolbelt)这个 repo 的入门教程, 这个 repo 涵盖了很多高级实用的 typescript 类型定义, 欢迎 star

以及, 作者将源码也放到了[github](https://github.com/pirix-gh/medium)上, 增加了一些新的内容, 比如`pipe`等新的类型定义, 可以自己 clone 下来试一试

再次感谢作者[@pirix-gh](https://github.com/pirix-gh)

## 参考
- https://hackernoon.com/learn-advanced-typescript-4yl727e6
- https://stackoverflow.com/q/51859461/12733140 
- https://stackoverflow.com/q/58770087/12733140
- https://www.typescriptlang.org/

简单聊一聊柯里化和 TypeScript 泛型 #9

Description

从柯里化讲起

添加类型

overload 重载

重载定义类型

泛型

需求

基本概念

泛型类型和泛型函数(generic type & generic function)

元祖类型

泛型基本类型推导

Params

Head

Tail

HasTail

ObjectInferValue

ObjectInferKey

FunctionInfer

PromiseInfer

ArrayInfer

TupleInfer

测试

Equals

assertType / assertNotType

柯里化类型 1

CurryV0

CurryV1

CurryV2

递归类型与其他泛型推导

Last

Length

Prepend

Drop

Cast

柯里化类型 2

CurryV3

CurryV4

CurryV5

占位符(Placeholders)

关于原文和源码

参考

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions