函数式编程

从本文你能了解到哪些知识

• 认识函数式编程
• 函数前置知识
  • 函数是一等公民
  • 高阶函数
  • 闭包
• 函数式编程基础
  • lodash
  • 纯函数
  • 柯里化
  • 函数组合
• 函子
  • Functor
  • MayBe
  • Eiter
  • IO
  • Task
  • Monad

什么是函数式编程

函数式编程(Functional Programming, FP)，FP 是编程范式之一，我们常听说的编程范式还有面向过程 编程、面向对象编程。

• 编程范式类型:
  • 面向过程编程的思维方式：分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步的实现，使用的时候一个一个依次调用就可以了，就好比在设计一条流水线，面向对象编程其实是一种机械式的思维方式。
  • 面向对象编程的思维方式：把现实世界中的事物抽象成程序世界中的类和对象，通过封装、继承和多态来演示事物之前的联系。
  • 函数式编程的思维方式：把现实世界中的事物和事物之间的联系抽象到程序世界（对运算过程进行抽象）
    • 程序的本质：根据输入通过某运算获得相应的输出，程序开发过程中会涉及很多有输入和输出的函数。
    • x->f(联系，映射)->y，y=f(x)
    • 函数式编程中的函数指的不是程序中的函数(方法)，而是数学中的函数即映射关系，例如y=shin(x)，x和y的关系
    • 相同的输入始终要得到相同的输出（纯函数）
    • 函数式编程用来描述数据（函数）之间的映射关系

演示：

// 面向过程
let num1 = 1;
let num2 = 2;
let num = num1 + num2;
console.log(num);

//面向对象
class addSum {
  constructor(num1, num2) {
    this.num = num1 + num2;
  }
}

const getSum = new addSum(1, 2);
const num = getSum.num;
console.log(num);

//函数式编程
function add(n1, n2) {
  return n1 + n2;
}
const num = add(1, 2);
console.log(num);

为什么要学习函数式编程

函数式编程是非常古老的一个概念，早于第一台计算机的诞生，函数式编程的历史。
那我们为什么现在还要学习函数式编程?

• 随着React的流行受到越来越多的关注
• vue3也开始拥抱函数式编程
• 函数式编程可以抛弃this
• 打包过程中可以更好的利用tree shaking 过滤无用的代码
• 方便测试，方便并行处理
• 有很多库可以帮助我们进行函数开发：lodash、underscore、remda、folktale

函数前置知识

MDN First-class Function

• 函数是一等公民
  • 函数可以存储在变量中
  • 函数可以作为参数 （）
  • 函数可以作为返回值（闭包）
• 高阶函数(Higher-order function)
  • 可以把函数作为参数传递给另一个函数
  • 可以把函数作为另一个函数的返回结果 （闭包）

把函数赋值给变量

// 把函数赋值给变量
let fn=function () {
	console.log("Hellow First-class Function")
}
fn()


//示例
const Controller = {
	view(posts){return view.index(posts)},
 	show(post){return view.show(post)},
  create(attrs){return view.create(attrs)},
	updata (post,attrs){return Db.updata(post,attrs)}
}

//优化后
const Controller = {
	view: view.index,
 	show:view.show,
  create:view.create,
	updata :view.updata
}

高阶函数

把函数作为参数

//高阶函数-函数作为参数

function forEach(array, fn) {
  for (let i = 0; i < array.length; i++) {
    fn(array[i]);
  }
}

//测试
let arr = [1, 2, 3, 4, 5];
// forEach(arr, (item) => console.log(item));

// filter
function filter(array, fn) {
  let results = [];
  for (let i = 0; i < array.length; i++) {
    if (fn(array[i])) {
      results.push(array[i]);
    }
  }
  return results;
}

//测试
let r=filter(arr, (item) => item % 2 === 0);
console.log(r)

使用高阶函数的意义

• 抽象可以帮我们屏蔽细节,只需要关注与我们的目标
• 高阶函数是用来抽象通用的问题

//面向过程的方式
let array = [1, 2, 3, 4];
for (let i = 0; i > array.length; i++) {
  console.log(array[i]);
}

//高阶函数
let array = [1, 2, 3, 4];
forEach(array, (item) => {
  console.log(item);
});

let r = filter(array, (item) => {
  return item % 2 === 0;
});

常用高阶函数

• forEach
• map
• filter
• every
• some
• find/findIndex
• reduce
• sort
• ......

// 模拟常用高阶函数：map、every、some

// map
function map(array, fn) {
  let results = [];
  for (let value of array) {
    if (fn(value)) {
      results.push(value);
    }
  }
  return results;
}

//测试
// let array = [1, 2, 3, 4, 15, 20];
// array = map(array, (v) => v > 10);
// console.log(array);

//every
function every(array, fn) {
  let result = true;
  for (let value of array) {
    result = fn(value);
    if (!result) {
      result = false;
      break;
    }
  }
  return result;
}

//测试
// let array = [2, 4];
// let results = every(array, (item) => item % 2 === 0);
// console.log(results);

// some
function some(array, fn) {
  let result = true;
  for (let value of array) {
    result = fn(value);
    if (result) {
      break;
    }
  }
  return result;
}

// 测试
let array = [1, 2, 4, 5, 6];
let results = some(array, (item) => item % 2 === 0);
console.log(results);

闭包

• 闭包(closure):函数和其周围的状态(词法环境)的引用捆版在一起形成闭包
  • 可以在另一个作用域中调用一个函数的内部函数并访问到该函数的作用域中的成员

// 函数作为返回值

function makeFn() {
  let msg = "Hellow Function";
  return function () {
    console.log(msg);
  };
}

const fn = makeFn();
fn();
//另一种调用
makeFn()();

//once
//思路:done标记由于词法作用域会被保存下来，并被更改为true，下面调用没用了)
function once(fn) {
  let done = false;
  return function () {
    if (!done) {
      done = true;
      return fn.apply(this, arguments);
    }
  };
}

const pay = once((money) => {
  console.log(money);
});
pay(5); //5
pay(5);//不打印
pay(5);//不打印

• 闭包的本质:函数在执行的时候回放到一个执行栈上当函数执行完毕之后会从执行栈上移除,但是堆上的作用域成员因为被外部引用不能释放，因此内部的函数依然可以访问外部函数的成员
• 闭包案例

// 生成计算数字的多少次幂的函数

function makePower(power) {
  return function (number) {
    return Math.pow(power, number);
  };
}
let power2 = makePower(2);//返回一个2次幂的函数
let power3 = makePower(3);//返回一个3次幂的函数

console.log(power2(4));
console.log(power2(5));
console.log(power3(4));

//求工资的函数  工资=绩效+基本工资
function makeSalary(x) {
  return function (y) {
    return x + y;
  };
}

let makeSalaryX = makeSalary(2000);//返回一个基本工资是2000的函数
let makeSalaryY = makeSalary(1000);//返回一个基本工资是1000的函数

console.log(makeSalaryX(2000));//4000
console.log(makeSalaryY(1000));//2000

函数式编程基础

• lodash:是一个纯函数的功能库,提供了对数组，数字，对象，字符串，函数等操作的一些方法。本文中会使用到一些基本的方法
• 纯函数
• 柯里化
• 函数组合

纯函数

• 概念：相同的输入永远会得到相同的输出,而且没有任何可观察的副作用
  • 纯函数就类似数学中的函数(用来描述输入和输出之间的关系),y=f(x)

• 数组的slice 和 splice 分别是纯函数和不纯的函数
  • slice 返回数组中的指定部分，不会改变原数组 （纯函数）
  • splice 对数组进行操作返回该数组,会改变原数组**（不纯函数） **

演示

// 纯函数和不纯的函数
// slice / splice

let array = [1, 2, 3, 4, 5, 6];

// 纯函数  相同输入永远得到相同的输出
console.log(array.slice(0, 3));
// =>[ 1, 2, 3 ]
console.log(array.slice(0, 3));
// =>[ 1, 2, 3 ]
console.log(array.slice(0, 3));
// =>[ 1, 2, 3 ]

// 不纯的函数
console.log(array.splice(0, 3));
// =>[ 1, 2, 3 ]
console.log(array.splice(0, 3));
// =>[ 4, 5, 6 ]
console.log(array.splice(0, 3));
// =>[]

// 纯函数
function addSum(n1, n2) {
  return n1 + n2;
}
console.log(addSum(1, 2)); //3
console.log(addSum(1, 2)); //3
console.log(addSum(1, 2)); //3

纯函数的好处**

• 可缓存
  • 因为纯函数对相同的输入始终有相同的输出，所以可以把纯函数的结果缓存起来

演示：

// 记忆函数
//lodash中的memoize方法
const _ = require("lodash");
function getArea(r) {
  console.log(r);
  return Math.PI * r * r;
}

let getAreaWithMemory = _.memoize(getArea);
console.log(getAreaWithMemory(4));
console.log(getAreaWithMemory(4));
console.log(getAreaWithMemory(4));

// 模拟 memoize 方法的实现
function memoize(fn) {
    let cache={}
   return function (){
        let arg_str=JSON.stringify(arguments)
        cache[arg_str]=cache[arg_str] || fn.apply(fn,arguments)
        return  cache[arg_str]
   }
  }

let getAreaWithMemory = memoize(getArea);
console.log(getAreaWithMemory(4));
console.log(getAreaWithMemory(4));
console.log(getAreaWithMemory(4));

• 可测试
  • 纯函数让测试更方便
• 并行处理
  • 在多线程环境下并行操作共享的内存数据会出现意外情况
  • 纯函数不需要访问共享的内存数据，所以在并行环境下可以任意运行纯函数（web work）

副作用

• 纯函数:对于相同的输入永远会得到相同的输出，而且没有任何可观察的副作用

// 不纯的
let mini = 18;
function checkAge(age) {
  return age >= mini;
}

// 测试
// checkAge(20)  //true

// 测试
let mini = 22;
checkAge(20)   //fakse


//纯函数  (有硬编码,后续可通过柯理化解决)
function checkAge(age) {
  let mini = 18;
  return age >= mini;
}

副作用让一个纯函数变得不纯（如上例）,纯函数根据相同的输入得到相同的输出，如果函数依赖于外部的状态就无法保证输出相同，就会带来副作用。
副作用来源：

• 配置文件
• 数据库
• 获取用户的输入
• ......

所有的外部交互都有可能带来副作用，副作用也使得方法通用性下降不适合扩展和可重用性，同时副作用会给程序中带来安全隐患给程序带来不确定性，但是副作用不可能完全禁止，尽可能控制他们在可控范围内发生。

柯里化(Haskell Brooks curry)

• 使用柯里化解决上一个案例中硬编码的问题

// 柯里化演示
function checkAge(age) {
  let min = 18;
  return age >= min;
}

//普通的纯函数
function checkAge(age, min) {
  return age >= min;
}

//柯里化的函数
function checkAge(min) {
  return function (age) {
    return age >= min;
  };
}

//ES6
let checkAge = (min) => (age) => age >= min;

let checkAge18 = checkAge(18) let checkAge20 = checkAge(20)
checkAge18(24)
checkAge18(20)

• 柯里化(Currying)
  • 当一个函数有多个参数的时候先传递一部分参数调用它(这部分参数以后永远不变)
  • 然后返回一个新的函数接收剩余的参数，返回结果

Lodash中的柯里化函数

• _curry(func)
  • 功能:创建一个函数，该函数接收一个或多个func的参数，如果func所需要的参数都被提供则执行func并返回执行的结果。否则会继续返回该函数并等待接收剩余的参数。
  • 参数：需要柯里化的函数

// lodash 中的 curry 基本使用
const _ = require("lodash");

function getSum(a, b, c) {
  return a + b + c;
}

const curried = _.curry(getSum);

console.log(curried(1)(2)(3));
console.log(curried(1, 2)(3));
console.log(curried(1)(2, 3));

// 柯里化案例
// ''.match(/\s+/g)
// ''.match(/\d+/g)

const _ = require("lodash");

//实现字符串是否匹配正则
let match = _.curry((reg, str) => {
  return str.match(reg);
});

const haveSpace = match(/\s+/g);
const haveNumber = match(/\d+/g);

//过滤数组  返回匹配的数组

let filter = _.curry(function (fn, array) {
  return array.filter(fn);
});

let findSpace = filter(haveSpace);
let findNumber = filter(haveNumber);

console.log(filter(haveSpace, ["John Connor", "John_Donne"]));
console.log(filter(haveNumber, ["John Connor", "John_Donne"]));

console.log(findSpace(["John Connor", "John_Donne"]));
console.log(findNumber(["John Connor", "John_Donne"]));

// 模拟实现 lodash 中的 curry 方法

function getSum(a, b, c) {
  return a + b + c;
}

const curried = curry(getSum);

console.log(curried(1, 2, 3));
console.log(curried(1)(2, 3));
console.log(curried(1, 2)(3));

function curry(func) {
  return function curriedFn(...args) {
    if (args.length < func.length) {
      return function () {
        return curriedFn(...args.concat(Array.from(arguments)));
      };
    }
    return func(...args);
  };
}

总结

• 柯里化可以让我们给一个函数传递较少的参数得到一个已经记住了某些固定参数的新函数
• 这是一种对函数参数的"缓存"
• 让函数变的更灵活，让函数的粒度更小
• 可以把多元函数转换成一元函数，可以组合使用函数产生强大的功能

函数组合

• 纯函数和柯里化很容易写出洋葱代码h(g(f(x)))
  • 获取数组的最后一个元素在转换成大写字母 _.toUpper(_.first(_.reverse(array)));
• 函数组合可以让我们把细粒度的函数重新组合生成一个新的函数

管道

下面这张图表示程序中使用函数处理数据的过程，给fn函数输入参数a，返回结果b，可以想想a数据通过一个管道得到了b数据。

当fn函数比较复杂的时候，我们可以把函数fn拆分成多个小函数，此时多个中间运算过程产生的m和n。
下面这张图可以想象成把fn这个管道拆分成了3个管道f1，f2，f3，数据a通过管道f3得到结果m，m再通过管道f2得到结果n，n通过管道f1得到最终结果b

fn=compose(f1,f2,f3) 
b=fn(a)

函数组合

• 函数组合(compose):如果一个函数经过多个函数处理才能得到最终值，这个时候可以把中间过程的函数合并成一个函数
  • 函数就像是数据的管道，函数组合就是把这些管道连接起来，让数据穿过多个管道形成最终结果
  • 函数组合默认是从右到左执行

//函数组合演示
function compose(f, g) {
  return function (value) {
    return f(g(value));
  };
}

function reverse(array) {
  return array.reverse();
}

function first(array) {
  return array[0];
}

let last = compose(first, reverse);
console.log(last(array));

• lodash中的组合函数
• lodash 中组合函数flow()或者flowRight()，他们都可以组合多个函数
• flow()是从左到右运行
• **flowRight()**从右到左运行，但使用的更多一些

// lodash 中的函数组合的方法 _.flowRight()
const _ = require("lodash");

const reverse = (s) => s.reverse();

const first = (arr) => arr[0];

const toUpper = (s) => s.toUpperCase();

const last = _.flowRight(toUpper, first, reverse);

console.log(last(["one", "two", "three"]));

• 模拟实现lodash 的flowRight 方法

// 模拟 lodash 中的 flowRight

const reverse = (arr) => arr.reverse();
const first = (arr) => arr[0];
const toUpper = (s) => s.toUpperCase();

function flowRight(...args) {
  return function (value) {
    return args.reverse().reduce((value, fn) => {
      return fn(value);
    }, value);
  };
}

const f = flowRight(toUpper,first, reverse);
console.log(f(["one", "two", "three"]));

• 函数组合要满足结合律(associatvity)
  • 我们既可以把g和h组合，还可以把h和g组合，结果都是一样的

// 结合律(associativity)
let f = compose(f, g, h)
let associative = compose(compose(f, g), h) == compose(f, compose(g, h)) // true

• 所以代码还可以像下面这样

// 函数组合要满足结合律
const _ = require('lodash')

// const f = _.flowRight(_.toUpper, _.first, _.reverse)
// const f = _.flowRight(_.flowRight(_.toUpper, _.first), _.reverse)
const f = _.flowRight(_.toUpper, _.flowRight(_.first, _.reverse))


console.log(f(['one', 'two', 'three']))

调试

• 如何调试组合函数

// 函数组合 调试
// NEVER SAY DIE  --> never-say-die
// trace
const _ = require("lodash");

const trace = _.curry(function (tag, v) {
  console.log(tag + v);
  return v;
});

// 思路:字符串分割数组  循环转换数组中元素小写   join-

// _.split()
const split = _.curry((sep, str) => _.split(str, sep));

// _.toLower
const map = _.curry((fn, array) => _.map(array, fn));

// _.join
const join = _.curry((seq, arr) => _.join(arr, seq));

let f = _.flowRight(join("-"), trace("map之后"), map(_.toLower), trace("split之后 "), split(" "));
console.log(f("NEVER SAY DIE"));

• loadsh/fp
  • 因为lodash中的方法并不直接是柯里化后的函数，需要手动进行柯里化，lodash提供了fp模块现成的柯里化后的函数
  • lodash的fp模块提供了使用的对函数式编程友好的方法
  • 提供了不可变auto-curried iteratee-fist data-last(函数优先，数据之后) 的方法

// lodash 模块
const _ = require('lodash')
_.map(['a', 'b', 'c'], _.toUpper)
// => ['A', 'B', 'C']
_.map(['a', 'b', 'c'])
// => ['a', 'b', 'c']
_.split('Hello World', ' ') // lodash/fp 模块
const fp = require('lodash/fp') fp.map(fp.toUpper, ['a', 'b', 'c'])
fp.map(fp.toUpper)(['a', 'b', 'c'])
fp.split(' ', 'Hello World') fp.split(' ')('Hello World')

// lodash 的 fp 模块
// NEVER SAY DIE  --> never-say-die

// 因为lodash中的方法并不直接是柯里化后的函数，需要手动进行柯里化，lodash提供了fp模块现成的柯里化后的函数
const fp = require("lodash/fp");

const f = fp.flowRight(fp.join("-"), fp.map(fp.toLower), fp.split(" "));
console.log(f('NEVER SAY DIE'))

Point Free

Point Free:我们把数据处理的过程定义成与数据无关的合成运算，不需要用到代表数据的那个参数，只要把简单的运算步骤合成到一起，在使用这种模式之前我们需要定义一些基本运算函数.

• 不需要指明处理的数据
• 只需要合成运算过程
• 需要定义一些辅助的基本运算函数

const f = fp.flowRight(fp.join("-"), fp.map(fp.toLower), fp.split(" "));

案例演示

//非pointfree模式
// World => hello_world

function f(word) {
  return word.replace(/\s+/g, "_").toLowerCase();
}

// point free 模式
const fp = require("lodash/fp");

const f = fp.flowRight(fp.toLower, fp.replace(/\s+/g, "_"));

console.log(f("Hello     World"));

// 把一个字符串中的首字母提取并转换成大写, 使用. 作为分隔符
// world wild web ==> W. W. W
const fp = require('lodash/fp')

// 思路 分割数组 循环取第一个 转大写 
// const firstLetterToUpper=fp.flowRight(fp.join('.'),fp.map(fp.toUpper),fp.map(fp.first),fp.split(' '))

//上边代码中出现两次map 我们可以进行优化
const firstLetterToUpper=fp.flowRight(fp.join('.'),fp.map(fp.flowRight(fp.toUpper,fp.first)),fp.split(' '))

console.log(firstLetterToUpper("world wild web"))

函子（Functor）

为什么学习函子

到目前为止我们已经学习了函数式编程的一些基础，但是我们还没有演示如何在函数式编程中把副作用控制在可控范围内，异常处理，异步操作等。

函子是什么

• 容器:包含值和值变形关系(这个变形关系就是函数)
• 函子:是一个特殊的容器，通过一个普通的对象来实现，该对象具有map方法，map方法可以运行一个函数对值进行处理(变形关系)

Functor 函子

// Functor 函子
class Container {
  constructor(value) {
    this.value = value;
  }

  map(fn) {
    return new Container(fn(this.value));
  }
}

let c = new Container(5).map((x) => x + 1).map((x) => x + 1);
console.log(c);

由于使用new 关键字有点偏向面向对象 我们可以进行改造它让人更接近函数

class Container {
  static of(value) {
    return new Container(value);
  }

  constructor(value) {
    this.value = value;
  }

  map(fn) {
    return new Container(fn(this.value));
  }
}

let c = Container.of(5)
  .map((x) => x + 1)
  .map((x) => x + 1);
console.log(c);

• 总结
  • 函数式编程的运算不直接操作值，而是由函子完成
  • 函子就是一个实现了map契约的对象
  • 我们可以把函子想象成一个盒子，这个盒子里封装了一个值
  • 想要处理盒子中的值，我们需要给盒子的map方法传递一个处理值的函数（纯函数）,由这个函数来对值进行处理
  • 最终map方法返回一个包含新值的盒子（函子）
• 在Functor中如果我们传入null或者undefined

// 值如果不小心传入了空值(副作用) Container.of(null)
Container.of(null)
		.map(x => x.toUpperCase())
// TypeError: Cannot read property 'toUpperCase' of null

 Container.of(undefined)
 		.map(x => x.toUpperCase())
// TypeError: Cannot read property 'toUpperCase' of undefined

为解决此问题我们介绍下一个函子：MayBe 函子

MayBe函子

• 我们在编程过程中可能会遇到很多错误，需要对这些错误做相应的处理
• MayBe函子的作用就是可以对外部的空值情况做处理 （控制副作用在允许的范围）

// MayBe 函子
class MayBe {
  static of(value) {
    return new MayBe(value);
  }

  constructor(value) {
    this.value = value;
  }

  //如果对空值变形的化直接返回值为null的函子
  map(fn) {
    return this.isNothing() ? MayBe.of(null) : new MayBe(fn(this.value));
  }

  isNothing() {
    return this.value === null || this.value === undefined;
  }
}

let c = MayBe.of(1)
  .map((x) => x + 1)
// => MayBe { _value: 2 }
  .map((x) => (x = null))
// => MayBe { _value: null }
  .map((x) => x.toUpperCase());
// => MayBe { _value: null }

在MayBe函子中,我们很难确认是哪一步产生空值问题,如下例:

MayBe.of(1)
  .map((x) => x + 1)
  .map((x) => (x = null))
  .map((x) => x.toUpperCase());
.map(x => x.split(' '))
// => MayBe { _value: null }

为解决此问题我们介绍下一个函子：Either 函子

Either 函子

• Either 两者中的任何一个，类似与if...else...的处理
• 异常会让函数变的不纯，Either函子可以用来做异常处理

// Either 函子
class Left {
  static of (value) {
    return new Left(value)
  }

  constructor (value) {
    this._value = value
  }

  map (fn) {
    return this
  }
}

class Right {
  static of (value) {
    return new Right(value)
  }

  constructor (value) {
    this._value = value
  }

  map (fn) {
    return Right.of(fn(this._value))
  }
}

// let r1 = Right.of(12).map(x => x + 2)
// let r2 = Left.of(12).map(x => x + 2)

// console.log(r1)
// console.log(r2)


function parseJSON (str) {
  try {
    return Right.of(JSON.parse(str))
  } catch (e) {
    return Left.of({ error: e.message })
  }
}

// let r = parseJSON('{ name: zs }')
// console.log(r)

let r = parseJSON('{ name: "zs" }')
          .map(x => x.name.toUpperCase())
console.log(r)

优化思考：我们知道开发中难免会有一些不纯的动作，我们可不可以把这些不纯的操作让他延迟执行呢
为解决此问题我们介绍下一个函子：IO 函子

IO函子

• IO函子中的_value是一个函数，这里是把函数作为值来处理
• IO函子可以把不纯的动作存储到_value中，延迟执行这个不纯的操作(惰性执行)，保证当前的操作纯
• 把不纯的操作交给调用者来处理

// IO 函子
const fp = require("lodash/fp");

class IO {
  static of(value) {
    return new IO(function () {
      return value;
    });
  }

  constructor(fn) {
    this.value = fn;
  }

  map(fn) {
     //把当前的value(函数)和传入的fn组合成一个新的函数
    return new IO(fp.flowRight(fn, this.value));
  }
}

const r = IO.of(1).map((x) => x + 2);
console.log(r);
//=>IO { value: [Function] }
console.log(r.value());
//=>3

Task函子

• 异步任务的实现过于复杂，我们使用folktale中的Task来演示
• folktale一个标准的函数式编程库
  • 和lodash ramda不同的是,他没有提供很多功能函数
  • 只提供了一些函数式处理的操作，例如:compose，curry等，一些函子Task，Either，MayBe等

演示folktale中的curry compose

const { compose, curry } = require('folktale/core/lambda')
const { toUpper, first } = require('lodash/fp')
// 第一个参数是传入函数的参数个数
let f = curry(2, function (x, y) {
	console.log(x + y)
})
f(3, 4)
f(3)(4)
// 函数组合
let f = compose(toUpper, first) 
f(['one', 'two'])

// Task 处理异步任务
const fs = require("fs");
const { task } = require("folktale/concurrency/task");
const { split, find } = require("lodash/fp");

function readFile(filername) {
  return task((resolver) => {
    fs.readFile(filername, "utf-8", (err, data) => {
      if (err) resolver.reject(err);
      resolver.resolve(data);
    });
  });
}

// 调用 run 执行
readFile("package.json")
  .map(split("\n"))
  .map(find((x) => x.includes("version")))
  .run()
  .listen({
    onRejected: function (err) {
      console.log(err);
    },
    onResolved: function (data) {
      console.log(data);
    },
  });

Pointed 函子

• pointed函子是实现了of静态方法的函子
• of方法是为了避免使用new来创建对象，更深层的含义是of方法用来吧值放到上下文Context(把值放到容器中,使用map来处理值)

class Container{
	static of(value){
  	return new Container(value)
  }
  ......
}

 Container.of(1)
		.map((x)=>x+1)
  
  

Monad 函子

在使用IO函子的时候，如果我们写出如下代码：

// IO 函子的问题
const fs = require('fs')
const fp = require('lodash/fp')

class IO {
  static of (value) {
    return new IO(function () {
      return value
    })
  }

  constructor (fn) {
    this._value = fn
  }

  map (fn) {
    return new IO(fp.flowRight(fn, this._value))
  }
}

let readFile = function (filename) { 
  return new IO(function () {   //{value:fs.readFileSync(filename, 'utf-8')   }
    return fs.readFileSync(filename, 'utf-8')  
  })
}

let print = function (x) { // x= {value:()=>fs.readFileSync(filename, 'utf-8')  }
  return new IO(function () {  //  {value:{value:fs.readFileSync(filename, 'utf-8')  } }
    console.log(x)
    return x
  })
}

let cat = fp.flowRight(print, readFile)
// IO(IO(x))
let r = cat('package.json')
console.log(r._value()._value())  //两层嵌套所以需要.value().value()