l**********n
发帖数: 8443 | 1 我有个Option[T], 用map和flatmap有什么区别？返回什么type？ |
l**********n
发帖数: 8443 | 2 用map是返回一个Option[_]吧？如果f: T => V, 就用map，返回Option[V], 如果f： T
=> Option[V],就用flatmap， 返回Option[V], am I right? |
p*****2
发帖数: 21240 | 3 functor monad 的区别
【在 l**********n 的大作中提到】
: 我有个Option[T], 用map和flatmap有什么区别？返回什么type？
|
g*****g
发帖数: 34805 | 4 map是一对一的，flatmap可以是一对N的。典型的例子就是value是个list。map返回
list of list，flatmap返回merged的list.
【在 l**********n 的大作中提到】
: 我有个Option[T], 用map和flatmap有什么区别？返回什么type？
|
p*****2
发帖数: 21240 | 5
list只是一种monad
【在 g*****g 的大作中提到】
: map是一对一的，flatmap可以是一对N的。典型的例子就是value是个list。map返回
: list of list，flatmap返回merged的list.
|
g*****g
发帖数: 34805 | 6 我觉得你给这些高大上的词无助于解释他们的区别。
【在 p*****2 的大作中提到】
:
: list只是一种monad
|
p*****2
发帖数: 21240 | 7
我一直以为LZ是懂monad的。
【在 g*****g 的大作中提到】
: 我觉得你给这些高大上的词无助于解释他们的区别。
|
l**********n
发帖数: 8443 | 8 Option是monad吧？Scala的monad是通过trait实现的吧？
【在 p*****2 的大作中提到】
:
: 我一直以为LZ是懂monad的。
|
l**********n
发帖数: 8443 | 9 apply method is the unit function
【在 l**********n 的大作中提到】
: Option是monad吧？Scala的monad是通过trait实现的吧？
|
l**********n
发帖数: 8443 | 10 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
【在 l**********n 的大作中提到】
: apply method is the unit function
|
|
|
l**********n
发帖数: 8443 | 11 scala use trait and implicit to provide type class and type class members.
【在 l**********n 的大作中提到】
: 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
|
d******e
发帖数: 2265 | 12 flatmap就是map后再flat一下
【在 l**********n 的大作中提到】
: 我有个Option[T], 用map和flatmap有什么区别？返回什么type？
|
H****S
发帖数: 1359 | 13 返回的类型都是一样的，但是一个接受A => B，另外一个接受A => Option[B]。实际上
map是多余的，
Option.map(f) = Option.flatMap(f andThen Option.apply)
【在 l**********n 的大作中提到】
: 我有个Option[T], 用map和flatmap有什么区别？返回什么type？
|
c******o
发帖数: 1277 | 14 There are things that has map but does NOT have flatMap
【在 H****S 的大作中提到】
: 返回的类型都是一样的，但是一个接受A => B，另外一个接受A => Option[B]。实际上
: map是多余的，
: Option.map(f) = Option.flatMap(f andThen Option.apply)
|
d****r
发帖数: 300 | 15 这个只对list成立。真正的理解从monad开始。
【在 g*****g 的大作中提到】
: map是一对一的，flatmap可以是一对N的。典型的例子就是value是个list。map返回
: list of list，flatmap返回merged的list.
|
H****S
发帖数: 1359 | 16 他是问option的情况，我这样回答有什么错？我觉得好虫说得对，不要一上来就扯
monad和functor，要针对具体问题具体回答。
【在 c******o 的大作中提到】
: There are things that has map but does NOT have flatMap
|
p*****2
发帖数: 21240 | 17 为什么是多余的
【在 H****S 的大作中提到】
: 他是问option的情况，我这样回答有什么错？我觉得好虫说得对，不要一上来就扯
: monad和functor，要针对具体问题具体回答。
|
z****e
发帖数: 54598 | 18 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] |
p*****2
发帖数: 21240 | 19 解释了个表面
Iterables)
【在 z****e 的大作中提到】
: 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]
|
q*c
发帖数: 9453 | 20 但是有助于逼格啊。
【在 g*****g 的大作中提到】
: 我觉得你给这些高大上的词无助于解释他们的区别。
|
|
|
c******o
发帖数: 1277 | 21 从下面的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[B]
override def map[A, B](la: F[A])(f: A => B): F[B] =
ap(la)(unit(f))
}
// Applicative Law
// identity: ap(a, unit(id)) == a
// composition: ap(ap(a, g), f) == ap(a, ap(g, ap(f, unit(compose))))
// homomorphism: ap(unit(a), unit(f)) == unit(f(a))
// interchange: ap(unit(a), f) == ap(f, unit(f => f(x)))
trait Monad[F[_]] extends Applictive[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 => flatMap(la)(t2 => unit(t1(t2))))
override def map[A,B](ma: F[A])(f: A => B): F[B] =
flatMap(ma)(a => unit(f(a)))
}
// 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) |
c******o
发帖数: 1277 | 22 从下面的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 test1 =
x1.map(oneVarFunc)
//Applicative Functor
def test2 = {
optionap(x2)(x1.map(twoVarFunc.curried))
}
def test2_1 = {
optionap(x3)(x2.map(twoVarFunc.curried))
}
//Monad
def test3 = {
for {
r1 <- x1
r2 <- x2
} yield {
if(r1 == 1) {
r1 * r2
} else {
r1 + r2
}
}
}
def compose[A,B,C](f: A => List[B], g: B => List[C]): A => List[C] = ???
} |
p*****2
发帖数: 21240 | 23 monad 一定是 functor
functor 不一定是monad
所以map不是可有可无的
【在 c******o 的大作中提到】
: 从下面的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]
: }
|
d******e
发帖数: 2265 | 24 还在讨论。俺们草蜢快类型的根本不管什么术语。上个 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
网上的例子。简单说,为了box类型 （monad)的composable,又不想option option
option 1000 times [A]
就用flat map,或者for compreshion。其实还是for -comprehenision好懂，不用大讨
论了。
【在 p*****2 的大作中提到】
: monad 一定是 functor
: functor 不一定是monad
: 所以map不是可有可无的
|
p*****2
发帖数: 21240 | 25 future是monad呀
你要用list map更普遍 更容易懂
例：
【在 d******e 的大作中提到】
: 还在讨论。俺们草蜢快类型的根本不管什么术语。上个 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)
: }
|
d******e
发帖数: 2265 | 26 说list大家都明白。换到option上就不太好理解了。其实就是壳子套壳子，再打开一个
壳子。monad这写名词我学玩haskell早忘光了。又不每天用
【在 p*****2 的大作中提到】
: future是monad呀
: 你要用list map更普遍 更容易懂
:
: 例：
|
l**********n
发帖数: 8443 | 27 it is about non-deterministic. so Option is a good example. try is good too.
container is not a good explanation. container is about type safety.
【在 d******e 的大作中提到】
: 说list大家都明白。换到option上就不太好理解了。其实就是壳子套壳子，再打开一个
: 壳子。monad这写名词我学玩haskell早忘光了。又不每天用
|
d******e
发帖数: 2265 | 28 不是很确定我理解正确与否。特别是type safety.
不过box或者container是通用的比喻。
I already mentioned that Option[A] is a container for a value of type A.
More precisely, you may think of it as some kind of collection – some
special snowflake of a collection that contains either zero elements or
exactly one element of type A. This is a very powerful idea!
还有：
http://learnyouahaskell.com/functors-applicative-functors-and-m
too.
【在 l**********n 的大作中提到】
: it is about non-deterministic. so Option is a good example. try is good too.
: container is not a good explanation. container is about type safety.
|
l**********n
发帖数: 8443 | 29 你要说collection, 熟悉oop的人就会以为是collection API, 其实更应该是个type
class.
【在 d******e 的大作中提到】
: 不是很确定我理解正确与否。特别是type safety.
: 不过box或者container是通用的比喻。
: I already mentioned that Option[A] is a container for a value of type A.
: More precisely, you may think of it as some kind of collection – some
: special snowflake of a collection that contains either zero elements or
: exactly one element of type A. This is a very powerful idea!
: 还有：
: http://learnyouahaskell.com/functors-applicative-functors-and-m
:
: too.
|
p*****2
发帖数: 21240 | 30
那是因为flapMap这个函数名起的有问题，换成bind就明了了。
【在 d******e 的大作中提到】
: 说list大家都明白。换到option上就不太好理解了。其实就是壳子套壳子，再打开一个
: 壳子。monad这写名词我学玩haskell早忘光了。又不每天用
|
|
|
z****e
发帖数: 54598 | 31
no
collection和collections是两回事
java中也是这样的
【在 l**********n 的大作中提到】
: 你要说collection, 熟悉oop的人就会以为是collection API, 其实更应该是个type
: class.
|
z****e
发帖数: 54598 | 32 换bind才崩溃
bind另有他用
在observer时候用得最多
【在 p*****2 的大作中提到】
:
: 那是因为flapMap这个函数名起的有问题，换成bind就明了了。
|
z****e
发帖数: 54598 | 33 没几个人用术语，整个回帖看下来
多数人对于术语的使用是一种批判的态度
更多人是举例，解决问题
例：
【在 d******e 的大作中提到】
: 还在讨论。俺们草蜢快类型的根本不管什么术语。上个 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)
: }
|
l**********n
发帖数: 8443 | 34 一堆人都没有真正理解scala, 包招那些monad挂在嘴边的。this is because there is
an implicit conversion to Iterable, so that one can call Iterable methods
on Option.
【在 z****e 的大作中提到】
: 没几个人用术语，整个回帖看下来
: 多数人对于术语的使用是一种批判的态度
: 更多人是举例，解决问题
:
: 例：
|
p*****2
发帖数: 21240 | 35
is
it's implementation details if it's true. concept is at higher level. To
understand monad, you don't have to know implementation.
【在 l**********n 的大作中提到】
: 一堆人都没有真正理解scala, 包招那些monad挂在嘴边的。this is because there is
: an implicit conversion to Iterable, so that one can call Iterable methods
: on Option.
|
l******t
发帖数: 55733 | 36
我喜欢用context。context处理context内部的事，你处理你的事。
【在 d******e 的大作中提到】
: 不是很确定我理解正确与否。特别是type safety.
: 不过box或者container是通用的比喻。
: I already mentioned that Option[A] is a container for a value of type A.
: More precisely, you may think of it as some kind of collection – some
: special snowflake of a collection that contains either zero elements or
: exactly one element of type A. This is a very powerful idea!
: 还有：
: http://learnyouahaskell.com/functors-applicative-functors-and-m
:
: too.
|
p*****2
发帖数: 21240 | 37 container with context
【在 l******t 的大作中提到】
:
: 我喜欢用context。context处理context内部的事，你处理你的事。
|
l******t
发帖数: 55733 | 38
也可以这么说。box也没问题。自己手办几个就明白了。
【在 p*****2 的大作中提到】
: container with context
|
