H*y
2 楼
外出几天。因为一些原因,小猫自己留在家里不方便。小猫极不喜欢关笼子,所以尽量
不送去宠物医院寄存。
6个月大,爱打滚。
不挑食,不挑猫沙。
可以提供所需物品,也可付些钱。
谢谢 :-)
如果有兴趣,请联系 832 566 0185 李
不送去宠物医院寄存。
6个月大,爱打滚。
不挑食,不挑猫沙。
可以提供所需物品,也可付些钱。
谢谢 :-)
如果有兴趣,请联系 832 566 0185 李
c*o
3 楼
zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
我想可能是我没讲清楚,现在解释一下。
对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
debug)都是派生的而已。
我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
颦而已。
我想可能是我没讲清楚,现在解释一下。
对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
debug)都是派生的而已。
我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
颦而已。
j*n
4 楼
'scumbag'这家公司其实什么都好,就是有个毛病,喜欢在不入流的媒体上打绿卡广告
。交投名状前建议搞清楚是真招人还是假招人,不然人家还要想方设法disqualify你,
你简历如果实在太强,那没办法还要先cancel这个广告,换个地方再打一次,人家绿卡
申请人还要咒你一万遍啊一万遍。
。交投名状前建议搞清楚是真招人还是假招人,不然人家还要想方设法disqualify你,
你简历如果实在太强,那没办法还要先cancel这个广告,换个地方再打一次,人家绿卡
申请人还要咒你一万遍啊一万遍。
p*2
5 楼
Try monad是很不错的,我们大量使用。
l*n
7 楼
没错。
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
p*j
8 楼
我怎么听说他家不办绿卡的呢?奇怪
b*e
9 楼
嗯,就是说程序的semantics是composable的。这对test automation也有帮助。
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
d*r
11 楼
能达到这种效果确实很牛, FP菜鸟的疑问是:
会不会编写时候造成各种过度解耦和不自然的模式,
导致: 1.效率下降(CPU, memory消耗太多); 2.模型理解很不自然.
请 FP 大牛说说, 上面2个是不是 FP 很难解决的问题?
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
会不会编写时候造成各种过度解耦和不自然的模式,
导致: 1.效率下降(CPU, memory消耗太多); 2.模型理解很不自然.
请 FP 大牛说说, 上面2个是不是 FP 很难解决的问题?
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
m*u
13 楼
如果“好的fp追求短小精干的函数和它们的组合", 那完了。。。
现在的框架思想(大一统思想)满天飞,城头变幻大王旗,一天一个新框架的现实条件
下,“追求短小精干的函数和它们的组合”不符合码农的操性。
我们准备开倒车,回到API上,废掉框架,“追求短小精干的函数和它们的组合”,结
果遇到了很多码农的阻力(尽管他们天天被框架操的死去活来)。码农是记吃不记打的
(喜欢快糙猛的快感),“好的fp追求短小精干的函数和它们的组合",码农们表示走不
通啊。。。
现在的框架思想(大一统思想)满天飞,城头变幻大王旗,一天一个新框架的现实条件
下,“追求短小精干的函数和它们的组合”不符合码农的操性。
我们准备开倒车,回到API上,废掉框架,“追求短小精干的函数和它们的组合”,结
果遇到了很多码农的阻力(尽管他们天天被框架操的死去活来)。码农是记吃不记打的
(喜欢快糙猛的快感),“好的fp追求短小精干的函数和它们的组合",码农们表示走不
通啊。。。
c*o
15 楼
这个不是大牛的回复。
1. 是的“效率下降”是有的,但是并不都会下降,有时候会更好。一般来说,
immutability 会有浪费,lazy loading 会有节约。recursive和loop其实是一样的。
这也是为什么,在云计算里,在硬件越来越便宜的情况下,软件越来越复杂的现在,fp
会开始被使用。
2. 这个倒没啥,习惯了其实就是另一套,没啥难不难的,oo/imprative 的模型理解很
自然么?学语言的时候都过一遍了,你还记得当时的理解痛苦么?
【在 d*******r 的大作中提到】
: 能达到这种效果确实很牛, FP菜鸟的疑问是:
: 会不会编写时候造成各种过度解耦和不自然的模式,
: 导致: 1.效率下降(CPU, memory消耗太多); 2.模型理解很不自然.
: 请 FP 大牛说说, 上面2个是不是 FP 很难解决的问题?
1. 是的“效率下降”是有的,但是并不都会下降,有时候会更好。一般来说,
immutability 会有浪费,lazy loading 会有节约。recursive和loop其实是一样的。
这也是为什么,在云计算里,在硬件越来越便宜的情况下,软件越来越复杂的现在,fp
会开始被使用。
2. 这个倒没啥,习惯了其实就是另一套,没啥难不难的,oo/imprative 的模型理解很
自然么?学语言的时候都过一遍了,你还记得当时的理解痛苦么?
【在 d*******r 的大作中提到】
: 能达到这种效果确实很牛, FP菜鸟的疑问是:
: 会不会编写时候造成各种过度解耦和不自然的模式,
: 导致: 1.效率下降(CPU, memory消耗太多); 2.模型理解很不自然.
: 请 FP 大牛说说, 上面2个是不是 FP 很难解决的问题?
c*o
17 楼
说实话,就算不编FP, 理解这些也是很有意义的。
z*e
18 楼
其实你应该说monad的
为啥避开了呢?
那个adt就是一个典型的monad
为啥避开了呢?
那个adt就是一个典型的monad
z*e
19 楼
理解这个还是要从monad入手
monad其实就是一种aop
真正的aop要难过一般的monad
理解了aop,monad也不太难
monad其实就是一种aop
真正的aop要难过一般的monad
理解了aop,monad也不太难
z*e
20 楼
你的目的换个说法
就是你写的func必需能够完全按照你的预想的去执行
否则就是错
所以如果有程序猿未考虑到的exception抛出
那就是程序猿的错,而非框架的问题
就是你写的func必需能够完全按照你的预想的去执行
否则就是错
所以如果有程序猿未考虑到的exception抛出
那就是程序猿的错,而非框架的问题
c*o
23 楼
FP不是就只有monad的,很多时候用applicative functor, 甚至Traversable, 这个其
实都不重要,重要的是思想和目的。
”充分发挥机能“也不是fp的目的,其实虽然资源利用率高,但是我的经验是单位工作
,资源消耗的多了。
最大的目的是清晰,明了,可理解的的编程。显然很多时候大家都光看表面的东西了。
实都不重要,重要的是思想和目的。
”充分发挥机能“也不是fp的目的,其实虽然资源利用率高,但是我的经验是单位工作
,资源消耗的多了。
最大的目的是清晰,明了,可理解的的编程。显然很多时候大家都光看表面的东西了。
z*e
25 楼
顺便问你一个问题
monad是不是就是一个aspect which is monadic type
以及针对这部分的操作,也就是bind
所以monad不仅仅是一个数据结构,同时也是一个computation unit?
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
monad是不是就是一个aspect which is monadic type
以及针对这部分的操作,也就是bind
所以monad不仅仅是一个数据结构,同时也是一个computation unit?
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
z*e
26 楼
就是monad其实就是一个很小的自成体系的一个module
只不过这个module非常小,甚至小于函数的scope
所以换个名字,叫monad,一般module包含有多个函数以及object
只不过这个module非常小,甚至小于函数的scope
所以换个名字,叫monad,一般module包含有多个函数以及object
c*o
27 楼
Warning: boring stuff next.太长了,不知道有人看没有。
monad不是一个数据结构,它是一个“类型“的一个“类型”的一个“类型”。(
higher order type)
举例
type:
String
first order type:
List[X], can be List[String], List[Int], List[Double]
higher order type :
Monad, Can be List[X], Try[X], Option[X]
严格来说,Monad是一个高阶的类型,一个“类型“的一个“类型”的一个“类型”
他的定义就是一个类型F,如果能在之上定义
def unit[A](a: => A): F[A]
def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B]
这个类型就是一个monad.
比如List
def unit[A](a: => A): List[A]
给一个x,我能用unit做一个一个元素的List: (x)
scala> List("a")
res0: List[String] = List(a)
这儿的List constructor 就是unit
def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B]
scala> val la = List("test1ntest2n", "test3ntest4n")
la: List[String] =
List("test1
test2
", "test3
test4
")
scala> def f: String => List[String] = (x: String) => x.split("n").toList
f: String => List[String]
scala> la.flatMap(f)
res1: List[String] = List(test1, test2, test3, test4)
monad的定义就是有些类型有共同点:
都可以在这些类型之上定义
def unit[A](a: => A): F[A]
def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B]
他们就是monad
应为抽象了共同点,所以才强大。
正式的定义还要加上条件约束:
// Monad Law
// left identity: f(a) == flatmap(unit(a), f)
// right identity: a == flatMap(a, x => unit(x))
// associativity: flatMap(a, x => flatMap(f(x), g)) == flatMap(flatMap(a, f)
, g)
所以数据结构/computation unit很难归纳它。
List是monad其实是说List是monadic type
【在 z****e 的大作中提到】
: 顺便问你一个问题
: monad是不是就是一个aspect which is monadic type
: 以及针对这部分的操作,也就是bind
: 所以monad不仅仅是一个数据结构,同时也是一个computation unit?
monad不是一个数据结构,它是一个“类型“的一个“类型”的一个“类型”。(
higher order type)
举例
type:
String
first order type:
List[X], can be List[String], List[Int], List[Double]
higher order type :
Monad, Can be List[X], Try[X], Option[X]
严格来说,Monad是一个高阶的类型,一个“类型“的一个“类型”的一个“类型”
他的定义就是一个类型F,如果能在之上定义
def unit[A](a: => A): F[A]
def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B]
这个类型就是一个monad.
比如List
def unit[A](a: => A): List[A]
给一个x,我能用unit做一个一个元素的List: (x)
scala> List("a")
res0: List[String] = List(a)
这儿的List constructor 就是unit
def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B]
scala> val la = List("test1ntest2n", "test3ntest4n")
la: List[String] =
List("test1
test2
", "test3
test4
")
scala> def f: String => List[String] = (x: String) => x.split("n").toList
f: String => List[String]
scala> la.flatMap(f)
res1: List[String] = List(test1, test2, test3, test4)
monad的定义就是有些类型有共同点:
都可以在这些类型之上定义
def unit[A](a: => A): F[A]
def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B]
他们就是monad
应为抽象了共同点,所以才强大。
正式的定义还要加上条件约束:
// Monad Law
// left identity: f(a) == flatmap(unit(a), f)
// right identity: a == flatMap(a, x => unit(x))
// associativity: flatMap(a, x => flatMap(f(x), g)) == flatMap(flatMap(a, f)
, g)
所以数据结构/computation unit很难归纳它。
List是monad其实是说List是monadic type
【在 z****e 的大作中提到】
: 顺便问你一个问题
: monad是不是就是一个aspect which is monadic type
: 以及针对这部分的操作,也就是bind
: 所以monad不仅仅是一个数据结构,同时也是一个computation unit?
z*e
28 楼
定义第二个条件是为了啥?
为了flatMap操作方便?
【在 c******o 的大作中提到】
: Warning: boring stuff next.太长了,不知道有人看没有。
: monad不是一个数据结构,它是一个“类型“的一个“类型”的一个“类型”。(
: higher order type)
: 举例
: type:
: String
: first order type:
: List[X], can be List[String], List[Int], List[Double]
: higher order type :
: Monad, Can be List[X], Try[X], Option[X]
为了flatMap操作方便?
【在 c******o 的大作中提到】
: Warning: boring stuff next.太长了,不知道有人看没有。
: monad不是一个数据结构,它是一个“类型“的一个“类型”的一个“类型”。(
: higher order type)
: 举例
: type:
: String
: first order type:
: List[X], can be List[String], List[Int], List[Double]
: higher order type :
: Monad, Can be List[X], Try[X], Option[X]
z*e
29 楼
总结一下
首先monad能够通过一个type转换成另外一种monadic type(return?)
所谓monadic type就是能够通过flatmap进行依次转换的东西(bind?)
所以包含有生成list方法的List class是一个monad
同样,包含有生成map方法的HashMap也是一个monad
嗯,Set好像也可以
【在 c******o 的大作中提到】
: Warning: boring stuff next.太长了,不知道有人看没有。
: monad不是一个数据结构,它是一个“类型“的一个“类型”的一个“类型”。(
: higher order type)
: 举例
: type:
: String
: first order type:
: List[X], can be List[String], List[Int], List[Double]
: higher order type :
: Monad, Can be List[X], Try[X], Option[X]
首先monad能够通过一个type转换成另外一种monadic type(return?)
所谓monadic type就是能够通过flatmap进行依次转换的东西(bind?)
所以包含有生成list方法的List class是一个monad
同样,包含有生成map方法的HashMap也是一个monad
嗯,Set好像也可以
【在 c******o 的大作中提到】
: Warning: boring stuff next.太长了,不知道有人看没有。
: monad不是一个数据结构,它是一个“类型“的一个“类型”的一个“类型”。(
: higher order type)
: 举例
: type:
: String
: first order type:
: List[X], can be List[String], List[Int], List[Double]
: higher order type :
: Monad, Can be List[X], Try[X], Option[X]
z*e
31 楼
感觉只要是集合体,都可以flatmap操作
除非flatmap有自己一套恶心的定义
应该没有,所以其实monad就是一个通过某个参数生成一个集合
只要能做到这一步,那么这个集合就是一个monad
所以其实不仅仅是list/map/set,其他general的结构也都可以做成monad
但是一般还是list/map/set
这样理解对不对?
除非flatmap有自己一套恶心的定义
应该没有,所以其实monad就是一个通过某个参数生成一个集合
只要能做到这一步,那么这个集合就是一个monad
所以其实不仅仅是list/map/set,其他general的结构也都可以做成monad
但是一般还是list/map/set
这样理解对不对?
z*e
32 楼
配音一下做成video放到youtube上去吧
【在 c******o 的大作中提到】
: 再推荐一下
: http://www.slideshare.net/hangzhao54/fp-in-scala-part-1
: http://www.slideshare.net/hangzhao54/fp-in-scala-part-2
: 我写的。
【在 c******o 的大作中提到】
: 再推荐一下
: http://www.slideshare.net/hangzhao54/fp-in-scala-part-1
: http://www.slideshare.net/hangzhao54/fp-in-scala-part-2
: 我写的。
c*o
33 楼
不是,
Map是一个monad,因为
它也能实现unit/flatMap
但是那里面的
def unit[A](a: => A): F[A]
def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B]
F就是Map
上一页刚才的实现
F是List
所以才说monad是type of type of type
type (Monad) of type (List, Map) of type (List[String], List[Int], Map[
String], Map[Int])
【在 z****e 的大作中提到】
: 总结一下
: 首先monad能够通过一个type转换成另外一种monadic type(return?)
: 所谓monadic type就是能够通过flatmap进行依次转换的东西(bind?)
: 所以包含有生成list方法的List class是一个monad
: 同样,包含有生成map方法的HashMap也是一个monad
: 嗯,Set好像也可以
Map是一个monad,因为
它也能实现unit/flatMap
但是那里面的
def unit[A](a: => A): F[A]
def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B]
F就是Map
上一页刚才的实现
F是List
所以才说monad是type of type of type
type (Monad) of type (List, Map) of type (List[String], List[Int], Map[
String], Map[Int])
【在 z****e 的大作中提到】
: 总结一下
: 首先monad能够通过一个type转换成另外一种monadic type(return?)
: 所谓monadic type就是能够通过flatmap进行依次转换的东西(bind?)
: 所以包含有生成list方法的List class是一个monad
: 同样,包含有生成map方法的HashMap也是一个monad
: 嗯,Set好像也可以
c*o
34 楼
c*o
37 楼
BTW,有一个很有用的知识
只要能实现flatMap, unit, 就可以用它们实现map
def map[A,B](fa: F[A])(f: A => B): F[B]
map就好理解的多,基本上是提取内容作操作再塞回去。
scala> val lb = List(1,2,3,4)
lb: List[Int] = List(1, 2, 3, 4)
scala> lb.map(x => x+1)
res4: List[Int] = List(2, 3, 4, 5)
和monad一样,能实现map的就叫functor
每一个monad 一定是一个 functor, 因为map能用flatMap/unit抽象的实现。
只要能实现flatMap, unit, 就可以用它们实现map
def map[A,B](fa: F[A])(f: A => B): F[B]
map就好理解的多,基本上是提取内容作操作再塞回去。
scala> val lb = List(1,2,3,4)
lb: List[Int] = List(1, 2, 3, 4)
scala> lb.map(x => x+1)
res4: List[Int] = List(2, 3, 4, 5)
和monad一样,能实现map的就叫functor
每一个monad 一定是一个 functor, 因为map能用flatMap/unit抽象的实现。
c*o
40 楼
介于monad functor之间的是applicative,是stream processing 的重要角色。
BTW,这些都能用java实现,只是不能抽象的实现。
能实现list/stream/map monad,但是不能实现抽象的monad
【在 c******o 的大作中提到】
: BTW,有一个很有用的知识
: 只要能实现flatMap, unit, 就可以用它们实现map
: def map[A,B](fa: F[A])(f: A => B): F[B]
: map就好理解的多,基本上是提取内容作操作再塞回去。
: scala> val lb = List(1,2,3,4)
: lb: List[Int] = List(1, 2, 3, 4)
: scala> lb.map(x => x+1)
: res4: List[Int] = List(2, 3, 4, 5)
: 和monad一样,能实现map的就叫functor
: 每一个monad 一定是一个 functor, 因为map能用flatMap/unit抽象的实现。
BTW,这些都能用java实现,只是不能抽象的实现。
能实现list/stream/map monad,但是不能实现抽象的monad
【在 c******o 的大作中提到】
: BTW,有一个很有用的知识
: 只要能实现flatMap, unit, 就可以用它们实现map
: def map[A,B](fa: F[A])(f: A => B): F[B]
: map就好理解的多,基本上是提取内容作操作再塞回去。
: scala> val lb = List(1,2,3,4)
: lb: List[Int] = List(1, 2, 3, 4)
: scala> lb.map(x => x+1)
: res4: List[Int] = List(2, 3, 4, 5)
: 和monad一样,能实现map的就叫functor
: 每一个monad 一定是一个 functor, 因为map能用flatMap/unit抽象的实现。
z*e
45 楼
flatMap
concaMap
filter
reduce
还包括map,不是collection那个map
这些在rxjava里面都有了
感觉就是scala前面做,java跟着后面抄
java8弄了lambda(without currying)
vert.x弄了async(without immutable&mul-process)
rxjava弄了monad(collection part, without side effect)
这种选择性吸收深得我心啊,取其精华,弃其糟粕
下一个弄啥?streaming吗?
concaMap
filter
reduce
还包括map,不是collection那个map
这些在rxjava里面都有了
感觉就是scala前面做,java跟着后面抄
java8弄了lambda(without currying)
vert.x弄了async(without immutable&mul-process)
rxjava弄了monad(collection part, without side effect)
这种选择性吸收深得我心啊,取其精华,弃其糟粕
下一个弄啥?streaming吗?
z*e
46 楼
+观感正面,-观感负面
lambda +,写程序更简洁些
currying -,混乱,map到底是func还是obj?
1st-class func -,混乱,理由同上,同时需要跟immutable配合
immutable -,同上
monad +,collection部分不错,但是如果是包装其他的则观感负面
functor +,不错,理由同上
dynamic type +,有限滴使用,搬运数据时候用,否则混乱
async +,可以提升性能
single thread -,这哥们是来搞笑的
scala以上全部都可以做,也都可以不做
clojure到dynamic type以上都必需做到,谁让它纯呢?
java基本上就只允许做观感正面部分,除了dynamic type
which可以交给groovy完成,负面部分不是特别麻烦就是会被禁
java8加了lambda
vert.x有async
rxjava有functor和monad
lambda +,写程序更简洁些
currying -,混乱,map到底是func还是obj?
1st-class func -,混乱,理由同上,同时需要跟immutable配合
immutable -,同上
monad +,collection部分不错,但是如果是包装其他的则观感负面
functor +,不错,理由同上
dynamic type +,有限滴使用,搬运数据时候用,否则混乱
async +,可以提升性能
single thread -,这哥们是来搞笑的
scala以上全部都可以做,也都可以不做
clojure到dynamic type以上都必需做到,谁让它纯呢?
java基本上就只允许做观感正面部分,除了dynamic type
which可以交给groovy完成,负面部分不是特别麻烦就是会被禁
java8加了lambda
vert.x有async
rxjava有functor和monad
z*e
47 楼
灌水收获也是如此
主要还是看scala那几个在说啥
其他clj和js的都在扯蛋
主要还是看scala那几个在说啥
其他clj和js的都在扯蛋
d*u
53 楼
终于看到一个学过FP的了
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
h*i
54 楼
说得不错。用了FP做大项目之后,发现主要的好处就是这个,一切都是分离的,很容易
修改,一般就动一两个地方。很适合做商业逻辑,所以我觉得FP在做应用上有前途。做
轮子真没有太多优势。
其他的区别真的不太大。
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
修改,一般就动一两个地方。很适合做商业逻辑,所以我觉得FP在做应用上有前途。做
轮子真没有太多优势。
其他的区别真的不太大。
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
h*i
56 楼
OO和FP不矛盾。
Clojure里面,大型项目目前流行用record, protocol, component DI这一套来管理共
享的状态和资源,其实就是OOP,不过是FP的OOP。
但Clojure绝大部分的代码还是在immutable data上面折腾,充分利用FP的优势。
imperative OOP的毛病是本质上各种东西都是closely coupled, 因为你把一个object
的reference给别人之后,别人想干啥就干啥,所以你不能放心的给别人,要搞各种
pattern,弄得很复杂。这就没有FP那种“动这里绝对伤不到那里”的让人放心的保证
,这是最大的不同。所以我反复强调,用Clojure最大的不同就是immutable data, 是
一种不同的思维方式,因为很多IP程序员觉得最基本的东东都不能用了,得想别的办法
。不过其实过了这个坎,就会觉得其实别的办法也很简单(也许更简单?),以前不知
道而已。就为了能简简单单地放心,这个坎还是值得翻过去的。
【在 p*****2 的大作中提到】
:
: 项目大了就需要上OO了。FP也不例外。
Clojure里面,大型项目目前流行用record, protocol, component DI这一套来管理共
享的状态和资源,其实就是OOP,不过是FP的OOP。
但Clojure绝大部分的代码还是在immutable data上面折腾,充分利用FP的优势。
imperative OOP的毛病是本质上各种东西都是closely coupled, 因为你把一个object
的reference给别人之后,别人想干啥就干啥,所以你不能放心的给别人,要搞各种
pattern,弄得很复杂。这就没有FP那种“动这里绝对伤不到那里”的让人放心的保证
,这是最大的不同。所以我反复强调,用Clojure最大的不同就是immutable data, 是
一种不同的思维方式,因为很多IP程序员觉得最基本的东东都不能用了,得想别的办法
。不过其实过了这个坎,就会觉得其实别的办法也很简单(也许更简单?),以前不知
道而已。就为了能简简单单地放心,这个坎还是值得翻过去的。
【在 p*****2 的大作中提到】
:
: 项目大了就需要上OO了。FP也不例外。
l*s
57 楼
immutable就是拿性能换开发效率,写c++接受不了可以理解,写java的接受不了只能是
精分了。
object
【在 h*i 的大作中提到】
: OO和FP不矛盾。
: Clojure里面,大型项目目前流行用record, protocol, component DI这一套来管理共
: 享的状态和资源,其实就是OOP,不过是FP的OOP。
: 但Clojure绝大部分的代码还是在immutable data上面折腾,充分利用FP的优势。
: imperative OOP的毛病是本质上各种东西都是closely coupled, 因为你把一个object
: 的reference给别人之后,别人想干啥就干啥,所以你不能放心的给别人,要搞各种
: pattern,弄得很复杂。这就没有FP那种“动这里绝对伤不到那里”的让人放心的保证
: ,这是最大的不同。所以我反复强调,用Clojure最大的不同就是immutable data, 是
: 一种不同的思维方式,因为很多IP程序员觉得最基本的东东都不能用了,得想别的办法
: 。不过其实过了这个坎,就会觉得其实别的办法也很简单(也许更简单?),以前不知
精分了。
object
【在 h*i 的大作中提到】
: OO和FP不矛盾。
: Clojure里面,大型项目目前流行用record, protocol, component DI这一套来管理共
: 享的状态和资源,其实就是OOP,不过是FP的OOP。
: 但Clojure绝大部分的代码还是在immutable data上面折腾,充分利用FP的优势。
: imperative OOP的毛病是本质上各种东西都是closely coupled, 因为你把一个object
: 的reference给别人之后,别人想干啥就干啥,所以你不能放心的给别人,要搞各种
: pattern,弄得很复杂。这就没有FP那种“动这里绝对伤不到那里”的让人放心的保证
: ,这是最大的不同。所以我反复强调,用Clojure最大的不同就是immutable data, 是
: 一种不同的思维方式,因为很多IP程序员觉得最基本的东东都不能用了,得想别的办法
: 。不过其实过了这个坎,就会觉得其实别的办法也很简单(也许更简单?),以前不知
z*e
60 楼
胡扯蛋
当你用了pure fp做多线程的时候
你几乎是不得不用immutable,否则就需要lock了
lock没有多少人真搞的,绝大多数人都会选择框架
无论是oop还是fp,而fp的框架必需用immutable,你根本就没有选择的权力
否则状态马上就escape鸟,这个跟oop完全不一样
oop才是真正的允许你选择要不要用immutable
因为oop可以保证object本身被线程单独执行,而非func
scope变大了,人的自由度自然就上升了
【在 l*********s 的大作中提到】
: immutable就是拿性能换开发效率,写c++接受不了可以理解,写java的接受不了只能是
: 精分了。
:
: object
当你用了pure fp做多线程的时候
你几乎是不得不用immutable,否则就需要lock了
lock没有多少人真搞的,绝大多数人都会选择框架
无论是oop还是fp,而fp的框架必需用immutable,你根本就没有选择的权力
否则状态马上就escape鸟,这个跟oop完全不一样
oop才是真正的允许你选择要不要用immutable
因为oop可以保证object本身被线程单独执行,而非func
scope变大了,人的自由度自然就上升了
【在 l*********s 的大作中提到】
: immutable就是拿性能换开发效率,写c++接受不了可以理解,写java的接受不了只能是
: 精分了。
:
: object
p*2
61 楼
immutable不是万能的。
object
【在 h*i 的大作中提到】
: OO和FP不矛盾。
: Clojure里面,大型项目目前流行用record, protocol, component DI这一套来管理共
: 享的状态和资源,其实就是OOP,不过是FP的OOP。
: 但Clojure绝大部分的代码还是在immutable data上面折腾,充分利用FP的优势。
: imperative OOP的毛病是本质上各种东西都是closely coupled, 因为你把一个object
: 的reference给别人之后,别人想干啥就干啥,所以你不能放心的给别人,要搞各种
: pattern,弄得很复杂。这就没有FP那种“动这里绝对伤不到那里”的让人放心的保证
: ,这是最大的不同。所以我反复强调,用Clojure最大的不同就是immutable data, 是
: 一种不同的思维方式,因为很多IP程序员觉得最基本的东东都不能用了,得想别的办法
: 。不过其实过了这个坎,就会觉得其实别的办法也很简单(也许更简单?),以前不知
object
【在 h*i 的大作中提到】
: OO和FP不矛盾。
: Clojure里面,大型项目目前流行用record, protocol, component DI这一套来管理共
: 享的状态和资源,其实就是OOP,不过是FP的OOP。
: 但Clojure绝大部分的代码还是在immutable data上面折腾,充分利用FP的优势。
: imperative OOP的毛病是本质上各种东西都是closely coupled, 因为你把一个object
: 的reference给别人之后,别人想干啥就干啥,所以你不能放心的给别人,要搞各种
: pattern,弄得很复杂。这就没有FP那种“动这里绝对伤不到那里”的让人放心的保证
: ,这是最大的不同。所以我反复强调,用Clojure最大的不同就是immutable data, 是
: 一种不同的思维方式,因为很多IP程序员觉得最基本的东东都不能用了,得想别的办法
: 。不过其实过了这个坎,就会觉得其实别的办法也很简单(也许更简单?),以前不知
d*r
62 楼
大牛是做科学计算的类项目的吧, 你觉得多用immutable一般资源耗费如何, 比如一般
内存耗费Clojure比Java多多少?
object
【在 h*i 的大作中提到】
: OO和FP不矛盾。
: Clojure里面,大型项目目前流行用record, protocol, component DI这一套来管理共
: 享的状态和资源,其实就是OOP,不过是FP的OOP。
: 但Clojure绝大部分的代码还是在immutable data上面折腾,充分利用FP的优势。
: imperative OOP的毛病是本质上各种东西都是closely coupled, 因为你把一个object
: 的reference给别人之后,别人想干啥就干啥,所以你不能放心的给别人,要搞各种
: pattern,弄得很复杂。这就没有FP那种“动这里绝对伤不到那里”的让人放心的保证
: ,这是最大的不同。所以我反复强调,用Clojure最大的不同就是immutable data, 是
: 一种不同的思维方式,因为很多IP程序员觉得最基本的东东都不能用了,得想别的办法
: 。不过其实过了这个坎,就会觉得其实别的办法也很简单(也许更简单?),以前不知
内存耗费Clojure比Java多多少?
object
【在 h*i 的大作中提到】
: OO和FP不矛盾。
: Clojure里面,大型项目目前流行用record, protocol, component DI这一套来管理共
: 享的状态和资源,其实就是OOP,不过是FP的OOP。
: 但Clojure绝大部分的代码还是在immutable data上面折腾,充分利用FP的优势。
: imperative OOP的毛病是本质上各种东西都是closely coupled, 因为你把一个object
: 的reference给别人之后,别人想干啥就干啥,所以你不能放心的给别人,要搞各种
: pattern,弄得很复杂。这就没有FP那种“动这里绝对伤不到那里”的让人放心的保证
: ,这是最大的不同。所以我反复强调,用Clojure最大的不同就是immutable data, 是
: 一种不同的思维方式,因为很多IP程序员觉得最基本的东东都不能用了,得想别的办法
: 。不过其实过了这个坎,就会觉得其实别的办法也很简单(也许更简单?),以前不知
h*i
64 楼
我们不做科学计算,只做一般所谓的大数据的计算。主要的计算都是在线下进行的,分
布式,所以没觉得内存是问题。上线产品里面进行的计算都是非常简单的访问数据库和
对少量数据的计算,内存不是问题。用户多了的话也是同样的上更多的机器,所以
Clojure的资源消耗还没觉得是什么问题。
我没做过与Java的内存消耗比较。不过GC会回收不用的object(immutable data不是说
就不被回收了,呵呵),所以我觉得只要不是那种每一步都需要整个原始数据的算法,
应该不会太差。
同样的算法,这儿有比较不同语言的:
http://benchmarksgame.alioth.debian.org/u64q/clojure.html
【在 d*******r 的大作中提到】
: 大牛是做科学计算的类项目的吧, 你觉得多用immutable一般资源耗费如何, 比如一般
: 内存耗费Clojure比Java多多少?
:
: object
布式,所以没觉得内存是问题。上线产品里面进行的计算都是非常简单的访问数据库和
对少量数据的计算,内存不是问题。用户多了的话也是同样的上更多的机器,所以
Clojure的资源消耗还没觉得是什么问题。
我没做过与Java的内存消耗比较。不过GC会回收不用的object(immutable data不是说
就不被回收了,呵呵),所以我觉得只要不是那种每一步都需要整个原始数据的算法,
应该不会太差。
同样的算法,这儿有比较不同语言的:
http://benchmarksgame.alioth.debian.org/u64q/clojure.html
【在 d*******r 的大作中提到】
: 大牛是做科学计算的类项目的吧, 你觉得多用immutable一般资源耗费如何, 比如一般
: 内存耗费Clojure比Java多多少?
:
: object
j*x
65 楼
这个都是程序员说了算哦
写没有side effect的小函数几乎是所有语言都认同的best practice
。。。
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
写没有side effect的小函数几乎是所有语言都认同的best practice
。。。
【在 c******o 的大作中提到】
: zhaoce问我上次那个Try monad有啥好处,看起来一点的不好。
: 我想可能是我没讲清楚,现在解释一下。
: 对于使用FP的人,如果真正很好的理解/执行了fp的方法,编了程序。那么在这个程序
: 里,我(或者其他人)可以随意抽出一段(以函数为最小单位),以百分百的信心说我
: 知道这个编的对不对,好不好。 我可以百分百的信心进行修改,然后说我绝对没有任
: 何可能破坏程序的其他部分。(所以好的fp追求短小精干的函数和它们的组合)
: 这是FP编程最根本,最基本,最重要的目的。其他的好处(对并行好,对分布好,好
: debug)都是派生的而已。
: 我们讨论的FP的乱七八糟的东西只是达到这个目的的手段而已。
: 如果你的FP不能达到这个目的,像qxc抱怨的一样,那很可惜,你的FP可能只是东施效
相关阅读
求教一个高中概率问题人工智能下围棋超过人类, 是一个虚假结论, 纯属误导!今天看到这个网站还挺有意思的ubuntu 16.04 好像比14.04 难用[bssd]Dallas capital one招人【转】 FYI 业内人士评一下这篇基本适合深度学习的笔记本laptop哪个网站有当地每天的降雪总量?Weighted Graph Challenge 一道面试题AI is very very interesting...Do WhatQuote of computation余凯深访 | 中美 AI 竞赛差距加大,本土 AI 公司十年才能走向想上手deep learning的看过来GOTO论坛是大宇宙,微信是小宇宙如何测试一个网站能同时容纳的最高在线连接auto encoder 出来之后是不是没人再用PCA了再来问个 湾区雅图 对前端/全栈 一般期望会用啥后端上海交大人工智能成功鉴别“清纯”和“妖艳”美女 快科技 ugmb (转载)