FAQ
看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

--
您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
要查看更多选项,请访问 https://groups.google.com/d/optout。

Search Discussions

  • Liu Sam at May 9, 2014 at 2:04 am
    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map 和 flattenMap 之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用 monad 的方式包装起来用。这里分享一个之前转发的文章(http://wind13.lofter.com/post/b2b9b_f33079),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:
    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Fei Wang at May 9, 2014 at 3:00 am
    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器


    2014-05-09 10:04 GMT+08:00 Liu Sam <worldwind13@gmail.com>:
    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map 和
    flattenMap
    之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用
    monad 的方式包装起来用。这里分享一个之前转发的文章(http://wind13.lofter.com/post/b2b9b_f33079
    ),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:

    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Xiang Zhang at May 9, 2014 at 3:03 am
    to making imperative programming in functional programming.

    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang <pythonee@gmail.com>:
    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器


    2014-05-09 10:04 GMT+08:00 Liu Sam <worldwind13@gmail.com>:

    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map 和
    flattenMap
    之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用
    monad 的方式包装起来用。这里分享一个之前转发的文章(http://wind13.lofter.com/post/b2b9b_f33079
    ),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:

    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Fei Wang at May 9, 2014 at 3:48 am
    能给点伪代码吗


    2014-05-09 11:03 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:
    to making imperative programming in functional programming.

    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器


    2014-05-09 10:04 GMT+08:00 Liu Sam <worldwind13@gmail.com>:

    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map 和
    flattenMap
    之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用
    monad 的方式包装起来用。这里分享一个之前转发的文章(http://wind13.lofter.com/post/b2b9b_f33079
    ),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:

    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Xiang Zhang at May 9, 2014 at 3:56 am
    我不熟悉scala,我是用F#的,不过我最近开发的一款产品Alea.cuBase (http://www.quantalea.net) 就是采用的
    monad来定义GPU 程序,比如:

    let gpuTemplate = cuda {
        let! kernel1 = <@ fun x y -> .... @> |> Compiler.DefineKernel
        let! kernel2 = <@ fun x y -> .... @> |> Compiler.DefineKernel
        return Entry(fun program -> ...) }

    这里 cuda 就是一个定义的monad,里面的let binding是用的 let!
    ,这样就定义了一系列的定义函数,但并没有编译GPU代码,所以我称之为 template.
    接下来我可以开始编译GPU code:

    let program = Compiler.load gpuTemplate Worker

    这样,这个template就被编译了,而我们之前的各个definekernel将会被这里执行.


    2014-05-09 11:48 GMT+08:00 Fei Wang <pythonee@gmail.com>:
    能给点伪代码吗


    2014-05-09 11:03 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    to making imperative programming in functional programming.
    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器


    2014-05-09 10:04 GMT+08:00 Liu Sam <worldwind13@gmail.com>:

    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map 和
    flattenMap
    之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用
    monad 的方式包装起来用。这里分享一个之前转发的文章(http://wind13.lofter.com/post/b2b9b_f33079
    ),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:

    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Xiang Zhang at May 9, 2014 at 3:59 am
    你可以去网上搜索一下 state monad


    2014-05-09 11:56 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:
    我不熟悉scala,我是用F#的,不过我最近开发的一款产品Alea.cuBase (http://www.quantalea.net) 就是采用的
    monad来定义GPU 程序,比如:

    let gpuTemplate = cuda {
    let! kernel1 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    let! kernel2 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    return Entry(fun program -> ...) }

    这里 cuda 就是一个定义的monad,里面的let binding是用的 let!
    ,这样就定义了一系列的定义函数,但并没有编译GPU代码,所以我称之为 template.
    接下来我可以开始编译GPU code:

    let program = Compiler.load gpuTemplate Worker

    这样,这个template就被编译了,而我们之前的各个definekernel将会被这里执行.


    2014-05-09 11:48 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    能给点伪代码吗

    2014-05-09 11:03 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    to making imperative programming in functional programming.
    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器


    2014-05-09 10:04 GMT+08:00 Liu Sam <worldwind13@gmail.com>:

    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map 和
    flattenMap
    之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用
    monad 的方式包装起来用。这里分享一个之前转发的文章(
    http://wind13.lofter.com/post/b2b9b_f33079
    ),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:

    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Xiang Zhang at May 9, 2014 at 4:15 am
    补充说一下,也许一开始就接触I/O monad可能不是很习惯,建议可以先搜索一下 maybe monad 和 state
    monad,然后再阅读一下monad的blog,就会比较清楚一点,我个人感觉,monad实际上是一些高阶函数的嵌套。


    2014-05-09 11:59 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:
    你可以去网上搜索一下 state monad


    2014-05-09 11:56 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    我不熟悉scala,我是用F#的,不过我最近开发的一款产品Alea.cuBase (http://www.quantalea.net) 就是采用的
    monad来定义GPU 程序,比如:

    let gpuTemplate = cuda {
    let! kernel1 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    let! kernel2 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    return Entry(fun program -> ...) }

    这里 cuda 就是一个定义的monad,里面的let binding是用的 let!
    ,这样就定义了一系列的定义函数,但并没有编译GPU代码,所以我称之为 template.
    接下来我可以开始编译GPU code:

    let program = Compiler.load gpuTemplate Worker

    这样,这个template就被编译了,而我们之前的各个definekernel将会被这里执行.


    2014-05-09 11:48 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    能给点伪代码吗

    2014-05-09 11:03 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    to making imperative programming in functional programming.
    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器


    2014-05-09 10:04 GMT+08:00 Liu Sam <worldwind13@gmail.com>:

    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map 和
    flattenMap
    之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用
    monad 的方式包装起来用。这里分享一个之前转发的文章(
    http://wind13.lofter.com/post/b2b9b_f33079
    ),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:

    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Caoyuan at May 9, 2014 at 8:16 am
    为什么会有monad这些东西,我在微博上断断续续说过一些,贴在这里:

    单从monad是这样那样,能这样那样,去理解monad
    ,确实像盲人摸象,很难把握它。可如果你跳出来,想像什么样的东西能够作为最基本的单元来概括运算的本质,不管它是值的运算、还是类型的运算、不管是什么类型或者类型的类型,或者是运算的运算,可能能帮助你理解为什么
    monad会是这个样子。

    一种东西变换之后还是自己,但又不会完全是自己,因为需要能引入新的能力。同时它们串起来能处理所有问题,而问题本身又可以表达为自己,同时可以串起来被处理。

    而monad就是一个通用的combinator
    interface。//@GeniusVczh<http://weibo.com/n/GeniusVczh?from=feed&loc=at>:
    这个东西就是combinator

    要实现这种变换,可以先从虚空中想像出一种context,不管里面怎么变,出来还是这个它。最简单的就是“有(Just)”和“无(Nothing)”,都归类为Maybe,然后是List之类的集合,再往上,包括运算本身比如Functor,Applicative等,最后终于到了IO。//
    @邓草原 <http://weibo.com/n/%E9%82%93%E8%8D%89%E5%8E%9F?from=feed&loc=at>: 而
    monad就是一个通用的combinator interface


    2014-05-09 12:15 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:
    补充说一下,也许一开始就接触I/O monad可能不是很习惯,建议可以先搜索一下 maybe monad 和 state
    monad,然后再阅读一下monad的blog,就会比较清楚一点,我个人感觉,monad实际上是一些高阶函数的嵌套。


    2014-05-09 11:59 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    你可以去网上搜索一下 state monad

    2014-05-09 11:56 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    我不熟悉scala,我是用F#的,不过我最近开发的一款产品Alea.cuBase (http://www.quantalea.net)
    就是采用的 monad来定义GPU 程序,比如:

    let gpuTemplate = cuda {
    let! kernel1 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    let! kernel2 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    return Entry(fun program -> ...) }

    这里 cuda 就是一个定义的monad,里面的let binding是用的 let!
    ,这样就定义了一系列的定义函数,但并没有编译GPU代码,所以我称之为 template.
    接下来我可以开始编译GPU code:

    let program = Compiler.load gpuTemplate Worker

    这样,这个template就被编译了,而我们之前的各个definekernel将会被这里执行.


    2014-05-09 11:48 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    能给点伪代码吗

    2014-05-09 11:03 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    to making imperative programming in functional programming.
    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器


    2014-05-09 10:04 GMT+08:00 Liu Sam <worldwind13@gmail.com>:

    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map
    和 flattenMap
    之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用
    monad 的方式包装起来用。这里分享一个之前转发的文章(
    http://wind13.lofter.com/post/b2b9b_f33079
    ),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:

    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Fei Wang at May 9, 2014 at 9:28 am

    2014-05-09 16:16 GMT+08:00 Caoyuan <dcaoyuan@gmail.com>:

    这个东西就是combinator

    这个总结有点击中我的感觉了,我就是觉得Monad是极其抽象的,它什么都可以包,而且一旦包上去
    就脱不下来了​



    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Fei Wang at May 9, 2014 at 9:37 am
    如果有人用Monad和非Monad的方式来对比一段程序(哪怕是伪代码),由浅入深,估计我这种新手更好理解,主要FP里面的理论太多
    其实说combinator,我还是得去了解下combinator是什么


    2014-05-09 16:16 GMT+08:00 Caoyuan <dcaoyuan@gmail.com>:
    为什么会有monad这些东西,我在微博上断断续续说过一些,贴在这里:

    单从monad是这样那样,能这样那样,去理解monad
    ,确实像盲人摸象,很难把握它。可如果你跳出来,想像什么样的东西能够作为最基本的单元来概括运算的本质,不管它是值的运算、还是类型的运算、不管是什么类型或者类型的类型,或者是运算的运算,可能能帮助你理解为什么
    monad会是这个样子。

    一种东西变换之后还是自己,但又不会完全是自己,因为需要能引入新的能力。同时它们串起来能处理所有问题,而问题本身又可以表达为自己,同时可以串起来被处理。

    而monad就是一个通用的combinator interface。//@GeniusVczh<http://weibo.com/n/GeniusVczh?from=feed&loc=at>:
    这个东西就是combinator


    要实现这种变换,可以先从虚空中想像出一种context,不管里面怎么变,出来还是这个它。最简单的就是“有(Just)”和“无(Nothing)”,都归类为Maybe,然后是List之类的集合,再往上,包括运算本身比如Functor,Applicative等,最后终于到了IO。//
    @邓草原 <http://weibo.com/n/%E9%82%93%E8%8D%89%E5%8E%9F?from=feed&loc=at>: 而
    monad就是一个通用的combinator interface


    2014-05-09 12:15 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    补充说一下,也许一开始就接触I/O monad可能不是很习惯,建议可以先搜索一下 maybe monad 和 state
    monad,然后再阅读一下monad的blog,就会比较清楚一点,我个人感觉,monad实际上是一些高阶函数的嵌套。


    2014-05-09 11:59 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    你可以去网上搜索一下 state monad

    2014-05-09 11:56 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    我不熟悉scala,我是用F#的,不过我最近开发的一款产品Alea.cuBase (http://www.quantalea.net)
    就是采用的 monad来定义GPU 程序,比如:

    let gpuTemplate = cuda {
    let! kernel1 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    let! kernel2 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    return Entry(fun program -> ...) }

    这里 cuda 就是一个定义的monad,里面的let binding是用的 let!
    ,这样就定义了一系列的定义函数,但并没有编译GPU代码,所以我称之为 template.
    接下来我可以开始编译GPU code:

    let program = Compiler.load gpuTemplate Worker

    这样,这个template就被编译了,而我们之前的各个definekernel将会被这里执行.


    2014-05-09 11:48 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    能给点伪代码吗

    2014-05-09 11:03 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    to making imperative programming in functional programming.
    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器


    2014-05-09 10:04 GMT+08:00 Liu Sam <worldwind13@gmail.com>:

    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map
    和 flattenMap
    之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用
    monad 的方式包装起来用。这里分享一个之前转发的文章(
    http://wind13.lofter.com/post/b2b9b_f33079
    ),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:

    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Caoyuan at May 9, 2014 at 9:41 am
    http://weibo.com/p/1005051875401263/weibo?profile_ftype=1&key_word=monad&is_search=1#_0


    http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html


    2014-05-09 17:37 GMT+08:00 Fei Wang <pythonee@gmail.com>:
    如果有人用Monad和非Monad的方式来对比一段程序(哪怕是伪代码),由浅入深,估计我这种新手更好理解,主要FP里面的理论太多
    其实说combinator,我还是得去了解下combinator是什么


    2014-05-09 16:16 GMT+08:00 Caoyuan <dcaoyuan@gmail.com>:
    为什么会有monad这些东西,我在微博上断断续续说过一些,贴在这里:

    单从monad是这样那样,能这样那样,去理解monad
    ,确实像盲人摸象,很难把握它。可如果你跳出来,想像什么样的东西能够作为最基本的单元来概括运算的本质,不管它是值的运算、还是类型的运算、不管是什么类型或者类型的类型,或者是运算的运算,可能能帮助你理解为什么
    monad会是这个样子。


    一种东西变换之后还是自己,但又不会完全是自己,因为需要能引入新的能力。同时它们串起来能处理所有问题,而问题本身又可以表达为自己,同时可以串起来被处理。

    而monad就是一个通用的combinator interface。//@GeniusVczh<http://weibo.com/n/GeniusVczh?from=feed&loc=at>:
    这个东西就是combinator


    要实现这种变换,可以先从虚空中想像出一种context,不管里面怎么变,出来还是这个它。最简单的就是“有(Just)”和“无(Nothing)”,都归类为Maybe,然后是List之类的集合,再往上,包括运算本身比如Functor,Applicative等,最后终于到了IO。//
    @邓草原 <http://weibo.com/n/%E9%82%93%E8%8D%89%E5%8E%9F?from=feed&loc=at>: 而
    monad就是一个通用的combinator interface


    2014-05-09 12:15 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    补充说一下,也许一开始就接触I/O monad可能不是很习惯,建议可以先搜索一下 maybe monad 和 state
    monad,然后再阅读一下monad的blog,就会比较清楚一点,我个人感觉,monad实际上是一些高阶函数的嵌套。


    2014-05-09 11:59 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    你可以去网上搜索一下 state monad

    2014-05-09 11:56 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    我不熟悉scala,我是用F#的,不过我最近开发的一款产品Alea.cuBase (http://www.quantalea.net)
    就是采用的 monad来定义GPU 程序,比如:

    let gpuTemplate = cuda {
    let! kernel1 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    let! kernel2 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    return Entry(fun program -> ...) }

    这里 cuda 就是一个定义的monad,里面的let binding是用的 let!
    ,这样就定义了一系列的定义函数,但并没有编译GPU代码,所以我称之为 template.
    接下来我可以开始编译GPU code:

    let program = Compiler.load gpuTemplate Worker

    这样,这个template就被编译了,而我们之前的各个definekernel将会被这里执行.


    2014-05-09 11:48 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    能给点伪代码吗

    2014-05-09 11:03 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    to making imperative programming in functional programming.
    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器


    2014-05-09 10:04 GMT+08:00 Liu Sam <worldwind13@gmail.com>:

    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是
    map 和 flattenMap
    之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用
    monad 的方式包装起来用。这里分享一个之前转发的文章(
    http://wind13.lofter.com/post/b2b9b_f33079
    ),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:

    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Fei Wang at May 9, 2014 at 11:17 am
    对了,这里这个combinator和那个传说中的Y combinator是一回事吗


    2014-05-09 16:16 GMT+08:00 Caoyuan <dcaoyuan@gmail.com>:
    为什么会有monad这些东西,我在微博上断断续续说过一些,贴在这里:

    单从monad是这样那样,能这样那样,去理解monad
    ,确实像盲人摸象,很难把握它。可如果你跳出来,想像什么样的东西能够作为最基本的单元来概括运算的本质,不管它是值的运算、还是类型的运算、不管是什么类型或者类型的类型,或者是运算的运算,可能能帮助你理解为什么
    monad会是这个样子。

    一种东西变换之后还是自己,但又不会完全是自己,因为需要能引入新的能力。同时它们串起来能处理所有问题,而问题本身又可以表达为自己,同时可以串起来被处理。

    而monad就是一个通用的combinator interface。//@GeniusVczh<http://weibo.com/n/GeniusVczh?from=feed&loc=at>:
    这个东西就是combinator


    要实现这种变换,可以先从虚空中想像出一种context,不管里面怎么变,出来还是这个它。最简单的就是“有(Just)”和“无(Nothing)”,都归类为Maybe,然后是List之类的集合,再往上,包括运算本身比如Functor,Applicative等,最后终于到了IO。//
    @邓草原 <http://weibo.com/n/%E9%82%93%E8%8D%89%E5%8E%9F?from=feed&loc=at>: 而
    monad就是一个通用的combinator interface


    2014-05-09 12:15 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    补充说一下,也许一开始就接触I/O monad可能不是很习惯,建议可以先搜索一下 maybe monad 和 state
    monad,然后再阅读一下monad的blog,就会比较清楚一点,我个人感觉,monad实际上是一些高阶函数的嵌套。


    2014-05-09 11:59 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    你可以去网上搜索一下 state monad

    2014-05-09 11:56 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    我不熟悉scala,我是用F#的,不过我最近开发的一款产品Alea.cuBase (http://www.quantalea.net)
    就是采用的 monad来定义GPU 程序,比如:

    let gpuTemplate = cuda {
    let! kernel1 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    let! kernel2 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    return Entry(fun program -> ...) }

    这里 cuda 就是一个定义的monad,里面的let binding是用的 let!
    ,这样就定义了一系列的定义函数,但并没有编译GPU代码,所以我称之为 template.
    接下来我可以开始编译GPU code:

    let program = Compiler.load gpuTemplate Worker

    这样,这个template就被编译了,而我们之前的各个definekernel将会被这里执行.


    2014-05-09 11:48 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    能给点伪代码吗

    2014-05-09 11:03 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    to making imperative programming in functional programming.
    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器


    2014-05-09 10:04 GMT+08:00 Liu Sam <worldwind13@gmail.com>:

    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map
    和 flattenMap
    之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用
    monad 的方式包装起来用。这里分享一个之前转发的文章(
    http://wind13.lofter.com/post/b2b9b_f33079
    ),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:

    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Xiang Zhang at May 9, 2014 at 11:42 am
    说monad确实让人云里雾里,所以在F#里,微软将其称为computation
    expression,又称为workflow,我觉得这更容易让大众理解一些。


    2014-05-09 19:17 GMT+08:00 Fei Wang <pythonee@gmail.com>:
    对了,这里这个combinator和那个传说中的Y combinator是一回事吗


    2014-05-09 16:16 GMT+08:00 Caoyuan <dcaoyuan@gmail.com>:
    为什么会有monad这些东西,我在微博上断断续续说过一些,贴在这里:

    单从monad是这样那样,能这样那样,去理解monad
    ,确实像盲人摸象,很难把握它。可如果你跳出来,想像什么样的东西能够作为最基本的单元来概括运算的本质,不管它是值的运算、还是类型的运算、不管是什么类型或者类型的类型,或者是运算的运算,可能能帮助你理解为什么
    monad会是这个样子。


    一种东西变换之后还是自己,但又不会完全是自己,因为需要能引入新的能力。同时它们串起来能处理所有问题,而问题本身又可以表达为自己,同时可以串起来被处理。

    而monad就是一个通用的combinator interface。//@GeniusVczh<http://weibo.com/n/GeniusVczh?from=feed&loc=at>:
    这个东西就是combinator


    要实现这种变换,可以先从虚空中想像出一种context,不管里面怎么变,出来还是这个它。最简单的就是“有(Just)”和“无(Nothing)”,都归类为Maybe,然后是List之类的集合,再往上,包括运算本身比如Functor,Applicative等,最后终于到了IO。//
    @邓草原 <http://weibo.com/n/%E9%82%93%E8%8D%89%E5%8E%9F?from=feed&loc=at>: 而
    monad就是一个通用的combinator interface


    2014-05-09 12:15 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    补充说一下,也许一开始就接触I/O monad可能不是很习惯,建议可以先搜索一下 maybe monad 和 state
    monad,然后再阅读一下monad的blog,就会比较清楚一点,我个人感觉,monad实际上是一些高阶函数的嵌套。


    2014-05-09 11:59 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    你可以去网上搜索一下 state monad

    2014-05-09 11:56 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    我不熟悉scala,我是用F#的,不过我最近开发的一款产品Alea.cuBase (http://www.quantalea.net)
    就是采用的 monad来定义GPU 程序,比如:

    let gpuTemplate = cuda {
    let! kernel1 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    let! kernel2 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    return Entry(fun program -> ...) }

    这里 cuda 就是一个定义的monad,里面的let binding是用的 let!
    ,这样就定义了一系列的定义函数,但并没有编译GPU代码,所以我称之为 template.
    接下来我可以开始编译GPU code:

    let program = Compiler.load gpuTemplate Worker

    这样,这个template就被编译了,而我们之前的各个definekernel将会被这里执行.


    2014-05-09 11:48 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    能给点伪代码吗

    2014-05-09 11:03 GMT+08:00 Xiang Zhang <soloman817@gmail.com>:

    to making imperative programming in functional programming.
    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang <pythonee@gmail.com>:

    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器


    2014-05-09 10:04 GMT+08:00 Liu Sam <worldwind13@gmail.com>:

    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是
    map 和 flattenMap
    之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用
    monad 的方式包装起来用。这里分享一个之前转发的文章(
    http://wind13.lofter.com/post/b2b9b_f33079
    ),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com



    在 2014年5月8日,下午7:17,Fei Wang <pythonee@gmail.com> 写道:

    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Tao at May 9, 2014 at 3:15 pm
    确实,不要为一个看起来奇怪的词而纠结。不要被名字吓到了。。。

    --
    tao
    Sent with Sparrow (http://www.sparrowmailapp.com/?sig)

    On Friday, May 9, 2014 at 7:42 PM, Xiang Zhang wrote:

    说monad确实让人云里雾里,所以在F#里,微软将其称为computation expression,又称为workflow,我觉得这更容易让大众理解一些。



    2014-05-09 19:17 GMT+08:00 Fei Wang (mailto:pythonee@gmail.com)>:
    对了,这里这个combinator和那个传说中的Y combinator是一回事吗


    2014-05-09 16:16 GMT+08:00 Caoyuan (mailto:dcaoyuan@gmail.com)>:
    为什么会有monad这些东西,我在微博上断断续续说过一些,贴在这里:

    单从monad是这样那样,能这样那样,去理解monad,确实像盲人摸象,很难把握它。可如果你跳出来,想像什么样的东西能够作为最基本的单元来概括运算的本质,不管它是值的运算、还是类型的运算、不管是什么类型或者类型的类型,或者是运算的运算,可能能帮助你理解为什么monad会是这个样子。

    一种东西变换之后还是自己,但又不会完全是自己,因为需要能引入新的能力。同时它们串起来能处理所有问题,而问题本身又可以表达为自己,同时可以串起来被处理。

    而monad就是一个通用的combinator interface。//@GeniusVczh (http://weibo.com/n/GeniusVczh?from=feed&loc=at): 这个东西就是combinator

    要实现这种变换,可以先从虚空中想像出一种context,不管里面怎么变,出来还是这个它。最简单的就是“有(Just)”和“无(Nothing)”,都归类为Maybe,然后是List之类的集合,再往上,包括运算本身比如Functor,Applicative等,最后终于到了IO。//@邓草原 (http://weibo.com/n/%E9%82%93%E8%8D%89%E5%8E%9F?from=feed&loc=at): 而monad就是一个通用的combinator interface


    2014-05-09 12:15 GMT+08:00 Xiang Zhang (mailto:soloman817@gmail.com)>:
    补充说一下,也许一开始就接触I/O monad可能不是很习惯,建议可以先搜索一下 maybe monad 和 state monad,然后再阅读一下monad的blog,就会比较清楚一点,我个人感觉,monad实际上是一些高阶函数的嵌套。


    2014-05-09 11:59 GMT+08:00 Xiang Zhang (mailto:soloman817@gmail.com)>:
    你可以去网上搜索一下 state monad


    2014-05-09 11:56 GMT+08:00 Xiang Zhang (mailto:soloman817@gmail.com)>:
    我不熟悉scala,我是用F#的,不过我最近开发的一款产品Alea.cuBase (http://www.quantalea.net) 就是采用的 monad来定义GPU 程序,比如:

    let gpuTemplate = cuda {
    let! kernel1 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    let! kernel2 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    return Entry(fun program -> ...) }

    这里 cuda 就是一个定义的monad,里面的let binding是用的 let! ,这样就定义了一系列的定义函数,但并没有编译GPU代码,所以我称之为 template.
    接下来我可以开始编译GPU code:

    let program = Compiler.load gpuTemplate Worker

    这样,这个template就被编译了,而我们之前的各个definekernel将会被这里执行.


    2014-05-09 11:48 GMT+08:00 Fei Wang (mailto:pythonee@gmail.com)>:
    能给点伪代码吗


    2014-05-09 11:03 GMT+08:00 Xiang Zhang (mailto:soloman817@gmail.com)>:
    to making imperative programming in functional programming.

    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang (mailto:pythonee@gmail.com)>:
    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器



    2014-05-09 10:04 GMT+08:00 Liu Sam (mailto:worldwind13@gmail.com)>:
    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map 和 flattenMap 之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用 monad 的方式包装起来用。这里分享一个之前转发的文章(http://wind13.lofter.com/post/b2b9b_f33079),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com (mailto:worldwind13@gmail.com)



    在 2014年5月8日,下午7:17,Fei Wang (mailto:pythonee@gmail.com)> 写道:
    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Tao at May 9, 2014 at 3:16 pm
    你想多了。。。

    --
    tao
    Sent with Sparrow (http://www.sparrowmailapp.com/?sig)

    On Friday, May 9, 2014 at 7:17 PM, Fei Wang wrote:

    对了,这里这个combinator和那个传说中的Y combinator是一回事吗



    2014-05-09 16:16 GMT+08:00 Caoyuan (mailto:dcaoyuan@gmail.com)>:
    为什么会有monad这些东西,我在微博上断断续续说过一些,贴在这里:

    单从monad是这样那样,能这样那样,去理解monad,确实像盲人摸象,很难把握它。可如果你跳出来,想像什么样的东西能够作为最基本的单元来概括运算的本质,不管它是值的运算、还是类型的运算、不管是什么类型或者类型的类型,或者是运算的运算,可能能帮助你理解为什么monad会是这个样子。

    一种东西变换之后还是自己,但又不会完全是自己,因为需要能引入新的能力。同时它们串起来能处理所有问题,而问题本身又可以表达为自己,同时可以串起来被处理。

    而monad就是一个通用的combinator interface。//@GeniusVczh (http://weibo.com/n/GeniusVczh?from=feed&loc=at): 这个东西就是combinator

    要实现这种变换,可以先从虚空中想像出一种context,不管里面怎么变,出来还是这个它。最简单的就是“有(Just)”和“无(Nothing)”,都归类为Maybe,然后是List之类的集合,再往上,包括运算本身比如Functor,Applicative等,最后终于到了IO。//@邓草原 (http://weibo.com/n/%E9%82%93%E8%8D%89%E5%8E%9F?from=feed&loc=at): 而monad就是一个通用的combinator interface


    2014-05-09 12:15 GMT+08:00 Xiang Zhang (mailto:soloman817@gmail.com)>:
    补充说一下,也许一开始就接触I/O monad可能不是很习惯,建议可以先搜索一下 maybe monad 和 state monad,然后再阅读一下monad的blog,就会比较清楚一点,我个人感觉,monad实际上是一些高阶函数的嵌套。


    2014-05-09 11:59 GMT+08:00 Xiang Zhang (mailto:soloman817@gmail.com)>:
    你可以去网上搜索一下 state monad


    2014-05-09 11:56 GMT+08:00 Xiang Zhang (mailto:soloman817@gmail.com)>:
    我不熟悉scala,我是用F#的,不过我最近开发的一款产品Alea.cuBase (http://www.quantalea.net) 就是采用的 monad来定义GPU 程序,比如:

    let gpuTemplate = cuda {
    let! kernel1 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    let! kernel2 = <@ fun x y -> .... @> |> Compiler.DefineKernel
    return Entry(fun program -> ...) }

    这里 cuda 就是一个定义的monad,里面的let binding是用的 let! ,这样就定义了一系列的定义函数,但并没有编译GPU代码,所以我称之为 template.
    接下来我可以开始编译GPU code:

    let program = Compiler.load gpuTemplate Worker

    这样,这个template就被编译了,而我们之前的各个definekernel将会被这里执行.


    2014-05-09 11:48 GMT+08:00 Fei Wang (mailto:pythonee@gmail.com)>:
    能给点伪代码吗


    2014-05-09 11:03 GMT+08:00 Xiang Zhang (mailto:soloman817@gmail.com)>:
    to making imperative programming in functional programming.

    纯函数编程是不能有副作用的,所有IO操作都有副作用,改变了状态,monad通过高阶函数来模拟这个过程。


    2014-05-09 11:00 GMT+08:00 Fei Wang (mailto:pythonee@gmail.com)>:
    好的,我看一下,目前我能理解的是Monad是一个类型容器,它解决IO还要靠延迟求值,但是不晓得
    为什么非要一个类型容器



    2014-05-09 10:04 GMT+08:00 Liu Sam (mailto:worldwind13@gmail.com)>:
    这个……看来你研究得比较深入了啊,我不太理解为什么需要 monad,看那个monad are elephant 的介绍中好象就是 map 和 flattenMap 之类的应用,函数式语言的特色嘛,函数被作为第一公民来对待,可以当参数,可以当返回结果,这也就只是我目前的理解,通俗了说就是用函数再组合出更牛的函数,用 monad 的方式包装起来用。这里分享一个之前转发的文章(http://wind13.lofter.com/post/b2b9b_f33079),不太理解作者说的内容,呵呵……也许对你能有些什么启发吧!

    Best regards!

    Sam Liu
    worldwind13@gmail.com (mailto:worldwind13@gmail.com)



    在 2014年5月8日,下午7:17,Fei Wang (mailto:pythonee@gmail.com)> 写道:
    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢


    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --
    Cheers,
    王飞

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com (mailto:scalacn+unsubscribe@googlegroups.com)。
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com (mailto:scalacn@googlegroups.com)。
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Hao huang at May 9, 2014 at 3:16 pm
    我是最近才开始了解scala。提供点资料,希望有用。

    http://www.ppurl.com/2013/09/functional-programming-in-scalameap.html
    这本书“Functional programming in scala"有这么一段:

    Functional programming (FP) is based on a simple premise with far-reaching
    implications: We construct our programs using only pure functions. In other
    words,
    functions that have no side effects. What does this mean exactly?
    Performing any
    of the following actions directly would involve a side effect:
    * Reassigning a variable
    * Modifying a data structure in place
    * Setting a field on an object
    * Throwing an exception or halting with an error
    * Printing to the console or reading user input
    * Reading from or writing to a file
    * Drawing on the screen

    用来解决这些side effects都需要monad,例如Option, Either, Future/Promise。

    这有个video的课程,讲师之一是Martin Odersky。
    你可以直接从第三周开始看:Monads and Effects
    https://class.coursera.org/reactive-001/lecture

    谢谢



    2014-05-08 19:17 GMT+08:00 Fei Wang <pythonee@gmail.com>:
    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • Xuefeng Wu at May 9, 2014 at 3:21 pm
    monad 可以很简单,也可以很复杂。像Haskell的IO是比较复杂的应用,可以先从简单的开始理解。

    *http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html
    <http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html>*



    像Scala 的 Option, Future都是Monad, 甚至我觉得Actor也是某种形式的monad.




    2014-05-08 19:17 GMT+08:00 Fei Wang <pythonee@gmail.com>:
    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢

    --
    您收到此邮件是因为您订阅了Google网上论坛中的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要发帖到此论坛,请发送电子邮件至scalacn@googlegroups.com
    要查看更多选项,请访问https://groups.google.com/d/optout。


    --

    ~Yours, Xuefeng Wu/吴雪峰 敬上

    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。
  • 杨博 at May 15, 2014 at 3:36 am
    Haskell原生语法有限制,禁止你执行有副作用的代码。哪怕是Scala中简单一句println("Hello,
    world!"),Haskell都做不到。

    所以Haskell必须用Monad来绕过这个限制。但是用基本语法使用Monad时,代码比较繁琐,所以Haskell又发明了关键字do配合Monad。

    Scala没有什么副作用的限制,所以Scala不需要Monad也能完成一切Monad能完成的工作。

    不过,Scala原生的副作用操作都是同步操作,在进行高并发编程时,性能不好。所以如果在Scala中实现类似Monad的模型,就可以执行异步操作,来提高性能。

    我有一个库就在Scala中实现了和Monad相同的函数模型。这个库是stateless-future(https://github.com/Atry/stateless-future),欢迎使用。

    这里有一个例子,用stateless-future(相当于Haskell的Monad)实现了一个简单的TCP服务端和客户端:

    https://github.com/Atry/stateless-future-util/blob/master/src/test/scala/com/qifun/statelessFuture/io/SocketTest.scala

    在 2014年5月8日星期四UTC+8下午7时17分59秒,Fei Wang写道:
    看了很多文章,尤其是monad are elephant之后,对monad有了一个算是比较全面的了解
    也写了一些实验代码,但是我不晓得,为什么前人会想出这样的东西,他们是怎么样的思路。
    我看很多地方都说纯函数的副作用,不确定性?尤其是haskell语言中,可惜我不是很懂haskell
    不晓得组里有人能科普下,为什么monad在函数式编程特别重要,他是基于什么思路一点点的引出来的呢
    --
    您收到此邮件是因为您订阅了 Google 网上论坛的“Scala中文社区”论坛。
    要退订此论坛并停止接收此论坛的电子邮件,请发送电子邮件到scalacn+unsubscribe@googlegroups.com
    要向此网上论坛发帖,请发送电子邮件至 scalacn@googlegroups.com
    要查看更多选项,请访问 https://groups.google.com/d/optout。

Related Discussions

Discussion Navigation
viewthread | post
Discussion Overview
groupscalacn @
postedMay 8, '14 at 11:18a
activeMay 15, '14 at 3:36a
posts19
users8

People

Translate

site design / logo © 2019 Grokbase