c******o
发帖数: 1277 | 1 从下面的code可以看出，flatMap 可以实现map,所以flatMap更强大（比map能干的事多
）， 但是map更常见 （有map不一定能实现flatMap)
// id function:
// def id[A](a: A): A = a
// compose function:
// def compose[A,B,C](f: B => C, g: A => B): A => C =
// a => f(g(a))
trait Functor[F[_]] {
def map[A,B](fa: F[A])(f: A => B): F[B]
}
// Functor Law
// identity: map(x)(id) == x
// composition: map(a)(compose(f, g)) == map(map(a,g), f)
trait Applictive[F[_]] extends Functor[F] {
def unit[A](a: => A): F[A]
def ap[A,B](la: F[A])(f: F[A => B]): F... 阅读全帖 |
|
c******o
发帖数: 1277 | 2 从下面的code 看出。
map能对一个数据（一个List, 一个Option, 一个Future) 进行操作。
applicative (ap) 能对多个数据进行操作。
monad能对对多个数据进行操作的同时，根据数据的内容动态改变操作流程。
基本上functor （map)，applicative functor (ap), monad (flatMap)的区别就是这
些。
object test {
def oneVarFunc: Int => Int = {
_ + 1
}
def twoVarFunc: (Int, Int) => Int = {
_ + _
}
def optionap[A,B](a: Option[A])(f: Option[A => B]): Option[B] =
f.flatMap(t1 => a.flatMap(t2 => Some(t1(t2))))
val x1 = Some(1)
val x2 = Some(2)
val x3 = None
//functor
def test... 阅读全帖 |
|
g*****g
发帖数: 34805 | 3 map是一对一的，flatmap可以是一对N的。典型的例子就是value是个list。map返回
list of list，flatmap返回merged的list. |
|
z****e
发帖数: 54598 | 4 scala的这部分解释起来费劲
看rxjava就很清晰了
map( ) — transform the items emitted by an Observable by applying a
function to each of them
flatMap( ), concatMap( ), and flatMapIterable( ) —
transform the items emitted by an Observable into Observables (or Iterables)
, then flatten this into a single Observable
map: 1 -> 1
flatmap: 1 -> *或者说[0,n] |
|
l**********n
发帖数: 8443 | 5 我有个Option[T], 用map和flatmap有什么区别？返回什么type？ |
|
l**********n
发帖数: 8443 | 6 用map是返回一个Option[_]吧？如果f: T => V, 就用map，返回Option[V], 如果f： T
=> Option[V],就用flatmap， 返回Option[V], am I right? |
|
l**********n
发帖数: 8443 | 7 because scala is oop, it is mentally hard thinking in fp. for example,
flatmap is a trait of monad, but map is a trait of functor |
|
|
H****S
发帖数: 1359 | 9 返回的类型都是一样的，但是一个接受A => B，另外一个接受A => Option[B]。实际上
map是多余的，
Option.map(f) = Option.flatMap(f andThen Option.apply) |
|
c******o
发帖数: 1277 | 10 There are things that has map but does NOT have flatMap |
|
d******e
发帖数: 2265 | 11 还在讨论。俺们草蜢快类型的根本不管什么术语。上个 code就明白了。以future为例：
def temperatureOkay(water: Water): Future[Boolean] = Future {
(80 to 85).contains(water.temperature)
}
val nestedFuture: Future[Future[Boolean]] = heatWater(Water(25)).map {
water => temperatureOkay(water)
}
val flatFuture: Future[Boolean] = heatWater(Water(25)).flatMap {
water => temperatureOkay(water)
}
val acceptable: Future[Boolean] = for {
heatedWater <- heatWater(Water(25))
okay <- temperatureOkay(heatedWater)
} yield okay
网上的例子。简单说,为了... 阅读全帖 |
|
c******o
发帖数: 1277 | 12 On the other hand, Monad is HARD to explain:
As a formal definition of a structure, Monad is
basically a group of types that can implement
unit/flatMap function that match the signature in
def unit[A](a: => A): F[A]
def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B]
But that is not enough, we also have law that
Monad type need to fulfill so that we know our
implementation of unit/flatMap is correct.
// Monad Law
// left identity: f(a) == flatmap(unit(a), f)
// right identity: a == flatMap(a, x => un... 阅读全帖 |
|
c******o
发帖数: 1277 | 13 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]... 阅读全帖 |
|
c******o
发帖数: 1277 | 14 你没看懂我的，我的就是这样，只不过没有把trait 拿出来。。。
再给你贴一个我的练习。
trait Functor[F[_]] {
def map[A,B](t: F[A])(f: A => B): F[B]
}
trait Applicative[F[_]] extends Functor[F]{
def unit[A](a: => A): F[A]
def ap[A,B](fa: F[A])(fab: F[A => B]): F[B]
override def map[A,B](t: F[A])(f: A => B): F[B] = ap(t)(unit(f))
}
trait Monad[F[_]] extends Applicative[F] {
def unit[A](a: => A): F[A]
def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B]
override def ap[A,B](la: F[A])(f: F[A => B]): F[B] =
flatMap(f)(t1 => flatM... 阅读全帖 |
|
c******o
发帖数: 1277 | 15 我写的和它类似，不过是没 implement eq/Ord
sealed trait List[+A]
case object Nil extends List[Nothing]
case class Cons[+A] (head: A, tail: List[A]) extends List[A]
object List {
def apply[A](as: A*): List[A] =
if (as.isEmpty) Nil
else Cons(as.head, apply(as.tail: _*))
private def asString_internal[A](l: List[A]): String =
l match {
case Nil => ""
case Cons(head,tail) => head.toString + " " + asString_internal(tail)
}
def toString[A](l: List[A]): String =
"[ " + asString_... 阅读全帖 |
|
H****S
发帖数: 1359 | 16 monad 其实只需要unit 和 flatmap就够了
zip就是一个flatmap加map的showcase。其实用pattern match也可以。
sealed trait Option[+A] {
def map[B](f: A => B): Option[B]
def isEmpty: Boolean
def get: A
def flatMap[B](f: A => Option[B]) = if (isEmpty) None else f(this.get)
def zip[B](ob: Option[B]): Option[(A, B)] = this flatMap (a => ob map (b =
> (a, b)))
}
case object None extends Option[Nothing] {
override def map[B](f: A => B) = None
override def get: A = throw new Exception("cannot get none")
override def i... 阅读全帖 |
|
c******o
发帖数: 1277 | 17 忘说了
for (
a1 <- attack...
a2 <- hitByThunder(a1)
a3 <- die(a2)
a4 <- hitByWind
) yield (combine (a1,a2))
其实是
attack.flatMap {
a1 => hitByThunder(_).flatMap {
a2 => die(_).flatMap {
a3 => hitByWind.map {
a4 => combine (a1,a2)
}
}
}
}
这才是FP combinator的真面目,你可一看到里面的higher order function, 用一个
function来改变一个type内部的内容，在产生一个同样的type |
|
c******o
发帖数: 1277 | 18 忘说了
for (
a1 <- attack...
a2 <- hitByThunder(a1)
a3 <- die(a2)
a4 <- hitByWind
) yield (combine (a1,a2))
其实是
attack.flatMap {
a1 => hitByThunder(_).flatMap {
a2 => die(_).flatMap {
a3 => hitByWind.map {
a4 => combine (a1,a2)
}
}
}
}
这才是FP combinator的真面目,你可一看到里面的higher order function, 用一个
function来改变一个type内部的内容，在产生一个同样的type |
|
c******o
发帖数: 1277 | 19 这个我也看了好几遍，不如书（functional programming in scala) 好懂
我觉得一般来说
functor/monad 最重要
然后看看monoid/foldable （这个最容易）
applicative/traversable,这个我到现在还不是那么懂。。。
arrow/comonad我就完全不懂了。。。
我前一段做的笔记:
trait Semigroup[A] {
def append(x: A, y: A): A
}
List(1,2,3,4).append(List(5)) = List(1,2,3,4,5)
trait Functor[T[_]]{
def map[A,B](ta:T[A])(f:A=>B):T[B]
}
map(List(1,2,3,4))(x=> x.toString) = List("1", "2", "3", "4")
simplest transform, like a foreach in someway
trait Applicative[T[_]] extends Functor[T]{
def unit[... 阅读全帖 |
|
z*******3
发帖数: 13709 | 20 简单， 写起来快，是真的java script
尤其是如果你对class MyClass{
public static void main(String[] args){}
}
这些感到厌烦的话
rxjava就是fp那些东西啊，map，filter，flatmap etc.
用来排除金字塔很管用啊
每次返回一个observable，然后subscribe你的callback method就好了
subscribe完之后继续返回observable，如此循环，就不用金字塔了
这些在同步中很容易写，在fp和异步中就变得麻烦起来
但是最终可以写成
a.map()
.flatmap()
.filter()
...这种方式
比之前的
a.map(...,flatmap(...,filter()))
这种美观多了
如果不是fp的话，这里还需要嵌套一层object做匿名类，烦死
而且这个做下去就是streaming，一旦streaming开始推广
以后这种搞法会越来越多
/* */, 还不如直接用 [email protected]
/* */ 了 |
|
c******o
发帖数: 1277 | 21 The 通俗易懂地 explanation is:
Now see all these formal definition, still what is a Monad for us programmer
? and Why we need them?
def unit[A](a: => A): M[A]
def flatMap[A,B](ma: M[A])(f: A => M[B]): M[B]
A bit long explanation here:
Monad seems just like a wrapper, it wraps in a basic type (A here), and put
into a context M, generate
a richer type (M[A] here). unit function does this.
We care about the value of type A in context M, but we hate part of the
context that is troublesome.
The troublesom... 阅读全帖 |
|
p*****2
发帖数: 21240 | 22 看来这个课程讲的是不怎么样。Scala只是50% functional，却在装纯。
That was one the worst introductions to monads I have ever seen. Having the
name flatMap for bind really hinders understanding even more as one
intuitively would assume that monads are about collections or at least
containers. But then Martin flips it around saying that flatMap is not just
for collections! Then he goes on to explain laws without much context. |
|
c******o
发帖数: 1277 | 23 我想了一下，有好几个办法，比如说
1. inherit from List, override flatMap
2. create a type wrap List, and implicit conversion it <-> List, implement
flatMap and/or other methods, in the new type.
不过都好像是为了OO/java妥协，不是那么自然。
当然还有一个选项：
use scalaz, https://github.com/scalaz/scalaz
scalaz里面基本上实现了几乎全部抽象的haskell代数结构 （monoid, applicative,
functor, monad, arrow, comonad etc....)
那里有抽象的monad,可以比较自然好看的实现你要做的事 |
|
c******o
发帖数: 1277 | 24 monad只要flatMap
map是 functor 的标志
zip 是 applicative functor 的标志
都可以由 flatMap和Some constructor实现
所以monad 是 applicative，applicative是 functor
= |
|
H****S
发帖数: 1359 | 25 如果只有flatMap，unit是必须要有的，否则map无从实现
def map[B](f: A => B): Option[B] = this flatMap (a => unit(f(a)))
这些细节对于application developer来说其实并不重要，大多数人实际过程中直接让
for comprehension做所有的heavy lifting
def zip[A, B](oa: Option[A], ob: Option[B]) = for {
a <- oa
b <- ob
} yield (a, b)
BTW, 我个人其实比较偏向这样写来着
def zip[A, B](oa: Option[A], ob: Option[B]) = (oa, ob) match {
case (Some(a), Some(b)) => Some((a, b))
case _ => None
}
而且个人认为对于scala的使用不用过于强调它的FP特性。我之前写程序过于强调
procedure一定要足够pure，如果有一个var存在即便是在actor内部，那就像吃了... 阅读全帖 |
|
c******o
发帖数: 1277 | 26 这是很典型的实际应用coding,如果把list换成无始无终的stream就更加清楚了。
这是很典型的applicative functor, 基本上是用zip combinator.
那为啥要问monad呢？ 每一个monad都是applicative functor,但是不是每个
applicative functor都是monad
的。
list 可以用monad的map, flatMap来实现，但是很不清楚。 用zip就很好。
unlimited stream根本就没法用monad的map, flatMap，不会返回的。只能用 zip
因为unlimited stream不是monad.
如果你熟悉functor, applicative functor, monad 对一个问题，你很快就能想到怎么
处理。
对于处理某个问题的lib你也很快就能上手。 |
|
z****e
发帖数: 54598 | 27 感觉只要是集合体，都可以flatmap操作
除非flatmap有自己一套恶心的定义
应该没有，所以其实monad就是一个通过某个参数生成一个集合
只要能做到这一步，那么这个集合就是一个monad
所以其实不仅仅是list/map/set，其他general的结构也都可以做成monad
但是一般还是list/map/set
这样理解对不对？ |
|
c******o
发帖数: 1277 | 28 不是，
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]) |
|
c******o
发帖数: 1277 | 29 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抽象的实现。 |
|
m****o
发帖数: 182 | 30 rxjava需要实现多线程处理的话，需要把每个操作flatmap到一个observable上去，然
后subscribeOn一个scheduler，你的情况可以直接上库自带的computational
scheduler。注意flatmap是不考虑输入输出顺序统一的，这一点很其他主流fp库设计不
同容易搞错。如果需要输入输出顺序统一，需要用concatmap。
另外好像你不是很在乎使用全局线程池，那样的话可以直接用前面有人提到的java8原
生的parallelMap。
val in = new BufferedReader(new InputStreamReader(System.in))
try {
val stream = in.lines()
try stream.parallelMap(data => ???).filter(data => ???).forEach{/* here is
your sink */}
finally stream.close()
}
finally {
in.close()
} |
|
c*****a
发帖数: 808 | 31 来个spark的
val file = spark.textFile("hdfs://documents")
val words = file.flatMap(l=> l.split(" ")).map(w => (w, 1)).groupByKey(10000
).filter(p => p._2.size>5000).map(_._1)
|
|
z****e
发帖数: 54598 | 32
，
第一个就是big data， spark那些主要在做的
hadoop，ml这些常用的工具就是flatmap, filter etc. |
|
r*****n
发帖数: 35 | 33 Scala code, not tested
object Parenthesis {
def main(args: Array[String]) {
val ret = constructTree("1+3*5")
println("start")
ret.foreach(println)
}
def wrap(c: Char): (Int, Int)=>Int = {
c match {
case '+' => (x, y) => x + y
case '-' => (x, y) => x - y
case '*' => (x, y) => x * y
}
}
def constructTree(input: String): Array[Int] = {
var split = false
var ret = (0 until input.length).flatMap{ idx =>
input(idx) match {
case '+' ... 阅读全帖 |
|
|
t**r
发帖数: 3428 | 35 scala学一学绝对有用
scala可能不会一直火，但是他那些functional 的idiom 到其他语言里也用的上。
大多数java/cpp码农无法清楚的搞清楚map, flatmap,reduce的含义。学学斯科拉可以
幫助理解 |
|
t**r
发帖数: 3428 | 36 scala学一学绝对有用
scala可能不会一直火，但是他那些functional 的idiom 到其他语言里也用的上。
大多数java/cpp码农无法清楚的搞清楚map, flatmap,reduce的含义。学学斯科拉可以
幫助理解 |
|
B***i
发帖数: 724 | 37 scalding 里就用map, flatMap 等等来 来实现 一般fp的mapping, , 用 groupby 来实
现 maping + reducing |
|
c******o
发帖数: 1277 | 38 不熟c#
Scala 的future重点是能用flatMap/map composite.
多个future 可以用任意逻辑对其中的结果任意组合 （同时每一个都是独立，相对其他
async）（除非参数上有相对的先后，那也是自动会等待), 我一个callback都不用写，
只用在最后为组合的总和写一个（要是在一些framework里，最后一个 callback 都被
代劳了）。 |
|
c******o
发帖数: 1277 | 39 用了几个月scala. 说一下我的感觉
scala是一个general purpose language, 它有足够的工具解决绝大部分项目和问题。
scala不是一个all purpose language,它明显在很多领域只是可以用而已。大部分领域
有更好的语言了。
我的感觉是，scala最适用于：
1. 多并发，大规模的后端，很好的支持并发。
2. 分布式系统，高可用性，高容错，分布式实现容易。
3. 复杂逻辑后端，有很多很好的抽象方法可以选用，用的好，可以很干净。
4. 各种专业的库，是一个很好的建库的语言，当然，要求也高。
这些主要是因为：
1. FP和OO的融合使得scala有很强大的标准库支持，也很容易使人迷惑， 看看那个
play的Json library, 很强大，也很囧。
2. FP和OO的融合使得scala有很多种抽象的方法，很强大，但是也很容易被滥用，太多
pattern可以用来干同一件事。
3. 静态类型和type inference使得scala很适合大型，复杂的系统,高效的系统，也能
够写出比较简洁和干净的代码，要是不注意，容易影响可读性。
4. 调用jav... 阅读全帖 |
|
c******o
发帖数: 1277 | 40 再来一个程序
运行结果是在下一贴
import scala.concurrent._
import ExecutionContext.Implicits.global
object F extends App {
val xFut: Future[Int] = future {
Thread.sleep(10000);
println("x happened");
10
}.flatMap(i => Future.successful(i + 1))
val aFut: Int => Future[(Option[Int], Option[Int])] = a => {
val yFut: Future[Option[Int]] = future {
println("y begin")
Thread.sleep(6000);
println("y happened " + a);
Some(20)
}
val zFut: Future[Option[Int]] = future {
println(... 阅读全帖 |
|
c******o
发帖数: 1277 | 41 再来一个程序
运行结果是在下一贴
import scala.concurrent._
import ExecutionContext.Implicits.global
object F extends App {
val xFut: Future[Int] = future {
Thread.sleep(10000);
println("x happened");
10
}.flatMap(i => Future.successful(i + 1))
val aFut: Int => Future[(Option[Int], Option[Int])] = a => {
val yFut: Future[Option[Int]] = future {
println("y begin")
Thread.sleep(6000);
println("y happened " + a);
Some(20)
}
val zFut: Future[Option[Int]] = future {
println(... 阅读全帖 |
|
c******o
发帖数: 1277 | 42 运行结果在下一贴
import scala.concurrent._
import ExecutionContext.Implicits.global
object F extends App {
val xFut: Future[Int] = future {
Thread.sleep(10000);
println("x happened");
10
}.flatMap(i => Future.successful(i + 1))
val aFut: Int => Future[(Int, Int)] = a => {
val yFut: Future[Int] = future {
println("y begin")
Thread.sleep(6000);
println("y happened " + a);
20
}
val zFut: Future[Int] = future {
println("z begin")
Thread.sleep(5000);
print... 阅读全帖 |
|
c******o
发帖数: 1277 | 43 我觉得作用就是你可以在一定的时候自己写。并且能确定你写的可以compose (monad有
固定的property可以check).
你知道它是monad以后，可以马上就用join/map/unit写出一堆各种各样的function
(都可以用 join/map/unit写出来, 或者 flatMap/unit， 两个都是minimum set)。
就是一个抽象结构。有兴趣研究一下scalaz就知道了。 |
|
c******o
发帖数: 1277 | 44 For 就是一个 syntax sugar
Monad的本质是就是一个抽象代数结构。带flatMap/unit的
编程用它是为了control effect，让各种带effect的都可以compose
很多monad你用了可能都没注意到。
Monad 不是唯一的重要东西。
最近几年， applicative functor 就很火。
这些其实和app developer 关系不大，但是自己写reusable code（library/routine)
离不开 |
|
p*****2
发帖数: 21240 | 45
)
我看clojure上，同样的数据类型我可以应用不同的monad上去。这个Scala怎么搞？怎
么感觉每个type自己实现了flatmap和unit，也就是说只有一个monad呢？要想应用另外
的monad要新建一个type吗？ |
|
|
c******o
发帖数: 1277 | 47 你太敏感，我根本不觉得多少行代码有啥意义，我啥时候吹捧过那个。
我不用for,因为scala的for 不是 loop,只是flatMap/map的语法糖
着眼点是：
一个是固定逻辑处理，用var
一个是传入逻辑（函数）处理， 不用变量 var
你看看你的那上一个（不使这个）,就是一个半FP半OO,不要和我说java里没有FP |
|
k**********g
发帖数: 989 | 48
不是直接翻译公式，而是借用 flatmap 的概念简化了矩阵编程。MATLAB 对於非矩阵编
程用处不大。 |
|
T***1
发帖数: 445 | 49 你这个外行外大了。scala的精髓是flatMap,不是递归 |
|
c******o
发帖数: 1277 | 50 不，我意思是 实现类
Option[A]
Option 可以是 None 或者 Some[A]
至少实现以下三个方法
flatMap
map
zip
我其实不是开玩笑，你写写我说的两个题，碰到的问题就知道送我为什么问。
里面包括了好多重要的东西。
bubble sort 不要 stack overflow啊，要都是immutable啊
为啥选那三个method来做option,怎么实现[A] ? |
|
