在我們查閱 Ramda 的文檔 時, 常會見到一些"奇怪"的類型簽名和用法，例如：

(Applicative f, Traversable t) => (a → f a) → t (f a) → f (t a)

或者，某一些函數"奇怪"的用法：

// R.ap can also be used as S combinator // when only two functions are passed 
R.ap(R.concat, R.toUpper)('Ramda') //=> 'RamdaRAMDA'

這些"奇怪"的點背后投射著 Ramda "更深"一層的設計邏輯, 本文將會對此作出講解, 并闡述背后通用的函數式編程理論知識。

Ramda 為人熟知的一面?

Ramda 經常被當做 Lodash 的另外一個"更加FP"的替代庫，相對于 Lodash，Ramda 的優勢(之一)在于完備的柯里化與 data last 的設計帶來的便捷的管道式編程(pipe)。

舉一個簡單的代碼對比示例：

• Ramda:

const myFn = R.pipe (
  R.fn1,
  R.fn2 ('arg1', 'arg2'),
  R.fn3 ('arg3'),
  R.fn4
)

• Lodash:

const myFn = (x, y) => {
  const var1 = _.fn1 (x, y)
  const var2 = _.fn2 (var1, 'arg1', 'arg2')
  const var3 = _.fn3 (var2, 'arg3')
  return _.fn4 (var3)
}

Ramda 類型簽名?

在 Ramda 的 API 文檔中, 類型簽名的語法有些"奇怪":

• add: Number → Number → Number

我們結合 Ramda 的柯里化規則, 稍加推測, 可以將這個函數轉換為TypeScript 的定義：

export function add(a: number, b: number): number;
export function add(a: number): (b: number) => number;

OK, 那為什么Ramda 的文檔不直接使用TypeScript 表達函數的類型呢? -- 因為更加簡潔!

Ramda 文檔中的類型簽名使用的是Haskell 的語法, Haskell 作為一門純函數式編程語言, 可以很簡潔地表達柯里化的語義, 相較之下, TypeScript 的表達方式就顯得比較臃腫。

當然, 使用Haskell 的類型簽名的意義不僅于此, 讓我們再看看其他"奇怪"的函數類型：

• ap:

[a → b] → [a] → [b]
Apply f => f (a → b) → f a → f b
(r → a → b) → (r → a) → (r → b)

結合文檔中的demo：

R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]

R.ap([R.concat('tasty '), R.toUpper], ['pizza', 'salad']); //=> ["tasty pizza", "tasty salad", "PIZZA", "SALAD"] 

// R.ap can also be used as S combinator 
// when only two functions are passed 
R.ap(R.concat, R.toUpper)('Ramda') //=> 'RamdaRAMDA'

[a → b] → [a] → [b]我們好理解, 就是笛卡爾積；

(r → a → b) → (r → a) → (r → b)我們也能理解, 就是兩個函數的串聯；

Apply f => f (a → b) → f a → f b就有點難理解了, 語法上就有些陌生, 我們先將其翻譯成TypeScript 語法：

:), 好吧, 這段類型沒法簡單地翻譯成TypeScript, 因為: TypeScript 不支持將 「類型構造器」 作為類型參數！舉個例子：

type T<F> = F<number>;

報錯信息如下:

Type 'F' is not generic.

在類型簽名中F?是一個類型構造器, 既和Array一樣的 「返回類型的類型」， 然而, TypeScript 里根本無法聲明"一個類型參數為類型構造器"。

正如示例中type T<F> = F<number>;?中, 我們無法告訴TypeScript, 這里的F?是一個類型構造器, 所以當將number?傳入F的時候, 就報錯了。

OK, 我們假設TypeScript 支持聲明"一個類型參數為類型構造器", 讓我們再來看看Apply f => f (a → b) → f a → f b該怎么翻譯：

type AP = <F extends Appy, A, B>(f: F<((a: A) => B)>) => (fa: F<A>) => F<B>;

這里的F可以理解為一種 「上下文」, 這段類型簽名可以先簡單地理解為:

將一個包裹在上下文中的「函數」取出, 再將另一個包裹在上下文中的「值」取出, 調用函數后, 將函數的返回值重新包裹進上下文中并返回。

這里的 「上下文」 是一個泛指, 比如我們可以將其特異化(specialize)為 Promise :

type AP = <A, B>(f: Promise<((a: A) => B)>) => (fa: Promise<A>) => Promise<B>;  
const ap: AP = (f) => fa => f.then(ff => fa.then(ff));

ap? 或說 Apply 作為函數式編程中的一種常見抽象, 有非常重要重要的學習意義, 但其抽象的解析超出本文范圍, 在這里我們只聚焦于「是什么」, 暫不考慮「為什么」。

那么, (r → a → b) → (r → a) → (r → b)與Apply f => f (a → b) → f a → f b是什么關系?

他們之間是同父異母的關系, (r → a → b) → (r → a) → (r → b)?是對Apply f => f (a → b) → f a → f b的特異化, 正如我們對Promise 做的那樣。

函數也可以是一個 「上下文」?

答案是可以的, 我們可以將一個一元函數a -> b?理解為"一個包裹在上下文中的b?, 只不過為了獲取這個b?, 需要先傳入一個a。

先看看 Haskell 對ap 的定義:

instance Applicative ((->) r) where
    (<*>) f g x = f x (g x)

替換為TypeScript 的實現, 我們將上面的Promise 的例子稍微修改下, 得出：

type F<A> = (a: any) => A;

type AP = <A, B>(f: F<((a: A) => B)>) => (fa: F<A>) => F<B>;  
  
const ap: AP = f => fa => {  
    return (r) => f(r)(fa(r));  
}

同樣的, 我們得到Apply 特異化為Array 的實現：

type AP = <A, B>(f: Array<((a: A) => B)>) => (fa: Array<A>) => Array<B>;

const ap: AP = f => fa => {
 return f.flatMap(ff => fa.map(ff));
};

綜上所述, 我們可以得出結論：

ap的類型簽名[a → b] → [a] → [b]和(r → a → b) → (r → a) → (r → b)是Apply f => f (a → b) → f a → f b的特異化。