`
netcome
  • 浏览: 464128 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

函数式思维: 函数设计模式,第 1 部分

 
阅读更多

关于本系列

系列 的目标是重新调整您对函数思维的认识,帮助您以全新的方式看待常见问题,并提升您的日常编码能力。本系列文章将探讨函数编程概念、允许在 Java™ 语言中进行函数式编程的框架、在 JVM 上运行的函数编程语言,以及语言设计的未来方向。本系列面向那些了解 Java 及其抽象工作原理,但对函数语言不甚了解的开发人员。

函数世界中的一些经验主义者认为设计模式的概念有缺陷,在函数式编程中不需要。在模式 的狭义解释下该观点可能成立,但这是一个更多关于语义而非使用的论点。设计模式的概念 (针对常见问题的指定编目解决方案)是合理的。但是,模式有时在不同的范式下以不同的形式出现。因为构建块和问题解决方法在函数世界中是不同的,一些传统的 Gang of Four 模式(参阅 参考资料 )消失了,而其他模式存在问题,但解决问题的方式大相径庭。本期和下一期将研究一些传统的设计模式,并以函数式思维从全新角度来思考它们。

在函数编程领域,传统设计模式通常以三种方式之一表现:

  • 模式由语言吸收。
  • 模式解决方案仍然存在于函数范式中,但是实现细节有所不同。
  • 解决方案使用其他语言或范式缺乏的功能实现。(例如,许多使用元编程的解决方案简洁且优雅,但无法通过 Java 实现。)

我会依次研究这三种情况,在本期中从一些熟悉的模式入手,大部分模式全部或部分地纳入现代语言。

工厂和局部套用(currying)

局部套用 (Currying) 是许多函数语言的一种特性。它是以数学家 Haskell Curry 的名字命名的(Haskell 编程语言也是以该数学家命名),能够对多参数函数进行转换,以便将它用作一串单参数函数进行调用。与此密切相关的是部分应用 (partial application) ,该技术可以将固定值分配给函数的一个或多个参数,从而生成另一个更小的元数 (arity) 函数(元数是函数参数的个数)。我在 “函数式思维:运用函数式思维,第 3 部分 ” 中讨论过这两种技术。

在设计模式上下文中,局部套用充当一个函数工厂。函数式编程语言中的一个常见特性是一等(first-class)(或高阶)函数,它允许函数充当任何其他数据结构。多亏这一特性,我可以轻松创建基于一些条件返回其他函数的函数,这就是工厂的精髓。例如,如果您有一个将两个数字相加的通用函数,您可以将局部套用用作一个工厂来创建总是将其参数加 1 的函数,即一个增量器,如清单 1 所示,使用 Groovy 语言实现:


清单 1. 局部套用作为函数工厂

def adder = { x, y -> return x + y } def incrementer = adder.curry(1) println "increment 7: ${incrementer(7)}" // prints "increment 7: 8"

 

清单 1 中,我将第一个参数局部套用为 1 ,返回一个接受单一参数的函数。本质上,我创建了一个函数工厂。

当您的语言本机支持这种行为时,它往往被用作其他大小对象的构建块。例如,看看如清单 2 所示的 Scala 示例:


清单 2. Scala 对局部套用的 “随意” 使用

object CurryTest extends Application { 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 dividesBy(n: Int)(x: Int) = ((x % n) == 0) val nums = List(1, 2, 3, 4, 5, 6, 7, 8) println(filter(nums, dividesBy(2))) println(filter(nums, dividesBy(3))) }

 

清单 2 中的代码是 Scala 文档中递归和局部套用的示例之一(参阅 参考资料 )。filter() 方法通过 p 参数以递归的方式过滤一个整数列表。p 是一个谓词函数 ,函数领域中用于布尔函数的一个常见术语。filter() 方法检查看列表是否为空,如果为空,就直接返回;否则它通过谓词检查列表中的第一个元素(xs.head ),以确定是否应将其包含在过滤的列表中。如果它通过谓词测试,返回的就是一个新列表,其头在前面,过滤的尾部作为剩余部分。如果第一个元素没有通过谓词测试,返回的就只是列表的已过滤剩余部分。

从模式角度来看 清单 2 中比较有趣的是在 dividesBy() 方法中对局部套用的 “随意” 使用。注意,dividesBy() 接受两个参数,并根据第二个参数是否均衡地分为第一个参数,返回 truefalse 。但是,当该方法被作为 filter() 方法调用的一部分被调用时,它只在具有一个参数的情况下被调用,调用结果是一个局部套用过的函数,然后该函数被用作 filter() 方法中的谓词。

本例展示模式在函数式编程中表现的前两种方式,我在本文开始列出过它们。首先,局部套用被构建到语言或运行时中,因此函数工厂的概念是生来就有的,且不需要额外的结构。其次,它展示了我对不同实现的观点。如 清单 2 那样使用局部套用可能从来不会在传统的 Java 编程员身上发生;我们从未真正有过可移植代码,当然也从未想过从更通用的函数构建特定函数。事实上,在这里大部分的开发人员不会想到使用一个设计模式,因为从一个更通用的方法创建一个特定的 dividesBy() 方法似乎是一个小问题,而设计模式(很大程度上依赖于结构来解决问题,因而需要大量开销来实现)似乎是一个针对大问题的解决方案。按照本来意图使用局部套用不会证明一个特殊名称的程序的合理性,除了它已经拥有的名称。


一等函数(First-class)和设计模式

一等函数大大简化了许多常用的设计模式。(命令设计模式甚至消失了,因为您不再需要一个针对可移植功能的对象包装器。)

模板方法

一等函数使模板方法设计模式(参阅 参考资料 )更易于实现,因为它们能够移除可能不需要的结构。模板方法定义一个方法中算法的框架,把一些步骤委托给子类,并强制他们在不更改算法结构的情况下定义这些步骤。模板方法的典型实现如清单 3 所示,使用 Groovy 实现:


清单 3. 模板方法的 “标准” 实现

abstract class Customer { def plan def Customer() { plan = [] } def abstract checkCredit() def abstract checkInventory() def abstract ship() def process() { checkCredit() checkInventory() ship() } }

 

清单 3 中,process() 方法依赖于 checkCredit()checkInventory()ship() 方法,其定义必须由子类提供,因为它们是抽象方法。

由于一等函数可充当任何其他数据结构,我可以使用代码块重新定义 清单 3 中的示例,如清单 4 所示:


清单 4. 具有一等函数的模板方法

class CustomerBlocks { def plan, checkCredit, checkInventory, ship def CustomerBlocks() { plan = [] } def process() { checkCredit() checkInventory() ship() } } class UsCustomerBlocks extends CustomerBlocks{ def UsCustomerBlocks() { checkCredit = { plan.add "checking US customer credit" } checkInventory = { plan.add "checking US warehouses" } ship = { plan.add "Shipping to US address" } } }

 

清单 4 中,算法中的步骤只是类的属性,像任何其他属性一样是可分配的。在这个示例中,语言特性主要地吸收实现细节。将这一模式看作一个问题的解决方案(把步骤委派给后续的处理程序)仍然很有用,不过实现起来比较简单。

两种解决方案不是等同的。在 清单 3 中的 “传统” 模板方法示例中,抽象类需要子类来实现依赖的方法。当然,子类可能仅创建一个空的方法体,不过抽象方法定义形成一种文档,提醒 subclasser 将其考虑在内。另一方面,死板的方法声明可能不适合于需要更多灵活性的情景中。例如,我可以创建我的 Customer 类的一个版本,该类接受任何方法列表以供进行处理。

对代码块等功能的深度支持使语言更具有开发人员友好性。考虑这样一种情况,比如您想让 subclasser 跳过一些步骤。Groovy 有一种特殊的受保护访问运算符 (?. ),该运算符确保在调用一个对象的方法前该对象不为空。考虑清单 5 中的 process() 定义:


清单 5. 添加对代码块调用的保护

def process() { checkCredit?.call() checkInventory?.call() ship?.call() }

 

清单 5 中,实现子类的任何人可以选择要将代码分配哪些子方法,保留其他方法为空。

策略

一等函数简化的另一种流行设计模式是策略模式。策略定义一系列算法,封装每一种算法并使它们能够进行互换。它允许算法随使用它的客户不同而有所不同。一等函数使得构建和操作策略更简单。

用于计算产品数目的策略设计模式的一种传统实现如清单 6 所示:


清单 6. 为具有两个数目的产品使用策略设计模式

interface Calc { def product(n, m) } class CalcMult implements Calc { def product(n, m) { n * m } } class CalcAdds implements Calc { def product(n, m) { def result = 0 n.times { result += m } result } }

 

清单 6 中,我为具有两个数目的产品定义了一个接口。我使用两个不同的具体类(策略)实现接口:一个使用乘法,另一个使用加法。为测试这些策略,我创建了一个测试用例,如清单 7 所示:


清单 7. 测试产品策略

class StrategyTest { def listOfStrategies = [new CalcMult(), new CalcAdds()] @Test public void product_verifier() { listOfStrategies.each { s -> assertEquals(10, s.product(5, 2)) } } }

 

清单 7 所示,两个策略都返回同一个值。将代码块用作一等函数,我可以降低上一个示例的复杂性。考虑乘方策略用例,如清单 8 所示:


清单 8. 以更低的复杂性测试乘方

@Test public void exp_verifier() { def listOfExp = [ {i, j -> Math.pow(i, j)}, {i, j -> def result = i (j-1).times { result *= i } result }] listOfExp.each { e -> assertEquals(32, e(2, 5)) assertEquals(100, e(10, 2)) assertEquals(1000, e(10, 3)) } }

 

清单 8 中,我使用 Groovy 代码块直接定义了两个内联乘方策略。如 模板方法示例 中所示,我以简化繁。传统的方法强制围绕每个策略使用名称和结构,有时这是我们需要的。但是,注意,我建议对 清单 8 中的代码加入更严格的保护措施,鉴于我无法轻松绕过更传统的方法施加的限制,传统方法是一种动态与静态对比参数,而非函数式编程与设计模式对比的参数。

受一等函数影响的模式主要是语言吸收的模式示例。接下来,我要展示保持语义但又更改实现的一种模式。


享元 (Flyweight) 和内存化 (memoization)

享元模式是一种使用共享来支持大量细粒度对象引用的优化技术。您要保持对象池可用,为特定视图创建到该池的引用。享元使用一种规范对象(canonical object) 的思想,即一种表示该类型中所有其他对象的代表性对象。例如,您有一个特定的消费产品,产品的规范版本表示该类型的所有产品。在一个应用程序中,不要为每个用户创建一个产品列表,而要创建一个规范产品列表,每个用户拥有对他们产品列表的引用。

考虑清单 9 中建模计算机类型的类:


清单 9. 建模计算机类型的简单类

class Computer { def type def cpu def memory def hardDrive def cd } class Desktop extends Computer { def driveBays def fanWattage def videoCard } class Laptop extends Computer def usbPorts def dockingBay } class AssignedComputer { def computerType def userId public AssignedComputer(computerType, userId) { this.computerType = computerType this.userId = userId } }

 

在这些类中,比方说为每个用户创建一个新的 Computer 实例是效率低下的,假定所有计算机具有相同的规格。一个 AssignedComputer 会将一种计算机与一个用户关联起来。

让该代码更高效的一种常见方式是将工厂和享元模式相结合起来。考虑生成规范计算机类型的单例工厂,如清单 10 所示:


清单 10. 享元计算机实例的单例工厂

class ComputerFactory { def types = [:] static def instance; private ComputerFactory() { def laptop = new Laptop() def tower = new Desktop() types.put("MacBookPro6_2", laptop) types.put("SunTower", tower) } static def getInstance() { if (instance == null) instance = new ComputerFactory() instance } def ofType(computer) { types[computer] } }

 

ComputerFactory 类构建可能的计算机类型缓存,然后通过其 ofType() 方法交付适当的实例。这是一种传统的单例工厂,因为您使用 Java 编写它。

但是,单例也是一种设计模式(参阅 参考资料 ),它是运行时吸收模式的另一个好示例。考虑简化的 ComputerFactory ,其中使用 Groovy 提供的 @Singleton 注释,如清单 11 所示:


清单 11. 简化的单例工厂

@Singleton class ComputerFactory { def types = [:] private ComputerFactory() { def laptop = new Laptop() def tower = new Desktop() types.put("MacBookPro6_2", laptop) types.put("SunTower", tower) } def ofType(computer) { types[computer] } }

 

为测试工厂返回规范实例,我编写了一个单元测试,如清单 12 所示:


清单 12. 测试规范类型

@Test public void flyweight_computers() { def bob = new AssignedComputer(ComputerFactory.instance.ofType("MacBookPro6_2"), "Bob") def steve = new AssignedComputer(ComputerFactory.instance.ofType("MacBookPro6_2"), "Steve") assertTrue(bob.computerType == steve.computerType) }

 

跨实例保存常见信息是一个不错想法,这是我在涉足函数式编程时想保留的想法。但是,实现细节相当不同。这是在更改(更合适的说说是简化)实现时保留模式语义 的一个示例。

函数式思维:Groovy 中的函数式特性,第 3 部分 中,我介绍了内存化 特性,它能够构建到编程语言中,支持自动缓存递归的函数返回值。换言之,一个内存化函数支持运行时为您缓存值。Groovy 的最新版本支持内存化(参阅 参考资料 )。考虑清单 13 中定义的函数:


清单 13. 享元的内存化

def computerOf = {type -> def of = [MacBookPro6_2: new Laptop(), SunTower: new Desktop()] return of[type] } def computerOfType = computerOf.memoize()

 

清单 13 中,规范类型在 computerOf 函数内定义。为了创建一个函数的内存化实例,我直接调用 Groovy 运行时定义的 memoize() 方法。

清单 14 显示对比两种方法调用的一个单元测试:


清单 14. 对比方法

@Test public void flyweight_computers() { def bob = new AssignedComputer(ComputerFactory.instance.ofType("MacBookPro6_2"), "Bob") def steve = new AssignedComputer(ComputerFactory.instance.ofType("MacBookPro6_2"), "Steve") assertTrue bob.computerType == steve.computerType def sally = new AssignedComputer(computerOfType("MacBookPro6_2"), "Sally") def betty = new AssignedComputer(computerOfType("MacBookPro6_2"), "Betty") assertTrue sally.computerType == betty.computerType }

 

最终结果是一样的,但注意实现细节却有着巨大差别。对于 “传统” 设计模式,我创建了一个新类来充当工厂,实现两个模式。对于函数版本,我实现了一个方法,然后返回了一个内存化版本。卸载缓存等细节到运行时意味着手写的实现不太可能失败。在本用例中,我保留了享元模式的语义,但具有一个非常简单的实现。


结束语

在本期中,我介绍了设计模式的语义在函数式编程中表现的三种方式。首先,它们可以被语言或运行时吸收。我使用工厂、策略、单例和模板方法模式展示了相关示例。其次,模式可保留其语义,但具有完全不同的实现;我展示了使用类和使用内存化的享元模式示例。第三,函数语言和运行时可以有完全不同的特性,从而支持它们以完全不同的方式解决问题。

在下一期,我将继续研究设计模式和函数式编程的交叉,并展示第三种方法的示例。

 

本文转载于developerWorks,原文在这里

分享到:
评论

相关推荐

    Scala函数式编程

    很大篇幅都放在,使用scala实现scala默认库文件的API中,通过对简单的函数式编程逻辑的介绍和实践,主要是实践,建立起来一个比较明晰的scala思维模式,或者叫函数式编程的思维模式。 2 无副作用的函数式编程,同时...

    二十三种设计模式【PDF版】

    1.设计模式更抽象,J2EE 是具体的产品代码,我们可以接触到,而设计模式在对每个应用时才会产生具体代码。 2.设计模式是比 J2EE 等框架软件更小的体系结构,J2EE 中许多具体程序都是应用设计模式来完成的,当你深入...

    架构师思维导图【数据库系统】

    架构师思维导图 数据库系统 规范化理论 并发控制 关系代数 数据库设计过程 数据库模式 数据完整性约束 数据库安全措施 数据备份与恢复 数据库技术拓展 数据库性能优化 函数依赖 Armstrong公理 键 范式 模式分解 无损...

    写给大家看的面向对象编程书(第三版)

    第1章 面向对象概念介绍 1.1 过程式程序设计与OO程序设计 1.2 从过程式开发转向面向对象开发 1.3 对象到底是什么 1.4 类到底是什么 1.5 使用UML完成类图建模 1.6 封装和数据隐藏 ...第15章 设计模式 索引

    Elixir程序设计(英文版) pdf

    通过一步步的实验探索,引导读者逐步跳出已有的编程思维模式,以全新的函数式编程方式来思考及寻找解决实际问题的办法。然而本书并不像Programming Ruby 那样面面俱到,而是给读者讲述基本的Elixir 语法和编程思想,...

    如何利用多级抽象思维来设计库?

    而本文作者在此之前,还发表了一篇《Librarypatterns:Multiplelevelsofabstraction》,结合具体实例,向大家非常详细地介绍了库设计模式及库设计中的多级抽象思想。以下为具体译文:对于库设计理论来说,有几点在我...

    asp.net知识库

    深入剖析ASP.NET组件设计]一书第三章关于ASP.NET运行原理讲述的补白 asp.net 运行机制初探(httpModule加载) 利用反射来查看对象中的私有变量 关于反射中创建类型实例的两种方法 ASP.Net应用程序的多进程模型 NET委托...

    draft:人类程序设计语言设计稿

    略知晓编程语言历史的人都知道,目前存在的上千种编程语言中有两大高山,即 C 和 Lisp ,分别代表了主流的命令式和函数式两种风格。C 一直是工业界主流大众语言,常用于系统编程。而 Lisp 则相对小众,一般用于人工...

    写给大家看的面向对象编程书(第3版).[美]Matt Weisfeld(带详细书签).pdf

    第15章 设计模式 232 15.1 为什么研究设计模式 232 15.2 Smalltalk的模型/视图/控制器 233 15.3 设计模式的不同类型 234 15.3.1 创建型模式 235 15.3.2 结构型模式 239 15.3.3 行为型模式 241 15.4 反模式 ...

    Python语言程序设计习题答案.zip

    第1章Python编程初步。学习本章,要了解Python作为一种计算机程序设计脚本语言,结合了解释性、编译性和互动性的特点;了解在Linux和Windows中安装Python的方法;了解IDLE、PyCharm和Jupyter三种常用Python程序编辑...

    Python语言程序设计PPT课件.zip

    第1章Python编程初步。学习本章,要了解Python作为一种计算机程序设计脚本语言,结合了解释性、编译性和互动性的特点;了解在Linux和Windows中安装Python的方法;了解IDLE、PyCharm和Jupyter三种常用Python程序编辑...

    电子表格-数据计算-教学设计.doc

    课堂教学设计表 "课题 " 1.3 电子表格的数据计算 " "(章节名称)" " "学科 "信息技术 "授课年级 "八年级 "学期 "上 " "预计课时数 "1 "本案为其中第 1 课时"课型 "新课 " "选用教材 " "《初中信息技术》八年级...

    Java知识资料,后端资料,面试资料

    全面而深入的覆盖:我们的Java面试资料涵盖了Java编程语言的各个方面,包括基础知识、面向对象编程、多线程、集合框架、异常处理、IO操作、数据库连接、设计模式等。无论您是初学者还是经验丰富的开发者,我们的资料...

    Java后端资料,面试专题

    全面而深入的覆盖:我们的Java面试资料涵盖了Java编程语言的各个方面,包括基础知识、面向对象编程、多线程、集合框架、异常处理、IO操作、数据库连接、设计模式等。无论您是初学者还是经验丰富的开发者,我们的资料...

    Java后端资料,知识点,面试点

    全面而深入的覆盖:我们的Java面试资料涵盖了Java编程语言的各个方面,包括基础知识、面向对象编程、多线程、集合框架、异常处理、IO操作、数据库连接、设计模式等。无论您是初学者还是经验丰富的开发者,我们的资料...

    Java后端资料,面试题,后端知识点

    全面而深入的覆盖:我们的Java面试资料涵盖了Java编程语言的各个方面,包括基础知识、面向对象编程、多线程、集合框架、异常处理、IO操作、数据库连接、设计模式等。无论您是初学者还是经验丰富的开发者,我们的资料...

    Java后端资料,MyBatis面试专题

    全面而深入的覆盖:我们的Java面试资料涵盖了Java编程语言的各个方面,包括基础知识、面向对象编程、多线程、集合框架、异常处理、IO操作、数据库连接、设计模式等。无论您是初学者还是经验丰富的开发者,我们的资料...

    Java面试题及答案,Dubbo框架

    全面而深入的覆盖:我们的Java面试资料涵盖了Java编程语言的各个方面,包括基础知识、面向对象编程、多线程、集合框架、异常处理、IO操作、数据库连接、设计模式等。无论您是初学者还是经验丰富的开发者,我们的资料...

    Java热门面试题、Java面试指南

    全面而深入的覆盖:我们的Java面试资料涵盖了Java编程语言的各个方面,包括基础知识、面向对象编程、多线程、集合框架、异常处理、IO操作、数据库连接、设计模式等。无论您是初学者还是经验丰富的开发者,我们的资料...

Global site tag (gtag.js) - Google Analytics