一个简单的函子
class Container { constructor ( value ) { this . _value = value} map ( fn ) { return new Container ( fn ( this . _value) ) }
}
let r = new Container ( 3 ) . map ( v => v + 1 ) . map ( v => v * v)
console. log ( r)
Maybe 函子
class MayBe { static of ( value) { return new MayBe ( value) } constructor ( value ) { this . _value = value} map ( fn ) { return this . isNull ( ) ? MayBe. of ( null ) : MayBe. of ( fn ( this . _value) ) } isNull ( ) { return this . _value === null || this . _value === undefined }
}
let s1 = "hello world"
let s2 = null let r1 = MayBe. of ( s1) . map ( v => v. toUpperCase ( ) )
console. log ( r1) let r2 = MayBe. of ( s2) . map ( v => v. toUpperCase ( ) )
console. log ( r2)
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 ( v => v + 1 )
let r2 = Left. of ( 12 ) . map ( v => v + 1 ) console. log ( r1)
console. log ( r2)
IO 函子
const fp = require ( "lodash/fp" )
class IO { static of ( value) { return new IO ( ( ) => 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 ( ) )