标签: monads

我似乎真的不了解Map和FlatMap.我无法理解的是for-comprehension是如何嵌套调用map和flatMap的.以下示例来自Scala中的Functional Programming

def bothMatch(pat:String,pat2:String,s:String):Option[Boolean] = for {
            f <- mkMatcher(pat)
            g <- mkMatcher(pat2)
 } yield f(s) && g(s)

翻译成

def bothMatch(pat:String,pat2:String,s:String):Option[Boolean] = 
         mkMatcher(pat) flatMap (f => 
         mkMatcher(pat2) map (g => f(s) && g(s)))

mkMatcher方法定义如下:

  def mkMatcher(pat:String):Option[String => Boolean] = 
             pattern(pat) map (p => (s:String) => p.matcher(s).matches)

模式方法如下:

import java.util.regex._

def pattern(s:String):Option[Pattern] = 
  try {
        Some(Pattern.compile(s))
   }catch{
       case e: PatternSyntaxException => None
   }

如果有人能够阐明在这里使用map和flatMap背后的理由,那将会很棒.

可能重复:
什么是monad？

我想我明白'也许莫纳德'是什么,但我不确定其他类型.

众所周知,应用函子在组合下是封闭的,但是monad不是.但是,我一直难以找到一个具体的反例,表明monad并不总是构成.

这个答案给出[String -> a]了一个非monad的例子.在玩了一下之后,我直觉地相信它,但是这个答案只是说"加入无法实现"而没有给出任何理由.我想要更正式的东西.当然有很多类型的函数[String -> [String -> a]] -> [String -> a]; 必须表明任何这样的功能必然不符合monad法则.

任何例子(附带证据)都可以; 我不一定特别想要证明上述例子.

Edwin C. Brady撰写的关于Idris影响的"使用代数效应和依赖类型进行编程和推理"的论文包含(未引用的)声明:

尽管[效果和单子变换器]在功率上并不相同 - monad和monad变换器可以表达更多概念 - 但是捕获了许多常见的有效计算.

哪些例子可以通过monad变换器建模而不是效果？

我一直在读类别理论中的单子.monads的一个定义使用一对伴随函子.monad是使用这些仿函数的往返定义的.显然,在类别理论中,附加是非常重要的,但我没有看到关于伴随函子的Haskell monad的任何解释.有没有人给它一个想法？

为了帮助理解monad是什么,有人可以使用java提供一个例子吗？他们有可能吗？

如果你从这里下载预发布的lambda兼容JDK8,可以使用java表达lambda表达式http://jdk8.java.net/lambda/

使用此JDK的lambda示例如下所示,有人可以提供相对简单的monad吗？

public interface TransformService {
        int[] transform(List<Integer> inputs);
    }
    public static void main(String ars[]) {
        TransformService transformService = (inputs) -> {
            int[] ints = new int[inputs.size()];
            int i = 0;
            for (Integer element : inputs) {
                ints[i] = element;
            }
            return ints;
        };

        List<Integer> inputs = new ArrayList<Integer>(5) {{
            add(10);
            add(10);
        }};
        int[] results = transformService.transform(inputs);
    }

这就是Cont monad的定义方式:

newtype Cont r a = Cont { runCont :: (a -> r) -> r }

instance Monad (Cont r) where
    return a = Cont ($ a)
    m >>= k  = Cont $ \c -> runCont m $ \a -> runCont (k a) c

你能解释一下这是如何以及为何有效吗？它在做什么？

我对函数式编程中使用的monad和箭头的概念非常熟悉.我也明白它们可以用来解决类似的问题.

但是,对于如何选择在任何给定情况下使用哪一个,我仍然有点困惑.

我什么时候应该使用monads？什么时候应该使用箭头？

我已经学习 Haskell 几个星期了（只是为了好玩），刚刚观看了 Brian Beckman介绍 monad的精彩视频。他激励 monad 需要创建一个更通用的组合运算符。按照这个思路，如果我有两个功能：

f :: a -> b
g :: b -> c

组合运算符应该满足

h = g . f :: a -> c

由此我可以推断出正确的.运算符类型：

(.) : (b -> c) -> (a -> b) -> (a -> c)

说到 monad，假设我有两个功能：

f :: a -> m b
g :: b -> m c

在我看来，自然的选择是定义一个通用的组合运算符，其工作方式如下：

h = f >>= g :: a -> m c

在这种情况下，>>=运算符的类型签名为：

(>>=) :: (a -> …

我知道ST monad就像是IO的小兄弟,后者又是带有RealWorld魔法的状态monad .我可以想象状态,我可以想象RealWorld以某种方式被放入IO,但每次我写一个ST monad 的类型签名都ST让s我感到困惑.

举个例子吧ST s (STArray s a b).s那里的工作如何？它是否仅用于在计算之间建立一些人工数据依赖性,而不能像状态monad中的状态那样被引用(由于forall)？

我只是抛出想法,真的很感谢比我更有知识的人向我解释.