Ramda.js - propEq（字符串→a→對象→布爾） - 這個符號是什麼意思？

Question

我不明白這個快捷方式符號。

兩個例子：

1. propEq （字符串→A→對象→布爾）

2. sortBy （奧德B =>（A→B）→[A]→[A] ）

你能解密嗎？

是的，我知道如何找到它的文檔，但是這個文檔是相當描述很差

propEq

sortBy

Answer 1

Ramda有沒有最簡單的文檔來了解，這是肯定的。這裏是我如何解釋這個，希望它帶來一些清晰度：

在ramda中，大多數（如果不是全部）功能都是咖喱的。這意味着ramda中的任何函數都可以使用所有必需的參數或更少的參數來調用。如果提供的參數數量少於所需的數量，則結果將是另一個可以接收其餘參數的函數。當函數完全應用時，它將返回結果。

舉個例子，我們來看看propEq。正如你所寫，其簽名是：

propEq (String → a → Object → Boolean) 

那麼這是什麼意思？首先該函數應該做什麼：它將從一個對象中獲取一個屬性，並與給定的對象進行比較，並將比較結果作爲布爾值返回。

首先最右邊的屬性是返回值。完全應用後，propEq將返回一個布爾值。所以最後一部分很清楚。然後它仍然是：

String → a → Object 

這是我上面提到的參數，關鍵，價值和對象。因此，一個有效的電話是：

R.propEq('age', 30, { age: 30 }) --> true 

給出ramda組合性，這實際上可以在多個呼叫被打破：

R.propEq('age')(30)({ age: 30 }) --> true 

Answer 2

這看起來很像哈斯克爾。在Haskell中你有：

sortBy :: (Ord b) => (a -> b) -> [a] -> [a] 

右邊的東西是一個類型簽名。

[A]是元素類型爲A的列表類型。

A -> B是一個函數的類型，它需要一個A並返回B。

->是右結合：A -> B -> C裝置A -> (B -> C)，即，其採用A並返回一個函數，它接受一個B並返回一個C的功能。

Haskell沒有參數列表。相反，所有函數都以上述方式進行curlic：2​​個參數的函數實際上是一個返回另一個函數的函數（它接受另一個參數並返回實際結果）。另一種看待它的方法是斜視並說功能類型的格式爲A1 -> A2 -> ... -> An -> R，其中Ai是參數類型，而R是結果類型。

以大寫字母開頭的標識符是實際類型。以小寫字母開頭的標識符是類型變量（可以用作任何你想要的類型）。

=>將類型約束從實際類型中分離出來。這裏我們有Ord b，它要求用於b的類型支持排序（即<,>操作）。

全部放在一起：

sortBy是一個函數，它a -> b類型的參數，並返回[a] -> [a]類型的結果。

a -> b類型的參數是另一個函數，它將某些類型的值a映射到某種類型的b。 b必須是有序類型。

類型[a] -> [a]的結果是另一個函數，它將a類型的值列表映射到相同類型的列表。

想法是，如果要對不應直接比較的值列表進行排序，則可以使用sortBy以及從每個列表元素中提取比較值​​的輔助函數。然後sortBy返回一個排序列表（根據比較值）。

使用範例：

sortBy length ["don't", "fear", "the", "reaper"] 
=> ["the", "fear", "don't", "reaper"] 

這裏我們使用String作爲我們a和Int作爲我們b（因爲length :: String -> Int）。

注意，功能的應用程序左結合：f x y實際上意味着(f x) y（即，功能f應用於參數x，然後應用結果（必須是另一個功能）y）。

---

至於這是如何適用於JavaScript ...不知道。

也許他們想讓你把它叫做sortBy(getComparisonValue, inputList)或sortBy(getComparisonValue)(inputList)？

Answer 3

我個人不知道拉姆達，但這很清楚哈斯克爾的語法。

f :: Type 

f是一些與該類型Type。 JS：

var f = Type(...) 

---

f :: [Type] 

f是出頭的列表，所有Type型。 JS：

var f = [Type(...), Type(...), ...] 

---

f :: Type -> Type 

f是服用Type的值返回的Type

var f = function(t) { return Type(...) } 
f(Type(...)) 

---

f :: Type -> Type -> Type 

功能箭頭（->）的值的函數爲右擊T-關聯。這相當於

f :: Type -> (Type -> Type) 

這意味着f需要Type並返回一個函數，它接受一個Type並返回一個Type。這就是Haskell如何使用多個參數來執行功能。這種技術被稱爲討好的類型

var f = function(l) { return function(r) { return Type(...) } } 
f(Type(...))(Type(...)) 
// Ramda does dark magic that allows you to do vvvv as well 
f(Type(...), Type(...)) 

---

f :: a -> b -> a 

小寫字母標識符類型變量。在f的定義中，不知道a和b是什麼，外部代碼可以通過他們想要的任何東西。類型變量的函數滿足「參數性」。 f承諾，它不關心如何a和b工作，這限制了它可以做什麼。在Haskell，f只有一個可能的實現，這就是：

var left = function(l) { return function(r) { return l } } 
left(x)(y) === x 
left(1)("a") === 1 
// If it's a Ramda function 
left(1, "a") === 1 

---

max :: Ord a => a -> a -> a 

(...) =>指定 「的約束。」此功能適用於任何類型的a，只要有一些方法可以對其進行排序，約束條件爲Ord a。 max仍然有些參數：它可以檢查的a的唯一部分是它的順序;除此之外，將無法分析任何內容。

var max = function(a) { return function(b) { return a > b ? a : b } } 
max(1)(94) === 94 
max({})(5) // Not allowed 
// Since {} and 5 aren't the same type, the above call to max is bad 
// JS is not strongly typed enough to warn you, but it just won't work out 
max({})({}) 
// Object does not have an ordering to it, so the above call is bad, 
// because the (Ord a) constraint is violated. 

---

propEq :: String -> a -> Object -> Boolean 

propEq需要一個字符串，任何類型的一些值，Object，然後做一些事情對他們來說，回國Boolean。根據該文件，它可以幫助把它作爲

propEq :: String -> a -> (Object -> Boolean) 

這需要一個屬性名和值該屬性，返回一個謂詞是匹配的對象如此。

---

sortBy :: (Ord b) => (a -> b) -> [a] -> [a] 

sortBy需要一個功能，它需要訂購返回類型。然後它可以通過使用函數將每個a變成b，然後使用Ord b來找出如何對b進行排序，然後基於b對a進行排序，來對a的列表進行排序。

var nameGetter = prop("name") // function(obj) { return obj.name } 
sortBy(nameGetter, [{ name: "Alice" }, { name: "Charlie" }, { name: "Bob" }]) 
// [{ name: "Alice" }, { name: "Bob" }, { name: "Charlie" }]