小编Zhi*_*gor的帖子

网上有很多有趣的haskell片段。这篇文章可以在这个（很棒的）堆栈溢出问题下找到。作者写道：

discount ? Floating ? ? ? ? ? ? ? ? ?
discount ? df x = x * (1 + df) ** (-?)

那些花哨的箭头和点只是让在线页面看起来更好的一种方式，还是有一个实际的 Haskell 扩展（或其他什么，我不太了解术语）可以编译这样的东西？我应该注意到，->代码中也使用了通常的。

我有一种强烈的感觉，这不是我第一次看到这样的事情。

我有以下代码：

struct Abs {
    virtual void f(int x) = 0;
    virtual void f(double x) final { std::cout << 2; }
};

struct Sub: public Abs {
    void f(int x) final { std::cout << 1; }
};

Abs是一个抽象类，由纯成员函数void f(int)及其重载版本组成void f(double x)，该版本不再是纯成员函数final。如果我尝试void f(int)在派生结构中重写Sub，它会隐藏并打印void f(double)以下函数，转换为：main11.01int

int main() {
    Sub x = {};
    x.f(1.01);
    return 0;
}

我该如何克服这个问题？另外，为什么会这样呢？

这是我要参考的 SO 帖子。此外，我将在该问题中使用与 OP 相同的片段，以免分离材料。

据众所周知的是一个ArrowApply实例产生一个单子，反之亦然：

newtype ArrowMonad a b = ArrowMonad (a () b)

instance Arrow a => Functor (ArrowMonad a) where
    fmap f (ArrowMonad m) = ArrowMonad $ m >>> arr f

instance Arrow a => Applicative (ArrowMonad a) where
   pure x = ArrowMonad (arr (const x))
   ArrowMonad f <*> ArrowMonad x = ArrowMonad (f &&& x >>> arr (uncurry id))

instance ArrowApply a => Monad (ArrowMonad a) where
    ArrowMonad m …

我试图理解约翰休斯著名的“将箭头概括为单子”中的“流作为箭头”部分。更准确地说，我有兴趣写下斐波那契流。

我稍微调整了休斯的定义：

data StreamProcessor a b = Get (a -> StreamProcessor a b) | 
                           Put b (StreamProcessor a b) |
                           Halt
put = Put
get = Get

首先，我将流处理器视为可能阻塞（等待输入）的列表。那是：

• Put :: b -> StreamProcessor a b -> StreamProcessor a b匹配(:) :: a -> [a] -> [a];
• Halt :: StreamProcessor a b匹配[] :: [a];
• Get :: (a -> StreamProcessor a b) -> StreamProcessor a b 帮助我们阻塞流并等待输入。

因此，如果我们删除 ，Get我们会得到一个类似列表的结构。如果我们也删除，Halt我们会得到一个类似无限列表的结构。

以下是我理解“斐波那契数列”的两种方式：

• 一个非阻塞的无限流（类似无限列表）： …

自由幺半群通常被视为“列表幺半群”。然而，我对其他可能给我们自由幺半群的可能结构感兴趣。

首先，让我们回顾一下自由幺半群的定义。我从来没有完全理解如何将一个自由幺半群定义为一个遵守幺半群定律而不是其他任何东西的结构。我们如何证明某事不遵守上述规则但不遵守规则？或者这只是一种直觉？

无论如何，我们将讨论函子。如果某个幺半群是免费的，我们就用一个免费的函子得到它。很明显，列表在这里非常方便：

free :: Set -> Mon
free a = ([a], (++), [])

然而，一个人可能会想出其他几个。例如，这是其中Last之一Data.Monoid：

freeLast :: Set -> Mon
freeLast a = (Last a, (<>) :: Last a -> Last a -> Last a, Last Nothing) 

那么，这个函子会生成Last一个自由幺半群吗？更一般地说，如果 存在一个守法实例Monoid (T a)，那么是T一个自由幺半群吗？

该Control.Arrow.Operations.ArrowCircuit课程适用于：

可用于解释同步电路的箭头类型。

我想知道这里的同步是什么意思。我在维基百科上查了一下，他们说的是数字电子产品。我的电子设备非常生锈，所以这里有一个问题：所谓的异步流处理器的这种实例有什么问题（如果有的话）：

data StreamProcessor a b = Get (a -> StreamProcessor a b) | 
                           Put b    (StreamProcessor a b) |
                           Halt

instance Category StreamProcessor where
    id = Get (\ x -> Put x id)
  
    Put c bc . ab = Put c (bc . ab)
    Get bbc . Put b ab = (bbc b) . ab
    Get bbc . Get aab = Get $ \ a -> (Get bbc) …

The Cartesian class from the constrained-category project is for categories, products of objects in which are objects in the same category yet again.

I wonder about the classes Cartesian extends:

class ( Category k                                      {- 1 -}
      , Monoid (UnitObject k)                           {- 2 -}
      , Object k (UnitObject k)                         {- 3 -}
      -- , PairObject k (UnitObject k) (UnitObject k)   {- 4 -}
      -- , Object k (UnitObject k,UnitObject k)         {- 5 -}
      ) => Cartesian k where
... …

不久前，我已经学会了Monoidal作为一种替代方式来表示Applicative。Typeclassopedia上有一个有趣的问题：

3. （棘手）证明给定你在第一个练习中的实现[pure并(<*>)用unit和(**)和相反的方式写下来]，通常的Applicative规律和上述Monoidal规律是等价的。

以下是这些课程和法律：

-- A note from https://wiki.haskell.org/Typeclassopedia#Alternative_formulation:
-- In this and the following laws, ? refers to isomorphism rather than equality. 
-- In particular we consider (x,()) ? x ? ((),x) and ((x,y),z) ? (x,(y,z)).

-- Monoidal.
class Functor f => Monoidal f where
  unit :: f ()
  (**) :: f a -> f b -> f (a,b)

-- unit ** …

我想知道是否可以使用Control.Arrow.loop实现阶乘。

loop :: ArrowLoop a => a (b, d) (c, d) -> a b c

一个显而易见的想法是实现某种终止分支（该分支对（类型c）的第一个元素不依赖于该对（类型d）的第二个元素的分支）。在我看来，这是无法完成的，因为我们无法d在第一次迭代期间将任何布尔函数应用于该对（type ）的第二个元素，因为它将导致无限递归，因此只给我们提供了参数（类型b），但任何布尔函数的结果都不会因迭代而有所不同（参数不变），因此，它要么立即终止，要么根本不会终止。我的另一个想法是创建无穷无尽的析因流，但这似乎也不是真实的，因为再次不能更改参数。因此，我有3个问题：

1. 我对以上几点正确吗？
2. 我是否还缺少其他任何有助于通过阶乘实现阶乘的概念Control.Arrow.loop？
3. 总有可能吗？

我一直在尝试mfix使用Control.Arrow.loop. 我想出了不同的定义，想看看哪个是mfix实际工作中的。

因此，我认为正确的解决方案如下：

mfix' :: MonadFix m => (a -> m a) -> m a
mfix' k = let f ~(_, d) = sequenceA (d, k d)
          in (flip runKleisli () . loop . Kleisli) f

正如人们所见，loop . Kleisli's 论点适用于Applicative实例。我发现这是一个好兆头，因为我们的打结大多被(>>=)正确论证中的严格破坏了。

这是另一个功能。我可以说这不是mfix完全相同的，但我发现的唯一情况不是很自然。看一看：

mfix'' k = let f ~(_, d) = fmap ((,) d) (return d >>= k)
           in (flip runKleisli () . loop . Kleisli) …