jcouyang / clojure-flavored-javascript Goto Github PK

当时的async function可能会放到ES7/ECMAScript 2016的规范中，但是发布的ES7只把

• exponentiation (**) operator
• Array.prototype.includes
  加入了标准

async function 在 ECMAScript 2017 草稿中

所以应该改成 使用ECMAScript 2017中的async函数

很高兴阅读您写的《前端函数式工程指南》。

我是一名从js入手开始接触fp的。

书非常赞，只是Clojure代码有点多了，集合map惰性求值的实现也是Clojure的代码，真心表示看不懂啊~

另外，国内有比较优质的fp论坛么？求推荐~ ：）

Monad 就是自函子范畴上的一个幺半群

但是举了这么些例子，怎么一点也看不出来 monad 与 monoid 的关系呢？倒是很明确 Monad 是个比较特殊的 Functor。

我们需要进一步的抽象才能解释这句话，首先，回顾前面 Monoid 的知识，比如那个 Sum 的 Monoid。

Sum.of(1).append(Sum.of(2)).append(Sum.of(0)) // => Sum.of(3)
这个 Monoid 很明显，它的二元操作是 append ，幺元是 Sum.of(0) ，范畴是 Sum 。 为了更明显我们可以降一个维度（范畴），把 Sum.of(1) 降成 1

(1 + 2 + 0)

但是 Monad 哪来的二元操作啊？一个 flat ，一个 fmap ，都是一元操作啊？

如果我们降一个维度， 到只有数字的维度上，

(1.2).3 = 1.(2.3)
二元操作 + 可以使得这个等式成立。 而幺元 0，又可以使得

0.2 = 2 = 2.0
在二元操作 + 上成立。

所以我们得到的 monoid 为 (数字集合，二元操作 + ，幺元 0)。

同样的，上升到函子的范畴上[fn:3]，注意是自函子 范畴 上的幺半群，就代表的是函子范畴而不是函子实例是幺半群，所以以 Maybe 为例，就需要符合：

(Maybe.Maybe).Maybe = Maybe.(Maybe.Maybe)
能找到一个二元操作使得上式成立？而不是：

(Just.of(1).append(Just.of(2))).append(Just.of(3)) = Just.of(1).append(Just.of(2).append(Just.of(3)))
这个二元操作就是我们刚实现的 Just Monad 的 flat。我们很容易可以把 flat 代入到式子变换成以下格式，

flat(flat(Maybe.Maybe).Maybe) = flat(Maybe.flat(Maybe.Maybe))
其中的 . 是两个类型组合在一起。如同函数的组合是 f.g x= f(g(x)) ，在函子范畴上的组合就是 Maybe 类型的值，在一个 Maybe 类型的容器中：

Maybe.Maybe = Maybe[Maybe]
再代入一遍，就非常清晰结合律的等式是成立的了：

flat(flat(Maybe[Maybe])[Maybe]) = flat(Maybe[flat(Maybe[Maybe])])
大声念出来应该就是： flat 一个容器为 flat(Maybe[Maybe]) 类型，其值类型为 Maybe 得到的类型等于， flat 一个 Maybe 类型，其内值类型为 flat(Maybe[Maybe]) 所得到的类型。

听起来比较像绕口令，仔细看看等式就能理解了。另外一个 monoid 的法则是需要有一个幺元，满足：

?.Maybe = Maybe = Maybe.?
我们很容易能猜到把 Maybe 代入就是我的解，因此任何 Maybe 类型都是幺元：

flat(M[M]) = M = flat(M[M])
所以，flat 就像 moniod 里的 append 一样，但是它并不连接值或是容器，而是连接函子组合，让函子在不同范畴间变换

到这里，我可以告诉你现在的 Just 就是 Monad 了， 它是 Functor 的加强，把 fmap 的结果铺平（flat）。同时又是 Applicative 的加强， Applicative 让我们可以用一般函数作用到在容器中的值，而 Monad 让我们可以把一个容器中的值传入一个接收值的函数中，并返回同样的容器

上面的内容前半段能看懂，但从
###同样的，上升到函子的范畴上[fn:3]，注意是自函子 范畴 上的幺半群，就代表的是函子范畴而不是函子实例是幺半群，所以以 Maybe 为例，就需要符合：

这段开始就很费解了。还请作者，对上面的文字推理再进行仔细思考，能否有好的表达?
我是几个月后，再来阅读时，还是堵住了。

另外，我觉得不是flat而是flatmap才是monad幺半群上的二元运算符?
拜托解疑

作者您寫的都是在 MAC 上的指令
brew install emacs --with-cocoa brew install cask cask install cask exec emacs --batch -l emacs.el -f org-publish-all
請問 windows 10 該如何 run 本書的範例?
<前端工程師的唯一選擇：JavaScript真功夫粹鍊>

一、 有本书，是scala 函数编程，里面有个例子：
有两个玩家p1和p2, 写一个函数，把p1,p2中得分高的打印出来。如下：
case class Player(name:String,score:Int) //这是一个Player的类，有两个属性，玩家姓名和得分

   def contest(p1:Player,p2:Player):Unit =     
		if(p1.score > p2.score)
			println("${p1.name} is the winner!")           //玩家1是赢家
			
			else if (p2.score >p1.score) 
			println("$(p2.name} is the winner!")           //玩家2是赢家
			
		else 
			println("It'a draw")                           //平局
			
上面的代码中，println函数是有副作用的，因为是要输出到IO里。

所以导致contest 这个方法是不纯的，有副作用，不容易测试。于是认为，需要把这个函数contest 进行修改，抽象出不纯的，变成一个由若干个纯函数组合模式。可以采用monad单子来抽象。
改进后的代码如下：

二、

case class Player(name:String,score:Int)

1.//trait类似于接口，只定义了一个方法，返回为空的意思。 描述有一个IO动作，至于这个动作什么时候执行，如何执行，则由外部来完成。
trait IO {def run:Unit}

2.纯函数，只返回赢家这个对象
def winner(p1:Player,p2:Player):Option[Player]= //Option有点类似于haskell中的Maybe
if(p1.score >p2.score) Some(p1)
else if (p1.score<p2.score ) Some(p2)
else None //平局

3. //生成赢家所要打印出来的信息串
   def winnerMsg(p:Option[player]) :Unit= p map {
   case Player(name,_) => "$name is the winner" //模式匹配，生成赢家的要打印的信息
   } getOrElse "it's a draw //不是直接调用println 输出到屏幕

4. //描述一个需要进行IO动作，具体的打印，则由系统的解释程序来完成
   def PrintLine(msg:String) :IO=
   new IO {def run =println(msg)}

5.最终的组合函数
def contest(p1:Player,p2:Player):IO=
PrintLine(winnerMsg(winner(p1,p2)))

于是整个contest 函数都是纯的，无副作用的，而且是可以测试的。
但是这里没有看到与单子的影子呀？
单子不是用来剥离副作用的吗？怎么个剥离呢？
你怎么理解？

在 Destructure 一节中，middleAndButton 中的 Button 应该是 Bottom 的笔误吧...

var orea = ["top","middle","bottom"];
var top = orea.shift(), middleAndButton = orea; // <1>
var wetMiddleAndButton = dipMilk(middleAndButton); // <2>
var button = lip(wetMiddleAndButton); // <3>
eat([top,button]); // <4>

真是本好书
但第P138页即---第7.2.5节 monad就是一个自函子范畴上的幺半群，这部分内容令我极度困顿。
图7-7中，右下角是Just 1呢，还是1(不在盒子里)
一个monid有三要素。集合，二元操作，幺元(必须是集合的一个成员或元素)，
一个monid(集合例如int，二元操作如+，幺元0)

请问，针对monad(比如Maybe单子)，来填一下
它的集合是什么，最好能列出三个以上集合元素，列出它的二元操作，列出它的幺元，幺元还必须是集合元素的一个成员

flat(flat(Maybe.Maybe).Maybe)=flat(Maybe.flat(Maybe.Maybe))
这个公式与(1.2).3 = 1.(2.3)相比，也很迷糊，如何对应?前者即出现Maybe,又出现flat，而且"."符号才是二元操作?

flat明明是一元操作呀?
可能文子解答不容易，可否请您简单影音一下，一边在纸上写，一边语音解说?
你对单子与幺半群的对比解释，可能最易让读者方便理解

顺祝节日快乐