就OOP程序员所能理解的(没有任何功能编程背景)而言,什么是monad?

它解决了什么问题,最常用的地方是什么?

使现代化

为了澄清我所寻求的理解,假设您正在将一个具有monad的FP应用程序转换为OOP应用程序。如何将monad的职责移植到OOP应用程序?


当前回答

在OO术语中,monad是一个流畅的容器。

最低要求是类<a>的定义,它支持构造函数Something(a a)和至少一个方法Something<B>flatMap(函数<a,Something<B>>)

可以说,monad类是否有签名Something<B>work()的方法来保存类的规则——编译器在编译时在flatMap中烘焙。

为什么单子有用?因为它是一个允许保留语义的可链式操作的容器。例如,可选<?>为Optional<String>、Optional<Integer>、Optional<MyClass>等保留isPresent的语义。

作为一个粗略的例子,

Something<Integer> i = new Something("a")
  .flatMap(doOneThing)
  .flatMap(doAnother)
  .flatMap(toInt)

注意,我们以字符串开头,以整数结尾。很酷。

在OO中,这可能需要一点努力,但Something上的任何方法如果返回Something的另一个子类,都符合返回原始类型容器的容器函数的标准。

这就是保持语义的方式——即容器的含义和操作不会改变,它们只是包装和增强容器内的对象。

其他回答

看到我对“什么是monad?”的回答了吗

它从一个激励性的例子开始,通过这个例子,导出一个monad的例子,并正式定义“monad”。

它假设不了解函数式编程,并且使用带有函数(参数):=表达式语法的伪代码和最简单的表达式。

这个C++程序是伪代码monad的一个实现。(仅供参考:M是类型构造函数,feed是“绑定”操作,wrap是“返回”操作。)

#include <iostream>
#include <string>

template <class A> class M
{
public:
    A val;
    std::string messages;
};

template <class A, class B>
M<B> feed(M<B> (*f)(A), M<A> x)
{
    M<B> m = f(x.val);
    m.messages = x.messages + m.messages;
    return m;
}

template <class A>
M<A> wrap(A x)
{
    M<A> m;
    m.val = x;
    m.messages = "";
    return m;
}

class T {};
class U {};
class V {};

M<U> g(V x)
{
    M<U> m;
    m.messages = "called g.\n";
    return m;
}

M<T> f(U x)
{
    M<T> m;
    m.messages = "called f.\n";
    return m;
}

int main()
{
    V x;
    M<T> m = feed(f, feed(g, wrap(x)));
    std::cout << m.messages;
}

在OO术语中,monad是一个流畅的容器。

最低要求是类<a>的定义,它支持构造函数Something(a a)和至少一个方法Something<B>flatMap(函数<a,Something<B>>)

可以说,monad类是否有签名Something<B>work()的方法来保存类的规则——编译器在编译时在flatMap中烘焙。

为什么单子有用?因为它是一个允许保留语义的可链式操作的容器。例如,可选<?>为Optional<String>、Optional<Integer>、Optional<MyClass>等保留isPresent的语义。

作为一个粗略的例子,

Something<Integer> i = new Something("a")
  .flatMap(doOneThing)
  .flatMap(doAnother)
  .flatMap(toInt)

注意,我们以字符串开头,以整数结尾。很酷。

在OO中,这可能需要一点努力,但Something上的任何方法如果返回Something的另一个子类,都符合返回原始类型容器的容器函数的标准。

这就是保持语义的方式——即容器的含义和操作不会改变,它们只是包装和增强容器内的对象。

我想说,与monads最接近的OO类比是“命令模式”。

在命令模式中,将普通语句或表达式包装在命令对象中。命令对象公开执行包装语句的执行方法。所以,语句被转换为可以随意传递和执行的第一类对象。可以组合命令,以便通过链接和嵌套命令对象来创建程序对象。

命令由单独的对象调用程序执行。使用命令模式(而不仅仅是执行一系列普通语句)的好处是,不同的调用程序可以将不同的逻辑应用于如何执行命令。

命令模式可用于添加(或删除)宿主语言不支持的语言功能。例如,在没有异常的假设OO语言中,可以通过向命令公开“try”和“throw”方法来添加异常语义。当命令调用throw时,调用程序会回溯到命令列表(或树),直到最后一次“try”调用。相反,您可以通过捕获每个单独命令抛出的所有异常,并将它们转换为错误代码,然后传递给下一个命令,从而从语言中删除异常语义(如果您认为异常是坏的)。

甚至更花哨的执行语义(如事务、非确定性执行或延续)也可以用本机不支持的语言实现。如果你仔细想想,这是一个非常强大的模式。

实际上,命令模式并没有像这样作为通用语言特性使用。将每个语句转换为单独的类的开销将导致无法忍受的样板代码。但原则上,它可以用于解决与在fp中使用monad解决的问题相同的问题。

monad在OO中是否具有“自然”解释取决于monad。在像Java这样的语言中,您可以将may monad转换为检查空指针的语言,这样失败的计算(即,在Haskell中生成Nothing)会将空指针作为结果发出。您可以将状态monad转换为通过创建可变变量和更改其状态的方法生成的语言。

monad是内函子范畴中的幺半群。

这句话所表达的信息非常深刻。你在一个monad中使用任何命令式语言。monad是一种“有序”的领域特定语言。它满足某些有趣的财产,这些属性使单子函数成为“命令式编程”的数学模型。Haskell使定义小型(或大型)命令式语言变得容易,这些语言可以以多种方式组合。

作为一名OO程序员,您使用语言的类层次结构来组织可以在上下文中调用的函数或过程的类型,即您所称的对象。monad也是对这个概念的抽象,因为不同的monad可以以任意方式组合,有效地将所有子monad的方法“导入”到范围中。

从体系结构上讲,然后使用类型签名来明确表示可以使用哪些上下文来计算值。

可以使用monad转换器来实现这一目的,并且有一个高质量的所有“标准”monad集合:

列表(通过将列表视为域进行非确定性计算)可能(计算可能失败,但报告不重要)错误(可能失败并需要异常处理的计算Reader(可以由普通Haskell函数组合表示的计算)编写器(使用顺序“渲染”/“记录”(到字符串、html等)进行计算)续(续)IO(取决于底层计算机系统的计算)状态(上下文包含可修改值的计算)

具有相应的monad变压器和类型类别。类型类允许通过统一monad的接口来组合monad,从而使具体monad可以实现monad“类”的标准接口。例如,模块Control.Monad.State包含一个类MonadState s m,(State s)是表单的一个实例

instance MonadState s (State s) where
    put = ...
    get = ...

长话短说,monad是一个函子,它将“上下文”附加到一个值上,它可以向monad中注入一个值,并且可以根据附加到它上的上下文来评估值,至少是以受限的方式。

So:

return :: a -> m a

是一个函数,它将a类型的值注入到m类型的monad“action”中。

(>>=) :: m a -> (a -> m b) -> m b

是一个执行monad操作、评估其结果并将函数应用于结果的函数。(>>=)的妙处在于结果在同一个monad中。换句话说,在m>>=f中,(>>=)从m中提取结果,并将其绑定到f,这样结果就在monad中。(或者,我们可以说(>>=)将f拉入m,并将其应用于结果。)因此,如果我们有f::a->m b和g::b->m c,我们可以“排序”动作:

m >>= f >>= g

或者,使用“do符号”

do x <- m
   y <- f x
   g y

(>>)的类型可能是发光的。它是

(>>) :: m a -> m b -> m b

它对应于C等过程语言中的(;)运算符。它允许使用以下表示法:

m = do x <- someQuery
       someAction x
       theNextAction
       andSoOn

在数学和哲学逻辑中,我们有框架和模型,这些框架和模型“自然”地用单子主义建模。解释是一种函数,它查看模型的域,并计算命题(或公式,在推广下)的真值(或推广)。在必要性的模态逻辑中,我们可能会说,如果命题在“每个可能的世界”中都是真的,那么它是必要的——如果它在每个可容许的域中都是真实的。这意味着命题语言中的模型可以具体化为一个模型,其域由不同模型的集合组成(一个对应于每个可能的世界)。每个monad都有一个名为“join”的方法,该方法将分层,这意味着结果为monad动作的每个monad动作都可以嵌入到monad中。

join :: m (m a) -> m a

更重要的是,这意味着monad在“层堆叠”操作下关闭。这就是monad转换器的工作原理:它们通过为以下类型提供“类联接”方法来组合monad:

newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) }

这样我们就可以将(MaybeT m)中的作用转换为m中的作用,有效地折叠层。在本例中,runMaybeT::MaybeT m a->m(Maybe a)是我们的类联接方法。(MaybeT m)是一个monad,MaybeT::m(Maybe a)->MaybeT ma实际上是m中一个新类型monad动作的构造函数。

函子的自由单元是通过堆叠f生成的单元,这意味着f的每个构造函数序列都是自由单元的元素(或者更确切地说,是与f的构造函数序列树形状相同的元素)。自由单体是一种用最少的锅炉板构建柔性单体的有用技术。在Haskell程序中,我可能会使用自由monad来为“高级系统编程”定义简单monad,以帮助维护类型安全(我只是在使用类型及其声明。使用组合子可以直接实现):

data RandomF r a = GetRandom (r -> a) deriving Functor
type Random r a = Free (RandomF r) a


type RandomT m a = Random (m a) (m a) -- model randomness in a monad by computing random monad elements.
getRandom     :: Random r r
runRandomIO   :: Random r a -> IO a (use some kind of IO-based backend to run)
runRandomIO'  :: Random r a -> IO a (use some other kind of IO-based backend)
runRandomList :: Random r a -> [a]  (some kind of list-based backend (for pseudo-randoms))

Monastem是您可能称之为“解释器”或“命令”模式的基础架构,抽象为最清晰的形式,因为每个单元计算都必须“运行”,至少是微不足道的。(运行时系统为我们运行IO monad,是任何Haskell程序的入口点。IO通过按顺序运行IO操作来“驱动”其余的计算)。

join的类型也是我们得到monad是内函子范畴中的幺半群的陈述的地方。由于其类型,联接对于理论目的来说通常更为重要。但了解类型意味着了解单子。Join和monad变换器的类Join类型在函数组合的意义上是内函子的有效组合。把它放在类似Haskell的伪语言中,

Foo::m(m a)<->(m.m)a

这里有一个简单的Monads解释和Marvel的案例研究。

单子是用于对有效的依赖函数进行排序的抽象。这里的有效意味着它们以F[a]的形式返回一个类型,例如Option[a],其中Option是F,称为类型构造函数。让我们通过两个简单步骤来了解这一点

下面的函数组合是可传递的。所以从A到C,我可以组成A=>B和B=>C。

 A => C   =   A => B  andThen  B => C

然而,如果函数返回一个像Option[A]这样的效果类型,即A=>F[B],则合成不起作用,因为我们需要A=>B,但我们有A=>F[B]。我们需要一个特殊的运算符“bind”,它知道如何融合这些返回F[a]的函数。

 A => F[C]   =   A => F[B]  bind  B => F[C]

“bind”函数是为特定的F定义的。

对于任何A,也有“return”,类型A=>F[A],也为特定的F定义。要成为Monad,F必须定义这两个函数。

因此,我们可以从任何纯函数A=>B构造有效函数A=>F[B],

 A => F[B]   =   A => B  andThen  return

但给定的F也可以定义自己不透明的“内置”特殊函数,这些函数的类型是用户无法自行定义的(纯语言),例如

“随机”(范围=>随机[Int])“print”(字符串=>IO[()])“尝试…捕捉”等。