函数式编程

发表于

柯里化默认只接受一个参数

1
2
3
4
5
6
7
8
9
10
function add(x,y) {
  return x+y;
}
add(1,2) //3
function addX(y) {
  return (x)=>x+y;
}
addX(1)(2) //3

一般约定，函子的标志就是容器具有map方法。该方法将容器里面的每一个值，映射到另一个容器

函数式编程一般约定，函子有一个of方法，用来生成新的容器

1
2
3
4
5
6
7
class  Functor {
  constructor(){}
  map(f){}
}
Functor.of =(val)=> {
    return new Functor(val);
}

Maybe 函子 空值检查

1
2
3
4
5
6
7
8
class Maybe extends Functor{
    map(f){
        return this.val?Maybe.of(f(this.val)):Maybe.of(null); 
    }
}
Maybe.of =(val)=> {
    return new Maybe(val);
}

Either 函子

条件运算if…else

1
2
3
4
5
6
7
8
9
10
11
12
class Either extends Functor{
     constructor(left,right){
         this.left =left; //else 使用的
         this.right =right; //if使用的
     }
     map(f){
             return this.right?Either.of(f(this.right),this.left):Either.of(f(this.left),this.right); 
         }
}
Either.of =(left,right)=> {
    return new Either(left,right);
}

ap 函子

1
2
3
4
5
6
7
8
class Ap extends Functor{
    ap(F){
        return Ap.of(this.val(F.val)); 
    }
}
Ap.of =(val)=> {
    return new Ap(val);
}

Monad 函子

Monad 函子的作用是，总是返回一个单层的函子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Monad extends Functor{
     constructor(){
    
     }
     join(){
         return this.val
     }
     chain(f){
             return this.map(f).join(); 
         }
}
Monad.of =()=> {
    return new Monad();
}

IO 操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
var fs = require('fs');
var readFile = function(filename) {
  return new IO(function() {
    return fs.readFileSync(filename, 'utf-8');
  });
};
var print = function(x) {
  return new IO(function() {
    console.log(x);
    return x;
  });
}
var tail = function(x) {
  return new IO(function() {
    return x[x.length - 1];
  });
}
readFile('./user.txt')
.chain(tail)
.chain(print)