Ruby 函数式编程
Ruby 函数式编程 by Arnau Sanchez
本文档翻译自 Arnau Sanchez (tokland)所编译的这份文档 RubyFunctionalProgramming。
同时也有日文版本。
目录
- 简介
- 理论部分
- Ruby的函数式编程
- 不要更新变量
- 用 Blocks 作为高阶函数
- 面向对象与函数式编程
- 万物皆表达式
- 递归
- 惰性枚举器
- 一个实际的例子
- 结论
- 简报
- 延伸阅读
简介
命令式编程比较牛吗？ 不！不！不！只是比较快，比较简单，比较诱人而已。
x = x + 1
在以前上小学的美好回忆裡，我们可能都曾对上面这行感到疑惑。这个 x 到底是什么呢？为什么加了一之后，x 仍然还是 x。
不知道为什么，我们就开始写程序了，也就不在乎这是为什么了。心想：“嗯”，“这不是什么大问题，编程就是事情做完最重要，没有必要去挑剔数学的纯粹性 （让大学裡的大鬍子教兽们去烦恼就好）” 。但我们错了，也因此付出极高的代价，只因我们不了解它。
理论部分
维基百科的解释：“函数式编程是一种写程序的范式，将计算视为对数学函数的求值，并避免使用状态及可变的数据” 换句话说，函数式编程提倡没有副作用的代码，不改变变量的值。这与命令式编程相反，命令式编程强调改变状态。
令人惊讶的是，函数式编程就这样而已。那…有什么好处呢？
更简洁的代码：“变量”一旦定义之后就不再改动，所以我们不需要追踪变量的状态，就可以理解一个函数、方法、类别、甚至是整个项目是怎么工作的。
引用透明：表达式可以用本身的值换掉。如果我们用同样的参数调用一个函数，我们确信输出会是一样的结果（没有其它的状态可改变它的值）。这也是为什么爱因斯坦说：“重复做一样的事却期望不同的结果”是疯狂的理由。
引用透明打开了前往某些美妙事物的大门
并行化：如果调用函数是各自独立的，则他们可以在不同的进程甚至是机器裡执行，而不会有竞态条件的问题。“平常” 写并发程序讨厌的细节（锁、semaphore…等）在函数式编程裡面通通消失不见了。
记忆化：由于函数调用的结果等于它的返回值，我们可以把这些值缓存起来。
模组化：代码裡不存有状态，所以我们可以将项目用小的黑箱连结起来，函数式编程提倡自底向上的编程风格。
容易调试：函数彼此互相隔离，只依赖输入与输出，所以很容易调试。
Ruby的函数式编程
一切都是这么美好，但怎样才能将函数式编程，应用到每天写 Ruby（Ruby 不是个函数式语言）的程序开发裡呢？函数式编程广义来说，是一种风格，可以用在任何语言。当然啦，用在特别为这种范式打造的语言裡显得更自然，但某种程度上来说，可以应用到任何语言。
让我们先釐清这一点：本文没有要提倡古怪的风格，比如仅仅为了要延续理论函数式编程的纯粹性所带来的古怪风格。反之，我想说的重点是，我们应该 当可以提昇代码的品质的时候，才使用函数式编程 ，不然这只不过是个糟糕的解决办法。
不要更新变量
别更新它们，创造新的变量。
不要对数组或字串做 append
No:
indexes = [1, 2, 3] indexes << 4 indexes # [1, 2, 3, 4]
Yes：
indexes = [1, 2, 3] all_indexes = indexes + [4] # [1, 2, 3, 4]
不要更新 hash
No:
hash = {:a => 1, :b => 2}
hash[:c] = 3
hash
Yes:
hash = {:a => 1, :b => 2}
new_hash = hash.merge(:c => 3)
牵扯到内存位置的地方，不要使用破坏性方法。
No:
string = "hello" string.gsub!(/l/, 'z') string # "hezzo"
Yes:
string = "hello" new_string = string.gsub(/l/, 'z') # "hezzo"
如何累积值
No:
output = [] output << 1 output << 2 if i_have_to_add_two output << 3
Yes:
output = [1, (2 if i_have_to_add_two), 3].compact
用 Blocks 作为高阶函数
如果一个语言要搞函数式，会需要高阶函数。高阶函数是什么？函数可以接受别的函数作为参数，并可以返回函数，就这么简单。
Ruby (与 Smalltalk 还有其它语言）在这个方面上非常特别，语言本身就内置这个功能： blocks 区块。区块是一段匿名的代码，你可以随意的传来传去或是执行它。让我们看区块的典型用途，来构造函数式编程的构造子。
init-empty + each + push = map
No:
dogs = [] ["milu", "rantanplan"].each do |name|dogs << name.upcase end dogs # => ["MILU", "RANTANPLAN"]
Yes:
dogs = ["milu", "rantanplan"].map do |name|name.upcase end # => ["MILU", "RANTANPLAN"]
init-empty + each + conditional push -> select/reject
No:
dogs = [] ["milu", "rantanplan"].each do |name|if name.size == 4dogs << nameend end dogs # => ["milu"]
Yes:
dogs = ["milu", "rantanplan"].select do |name|name.size == 4 end # => ["milu"]
initialize + each + accumulate -> inject
No:
length = 0 ["milu", "rantanplan"].each do |dog_name|length += dog_name.length end length # => 15
Yes:
length = ["milu", "rantanplan"].inject(0) do |accumulator, dog_name|accumulator + dog_name.length end # => 15
在这个特殊情况下，当累积器与元素之间有操作进行时，我们不需要区块，只要将操作传给符号即可。
length = ["milu", "rantanplan"].map(&:length).inject(0, :+) # 15
empty + each + accumulate + push -> scan
想像一下，你不仅想要摺迭(fold)的结果，也想要过程中产生的部分数值。用命令式编程风格，你可能会这么写：
lengths = [] total_length = 0 ["milu", "rantanplan"].each do |dog_name|lengths << total_lengthtotal_length += dog_name.length end lengths # [0, 4, 15]
在函数式的世界裡，Haskell 称之为 scan, C++ 称之为 partial_sum, Clojure 称之为 reductions。
令人讶异的是，Ruby 居然没有这样的函数！让我们自己写一个。这个怎么样：
lengths = ["milu", "rantanplan"].partial_inject(0) do |dog_name|dog_name.length end # [0, 4, 15]
Enumerable#partial_inject 可以这么实现：
module Enumerabledef partial_inject(initial_value, &block)self.inject([initial_value, [initial_value]]) do |(accumulated, output), element|new_value = yield(accumulated, element)[new_value, output << new_value]end[1]end end
实作的细节不重要，重要的是，当认出一个有趣的模式可以被抽象化时，我们将其写在另一个函式库，撰写文档，反覆测试。现在只要让实际的需求去完善你的扩充即可。
initial assign + conditional assign + conditional assign + ...
这样的程序我们常常看到：
name = obj1.name name = obj2.name if !name name = ask_name if !name
在此时你应该觉得这样的代码使你很不自在（一个变量一下是这个值，一下是这个；变量名 name 到处都是…等）。函数式的方式更简短，也更简洁：
name = obj1.name || obj2.name || ask_name
另一个有更复杂条件的例子：
def get_best_object(obj1, obj2, obj3)return obj1 if obj1.price < 20return obj2 if obj2.quality > 3obj3 end
可以写成像是这样的一个表达式：
def get_best_object(obj1, obj2, obj3)if obj1.price < 20obj1elsif obj2.quality > 3obj2elseobj3end end
确实有一点囉嗦，但逻辑比一堆行内 if/unless 来得清楚。经验法则告诉我们，仅在你确定会用到副作用时，使用行内条件式，而不是在变量赋值或返回的场合使用：
country = Country.find(1) country.invade if country.has_oil? # more code here
如何从 enumerable 创造一个 hash
Vanilla Ruby 没有从 Enumerable 转到 Hash 的直接对应（本人认为是一个遗憾的缺陷）。这也是为什么新手持续写出下面这个糟糕的模式(而你怎么能责怪他们呢？唉！）：
hash = {}
input.each do |item|hash[item] = process(item)
end
hash
这真的非常可怕！阿～～～！但手边有没有更好的办法呢？过去 Hash 构造子需要一个有着连续键值对的 flatten 集合 （阿，用 flatten 数组来描述映射？Lisp 曾这么做，但还是很丑陋）。幸运的是，Ruby 的最新版本也接受键值对，这样更有意义（作为 hash.to_a 的逆操作），现在你可以这么写：
Hash[input.map do |item|[item, process(item)] end]
不赖嘛，但这打破了平常的撰写顺序。在 Ruby 我们期望从左向右写，给对象调用方法。而“好的”函数式方式是使用 inject：
input.inject({}) do |hash, item|hash.merge(item => process(item))
end
我们都同意这还是很囉嗦，所以我们最好将它放在 Enumerable 模组，Facets 正是这么干的。它称之为 Enumerable#mash：
module Enumerabledef mash(&block)self.inject({}) do |output, item|key, value = block_given? ? yield(item) : itemoutput.merge(key => value)endend
end
["functional", "programming", "rules"].map { |s| [s, s.length] }.mash
# {"rules"=>5, "programming"=>11, "functional"=>10}
或使用 mash 及 选择性区块来一步完成：
["functional", "programming", "rules"].mash { |s| [s, s.length] }
# {"rules"=>5, "programming"=>11, "functional"=>10}
面向对象与函数式编程
Joe Armstrong (Erlang 发明人) 在 “Coders At work” 谈论过面向对象编程的重用性：
“我认为缺少重用性是面向对象语言造成的，而不是函数式语言。面向对象语言的问题是，它们带着语言执行环境的所有隐含资讯四处乱窜。你想要的是香蕉，但看到的却是香蕉拿在大猩猩手裡，而大猩猩的后面是整个丛林”
公平点说，我的看法是这不是面向对象编程的本质问题。你可以写出函数式的面向对象程序，但确定的是：
- 典型的 OOP 倾向强调改变对象的状态。
- 典型的 OOP 倾向层与层之间紧密的耦合。
- 典型的 OOP 将同一性(identity)与状态的概念搞溷了。
- 数据与代码的混合物，导致了概念与实际的问题产生。
Rich Hickey，Clojure 的发明人（一个给 JVM 用的函数式 Lisp 方言），在这场出色的演讲裡谈论了状态、数值以及同一性。
万物皆表达式
可以这么写：
if found_dog == our_dogname = found_dog.namemessage = "We found our dog #{name}!"
elsemessage = "No luck"
end
然而，控制结构（if, while, case 等）也返回表达式，所以只要这样写就好：
message = if found_dog == my_dogname = found_dog.name"We found our dog #{name}!"
else"No luck"
end
这样子我们不用重复变量名 message，企图也更明显：当有段长的程序（用了一堆我们不在乎的变量），我们可以专注在程序在干什么（返回讯息）。再强调一次，我们在缩小程序的作用域。
另一个函数式程序的好处是，表达式可以用来构造数据：
{:name => "M.Cassatt",:paintings => paintings.select { |p| p.author == "M.Cassatt" },:birth => painters.detect { |p| p.name == "M.Cassatt" }.birth.year,...
}
递归
纯函数式语言没有隐含的状态，大量利用了递归。要避免栈溢出，函数式使用一种称为尾递归优化(TCO)的机制。Ruby 1.9 有实作这种机制，但缺省没有打开。要是你希望你的程序，在哪都可以动的话，就不要使用它。
但是某些情况下，递归仍然是很有用的，即便是每次递归时都创建新的栈。注意！某些递归的用途可以用 foldings 来实现(像 Enumerable#inject)。
在 MRI-1.9 启用 TCO：
RubyVM::InstructionSequence.compile_option = {:tailcall_optimization => true,:trace_instruction => false,
}
简单例子：
module Mathdef self.factorial_tco(n, acc=1)n < 1 ? acc : factorial_tco(n-1, n*acc)end end
在递归深度不太可能很深的情况下，你仍可以使用：
class Nodehas_many :children, :class_name => "Node"def all_childrenself.children.flat_map do |child|[child] + child.all_childrenendend end
惰性枚举器
惰性求值延迟了表达式的求值，在真正需要时才会求值。与 eager evaluation 相反，eager evaluation 当一个变量被赋值时、函数被调用时…甚至根本没用到变量等状况，都立马对表达式求值，惰性不是函数式编程的必需品，但这是个符合函数式范式的好策略（Haskell 大概是最佳的例子，瀰漫着懒惰的语言）。
Ruby 所採用的基本上是 eager evaluation（虽然许多其它的语言，在条件还没满足前不对表达式求值，以及短路布林运算 &&, ||等）。然而，与任何内置高阶函数的语言一样，延迟求值是隐性支援，因为程序员自己决定区块何时被调用。
Enumerators 同样 从 Ruby 1.9 开始支援(1.8 请用 backports)，它们提供了一个简单的介面来定义惰性 enumerables。经典的例子是构造一个枚举器，返回所有的自然数：
require 'backports' # 1.8 才需要 natural_numbers = Enumerator.new do |yielder|number = 1loop doyielder.yield numbernumber += 1end end
可以用更函数式的精神改写：
natural_numbers = Enumerator.new do |yielder|(1..1.0/0).each do |number|yielder.yield numberend end
natural_numbers.take(10) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
现在，试试给 natural_numbers 做 map，发生什么事？它不会停止。标准的 enumerable 方法 (map, select 等）返回一个数组，所以在输入流是无穷大时，无法正常工作。让我们扩展 Enumerator 类别，比如加入这个惰性的 Enumerator#map：
class Enumeratordef map(&block)Enumerator.new do |yielder|self.each do |value|yielder.yield(block.call(value))endendend end
现在我们可以给所有自然数的流做 map 了：
natural_numbers.map { |x| 2*x }.take(10)
# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
枚举器是用来构造惰性行为的区块的好东西，但你可以使用用懒惰风格，实作了所有 enumerable 方法的函式库：
https://github.com/yhara/enumerable-lazy
require 'enumerable/lazy'
(1..1.0/0).lazy.map { |x| 2*x }.take(10).to_a
# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
惰性求值的好处
显而易见的好处: 无需在不必要的情况下，构造、储存完整的结构（也许，可以更有效率的使用 CPU 及内存）
不太显而易见的好处: 惰性求值使写程序不需要了解超出你所需的范围。让我们看一个例子：你写了某种解题工具，可以提供无数种解法，但在某个时候，你只想要前十种解法。你可能会这么写：
solver(input, :max => 10)
当你与惰性结构一起工作时，不需要说什么时候该结束。调用者自己会决定他需要多少值。代码变得更简单，责任归属到对的地方，也就是调用者：
solver(input).take(10)
一个实际的例子
练习：“前十个平方可被五整除的自然数的和是多少？”
Integer::natural.select { |x| x**2 % 5 == 0 }.take(10).inject(:+) #=> 275
让我们跟等价的命令式版本来比较：
n, num_elements, sum = 1, 0, 0 while num_elements < 10if n**2 % 5 == 0sum += nnum_elements += 1endn += 1 end sum #=> 275
我希望这个例子展示了这个文档裡讨论的函数式编程的优点：
更简洁: 你会撰写更少的代码。函数式程序处理的是表达式，而表达式可以连锁起来；命令式程序处理的是变量的改动（叙述式），而这不能连锁。
更抽象: 你可以争论我们使用
select,inject…等等，来隐藏了一大堆代码，我很高兴你这么说，因为我们正是这么干的。将通用的、可重用的代码隐藏起来，这是所有编程的重点 –– 但函数式编程特别是关于如何撰写抽象。感到开心不是因为写了更少的代码，而是因为藉由认出可重用的模式，简化了代码的复杂性。更有声明式的味道: 看看命令式的版本，第一眼看起来是一沱无用的代码 –– 没有注解的话 –– 它会做什么你完全没有概念。你可能会说：“好吧，从这裡开始读，草草记下
n与sum的值，进入某个迴圈，看看n与sum的值如何变化，看看最后一次迭代的情形” 等等。函数式版本另一方面是自我解释的，函数式版本描述、声明它在干的事，而不是如何干这件事。
“函数式编程就像是将你的问题叙述给数学家一样。命令式编程像是给白痴下指令” (arcus 在 Freenode #scheme 频道所说）
Ruby 函数式编程相关推荐
- java 函数式编程_函数式编程杂谈
比起命令式编程,函数式编程更加强调程序执行的结果而非执行的过程,倡导利用若干简单的执行单元让计算结果不断演进,逐层推导出复杂的运算.本文通过函数式编程的一些趣味用法来阐述学习函数式编程的奇妙之处. 一 ...
- Swift の 函数式编程
Swift 相比原先的 Objective-C 最重要的优点之一,就是对函数式编程提供了更好的支持. Swift 提供了更多的语法糖和一些新特性来增强函数式编程的能力,本文就在这方面进行一些讨论. S ...
- Java如何支持函数式编程？
简介:Java是面向对象的语言,无法直接调用一个函数.Java 8开始,引入了函数式编程接口与Lambda表达式,便于开发者写出更少更优雅的代码.什么是函数式编程?函数式编程的特点是什么?本文通过代码 ...
- 让JavaScript回归函数式编程的本质
JavaScript是一门被误会最深的语言,这话一点不假,我们看下它的发展历史. 1995年,Netscape要推向市场,需要一门脚本语言来配套它.是使用一门已有的语言,还是发明一门新的语言,这也不是 ...
- 函数式编程笔记 01
Cousera 上 Functional Programming Prinples in Scala 的笔记. 编程范式 范式描述了某些科学学科中独特的概念或者思考模式. 主要的编程范式: 命令式编程 ...
- 编程语言的发展趋势及未来方向（3）：函数式编程
关于声明式编程的还有一部分重要的内容,那便是函数式编程.函数式编程已经有很长时间的历史了,当年LISP便是个函数式编程语言.除了LISP以外我们还有其他许多函数式编程语言,如APL.Haskell.S ...
- java 函数式编程 示例_功能Java示例 第8部分–更多纯函数
java 函数式编程 示例 这是第8部分,该系列的最后一部分称为"示例功能Java". 我在本系列的每个部分中开发的示例是某种"提要处理程序",用于处理文档. ...
- python函数的作用降低编程复杂度_Python函数式编程
lambda 本文将介绍Python中函数式编程的特性.在对函数式编程的概念有了了解后,本文会介绍iterators和generators等语言特性,还有itertools和functools等相关的 ...
- javascript函数式_JavaScript中的函数式编程原理
javascript函数式 After a long time learning and working with object-oriented programming, I took a step ...
最新文章
- 红杉中国合伙人刘星：新零售新在哪里？
- transient关键字的作用_ArrayList Vector （transient关键字）--JAVA成长之路
- C语言面试题之华为篇2(答案全)
- Java最佳实践–高性能序列化
- Kafka ACL控制，用户权限能控制
- 英语学习笔记2019-11-08
- Java求三个数中的最大值
- c语言如何答应出数所在数组的下标_零基础学C语言——数组
- UNIX高级环境编程 第11、12章 线程同步及属性
- 机器学习笔记【二】逻辑回归与分类(1)：逻辑回归参数更新规则以及pytorch实现
- MYSQL导入导出.sql文件
- 关于依赖注入必备的初步知识
- 权限申请弹框_安卓Q | 位置权限三态化解析，用户要关心，开发者须警惕！
- 个人设想中的TCAX GUI生成的带python脚本代码的ASS字幕文件
- 静态路由 华三静态路由
- Centos yum安装Mysql
- springboot实战派PDF文档
- Resources文件夹
- 电路的基本定律--基尔霍夫电流定律和电压定律
- 海南企业成功研发我国第三代防伪技术