从函数式编程到Promise

译者按: 近年来，函数式语言的特性都被其它语言学过去了。JavaScript异步编程中大显神通的Promise，其实源自于函数式编程的Monad!

原文: Functional Computational Thinking?—?What is a monad?

译者: Fundebug

为了保证可读性，本文采用意译而非直译。另外，本文版权归原作者所有，翻译仅用于学习。

如果你使用函数式编程，不管有没有用过函数式语言，在某总程度上已经使用过Monad。可能大多数人都不知道什么叫做Monad。在这篇文章中，我不会用数学公式来解释什么是Moand，也不使用Haskell，而是用JavaScript直接写Monad。

作为一个函数式程序员，我首先来介绍一下基础的复合函数：

const add1 = x => x + 1
const mul3 = x => x * 3

const composeF = (f, g) => {
  return x => f(g(x))
}

const addOneThenMul3 = composeF(mul3, add1)
console.log(addOneThenMul3(4)) // 打印 15

复合函数composeF接收f和g两个参数，然后返回值是一个函数。该函数接收一个参数x, 先将函数g作用到x, 其返回值作为另一个函数f的输入。

addOneThenMul3是我们通过composeF定义的一个新的函数：由mul3和add1复合而成。

接下来看另一个实际的例子：我们有两个文件，第一个文件存储了第二个文件的路径，第二个文件包含了我们想要取出来的内容。使用刚刚定义的复合函数composeF, 我们可以简单的搞定：

const readFileSync = path => {
  return fs.readFileSync(path.trim()).toString()
}

const readFileContentSync = composeF(readFileSync, readFileSync)
console.log(readFileContentSync(‘./file1‘))

readFileSync是一个阻塞函数，接收一个参数path，并返回文件中的内容。我们使用composeF函数将两个readFileSync复合起来，就达到我们的目的。是不是很简洁？

但如果readFile函数是异步的呢？如果你用Node.js 写过代码的话，应该对回调很熟悉。在函数式语言里面，有一个更加正式的名字：continuation-passing style 或则 CPS。

我们通过如下函数读取文件内容：

const readFileCPS = (path, cb) => {
  fs.readFile(
    path.trim(),
    (err, data) => {
      const result = data.toString()
      cb(result)
    }
  )
}

但是有一个问题：我们不能使用composeF了。因为readCPS函数本身不在返回任何东西。

我们可以重新定义一个复合函数composeCPS,如下：

const composeCPS = (g, f) => {
  return (x, cb) => {
    g(x, y => {
      f(y, z => {
        cb(z)
      })
    })
  }
}

const readFileContentCPS = composeCPS(readFileCPS, readFileCPS)
readFileContentCPS(‘./file1‘, result => console.log(result))

注意：在composeCPS中，我交换了参数的顺序。composeCPS会首先调用函数g,在g的回调函数中，再调用f, 最终通过cb返回值。

接下来，我们来一步一步改进我们定义的函数。

第一步，我们稍微改写一下readFIleCPS函数：

const readFileHOF = path => cb => {
  readFileCPS(path, cb)
}

HOF是 High Order Function (高阶函数)的缩写。我们可以这样理解readFileHOF: 接收一个为path的参数，返回一个新的函数。该函数接收cb作为参数，并调用readFileCPS函数。

并且，定义一个新的复合函数:

const composeHOF = (g, f) => {
  return x => cb => {
    g(x)(y => {
      f(y)(cb)
    })
  }
}

const readFileContentHOF = composeHOF(readFileHOF, readFileHOF)
readFileContentHOF(‘./file1‘)(result => console.log(result))

第二步，我们接着改进readFileHOF函数：

const readFileEXEC = path => {
  return {
    exec: cb => {
      readFileCPS(path, cb)
    }
  }
}

readFileEXEC函数返回一个对象，对象中包含一个exec属性，而且exec是一个函数。

同样，我们再改进复合函数：

const composeEXEC = (g, f) => {
  return x => {
    return {
      exec: cb => {
        g(x).exec(y => {
          f(y).exec(cb)
        })
      }
    }
  }
}

const readFileContentEXEC = composeEXEC(readFileEXEC, readFileEXEC)
readFileContentEXEC(‘./file1‘).exec(result => console.log(result))

现在我们来定义一个帮助函数:

const createExecObj = exec => ({exec})

该函数返回一个对象，包含一个exec属性。

我们使用该函数来优化readFileEXEC函数：

const readFileEXEC2 = path => {
  return createExecObj(cb => {
    readFileCPS(path, cb)
  })
}

readFileEXEC2接收一个path参数，返回一个exec对象。

接下来，我们要做出重大改进，请注意！

迄今为止，所有的复合函数的两个参数都是函数，接下来我们把第一个参数改成exec对象。

const bindExec = (execObj, f) => {
  return createExecObj(cb => {
    execObj.exec(y => {
      f(y).exec(cb)
    })
  })
}

该bindExec函数返回一个新的exec对象。

我们使用bindExec来定义读写文件的函数：

const readFile2EXEC2 = bindExec(
  readFileEXEC2(‘./file1‘),
  readFileEXEC2
)
readFile2EXEC2.exec(result => console.log(result))

如果不是很清楚，我们可以这样写：

bindExec(
  readFileEXEC2(‘./file1‘),
  readFileEXEC2
)
.exec(result => console.log(result))

我们接下来把bindExec函数放入exec对象中：

const createExecObj = exec => ({
  exec,
  bind(f) {
    return createExecObj(cb => {
      this.exec(y => {
        f(y).exec(cb)
      })
    })
  }
})

如何使用呢？

readFileEXEC2(‘./file1‘)
.bind(readFileEXEC2)
.exec(result => console.log(result))

这已经和在函数式语言Haskell里面使用Monad几乎一模一样了。

我们来做点重命名：

  • readFileEXEC2 -> readFileAsync
  • bind -> then
  • exec -> done
readFileAsync(‘./file1‘)
.then(readFileAsync)
.done(result => console.log(result))

发现了吗？竟然是Promise!

Monad在哪里呢？

从composeCPS开始，都是Monad.

  • readFIleCPS是Monad。事实上，它在Haskell里面被称作Cont Monad；
  • exec 对象是一个Monad。事实上，它在Haskell里面被称作IO Monad。

Monad 有什么性质呢？

  1. 它有一个环境；
  2. 这个环境里面不一定有值；
  3. 提供一个获取该值的方法；
  4. 有一个bind函数可以把值从第一个参数Monad中取出来，并调用第二个参数函数。第二个函数要返回一个Monad。并且该返回的Monad类型要和第一个参数相同。

数组也可以成为Monad

Array.prototype.flatMap = function(f) {
  const r = []
  for (var i = 0; i < this.length; i++) {
    f(this[i]).forEach(v => {
      r.push(v)
    })
  }
  return r
}

const arr = [1, 2, 3]
const addOneToThree = a => [a, a + 1, a + 2]

console.log(arr.map(addOneToThree))
// [ [ 1, 2, 3 ], [ 2, 3, 4 ], [ 3, 4, 5 ] ]

console.log(arr.flatMap(addOneToThree))
// [ 1, 2, 3, 2, 3, 4, 3, 4, 5 ]

我们可以验证：

  1. [] 是环境
  2. []可以为空，值不一定存在；
  3. 通过forEach可以获取；
  4. 我们定义了flatMap来作为bind函数。

结论

  • Monad是回调函数 ?

    根据性质3，是的。

  • 回调函数式Monad?

    不是，除非有定义bind函数。

    关于Fundebug

Fundebug专注于JavaScript、微信小程序、微信小游戏、支付宝小程序、React Native、Node.js和Java实时BUG监控。 自从2016年双十一正式上线，Fundebug累计处理了7亿+错误事件，得到了Google、360、金山软件、百姓网等众多知名用户的认可。欢迎免费试用！

版权声明

转载时请注明作者Fundebug以及本文地址：

https://blog.fundebug.com/2017/06/21/write-monad-in-js/

原文地址：https://www.cnblogs.com/fundebug/p/9958393.html

时间： 2024-08-30 14:02:01

从函数式编程到Promise的相关文章

JS函数式编程【译】5.3 单子 (Monad)

单子是帮助你组合函数的工具. 像原始类型一样,单子是一种数据结构,它可以被当做装载让函子取东西的容器使用. 函子取出了数据,进行处理,然后放到一个新的单子中并将其返回. 我们将要关注三种单子: Maybes Promises Lenses 除了用于数组的map和函数的compose以外,我们还有三种函子(maybe.promise和lens). 这仅仅是另一些函子和单子. Maybe Maybe可以让我们优雅地使用有可能为空并且有默认值的数据.maybe是一个可以有值也可以没有值的变量,并且这对

JS函数式编程 3.1 Javascript的函数式库

?? Functional Programming in Javascript 主目录第三章 建立函数式编程环境 Javascript的函数式库 据说所有的函数式程序员都会写自己的函数库,函数式Javascript程序员也不例外. 随着如今开源代码分享平台如GitHab.Bower和NPM的涌现,对这些函数库进行分享.变得及补充变得越来越容易. 现在已经有很多Javascript的函数式变成苦,从小巧的工具集到庞大的模块库都有. 每一个库都宣扬着自己的函数式编程风格.从一本正经的数学风格到灵活松

给 JavaScript 开发者讲讲函数式编程

本文译自:Functional Programming for JavaScript People 和大多数人一样,我在几个月前听到了很多关于函数式编程的东西,不过并没有更深入的了解.于我而言,可能只是一个流行词罢了.从那时起,我开始更深地了解函数式编程并且我觉得应该为那些总能听到它但不知道究竟是什么的新人做一点事情. 谈及函数式编程,你可能会想到它们:Haskell 和 Lisp,以及很多关于哪个更好的讨论.尽管它们都是函数式语言,不过的确有很大的不同,可以说各有各的卖点.在文章的结尾处,我希

redux源码解析，函数式编程

提到redux,会想到函数式编程.什么是函数式编程?是一种很奇妙的函数式的编程方法.你会感觉函数式编程这么简单,但是用起来却很方便很神奇. 在<functional javascript>中,作者批评了java那种任何东西都用对象来写程序的方式,提倡了这种函数式编程. 之前看过一些函数式编程的例子(以下简称fp).提到fp会想到underscore和lodash,你会看到lodash的包中,唯一一个文件夹就是fp,里面是fp相关的函数. 在redux中,也是运用了很多fp的函数.其实在写js中

用函数式编程，从0开发3D引擎和编辑器（二）：函数式编程准备

大家好,本文介绍了本系列涉及到的函数式编程的主要知识点,为正式开发做好了准备. 函数式编程的优点 1.粒度小 相比面向对象编程以类为单位,函数式编程以函数为单位,粒度更小. 正所谓: 我只想要一个香蕉,而面向对象却给了我整个森林 2.性能好 大部分人认为函数式编程差,主要基于下面的理由(参考 JavaScript 函数式编程存在性能问题么?): 1)柯西化.函数组合等操作增加时间开销 2)map.reduce等操作,会进行多次遍历,增加时间开销 3)Immutable数据每次操作都会被拷贝为新的

JavaScript函数式编程（三）

JavaScript函数式编程(一) JavaScript函数式编程(二) 在第二篇文章里,我们介绍了 Maybe.Either.IO 等几种常见的 Functor,或许很多看完第二篇文章的人都会有疑惑: 『这些东西有什么卵用?』 事实上,如果只是为了学习编写函数式.副作用小的代码的话,看完第一篇文章就足够了.第二篇文章和这里的第三篇着重于的是一些函数式理论的实践,是的,这些很难(但并非不可能)应用到实际的生产中,因为很多轮子都已经造好了并且很好用了.比如现在在前端大规模使用的 Promise

JavaScript：了解一下函数式编程

一.简介 在JavaScript中,函数就是第一类公民,它可以像字符串.数字等变量一样,使用var修饰并作为数据使用.它可以作为数值.可以作为参数.还可以作为返回结果.可以说JavaScript就是函数式编程.ES6新语言特性中,箭头函数.扩展运算符会极大地帮助开发者利用函数式编程技术进行开发. //定义一个箭头函数 var print = (message) => console.log(message) 1.函数作为数值使用 //将函数作为数值使用 const array = ["XY

Python学习笔记八：文件操作（续），文件编码与解码，函数，递归，函数式编程介绍，高阶函数

文件操作(续) 获得文件句柄位置,f.tell(),从0开始,按字符数计数 f.read(5),读取5个字符 返回文件句柄到某位置,f.seek(0) 文件在编辑过程中改变编码,f.detech() 获取文件编码,f.encoding() 获取文件在内存中的编号,f.fileno() 获取文件终端类型(tty.打印机等),f.isatty() 获取文件名,f.name() 判断文件句柄是否可移动(tty等不可移动),f.seekable() 判断文件是否可读,f.readable() 判断文件是

PYTHON修饰器的函数式编程

转自:http://coolshell.cn/articles/11265.html Python修饰器的函数式编程 Python的修饰器的英文名叫Decorator,当你看到这个英文名的时候,你可能会把其跟Design Pattern里的Decorator搞混了,其实这是完全不同的两个东西.虽然好像,他们要干的事都很相似--都是想要对一个已有的模块做一些"修饰工作",所谓修饰工作就是想给现有的模块加上一些小装饰(一些小功能,这些小功能可能好多模块都会用到),但又不让这个小装饰(小功能