问题标签 [alternative-functor]

我是 Haskell 新手，我想知道为什么除了Either半群之外没有替代实例，它的行为与我对替代的预期一样：

此实例丢弃或纠正“错误”，当两个操作数都用 标记时Right，它采用第一个。这不正是替代方案提供的“选择”吗？

我希望 semigroup 实例大致如下所示：

这意味着它会传播错误并附加常规结果。

我想我Either对所涉及的类型类有错误的概念。

为什么是guard基于Alternative？

我问是因为guard只使用emptyfrom Alternative。它根本不使用<|>from Alternative。那么，为什么要Alternative首先使用呢？

Alternative我想这是因为's背后有一些未说明的想法empty与我们试图完成的目标完全匹配guard（停止False，继续True）。如果是这种情况，请告诉我这个未说明的想法。

但同时，如果觉得我们只是在忽略<|>. 感觉好像guard没有“完全捕捉”Alternative一切。我希望这是有道理的。更具体地说：他们为什么不发明另一种类型类，称为Stoppable(or Abortable) 并使用它而不是Alternative？

伟大的免费包中有一个不错的免费替代方案，它将 Functor 提升为左分配替代方案。

也就是说，主张是：

是一个替代同态，其中liftAlt. 而且，确实，它是一个，但仅适用于左分布的Alternative 实例。

当然，实际上，很少有替代实例实际上是左分配的。大多数实际重要的替代实例（解析器，大多数 Monad f 的 MaybeT f 等）都不是左分布的。这个事实可以通过一个例子来证明，其中runAlt和liftAlt不形成一个替代同态：

所以runAlt对于一些 Alternatives 来说只是一个 Alternative 同态，但不是全部。这是因为结构Alt 标准化了所有动作以分布在左侧。

Alt很棒，因为从结构上讲，Alt f是合法的Applicative并且Alternative. 没有任何可能的方法来Alt f a使用不遵循法律的 Applicative 和 Alternative 函数构造类型的值......类型本身的结构使其成为免费的替代品。

就像，对于列表，您不能使用不尊重、、和关联性的<>和构造列表。memptyx <> mempty = xmempty <> x = x

我编写了一个 Free 替代方案，它在结构上不强制执行 Applicative 和 Alternative 定律，但使用 runAlt/liftAlt 产生了一个有效的 Alternative 和 Applicative 同态：

在结构上，Alt f不是实际的Applicative，因为：

所以pure f <*> pure x在pure (f x)结构上与 不同。不是一个有效的应用程序，马上。

但是，使用给定的runAltand liftAlt：

这里runAlt确实可以作为一个有效的应用同态与给定的自然变换......

有人可以说我的 newAlt f是一个有效的 Alternative 和 Applicative，当被 定义的等价关系商时runAlt，我想。

无论如何，这只是有点不满意。有没有办法编写一个免费的替代方案，它在结构上是一个有效的替代方案和应用程序，而不强制执行左分配？

（特别是，我实际上对遵循左捕获法并在结构上执行它的方法感兴趣。这将是一件单独且有趣的事情，但并非完全必要。）

而且，如果没有任何办法，为什么不呢？

我们可以将延续单子变换器定义为

如果是via的成员，我们可以给出Cont r m一个 Alternative 实例mAlternative

然后允许some并many采用他们的默认方法。我的问题是，我们可以用's和来定义someand来代替默认定义吗？显而易见的选择manymsomemany

显然不起作用（他们甚至不进行类型检查）。有没有其他方法可以使用它们（如果我们m也需要成为一个单子，那很好）？

作为参考，some并且many必须是方程的最小解：

• some v = (:) <$> v <*> many v
• many v = some v <|> pure []

假设some :: m a -> m [a]并且many :: m a -> [a]满足这个定律，那么应该some :: Cont r m a -> Cont r m [a]和many :: Cont r m a -> Cont r m [a]。

对于instance Alternative [], (<|>) = (++). 所以我把(<|>)它当成某种拼接器，导致看似几乎万能的容器转换器：

事实上，我能够概括所有函数Data.List，这里有一些：

此外，这个类比产生了一些有趣的新实例，例如函子 sum ( Data.Functor.Sum) 的工作应用函子：

用这个类比概括所有函数并创建新实例实际上是个好主意，尤其是对于列表操作？

编辑：我特别担心返回类型不明确。对于普通的列表操作，返回类型可以从它的参数类型推导出来。但是“通用”版本不是，因为必须明确指定返回类型。这个问题严重到足以认为这个类比是危险的吗？（或者还有其他问题吗？）

编辑 2：如果我foldl'完全理解 的行为，universal 的时间复杂度splitAt（如上所示）必须是Θ(length xs)，foldl'对于每个元素都是严格的，对吧？如果是，那一定是个问题，因为它不如普通版本的Θ(min n (length xs)).

From reading this answer, I understand that the inclusion of empty in Alternative was largely a design decision to make Alternative a monoid (and thus more powerful). It seems to me this was also because otherwise you couldn't express any laws for Alternative.

But this is a pain if I have a generic applicative parser like so:

Clearly, we can get the same behavior as <|> and many/some from Control.Applicative with:

Even though none of these use empty, it seems like I am forced to re-implement them instead of deriving Alternative, because I can't conceive a generic way to instance empty for it (of course, I'd still need to instance <|> to get the preservation of state on parserA error, but then I could get some, many, optional and friends for free).

Digging into Parsec's source, it seems that it subverts this because it doesn't allow for custom error types (or at least, Parsec isn't parameterized by a custom error type):

Taking inspiration from this, it seems like the only reasonable way around this is to have my generic parser wrap the user error type with something like:

And then empty can be:

This just feels wrong, though. This wrapping only exists to appease the requirement for an empty and it makes consumers of this generic parser do more work to handle errors (they also must handle UnknownError now and unwrap their custom errors). Is there any way to avoid this?

我有一个如下所示的数据类型：

以及状态操作功能：

我正在尝试使用这些函数来帮助验证语法中的生产规则：

似乎isToken需要消耗当前令牌（使用consumeToken），以便递归调用charList然后处理以下令牌。但是，这样做意味着替代情况不会从与第一种情况相同的标记开始。

有没有标准的方法来处理这个问题？

我是一个通过 aeson 的 haskell 初学者，通过解析一些数据文件来了解更多关于这两者的知识。

通常当有一个数据文件时，可能是.json一个lua表格，.csv格式或其他，并且你想解析它们，总是有错误的机会。

例如，.json像这样的简单文件

有两个奇怪的地方："m1"有两个子键，一个有值 in String，一个在Int. "m2"只有一个子键，它与上面的键具有相同的键，但值具有不同的类型，即。Int.

如果是这样

使用 Aeson 解析它的一种简单方法是使用这些数据类型

如果钥匙丢失

这本可以完成这项工作

但是，如果它像第一个示例一样，键不仅可以没有值，而且可以有完全不同的值。

如果在它们中您只关心数字或字符串怎么办？有没有办法在不超出类型定义的情况下解析它们？

通过一些快速搜索，我发现 Alternative 类仅适用于此类问题，并且像*>,<>之类的运算符<|>可以证明是有用的，但我不确定如何。

我知道如果我只想要文本或数字，我需要定义一个可以封装所有三种机会的类型，比如

Data NeededVal = NoValue | TextValue | Needed Int

或者

Data NeededVal = NoValue | NumericValue | Needed String

但我不确定如何让它们成为 Applicative & Alternative 的实例，以便这个想法能够奏效。

这是我上一个问题的简短后续

在文章：“给你写一个 Haskellsome ”（第 34 页）中，给出了对“ ”和“ ”的以下解释many：

和函数自动从Alternative类型类定义派生而来。接受一个函数参数并重复应用它直到函数失败，然后产生收集到的结果。该函数的行为类似，但如果没有至少一个 匹配项，它将自行失败。manysomemanysome

我一直试图理解这个实现一段时间。

我不明白如何将“ many”和“ some”应用于“列表”或“ Maybe”。

我也不确定(:) <$> v <*> many_v。

这是如何得出的？

我有以下类型：

该类型Rep f a是一种有状态的计算，它将 String 作为初始状态并产生 a(String, a)作为计算的结果。计算结果包含在 functor 中f。

Rep 的 monad 实例如下：

Rep 的替代实例如下：

我还有以下功能：

上面的函数接受一个状态，empty如果状态是一个空列表则返回。如果 state 不是一个空列表，它返回一个元组，第一个元素是修改后的状态，第二个 a 被Char包裹在 functor 中f。

而且我还有以下函数和数据类型：

我无法理解上述功能的工作原理。在我看来，对于 string 中的每个字符，都会调用cs该readCharacter函数。如果返回的字符readCharacter是 string 的一个元素cs，则表达式的计算结果为 true。假设函子f是Maybe- thenguard (True)将返回 a Just ()，然后pure (Character x)返回。

但是，我不确定当保护表达式计算为 时会发生什么False。例如，假设函子是Maybe，guard False将返回Nothing。如果Nothing被退货guard False，是不是整体do block会退货Nothing？任何见解都值得赞赏。