你的腦袋可以這樣想嗎?

本文转载自:良葛格的Blog 有一天,你在瀏覽自己的程式碼,發現有兩大段程式碼幾乎一樣。實際上它們的確一樣,除了一個關於「Spaghetti」而另一個關於「Chocolate Moose」。
System.out.println("I"d like some Spaghetti!"); System.out.println("I"d like some Chocolate Moose!");
這例子看來是Java的,不過你就算不懂Java,也應該明白在幹甚麼。 重覆的程式碼是個問題。於是,你建立方法:
static void swedishChef(String food) { println("I"d like some " + food + "!"); } static void println(Object obj) { System.out.println(obj); }
 
swedishChef("Spaghetti!"); swedishChef("Chocolate Moose!");
嗯,這個例子很經典,但你能想到一個更深入的例子。這段程式碼的優勝之處有很多,你聽過上千次的:可維護性、可讀性、抽象性 = 好! 現在你留意到有另外兩段程式碼一模一樣,除了一個反覆呼叫一個叫boomBoom的方法, 另一個反覆呼叫一個喚作putInPot的。 除此之外,這兩段程式碼真的像雙生的。
println("get the lobster"); putInPot("lobster"); putInPot("water");
 
println("get the chicken"); boomBoom("chicken"); boomBoom("coconut");
現在你需要一個辦法,使得你可以將一個流程區塊替代另一個方法中的流程區塊。這是個重要的思考,因為你更易將常用的程式碼收藏在一個方法內。
interface Block<P> { void apply(P p); } static void cook(String food1, String food2, Block cooker) { println("get the " + food1); cooker.apply(food1); cooker.apply(food2); }
 
cook("lobster", "water", new Block<String>() { public void apply(String food) { putInPot(food); } }); cook("chicken", "coconut", new Block<String>() { public void apply(String food) { boomBoom(food); } });
看!我們成功將流程區塊替代了。 你的腦袋能想到嗎? 等等,假設你未定義putInPot或boomBoom這些方 法,那就直接實作在apply中, 另外呼叫cook時 看來有點醜,適當地使用變數,會比直接將它寫進一行內好看的多。
Block<String> putInPot = new Block<String>() { public void apply(String food) { println("pot " + food); } }; Block<String> boomBoom = new Block<String>() { public void apply(String food) { println("boom " + food);} }; cook("lobster", "water", putInPot); cook("chicken", "coconut", boomBoom);
呼叫cook時 清楚多了。臨時建立匿名類別實例時,也可以適當地起名,再丟到一個方法內。 當你一想到作為參數的匿名類別實例,你也許想到對某個List的元素進行相同動 作的程式碼。
List<Integer> numbers = asList(1, 2, 3);
 
List<Integer> multipliedWith2 = new ArrayList<>(); for (Integer number : numbers) { multipliedWith2.add(number * 2); }
常常要對List內 的所有元素做同一件事,因此你可以寫個這樣的方法來幫忙:
interface Mapper<P, R> { R apply(P p); } static <T, R> List<R> map(List<T> lt, Mapper<T, R> mapper) { List<R> mapped = new ArrayList<>(); for (T elem : lt) { mapped.add(mapper.apply(elem)); } return mapped; }
現在你可以將上面的東西寫成:
Mapper<Integer, Integer> multiply2 = new Mapper<Integer, Integer>() { public Integer apply(Integer number) { return number * 2; } }; List<Integer> multipliedBy2 = map(numbers, multiply2);
另一個常見的工作是將List內 的所有元素按某種方法合起來:
static Integer sum(List<Integer> numbers) { Integer sum = 0; for (Integer number : numbers) { sum += number; } return sum; } static String join(List<String> strs) { String joined = ""; for (String str : strs) { joined += str; } return joined; } println(sum(asList(1, 2, 3))); println(join(asList("a","b","c")));
sum和join長得很像,你也許 想將它們抽象化,變成將List內 所有元素按某種方法合起來的泛型方法:
interface Reducer<R, P> { R apply(R r, P p); } static <T, R> R reduce(List<T> lt, Reducer<R, T> reducer, R init) { R r = init; for(T elem : lt) { r = reducer.apply(r, elem); } return r; } static Integer sum(List<Integer> numbers) { Reducer<Integer, Integer> sumUp = new Reducer<Integer, Integer>() { public Integer apply(Integer sum, Integer number) { return sum + number; } }; return reduce(numbers, sumUp, 0); } static String join(List<String> strs) { Reducer<String, String> joinAll = new Reducer<String, String>() { public String apply(String all, String str) { return all + str; } }; return reduce(strs, joinAll, ""); }
如果用JavaScript之類具有一級函式的語言,可以更簡單地作這這些事。許多較舊的語言沒法子做這種事。有些語言容許你做,不過困難重重(例如C有 函數指標,但你要在別處宣告和定義函數)。而物件導向語言則認為不應該容許使用函數,像是這邊示範的Java。 如果你想將函數視為第一類物件,Java要求你建立一個有單方法的物件,稱之為Functor。另外許多物件導向語言要求你為類別建立個別檔案,結 果變得不怎麼快(klunky fast)。如果你的編程語言要求使用Functor,就不能徹底得到現代編程環境的好處。看看你可否退貨拿回些錢。 那麼使用具有一級函式的語言,你就能寫出來嗎?沒有一級函式是麻煩了些,但重點在於有沒有以上不斷思考的過程。嗯?不過就是寫出那些僅僅只是對List中每個元素做事的 小小方法,究竟能得到多少好處? 讓我們回到map函 數。對List內 的每個元素做事時,很可能並不在乎哪個元素先做。無論由第一個還是最後一個元素開始,結果都是一樣的,對不對?如果你手頭上有2個CPU,就可以寫段程式 碼,使得它們各對一半的元素工作,於是map就變快兩倍了。 或者你在全球有千千百百台伺服器(只是假設),還有一個很大很大的List,存放整個互聯網 的內容(同樣也只是假設)。現在你可以在這些伺服器上執行map,讓各台伺服器只處 理問題很小的一部份。 所以現在可以再舉個例子,要寫出能超快速搜尋整個互聯網的程式碼其實很簡單,只要呼叫一個以基本字串搜尋器作為參數的map方法即可。 這裡頭有件真正有趣的事值得注意:當你把map和reduce想成每個人都 能用的方法,而大家也都在用,只要有個超級天才,寫出能在全球巨型平行電腦陣列上執行map和reduce的程式碼,那 麼所有原本用單一迴圈能正常運行的舊程式碼,還是照樣能用,但是卻會快上千萬倍,也就是說可以用來在瞬間解決掉巨大的問題。 Lemme重覆了這一點。它把迴圈的基本概念抽象出來,你可以用任何所要的方式實作迴圈,其中包括能適切地配合額外硬體的實作方式。 你現在明白我想問的是:你是不是那種沒有一級函式就什麼都寫不了的程式設計師? 不了解函數式程式設計(Functional programming)就無法發明MapReduce這個讓Google延展性如此強大的演算法。Map和Reduce這個術語源自Lisp和函數式程 式設計。回想起來,對瞭解函數式程式設計的人來說,MapReduce實在是很明顯的事情,純粹的函數式程式沒有副作用,所以能輕易地平行化。 我希望你現在明白,確實地,有第一級函數的編程語言讓你找到更多抽象化的機會,也就是說你程式碼會更小、更緊密,不過就算沒有一級函式,你還是可以具有相 同的想法,撰寫出便於再用而且延展性更佳的程式。無數的Google應用軟體使用MapReduce,因此一有人改進其效率或修正臭蟲,這些應用軟體都得 益了。 每次我都會有點疑惑,在具有生產效益的編程環境,確實能讓你更容易在不同的抽象層次作業的環境。老掉牙的GW-BASIC不讓你寫函數。C有函數指標,但 是醜陋之極又不許匿名,一定得在其他地方實作,不能直接寫在使用的地方。Java則是讓你使用Functor這個更醜陋的東西。正如Steve Yegge所述,Java是個名詞王國。 那又如何?C語言就寫不出具有物件導向概念的程式碼?有了一級函式這樣的利器,你的等級就自然提昇?JDK8後會有Lambda了,如果你在先前的JDK 版本,就懂得在程式中作以上的處理,那你就更能從JDK8的Lambda中獲益:
static Integer sum(List<Integer> numbers) { return reduce(numbers, (sum, number) -> sum + number, 0); } static String join(List<String> strs) { return reduce(strs, (all, str) -> all + str, ""); }
你的腦袋沒辦法這樣想的話,最有可能的是,只會將JDK8的Lambda當作匿名類別的語法蜜糖罷了,也沒道理用了一級函式的動態語言,腦袋就會自動昇 級。別忘了有多少用Java寫的程式碼,一點都不物件導向。