-纯函数和柯里化很容易写出洋葱代码h(g(x()))
-函数组合可以让我们把细粒度的函数重新组合生成一个新的函数
-如果一个函数要经过多个函数处理才能得到最终值，这个时候可以把中间过程的函数合并成一个函数（默认从右到左执行）
-组合函数
-函数调试技巧，在函数之间写个打印日志函数，打印出上一个函数执行完的返回值
const _ = require('lodash');
// const log = v => {
// console.log(v)
// return v
// }
const trace = _.curry((tag,v) => {
console.log(tag,v);
return v;
})
const split = _.curry((sep,str) => _.split(str,sep))
const join = _.curry((sep,array) => _.join(array,sep))
const map = _.curry((fn,array) => _.map(array,fn))
const f = _.flowRight(join('-'),trace('map 之后'),map(_.toLower),trace('split 之后'),split(' '))
console.log(f('NEVER SAY DIE'));
lodash/fp
-提供了使用的对函数式编程友好的方法
-提供了不可变"auto-curried iteratee-first data-last"的方法
const fp = require('lodash/fp');
const f = fp.flowRight(fp.join('-'),fp.map(fp.toLower),fp.split(' '))
console.log(f('NEVER SAY DIE'));
注意点：lodash和fp模块的map方法有区别，例如parseInt函数必须使用fp模块的fp.map(lodash由于进制转换会出问题，当index小于2时 )
Point Free
-不需要致命处理的数据
-只需要合成运算过程
-需要定义一些辅助的基本运算函数
const f = fp.flowRight(fp.join('-'),fp.map(_.toLower),fp.split(" "));
const fp = require('lodash/fp');
const _ = require('lodash');
//把一个字符串中的首字母提取并转换成大写，并以. 作为分隔符
// world wild web ==> W. W. W.
const trace = _.curry((tag,v) =>{
console.log(tag,v);
return v;
})
const firstLetterToUpper = fp.flowRight(fp.join('. '),fp.map(fp.toUpper),trace('map之后'),fp.map(fp.first),trace('split之后'),fp.split(' '))
//改造
const firstLetterToUpper = fp.flowRight(fp.join('. '),fp.map(fp.flowRight(fp.toUpper,fp.first)),fp.split(' '))
console.log(firstLetterToUpper('world wild web'));
Functor（函子）
-why：在函数式编程中如何去控制副作用
-what：
1）容器：包含值和值的变形关系（这个变形关系就是函数）
2）是一个特殊的容器，通过一个普通的对象来实现，该对象具备map方法，map方法可以运行一个函数对值继续逆行处理（变形关系）
// class Container {
// constructor (value) {
// this._value= value;
// }
// map(fn){
// return new Container(fn(this._value))
// }
// }
// let r = new Container(5)
// .map(x => x + 1)
// .map(x => x * x)
// console.log(r);
class Container {
static of (value){
return new Container(value)
}
constructor (value) {
this._value= value;
}
map(fn){
return Container.of(fn(this._value))
}
}
let r = Container.of(5)
.map(x => x + 2)
.map(x => x * x)
console.log(r);
`函子总结：
- 函数式编程的运算不直接操作值，而由函子完成
-函子就是一个实现了map函数的对象
-我们可以把函子想象成一个盒子，这个盒子里封装了一个值
-想要处理盒子中的值，我们需要给盒子的map方法传递一个处理
之的函数（纯函数），有着函数来对值进行处理
-最终map方法返回一个包含新值的盒子（函子）
Maybe函子：解决函子传参为null、undefined，但无法知道哪一处传的的是null
Either函子：两者中的任何一个，类似于id else;异常会让函数变得不纯，Either可以用来做异常处理
IO函子：_value是一个函数，这里是把函数作为值来处理
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 r= IO.of(process).map(p => p.execPath)
console.log(r);
console.log(r._value());
Task异步执行：folktale库
const fs = require('fs')
const {task} = require('folktale/concurrency/task')
const {split ,find} = require('lodash/fp')
function readFile (filename) {
return task(resolver => {
fs.readFile(filename, 'utf-8' ,(err, data) => {
if(err) resolver.reject(err)
resolver.resolve(data);
})
})
}
readFile('package.json')
// .flowRight(find(x => x.includes('version')),split('\n'))
.map(split('\n'))
.map(find(x => x.includes('version')))
.run()
.listen({
onRejected:err =>{
console.log(err);
},
onResolved: value =>{
console.log(value);
}
})
Ponited函子
-实现了of静态方法的函子
-of方法是为了避免使用new来创建对象，更深层的含义是of方法用来把值放到上下文Context（把值放到容器中，使用map来处理）
Monad函子
-是可以变扁的pointed函子
-一个函子如果具有join和of两个方法并遵守一些定律就是一个Monad
