Spark局部套用和部分應(yīng)用方法是什么

本篇內(nèi)容主要講解“Spark局部套用和部分應(yīng)用方法是什么”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Spark局部套用和部分應(yīng)用方法是什么”吧!

    局部套用 和部分應(yīng)用 是來源于數(shù)學的語言技術(shù)（基于 20 世紀數(shù)學家 Haskell Curry 和其他人的工作成果）。這兩種技術(shù)存在于各種類型的語言中，可以單獨或同時存在于函數(shù)式語言中。局部套用和部分應(yīng)用使您能夠處理函數(shù)或方法的參數(shù)數(shù)量，通常的方法是為一些參數(shù)提供一個或多個默認值（稱為修正 參數(shù)）。所有 Java 下一代語言都包括局部套用和部分應(yīng)用，但以不同的方式實現(xiàn)它們。在本文中，我將介紹這兩種技術(shù)的不同之處，并展示它們在 Scala、Groovy 和 Clojure 中的實現(xiàn)細節(jié)，以及實際應(yīng)用。

注意術(shù)語

    出于本部分的目的，方法（method） 和 函數(shù)（function） 是可互換的。支持局部套用和部分應(yīng)用的面向?qū)ο笳Z言使用方法。同樣，函數(shù)參數(shù)（function parameter） 和 函數(shù)參數(shù)（function argument） 也是可互換的。由于這些概念起源于數(shù)學，因此我自始至終使用的是 函數(shù)（function） 和 參數(shù)（argument），但這并不意味著這兩種技術(shù)對方法不起作用。

定義和區(qū)別

對于業(yè)余人士來說，局部套用和部分應(yīng)用具有相同的效果。使用這兩種技術(shù)時，都可以創(chuàng)建一個一些參數(shù)具有預(yù)先提供值的函數(shù)版本：

• 局部套用是將多參數(shù)函數(shù)轉(zhuǎn)換為一系列單參數(shù)函數(shù)。它描述了轉(zhuǎn)換過程，而不是轉(zhuǎn)換函數(shù)的調(diào)用。調(diào)用方可以確定應(yīng)用了多少參數(shù)，從而創(chuàng)建一個參數(shù)更少的導出函數(shù)。

• 部分應(yīng)用將多參數(shù)函數(shù)轉(zhuǎn)換為一個參數(shù)更少的多參數(shù)函數(shù)，其值為提前提供的省略參數(shù)的值。本技術(shù)的名稱非常恰當：它將一些參數(shù)部分應(yīng)用到函數(shù)，并返回一個具有簽名（由剩余參數(shù)組成）的函數(shù)。

使用局部套用和部分應(yīng)用，可以提供參數(shù)值并返回一個可使用缺少參數(shù)調(diào)用的函數(shù)。但是，對函數(shù)應(yīng)用局部套用會返回鏈中的下一個函數(shù)，而部分應(yīng)用會將參數(shù)值綁到在運算期間提供的值上，生成一個具有更少 元數(shù)（參數(shù)的數(shù)量）的函數(shù)。當考慮具有兩個以上元數(shù)的函數(shù)時，這一區(qū)別會更加明顯。例如，process(x, y, z) 函數(shù)的完全套用版本是process(x)(y)(z)，其中 process(x) 和 process(x)(y) 都是接受一個參數(shù)的函數(shù)。如果只對第一個參數(shù)應(yīng)用了局部套用，那么 process(x) 的返回值將是接受一個參數(shù)的函數(shù)，因此僅接受一個參數(shù)。與此相反，在使用部分應(yīng)用時，會剩下一個具有更少元數(shù)的函數(shù)。對 process(x, y, z) 的一個參數(shù)使用部分應(yīng)用會生成接受兩個參數(shù)的函數(shù)：process(y, z)。

這兩種技術(shù)的結(jié)果通常是相同的，但二者的區(qū)別也很重要，人們通常會對它們之間的區(qū)別產(chǎn)生誤解。更復(fù)雜的是，Groovy 可以實現(xiàn)部分應(yīng)用和局部套用，但都將它們稱為 currying。而 Scala 具有偏應(yīng)用函數(shù)（partially applied function）和 PartialFunction，盡管它們的名稱類似，但它們卻是兩個不同的概念。

在 Scala 中

Scala 支持局部套用和部分應(yīng)用，還支持特征（trait），特征可以定義約束函數(shù)（constrained function）。

局部套用

在 Scala 中，函數(shù)可以將多個參數(shù)列表定義為括號組。調(diào)用參數(shù)數(shù)量比其定義數(shù)量少的函數(shù)時，會返回一個將缺少參數(shù)列表作為其參數(shù)的函數(shù)。請考慮 Scala 文檔的示例，如清單 1 所示。

清單 1. Scala 的參數(shù)局部套用

def filter(xs: List[Int], p: Int => Boolean): List[Int] =
    if (xs.isEmpty) xs
    else if (p(xs.head)) xs.head :: filter(xs.tail, p)
    else filter(xs.tail, p)

def modN(n: Int)(x: Int) = ((x % n) == 0)

val nums = List(1, 2, 3, 4, 5, 6, 7, 8)
println(filter(nums, modN(2)))
println(filter(nums, modN(3)))

在清單 1 中，filter() 函數(shù)遞歸地應(yīng)用傳遞的過濾條件。modN() 函數(shù)定義了兩個參數(shù)列表。在我使用 filter() 調(diào)用 modN 時，我傳遞了一個參數(shù)。filter() 函數(shù)被作為函數(shù)的第二個參數(shù)，具有一個 Int 參數(shù)和一個 Boolean 返回值，這與我傳遞的局部套用函數(shù)的簽名相匹配。

偏應(yīng)用函數(shù)

在 Scala 中還可以部分應(yīng)用函數(shù)，如清單 2 所示。

清單 2. Scala 中部分應(yīng)用的函數(shù)

def price(product : String) : Double =
  product match {
    case "apples" => 140
    case "oranges" => 223
}

def withTax(cost: Double, state: String) : Double =
  state match {
    case "NY" => cost * 2
    case "FL" => cost * 3
}val locallyTaxed = withTax(_: Double, "NY")val costOfApples = locallyTaxed(price("apples"))

assert(Math.round(costOfApples) == 280)

在清單 2 中，我首先創(chuàng)建了一個 price 函數(shù)，它返回了產(chǎn)品和價格之間的映射。然后我創(chuàng)建了一個 withTax() 函數(shù)，其參數(shù)為 cost 和state。但是，在特殊的源文件中，我知道要專門處理一個國家的稅收。我沒有對每次調(diào)用的額外參數(shù)應(yīng)用局部套用，而是部分應(yīng)用了 state參數(shù)，并返回一個 state 值固定的函數(shù)。locallyTaxed 函數(shù)接受一個參數(shù)，即 cost。

偏（約束）函數(shù)

Scala PartialFunction 特征可以與模式無縫地配合使用（請閱讀函數(shù)式思維 系列的 "Either 樹和模式匹配" 部分中的模式匹配）。盡管名稱類似，但此特征不會創(chuàng)建偏應(yīng)用函數(shù)。相反，可以使用它定義僅適用于值和類型定義子集的函數(shù)。

Case 塊是應(yīng)用偏函數(shù)（partial function）的一種方式。清單 3 使用了 Scala 的 case，沒有傳統(tǒng)對應(yīng)的 match 操作符。

清單 3. 使用不帶 match 的 case

val cities = Map("Atlanta" -> "GA", "New York" -> "New York",
  "Chicago" -> "IL", "San Francsico " -> "CA", "Dallas" -> "TX")

cities map { case (k, v) => println(k + " -> " + v) }

在清單 3 中，我創(chuàng)建了一個城市和該城市所對應(yīng)的州的映射。然后，我對該集合調(diào)用了 map 函數(shù)，map 會拆開鍵值對以輸出它們。在 Scala 中，包含 case 聲明的代碼塊是定義匿名函數(shù)的一種方式。不使用 case 可以更簡潔地定義匿名函數(shù)，但是，case 語法提供了如清單 4 所示的額外好處。

清單 4. map 和 collect 之間的區(qū)別

List(1, 3, 5, "seven") map { case i: Int ? i + 1 } // won't work
// scala.MatchError: seven (of class java.lang.String)

List(1, 3, 5, "seven") collect { case i: Int ? i + 1 }
// verify
assert(List(2, 4, 6) == (List(1, 3, 5, "seven") collect { case i: Int ? i + 1 }))

在清單 4 中，我不能在具有 case 的異構(gòu)集合上使用 map：我收到了 MatchError，因為函數(shù)試圖增加 seven 字符串。但是 collect 工作正常。為什么會出現(xiàn)這種不同？什么地方出錯了？

Case 塊定義的是偏函數(shù)，而不是偏應(yīng)用函數(shù)。偏函數(shù) 具有有限的允許值。例如，數(shù)學函數(shù) 1/x 是無效的，如果 x = 0。偏函數(shù)提供了一種定義允許值約束的方式。在 清單 4 的 collect 示例中，定義了 Int 而不是 String 的約束，因此沒有收集 seven 字符串。

要定義偏函數(shù)，還可以使用 PartialFunction 特征，如清單 5 所示。

清單 5. 在 Scala 中定義偏函數(shù)

val answerUnits = new PartialFunction[Int, Int] {
    def apply(d: Int) = 42 / d
    def isDefinedAt(d: Int) = d != 0
}

assert(answerUnits.isDefinedAt(42))
assert(! answerUnits.isDefinedAt(0))

assert(answerUnits(42) == 1)
//answerUnits(0)
//java.lang.ArithmeticException: / by zero

在清單 5 中，我從 PartialFunction 特征導出了 answerUnits，并提供了兩個函數(shù)：apply() 和 isDefinedAt()。apply() 函數(shù)計算值。我使用了 isDefinedAt()（PartialFunction 的必要方法）來定義確定參數(shù)適用性的約束。

還可以使用 case 塊實現(xiàn)偏函數(shù)，清單 5 的answerUnits 可以采用更簡潔的方式編寫，如清單 6 所示。

清單 6. answerUnits 的另一種定義

def pAnswerUnits: PartialFunction[Int, Int] =
    { case d: Int if d != 0 => 42 / d }

assert(pAnswerUnits(42) == 1)
//pAnswerUnits(0)
//scala.MatchError: 0 (of class java.lang.Integer)

在清單 6 中，我結(jié)合使用了 case 和保衛(wèi)條件來約束值并同時提供值。與 清單 5 的一個明顯區(qū)別是 MatchError（而不是ArithmeticException），因為清單 6 使用了模式匹配。

偏函數(shù)并不僅局限于數(shù)值類型。它可以使用所有類型的數(shù)值，包括 Any。可以考慮增量器（incrementer）的實現(xiàn)，如清單 7 所示。

清單 7. 在 Scala 中定義增量器

def inc: PartialFunction[Any, Int] =
    { case i: Int => i + 1 }

assert(inc(41) == 42)
//inc("Forty-one")
//scala.MatchError: Forty-one (of class java.lang.String)

assert(inc.isDefinedAt(41))
assert(! inc.isDefinedAt("Forty-one"))

assert(List(42) == (List(41, "cat") collect inc))

在清單 7 中，我定義了一個偏函數(shù)來接受任意類型的輸入 (Any)，但選擇對類型子集做出反應(yīng)。請注意，我還可以調(diào)用偏函數(shù)的isDefinedAt() 函數(shù)。使用 case 的 PartialFunction 特征的實現(xiàn)者可以調(diào)用 isDefinedAt()，它是隱式定義的。在 清單 4 中，我說明了 map 和 collect 的表現(xiàn)不同。偏函數(shù)的行為解釋了它們的區(qū)別：collect 旨在接受偏函數(shù)，并調(diào)用元素的 isDefinedAt() 函數(shù)，會忽略那些不匹配的函數(shù)。

在 Scala 中，偏函數(shù)和偏應(yīng)用函數(shù)的名稱類似，但是它們提供了不同的正交特性集。例如，沒有什么可以阻止您部分地應(yīng)用偏函數(shù)。

在 Groovy 中

在我的函數(shù)式思維 系列的 "運用函數(shù)式思維，第 3 部分" 中詳細介紹了 Groovy 中的局部套用和部分應(yīng)用。Groovy 通過 curry() 函數(shù)實現(xiàn)了局部套用，該函數(shù)來自 Closure 類。盡管名稱如此，但 curry() 實際上通過處理其下面的閉包塊來實現(xiàn)部分應(yīng)用。但是，您可以模擬局部套用，方法是使用部分應(yīng)用將函數(shù)減少為一系列部分應(yīng)用的單參數(shù)函數(shù)，如清單 8 所示。

清單 8. Groovy 的部分應(yīng)用和局部套用

def volume = { h, w, l -> return h * w * l }
def area = volume.curry(1)
def lengthPA = volume.curry(1, 1) //partial application
def lengthC = volume.curry(1).curry(1) // currying

println "The volume of the 2x3x4 rectangular solid is ${volume(2, 3, 4)}"
println "The area of the 3x4 rectangle is ${area(3, 4)}"
println "The length of the 6 line is ${lengthPA(6)}"
println "The length of the 6 line via curried function is ${lengthC(6)}"

在清單 8 中，在兩種 length 情況下，我使用 curry() 函數(shù)部分應(yīng)用了參數(shù)。但是，在使用 lengthC 時，通過部分地應(yīng)用參數(shù)，直到出現(xiàn)一連串的單參數(shù)函數(shù)為止，我制造了一種使用局部套用的幻覺。

在 Clojure 中

Clojure 包含 (partial f a1 a2 ...) 函數(shù)，它具有函數(shù) f 以及比所需數(shù)量更少的參數(shù)，而且返回一個在提供剩余參數(shù)時調(diào)用的部分應(yīng)用函數(shù)。清單 9 顯示了兩個示例。

清單 9. Clojure 的部分應(yīng)用

(def subtract-from-hundred (partial - 100))

(subtract-from-hundred 10)      ; same as (- 100 10)
; 90

(subtract-from-hundred 10 20)   ; same as (- 100 10 20)
; 70

在清單 9 中，我將 subtract-from-hundred 函數(shù)定義為部分應(yīng)用的 - 運算符（Clojure 中的運算符與函數(shù)無法區(qū)分），并提供 100 作為部分應(yīng)用的參數(shù)。Clojure 中的部分應(yīng)用適用于單參數(shù)函數(shù)和多參數(shù)函數(shù)，如清單 9 中的兩個示例所示。

由于 Clojure 是動態(tài)類型的，并且支持可變參數(shù)列表，因此局部套用并不能作為一種語言功能來實現(xiàn)。部分應(yīng)用將會處理必要的情況。但是，Clojure 被添加到 reducers 庫（參見 參考資料）的命名空間私有 (defcurried ...) 函數(shù)，支持在該庫中更輕松地定義一些函數(shù)。鑒于 Clojure 的 Lisp 傳承的靈活特點，可以輕松擴大 (defcurried ...) 的使用范圍。

常見用法

盡管局部套用和部分應(yīng)用具有復(fù)雜的定義和大量實現(xiàn)細節(jié)，但是它們在實際編程中都占有一席之地。

函數(shù)工廠

局部套用（和部分應(yīng)用）適合在傳統(tǒng)的面向?qū)ο笳Z言中實現(xiàn)工廠函數(shù)的位置使用。作為一個示例，清單 10 在 Groovy 中實現(xiàn)了一個簡單的adder 函數(shù)。

清單 10. Groovy 中的加法器和增量器

def adder = { x, y -> x + y}
def incrementer = adder.curry(1)

println "increment 7: ${incrementer(7)}" // 8

在清單 10 中，我使用 adder() 函數(shù)來導出 incrementer 函數(shù)。同樣，在 清單 2 中，我使用部分應(yīng)用創(chuàng)建了一個更簡潔的本地函數(shù)版本。

Template Method 設(shè)計模式

Gang of Four 設(shè)計模式之一是 Template Method 模式。它的用途是幫助定義算法 shell，使用內(nèi)部抽象方法來實現(xiàn)稍后的實現(xiàn)靈活性。部分應(yīng)用和局部套用可以解決相同的問題。使用部分應(yīng)用提供已知行為，并讓其他參數(shù)免費用于實現(xiàn)細節(jié)，這模擬了此面向?qū)ο笤O(shè)計模式的實現(xiàn)。

隱含值

與 清單 2 類似，一種常見的情況是您有一系列使用相似參數(shù)值調(diào)用的函數(shù)。例如，當與持久性框架交互時，必須將數(shù)據(jù)源作為第一個參數(shù)進行傳遞。通過使用部分應(yīng)用，可以隱式地提供值，如清單 11 所示。

清單 11. 使用部分應(yīng)用提供隱含值

(defn db-connect [data-source query params]
      ...)

(def dbc (partial db-connect "db/some-data-source"))

(dbc "select * from %1" "cust")

在清單 11 中，我使用了便利的 dbc 函數(shù)來訪問數(shù)據(jù)函數(shù)，無需提供數(shù)據(jù)源，就可以自動提供數(shù)據(jù)源。面向?qū)ο缶幊痰木瑁[含 this 上下文似乎出現(xiàn)在所有函數(shù)中）可以通過使用局部套用為所有函數(shù)提供 this 來實現(xiàn)，這使得它對用戶不可見。

到此，相信大家對“Spark局部套用和部分應(yīng)用方法是什么”有了更深的了解，不妨來實際操作一番吧！這里是億速云網(wǎng)站，更多相關(guān)內(nèi)容可以進入相關(guān)頻道進行查詢，關(guān)注我們，繼續(xù)學習！