l**********n
发帖数: 8443 | 1 powerset一行就实现了：
def powerset[A](s: Set[A]) = s.foldLeft(Set(Set.empty[A])) { case (ss, el) =
> ss ++ ss.map(_ + el) }
java得好几行吧？而且还是generics |
w******p
发帖数: 166 | 2 people needs to get 10x training time to learn about this, and those who
need to maintain such code have a hard time understand this, I don't think
this is better than java at all
for brain fucking there's a language called brainfuck and it's cooler |
l**********n
发帖数: 8443 | |
e*******o
发帖数: 4654 | 4 这么比显然不公平
fp 内置了一堆函数。
java也可以一行搞定 引入个lib就行了。
【在 l**********n 的大作中提到】
: 我觉得很简洁啊，一看就明白啊
|
q*c
发帖数: 9453 | 5 我觉得很好 所以就很好。
这个逻辑是太流行了。。。。尤其是左派里面。
【在 l**********n 的大作中提到】
: 我觉得很简洁啊，一看就明白啊
|
l**********n
发帖数: 8443 | 6 scala这个语言很powerful啊. 我尤其喜欢那个foldLeft。 |
e*******o
发帖数: 4654 | 7 哪个fp 没这个？
Perl 都有个reduce
【在 l**********n 的大作中提到】
: scala这个语言很powerful啊. 我尤其喜欢那个foldLeft。
|
l**********n
发帖数: 8443 | 8 Perl 是 fp？
【在 e*******o 的大作中提到】
: 哪个fp 没这个？
: Perl 都有个reduce
|
c*******9
发帖数: 9032 | 9 这个瞎说，你想想你花多少时间学java，学这个你花过时间吗。
【在 w******p 的大作中提到】
: people needs to get 10x training time to learn about this, and those who
: need to maintain such code have a hard time understand this, I don't think
: this is better than java at all
: for brain fucking there's a language called brainfuck and it's cooler
|
c*******9
发帖数: 9032 | 10 Lib能让你一下看清楚算法结构吗？
【在 e*******o 的大作中提到】
: 这么比显然不公平
: fp 内置了一堆函数。
: java也可以一行搞定 引入个lib就行了。
|
|
|
l**********n
发帖数: 8443 | 11 我比较喜欢scala的一点就是能清晰的看到算法。 |
N******K
发帖数: 10202 | 12 比 matlab如何
【在 l**********n 的大作中提到】
: 我比较喜欢scala的一点就是能清晰的看到算法。
|
l**********n
发帖数: 8443 | 13 you tell me. I am not familiar with matlab
【在 N******K 的大作中提到】
: 比 matlab如何
|
p***o
发帖数: 1252 | 14 写个BFS看看, 要不DFS也行
【在 l**********n 的大作中提到】
: 我比较喜欢scala的一点就是能清晰的看到算法。
|
c*******0
发帖数: 5247 | 15 这有什么，我第一次用haskell写快排的时候简直就是震惊，不敢相信这两行就写完了
，当年用C写快排的那个纠结还历历在目。
FP做算法描述天生非常牛逼。问题是这个世界大部分的程序不是算法描述。 |
p***o
发帖数: 1252 | 16 C的快排你跟haskell一样不写成in-place的也不难。
【在 c*******0 的大作中提到】
: 这有什么，我第一次用haskell写快排的时候简直就是震惊，不敢相信这两行就写完了
: ，当年用C写快排的那个纠结还历历在目。
: FP做算法描述天生非常牛逼。问题是这个世界大部分的程序不是算法描述。
|
g*****g
发帖数: 34805 | 17 错，java也只要一行，还要简洁无数倍。调用guava的Sets.powerSet(Set)就行了。既
不用脑子想，还无数人测试过。
我老人家说过多少次了，类库才是第一生产力。FP吭哧吭哧写出个函数，还欣赏简洁呢
，那边java产品都release了。
=
【在 l**********n 的大作中提到】
: powerset一行就实现了：
: def powerset[A](s: Set[A]) = s.foldLeft(Set(Set.empty[A])) { case (ss, el) =
: > ss ++ ss.map(_ + el) }
: java得好几行吧？而且还是generics
|
a*****e
发帖数: 1700 | 18 在 Haskell 里面也就一行：
powerset = filterM (\_ -> [True,False])
这里用到的 filterM 来自 Control.Monad 库，从它的类型基本可以推断出它的功能:
filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a]
也就是通过一个 monadic 的条件 (a -> m Bool)，筛选列表 [a]，得到结果的类型为
m [a]。
这样看，filterM 是一个非常 generic 的函数，和 powerset 八杆子打不着边，那么
最上面的定义该怎么理解呢？在 scala 里面使用 monad 应该也能给出类似的定义。
这里学 Haskell 和 Scala 的那几位，谁能解释清楚了，我打赏 50 个包子 :-)
另：goodbug 那个 java 版本是 tautology，从中学不到任何知识，没意义。
=
【在 l**********n 的大作中提到】
: powerset一行就实现了：
: def powerset[A](s: Set[A]) = s.foldLeft(Set(Set.empty[A])) { case (ss, el) =
: > ss ++ ss.map(_ + el) }
: java得好几行吧？而且还是generics
|
l******t
发帖数: 55733 | 19
这几个函数是fp的标配啊。没lambda java再怎么写也没这个境界
【在 e*******o 的大作中提到】
: 这么比显然不公平
: fp 内置了一堆函数。
: java也可以一行搞定 引入个lib就行了。
|
V*********r
发帖数: 666 | 20
"意义"在于getting things done，不在于“学知识”
【在 a*****e 的大作中提到】
: 在 Haskell 里面也就一行：
: powerset = filterM (\_ -> [True,False])
: 这里用到的 filterM 来自 Control.Monad 库，从它的类型基本可以推断出它的功能:
: filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a]
: 也就是通过一个 monadic 的条件 (a -> m Bool)，筛选列表 [a]，得到结果的类型为
: m [a]。
: 这样看，filterM 是一个非常 generic 的函数，和 powerset 八杆子打不着边，那么
: 最上面的定义该怎么理解呢？在 scala 里面使用 monad 应该也能给出类似的定义。
: 这里学 Haskell 和 Scala 的那几位，谁能解释清楚了，我打赏 50 个包子 :-)
: 另：goodbug 那个 java 版本是 tautology，从中学不到任何知识，没意义。
|
|
|
l*****t
发帖数: 2019 | 21 新来的？看一个foldLeft加pattern match把你给得瑟的。多写点，看看调试多麻烦。
写过一两千代码不准用var和mutable，回来再汇报心得。
=
【在 l**********n 的大作中提到】
: powerset一行就实现了：
: def powerset[A](s: Set[A]) = s.foldLeft(Set(Set.empty[A])) { case (ss, el) =
: > ss ++ ss.map(_ + el) }
: java得好几行吧？而且还是generics
|
a*****e
发帖数: 1700 | 22 那是对于你而言。对我来说，编程就是学习的过程。
【在 V*********r 的大作中提到】
:
: "意义"在于getting things done，不在于“学知识”
|
d********u
发帖数: 5383 | 23 学生和工作的是不一样。你基本还不具备工作能力。
【在 a*****e 的大作中提到】
: 那是对于你而言。对我来说，编程就是学习的过程。
|
f******2
发帖数: 2455 | 24 You write Scala code as job?
【在 l*****t 的大作中提到】
: 新来的？看一个foldLeft加pattern match把你给得瑟的。多写点，看看调试多麻烦。
: 写过一两千代码不准用var和mutable，回来再汇报心得。
:
: =
|
c*******9
发帖数: 9032 | 25 别人写好了你可以荡，沒别人做出来你就不会荡。
【在 V*********r 的大作中提到】
:
: "意义"在于getting things done，不在于“学知识”
|
c*******9
发帖数: 9032 | 26 臭臭的工作就是吃屎。
【在 d********u 的大作中提到】
: 学生和工作的是不一样。你基本还不具备工作能力。
|
d****n
发帖数: 12461 | 27 没法调试的语言就是渣。没法动态调试的语言也是渣。
【在 l*****t 的大作中提到】
: 新来的？看一个foldLeft加pattern match把你给得瑟的。多写点，看看调试多麻烦。
: 写过一两千代码不准用var和mutable，回来再汇报心得。
:
: =
|
a*****e
发帖数: 1700 | 28 工作就不需要学习了吗？保持学习于我而言是可以终身受益的。何况我只是表明一个我
对编程的态度而已。
你要是能够回答我的前面的问题，欢迎回贴。要是不能，也欢迎继续围观，看能否从中
学到有益的知识。
至于我的工作能力，还用不着你来操心。
【在 d********u 的大作中提到】
: 学生和工作的是不一样。你基本还不具备工作能力。
|
H****S
发帖数: 1359 | 29 用scanLeft更简洁
s.scanLeft(Set.empty[A])(_ + _)
=
【在 l**********n 的大作中提到】
: powerset一行就实现了：
: def powerset[A](s: Set[A]) = s.foldLeft(Set(Set.empty[A])) { case (ss, el) =
: > ss ++ ss.map(_ + el) }
: java得好几行吧？而且还是generics
|
H****S
发帖数: 1359 | 30 为什么不能用var和mutable？？这又不是Haskell。Scala的core code里面也用了一堆
的var啊。
【在 l*****t 的大作中提到】
: 新来的？看一个foldLeft加pattern match把你给得瑟的。多写点，看看调试多麻烦。
: 写过一两千代码不准用var和mutable，回来再汇报心得。
:
: =
|
|
|
a*****e
发帖数: 1700 | 31 你这个错了。再想想？
【在 H****S 的大作中提到】
: 用scanLeft更简洁
: s.scanLeft(Set.empty[A])(_ + _)
:
: =
|
H****S
发帖数: 1359 | 32 确实不对，和以前写的一个List搞混了，呵呵。偷个懒吧，
s.subsets.toSet()
【在 a*****e 的大作中提到】
: 你这个错了。再想想？
|
q*c
发帖数: 9453 | 33 这些同学还太年轻，觉得人类这点微末知识真是个菜。
人类一思考， 上帝就发笑。
整点钱日子舒服等死， 才是正道。 如果再有点精神追求， 那就世间第一人了。
【在 V*********r 的大作中提到】
:
: "意义"在于getting things done，不在于“学知识”
|
q*c
发帖数: 9453 | 34 如果你不得不做没人写过的东西 －－ 赶紧准备简历跳槽是正经。
【在 c*******9 的大作中提到】
: 别人写好了你可以荡，沒别人做出来你就不会荡。
|
c****e
发帖数: 1453 | 35 虽然我很挺Scala,但是这个东西基本是意淫用的，很少上升到手撸的程度。 |
g*****g
发帖数: 34805 | 36 各位小同学们还没有理解，把别人的东西凑起来捏出个产品，叫做架构师。
吭哧吭哧写底层powerset实现的，叫做程序猿。
【在 q*c 的大作中提到】
: 如果你不得不做没人写过的东西 －－ 赶紧准备简历跳槽是正经。
|
b***e
发帖数: 1419 | 37 To understand filterM, let’s look at the simple filter function without the
involvement of monads:
filter :: (a -> Bool) -> [a] -> [a]
filter f [] = []
filter f (x:xs) =
let b = f x
in let rest = filter xs
in if b then x: rest else rest
This is straightforward and the following call:
filter (\x -> x > 2) [1,2,3]
will return:
[3]
Now let’s lift this definition to a monadic version:
filterM :: (Monad m) => (a -> M Bool) -> [a] -> M [a]
filterM f [] = return []
filterM f (x:xs) =
do b <- f x
rest <- filterM f xs
if b then return (x:rest) else return rest
This is a straightforward monadic transformation where instead of let
notations, it uses do notation for monadic sequencing. If we put and Id
monad in place, then filterM is exactly the same as filter. But we can do
more interesting things with filterM if we put other non-trivial monads.
Before running into the power set function, let’s exam a contrived example
where a state monad can be used to track the number of the filtered out
results.
filterAndCount f a =
let fM = \x -> do let b = f x
if b then inc else nop
return b
in filterM fM a
filterAndCount will deliever both the filtered results and count of the
result list.
Then let’s get an understanding of the List monad. List monad is also
referred as the nondeterministic monad. So instead of the notion:
a = 1
which means a is equivalent to the value 1, we have the notion:
a <- [1,2]
which means a is equivalent to a nondeterministic value that’s either 1 or
2. The following program:
do a <- [1,2]
b <- [3,4]
return a * b
will yield the value:
[3,4,6,8]
We should read the program like this: if a is possibly 1 or 2, b is
possibly 3 or 4, then a * b is possibly 3,4,6 or 8.
Now it’s the time to understand the power set function:
powerset = filterM (\_ -> [True,False])
This means to apply a nondeterministic filter to each element of a list,
which either include the element or exclude it, and finally deliver all the
possible results. That is, exactly, the power set of the input.
为
【在 a*****e 的大作中提到】
: 在 Haskell 里面也就一行：
: powerset = filterM (\_ -> [True,False])
: 这里用到的 filterM 来自 Control.Monad 库，从它的类型基本可以推断出它的功能:
: filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a]
: 也就是通过一个 monadic 的条件 (a -> m Bool)，筛选列表 [a]，得到结果的类型为
: m [a]。
: 这样看，filterM 是一个非常 generic 的函数，和 powerset 八杆子打不着边，那么
: 最上面的定义该怎么理解呢？在 scala 里面使用 monad 应该也能给出类似的定义。
: 这里学 Haskell 和 Scala 的那几位，谁能解释清楚了，我打赏 50 个包子 :-)
: 另：goodbug 那个 java 版本是 tautology，从中学不到任何知识，没意义。
|
a*****e
发帖数: 1700 | 38
鼓掌！这结语讲的真心好。
楼主给出的 foldLeft 写法，和普通用循环的写法并无很大的分别，都是描述的计算
powerset 过程。而上述用 filterM 的写法，直接对应的是 powerset 的数学定义。
这两种表达方式的差别，正是 operational semantics 和 denotational semantics
的差别。通常，denotational 的抽象程度要高一些，但从另一个角度看，operational
可以更细致地区分语义上的差别。所以，取决于使用的上下文，并不能笼统地说一种
就一定好于另一种。
但是从语言设计的角度出发，即能够允许 operational 也能够允许 denotational 方
式定义函数或者描述事件的程序语言，要比只能允许其中一种方式的语言要更加
expressive。
的确，多数情况下我们并不关心 powerset 是如何实现的，有现成的库函数调用就好了
。但是不深入学习，就会错过一次锻炼抽象能力的机会。而正确恰当的抽象能力，才是
一个 architect 和一个 engineer 的真正区别。
After all, computer science is all about abstraction.
【在 b***e 的大作中提到】
: To understand filterM, let’s look at the simple filter function without the
: involvement of monads:
: filter :: (a -> Bool) -> [a] -> [a]
: filter f [] = []
: filter f (x:xs) =
: let b = f x
: in let rest = filter xs
: in if b then x: rest else rest
: This is straightforward and the following call:
: filter (\x -> x > 2) [1,2,3]
|
g*****g
发帖数: 34805 | 39 You can say that about everything, there are at least 10 variances of quick
sort, yet the difference is negligent for most developers.
At the end of the day, it's about getting the job done with quality and
speed. Reinvent wheel hardly helps.
operational
【在 a*****e 的大作中提到】
:
: 鼓掌！这结语讲的真心好。
: 楼主给出的 foldLeft 写法，和普通用循环的写法并无很大的分别，都是描述的计算
: powerset 过程。而上述用 filterM 的写法，直接对应的是 powerset 的数学定义。
: 这两种表达方式的差别，正是 operational semantics 和 denotational semantics
: 的差别。通常，denotational 的抽象程度要高一些，但从另一个角度看，operational
: 可以更细致地区分语义上的差别。所以，取决于使用的上下文，并不能笼统地说一种
: 就一定好于另一种。
: 但是从语言设计的角度出发，即能够允许 operational 也能够允许 denotational 方
: 式定义函数或者描述事件的程序语言，要比只能允许其中一种方式的语言要更加
|
w***g
发帖数: 5958 | 40 看不懂
=
【在 l**********n 的大作中提到】
: powerset一行就实现了：
: def powerset[A](s: Set[A]) = s.foldLeft(Set(Set.empty[A])) { case (ss, el) =
: > ss ++ ss.map(_ + el) }
: java得好几行吧？而且还是generics
|
|
|
l*****t
发帖数: 2019 | 41 不需要懂。这玩儿没实战意义。当年老师天天说immutable，monad，stream怎么怎么好
，几十年下来，原来预测的医药和航天、精密仪器等有可能火的行业都没火。
我粗鄙的认为，搞懂function as a first class citizens，懂map, filter, fold足
够了。industry就是industry，不是academia，没必要死楸immutable、monad。
【在 w***g 的大作中提到】
: 看不懂
:
: =
|
n****1
发帖数: 1136 | 42 我觉得核心是[True,False]这个，抓住了powerset(X)=2^X这个定义，然后其他的只要
类型过得了就肯定对了. 换句话说，应该解释清楚为啥[True,True,False]行不通
还有，这个实现其实没考虑order,也没考虑重复。
operational
【在 a*****e 的大作中提到】
:
: 鼓掌！这结语讲的真心好。
: 楼主给出的 foldLeft 写法，和普通用循环的写法并无很大的分别，都是描述的计算
: powerset 过程。而上述用 filterM 的写法，直接对应的是 powerset 的数学定义。
: 这两种表达方式的差别，正是 operational semantics 和 denotational semantics
: 的差别。通常，denotational 的抽象程度要高一些，但从另一个角度看，operational
: 可以更细致地区分语义上的差别。所以，取决于使用的上下文，并不能笼统地说一种
: 就一定好于另一种。
: 但是从语言设计的角度出发，即能够允许 operational 也能够允许 denotational 方
: 式定义函数或者描述事件的程序语言，要比只能允许其中一种方式的语言要更加
|
b***e
发帖数: 1419 | 43 [True, True, False]可以，就是有重复。
[True, False]考虑了可能的重复：如果输入是set的话，输出也是set。这个有
induction证明。Functional programming的一个好处就是证明有迹可循，对正确性的
confidence高。
Order无非是[True, False] or [False, True]。
【在 n****1 的大作中提到】
: 我觉得核心是[True,False]这个，抓住了powerset(X)=2^X这个定义，然后其他的只要
: 类型过得了就肯定对了. 换句话说，应该解释清楚为啥[True,True,False]行不通
: 还有，这个实现其实没考虑order,也没考虑重复。
:
: operational
|
z****e
发帖数: 54598 | 44 笑喷
这贴的回帖太娱乐了
【在 c*******9 的大作中提到】
: 臭臭的工作就是吃屎。
|
z****e
发帖数: 54598 | 45 可以让学术界的人好好搞搞scala
貌似现在也是这个趋势
学术界的各种工具，ml比如spark，r比如renjin
都是用scala来写
实战时候还是直接用java调用就是了
scala有成为jvm上的fortran的趋势
【在 l*****t 的大作中提到】
: 不需要懂。这玩儿没实战意义。当年老师天天说immutable，monad，stream怎么怎么好
: ，几十年下来，原来预测的医药和航天、精密仪器等有可能火的行业都没火。
: 我粗鄙的认为，搞懂function as a first class citizens，懂map, filter, fold足
: 够了。industry就是industry，不是academia，没必要死楸immutable、monad。
|
