[Functional Programming] Function modelling -- 3. Reader Monad
Reader Monad
Continue with previous post, here we have some helper functions:
const toUpper = s => s.toUpperCase();
const exclaim = s => `${s}!`;
And here is current code we have:
const Fn = run => ({ run, map: f => Fn(x => f(run(x))), chain: f => Fn(x => console.log("run(x)", run(x), f(run(x))) || f(run(x)).run(x)), concat(otherFn) { return Fn(x => run(x).concat(otherFn.run(x))); } });
Monad
Monad is all about nesting, for example, we have 'Fn' instead a 'Fn':
Fn(x => Fn(y => ...))
Monad job is to flatten it.
To implement a Monad interface, we need to implement 'chain' function:
const Fn = run => ({ run, concat(otherFn) { return Fn(x => run(x).concat(otherFn.run(x))) }, map(f) { return Fn(f => f(run(x))) }, chain(otherM) { } })
'chain' function take other Monad as arguement.
The implementation of 'chain' is pretty similar to 'map', the difference in meaning between 'map' & 'chain' is that we want to apply two 'Fn(method)' on the same value.
const Fn = run => ({ run, map: f => Fn( x => f(run(x)) ), chain: f => Fn( x => f(run(x)) .run(x) ), concat(otherFn) { return Fn(x => run(x).concat(otherFn.run(x))); } });
Taking an example:
Fn(toUpper)
.chain(upper => Fn(y => exclaim(upper)))
.run("hi"); // HI!
'run(x)' return value, in the example is the result of 'toUpper' which is 'HI'.
Then 'f(run(x))' return 'Fn' Monad:
Fn (
{
run: [Function],
map: [Function: map],
chain: [Function: chain],
concat: [Function: concat]
})
Last when we call 'f(run(x)).run(x)', we will get 'HI!', which is running 'exclaim' function over 'HI'.
Also .run function unwrap Fn, everytimes we call .run(), we will get its value, instead of Fn().
For 'chain' method:
chain(f) { // f() return another Fn // when you call .run(), it unwrapper Fn() return Fn((x) => f(run(x)).run(x)); },
it call two times 'run()' but only add one 'Fn', which means it unwrap one nested 'Fn'.
Fn.of()
We have seen the example: 'Fn(upper)', we don't get used to that... we somehow lift a function 'upper' into a Functor, then data come last when we run ".run('hi')".
We can change that, by passing the data first into 'Fn.of(data)', then we can doing mapping, chainning.
But there is another interesting thing, in the previous example, data: 'hi' is the only input. If now we lift data into Fn.of('hi'), then we run ".run(another_data)", now we have two data input.
Let's see 'Fn.of()' function first:
const Fn = run => ({ run, map: f => Fn(x => f(run(x))), chain: f => Fn(x => console.log("run(x)", run(x), f(run(x))) || f(run(x)).run(x)), // run two functions and concat the result concat(otherM) { return Fn(x => run(x).concat(otherM.run(x))); } }); Fn.of = x => Fn(() => x);
Example:
Fn.of("hi") .map(toUpper) .chain(upper => Fn(x => [upper, exclaim(x)])) .run("hello"); // [ 'HI', 'hello!' ]
As you can see, now we have two values. We have applied 'toUpper' transform on 'hi', and apply 'exclaim' function on "hello".
Example 2:
Fn.of("hi") .map(toUpper) .chain(upper => Fn(x => [upper, exclaim(x)])) // ["HI", 'hello!'] .chain(ary => Fn(x => [exclaim(ary[0]), x])) // ["HI!", "hello"] .run("hello");
We can keep chaining based on previous chain's result. But this time, we keep 'x' as it is. So now, this is interesting thing, the data we pass with '.run('hello')', always keep the same value every time we try to read it.
You can use it can enviormenet configuration object, anytime you need to read env variable you can get it from 'chain'. This partten is called: "Read Monda".
Think about Angular, for example, it is similar to dependency injection. For React, you can use it as Provider / Context.
Fn.ask()
Let's define a convenient function call 'ask'. So instead of using "Fn()" constructor
.chain(upper => Fn(x => [upper, exclaim(x)])
We want to do:
const Fn = run => ({ run, map: f => Fn(x => f(run(x))), chain: f => Fn(x => console.log("run(x)", run(x), f(run(x))) || f(run(x)).run(x)), // run two functions and concat the result concat(otherFn) { return Fn(x => run(x).concat(otherFn.run(x))); } }); Fn.of = x => Fn(() => x); Fn.ask = Fn(x => x);
Then we can refactor the previous example:
Fn.of("hi") .map(toUpper) .chain(upper => Fn.ask.map(x => [upper, exclaim(x)])) // ["HI", 'hello!'] .chain(ary => Fn.ask.map(x => [exclaim(ary[0]), x])) // ["HI!", "hello"] .run("hello");
相关文章
- Golang框架Gin入门实战--(6)Gin路由文件抽离
- 正则表达式--Perl正则表达式
- vppinfra--bitmap学习
- Polardb 核心存储 polarfs 是怎么进行数据存储的之核心构造(4)--译
- 新冠疫情预测模型--逻辑斯蒂回归拟合、SEIR模型
- React源码解读--更新的创建
- PaddleHub--飞桨预训练模型应用工具{风格迁移模型、词法分析情感分析、Fine-tune API微调}【一】
- kafka 结合springboot实战--第一节
- Photoshop CC2019软件安装图文教程--所有PS版本都有!
- React--8: 组件的三大核心属性2:props
- 深入浅出MySQL复制--MySQL的"核心科技"
- 干货分享--Pr一键添加字幕 (PR怎么安装)
- 【Linux】Linux 项目自动化构建工具 -- make/makefile 的使用
- 搜索引擎核心技术(PHP编程思路)--[1]