我理解 Alternative 类型类的要点是在两个事物之间进行选择，而我理解 Monoid 是关于组合事物的。

如果你仔细想想，它们是一样的。

+组合了一些东西(通常是数字) ，它的类型签名是 Int -> Int -> Int(或者其他什么)。

<|>操作符在替代品之间进行选择，它的类型签名也是相同的: 获取两个匹配的对象并返回一个组合的对象。

摘要

• 我们需要为一些应用函数定义(实例提供相同的操作) Monoid 实例，这些实例在应用函数级别上真正地结合，而不仅仅是提升较低级别的 Monoid。下面来自 litvar = liftA2 mappend literal variable的示例错误表明，<|>通常不能被定义为 liftA2 mappend; 在这种情况下，<|>通过组合解析器而不是它们的数据来工作。

• 如果我们直接使用 Monoid，我们需要语言扩展来定义实例。Alternative的类型更高，因此您可以在不需要语言扩展的情况下创建这些实例。

示例: 解析器

让我们假设我们正在解析一些声明，因此我们导入需要的所有内容

import Text.Parsec
import Text.Parsec.String
import Control.Applicative ((<$>),(<*>),liftA2,empty)
import Data.Monoid
import Data.Char

然后考虑如何解析一个类型，我们选择简单化:

data Type = Literal String | Variable String  deriving Show
examples = [Literal "Int",Variable "a"]

现在让我们为文字类型编写一个解析器:

literal :: Parser Type
literal = fmap Literal $ (:) <$> upper <*> many alphaNum

意义: 解析一个 upper大小写字符，然后解析 many alphaNumeric 字符，将结果组合成一个带有纯函数 (:)的字符串。然后，应用纯功能 Literal将这些 String转化为 Type。我们将以完全相同的方式解析变量类型，除了以 lower大小写字母开头:

variable :: Parser Type
variable = fmap Variable $ (:) <$> lower <*> many alphaNum

很好 parseTest literal "Bool" == Literal "Bool"正如我们所希望的。

问题3a: 如果要把应用效果和 Monoid 的行为结合起来，为什么不只是 liftA2 mappend

编辑: 哎呀——忘记实际使用 <|>了！
现在，让我们使用 Alternative 组合这两个解析器:

types :: Parser Type
types = literal <|> variable

这可以解析任何类型: parseTest types "Int" == Literal "Bool"和 parseTest types "a" == Variable "a"。 这是两个 解析器的组合，而不是两个 价值观的组合。这就是它在应用函数级别而不是数据级别工作的意义。

然而，如果我们尝试:

litvar = liftA2 mappend literal variable

那就是要求编译器在数据级别上组合它们生成的两个 价值观。 我们得到

No instance for (Monoid Type)
arising from a use of `mappend'
Possible fix: add an instance declaration for (Monoid Type)
In the first argument of `liftA2', namely `mappend'
In the expression: liftA2 mappend literal variable
In an equation for `litvar':
litvar = liftA2 mappend literal variable

因此，我们发现了第一件事; Alternative 类与 liftA2 mappend完全不同，因为它在不同的层次上组合对象——它组合解析器，而不是解析数据。如果你愿意这样想，它是真正更高级别的组合，而不仅仅是一个电梯。我不喜欢这么说，因为 Parser Type有类似 *的东西，但我们确实是在结合 Parser而不是 Type。

(即使对于具有 Monoid 实例的类型，liftA2 mappend也不会提供与 <|>相同的解析器。如果您在 Parser String上尝试它，您将得到一个接一个解析然后连接的 liftA2 mappend，而 <|>将尝试第一个解析器，如果失败则默认为第二个解析器。)

问题3b: Alternative 的 <|> :: f a -> f a -> f a和 Monoid 的 mappend :: b -> b -> b有什么不同？

首先，您应该注意到它并没有在 Monoid 实例上提供新的功能。

然而，其次，直接使用 Monoid 存在一个问题: 让我们尝试在解析器上使用 mappend，同时展示它与 Alternative的结构相同:

instance Monoid (Parser a) where
mempty = empty
mappend = (<|>)

哎呀! 我们得到

Illegal instance declaration for `Monoid (Parser a)'
(All instance types must be of the form (T t1 ... tn)
where T is not a synonym.
Use -XTypeSynonymInstances if you want to disable this.)
In the instance declaration for `Monoid (Parser a)'

因此，如果有一个应用函数 f，那么 Alternative实例显示 f a是一个 monoid，但是只能将它声明为带语言扩展名的 Monoid。

一旦我们将 {-# LANGUAGE TypeSynonymInstances #-}添加到文件的顶部，我们就可以定义

typeParser = literal `mappend` variable

令我们高兴的是，它的工作原理: parseTest typeParser "Yes" == Literal "Yes"和 parseTest typeParser "a" == Literal "a"。

即使您没有任何同义词(Parser和 String是同义词，所以它们不存在) ，您仍然需要 {-# LANGUAGE FlexibleInstances #-}来定义类似于下面这个实例的实例:

data MyMaybe a = MyJust a | MyNothing deriving Show
instance Monoid (MyMaybe Int) where
mempty = MyNothing
mappend MyNothing x = x
mappend x MyNothing = x
mappend (MyJust a) (MyJust b) = MyJust (a + b)

(可能的 monoid 实例通过提升底层 monoid 来绕过这个问题。)

使标准库不必要地依赖于语言扩展显然是不可取的。

这就是了。Alternative 是应用函子的幺半群(不仅仅是幺半群的一个提升)。它需要更高级的类型 f a -> f a -> f a，这样您就可以定义一个不需要语言扩展的类型。

其他问题:

1. 为什么 Alternative 需要一个空的方法/成员？
   因为拥有操作的标识有时是有用的。 例如，您可以定义 anyA = foldr (<|>) empty而不使用冗长的边界条件。

2. MonadPlus 类型类的意义何在？难道我不能用 Monad 和 Alternative 来释放它所有的优点吗？ 不，我建议你回到 和你有关的问题:

此外，即使 Applicative 是 Monad 的一个超级类，你最终还是会需要 MonadPlus 类，因为严格遵守 empty <*> m = empty并不足以证明 empty >>= f = empty。

我举了个例子，也许吧。我详细解释了，并用 这个答案证明了安塔尔的问题。为了得到这个答案，值得注意的是我能够使用 > > = 使 MonadPlus 实例违反了 Alternative 法则。

幺半群结构是有用的。替代是为应用函子提供它的最好方法。

我不会报道 MonadPlus，因为它的法律存在分歧。

在尝试并且找不到任何有意义的例子，在这些例子中 Applicative 的结构自然地导致 Alternative 实例不同意它的 Monoid 实例 * 之后，我最终想出了这个:

Alternative 定律比 Monoid 定律更严格，因为结果 不能依赖于内部类型。这就排除了大量 Monoid 实例作为 Alternative 的可能性。 这些数据类型允许部分(意味着它们只对某些内部类型起作用) Monoid 实例，这是 * -> *类型的额外“结构”所禁止的。例子:

• Monoid 的标准“也许”实例假定内部类型为 Monoid = > not an Alternative

• ZipList、 tuple 和函数都可以是 Monoid，如果它们的内部类型是 Monoid = > not Alternative

• 至少有一个元素的序列不能是替代序列，因为没有 empty:

  data Seq a
  = End a
  | Cons a (Seq a)
  deriving (Show, Eq, Ord)
  

On the other hand, some data types cannot be made Alternatives because they're *-kinded:

• unit -- ()
• Ordering
• numbers, booleans

My inferred conclusion: for types that have both an Alternative and a Monoid instance, the instances are intended to be the same. See also this answer.

_{excluding Maybe, which I argue doesn't count because its standard instance should not require Monoid for the inner type, in which case it would be identical to Alternative}

import Data.Monoid
import Control.Applicative

让我们跟踪 Monoid 和 Alternative 如何与 Maybe函数和 ZipList函数交互的例子，但让我们从头开始，部分是为了让所有的定义在我们的脑海中新鲜，部分是为了停止切换标签到位的黑客所有的时间，但主要是为了我可以 去总部查查纠正我的输入错误！

(<>) :: Monoid a => a -> a -> a
(<>) = mappend -- I'll be using <> freely instead of `mappend`.

这是“也许”的克隆:

data Perhaps a = Yes a | No  deriving (Eq, Show)


instance Functor Perhaps where
fmap f (Yes a) = Yes (f a)
fmap f No      = No


instance Applicative Perhaps where
pure a = Yes a
No    <*> _     = No
_     <*> No    = No
Yes f <*> Yes x = Yes (f x)
   

现在是 ZipList:

data Zip a = Zip [a]  deriving (Eq,Show)


instance Functor Zip where
fmap f (Zip xs) = Zip (map f xs)


instance Applicative Zip where
Zip fs <*> Zip xs = Zip (zipWith id fs xs)   -- zip them up, applying the fs to the xs
pure a = Zip (repeat a)   -- infinite so that when you zip with something, lengths don't change

结构1: 组合元素: 幺半群

也许是克隆人

首先让我们看看 Perhaps String。有两种组合它们的方法。首先是连接

(<++>) :: Perhaps String -> Perhaps String -> Perhaps String
Yes xs <++> Yes ys = Yes (xs ++ ys)
Yes xs <++> No     = Yes xs
No     <++> Yes ys = Yes ys
No     <++> No     = No

串联通过将 No当作 Yes []来处理，本质上是在字符串级别工作，而不是真正的或许级别。等于 liftA2 (++)。这是明智的和有用的，但也许我们可以推广从只使用 ++使用任何方式的组合-任何 Monoid 然后！

(<++>) :: Monoid a => Perhaps a -> Perhaps a -> Perhaps a
Yes xs <++> Yes ys = Yes (xs `mappend` ys)
Yes xs <++> No     = Yes xs
No     <++> Yes ys = Yes ys
No     <++> No     = No

Perhaps的这种幺半群结构试图在 a级别上尽可能多地工作。请注意 Monoid a约束，它告诉我们正在使用来自 a级别的结构。这不是一个替代结构，它是一个派生(提升) Monoid 结构。

instance Monoid a => Monoid (Perhaps a) where
mappend = (<++>)
mempty = No

在这里，我使用数据 a 的结构来为整个事情添加结构。如果我组合了 Set，我就能够添加一个 Ord a上下文。

ZipList 克隆

那么我们应该如何组合 元素和 zipList? 如果我们组合它们，这些 zip 应该是什么？

   Zip ["HELLO","MUM","HOW","ARE","YOU?"]
<> Zip ["this", "is", "fun"]
=  Zip ["HELLO" ? "this",   "MUM" ? "is",   "HOW" ? "fun"]


mempty = ["","","","",..]   -- sensible zero element for zipping with ?

但是对于 ?我们应该使用什么。我说唯一明智的选择是 ++。实际上，对于列表，是 (<>) = (++)

   Zip [Just 1,  Nothing, Just 3, Just 4]
<> Zip [Just 40, Just 70, Nothing]
=  Zip [Just 1 ? Just 40,    Nothing ? Just 70,    Just 3 ? Nothing]


mempty = [Nothing, Nothing, Nothing, .....]  -- sensible zero element

但是我们可以用什么来表示 ?呢? 我说我们要组合元素，所以我们应该再次使用 Monoid 中的元素组合运算符: <>。

instance Monoid a => Monoid (Zip a) where
Zip as `mappend` Zip bs = Zip (zipWith (<>) as bs) -- zipWith the internal mappend
mempty = Zip (repeat mempty)  -- repeat the internal mempty

这是使用 zip 组合元素的唯一合理方式——因此它是唯一合理的 monoid 实例。

有趣的是，这并不适用于上面的“也许”例子，因为 Haskell 不知道如何组合 Int-它应该使用 +还是 *？要在数值数据上获得一个 Monoid 实例，需要将它们包装在 Sum或 Product中，以告诉它使用哪个 Monoid。

Zip [Just (Sum 1),   Nothing,       Just (Sum 3), Just (Sum 4)] <>
Zip [Just (Sum 40),  Just (Sum 70), Nothing]
= Zip [Just (Sum 41),Just (Sum 70), Just (Sum 3)]


Zip [Product 5,Product 10,Product 15]
<> Zip [Product 3, Product 4]
=  Zip [Product 15,Product 40]

关键点

注意: Monoid 中的类型具有类 *这一事实正是允许我们将 Monoid a上下文放在这里的原因——我们也可以添加 Eq a或 Ord a。在 Monoid 中，原始元素很重要。Monoid 实例是 设计的，用于操作和组合结构中的数据。

(<||>) :: Perhaps String -> Perhaps String -> Perhaps String
Yes xs <||> Yes ys = Yes xs   -- if we can have both, choose the left one
Yes xs <||> No     = Yes xs
No     <||> Yes ys = Yes ys
No     <||> No     = No

(<||>) :: Perhaps a -> Perhaps a -> Perhaps a
Yes xs <||> Yes ys = Yes xs   -- if we can have both, choose the left one
Yes xs <||> No     = Yes xs
No     <||> Yes ys = Yes ys
No     <||> No     = No

instance Alternative Perhaps where
(<|>) = (<||>)
empty = No

Zip [1,3,4] <|> Zip [10,20,30,40] = ????

Zip [] <|> Zip ys = Zip ys
Zip xs <|> Zip [] = Zip xs

instance Alternative Zip where
empty = Zip []
Zip [] <|> x = x
Zip xs <|> _ = Zip xs

sum = foldr (+) 0
concat = foldr (++) []
msum = foldr (`mappend`) mempty          -- any Monoid
whichEverWorksFirst = foldr (<|>) empty  -- any Alternative