相关疑难解决方法(0)

谁首先说了以下几点？

monad只是endofunctors类别中的幺半群,问题是什么？

在一个不太重要的注意事项上,这是真的,如果是这样,你能给出一个解释(希望有一个可以被没有Haskell经验的人理解的那个)吗？

我正在努力,Data.Fresh并且Control.Monad.Trans.Fresh,正在进行中.定义用于生成新变量的接口,以及实现此接口的monad变换器.

我最初认为可以Applicative为我实现实例,FreshT v m只有Applicative m存在的唯一要求.但是,我卡住了,似乎我需要Monad m.不相信我的Haskell的福,我再转向变压器包,并且很惊讶我发现Control.Monad.Trans.State.Lazy和.Strict:

instance (Functor m, Monad m) => Applicative (StateT s m) where
    pure = return
    (<*>) = ap

所以这是我的问题:是否可以使用以下实例头创建具有等效语义的实例？

instance (Applicative m) => Applicative (StateT s m) where

Control.Monad.Free 实现一个免费的monad:

data Free f a = Pure a | Free (f (Free f a))

instance Functor f => Functor (Free f) where
  fmap f = go where
    go (Pure a)  = Pure (f a)
    go (Free fa) = Free (go <$> fa)

我在理解第二go行时遇到了很多麻烦,特别是在描述自由monad是什么的情况下.有些人可以描述一下这是如何工作的以及为什么它会成为Free f a一个免费的monad？

嗨,我正在尝试实现穷人的并发Monad.这是我的代码:

import Control.Monad

data Concurrent a = Concurrent ((a -> Action) -> Action)

data Action 
    = Atom (IO Action)
    | Fork Action Action
    | Stop

instance Monad Concurrent where
    (Concurrent ma) >>= f = Concurrent (\x -> ma(\y -> "Something return a Action")) 
    return x = Concurrent (\c -> c x)

这是我的分析: x有类型b,y有类型a,f有类型(a -> ((b ->Action) -> Action)).为了弄清楚"Something return a Action",我首先计算(f y),返回一种类型((b ->Action) -> Action).然后,如何使用它 …

在Mark Seemann 的博客文章和示例中，我第一次看到了自由 monad 作为构建纯代码和 IO 代码之间界限的一种方式。我的基本理解是，免费的 monad 可以让您构建纯函数的程序（抽象语法树 - AST），然后解释器将其转换为一系列不纯的过程调用。因此，该解释器将 AST 的纯操作转换为一系列 monadic IO 操作。

我想知道这是否是在重复 Haskell 运行时已经对 IO monad 所做的事情。如果我认为 IO 没什么特别的，而是一个常规的 Monad，其绑定函数>>=通过 IO 中的所有 monadic 操作对“真实世界”的状态进行排序，那么这种排序本身不提供任何计算（如在很好的答案在这里）。然后，我可以将所有 IO 操作（如getLine、writeFile等）视为自由 IO monad 中的操作，并将 Haskell 运行时视为解释器。运行时通过一些底层系统调用、C FFI调用等方式来解释每个IO动作，这显然是不纯的。

因此，在这个视图中，返回 IO 操作的函数只是构建 AST，然后由 Haskell 运行时解释。但到目前为止，一切都是纯粹的。在这种观点下，函数a -> IO b不是不纯的，就像在自由 monad 中的操作不是不纯的一样。

这种直觉是否正确？如果没有，它的不足之处在哪里？

我看过这篇文章，它对什么是自由 monad 进行了一些抽象的描述。我也理解 Monad Transformers 是什么，并且我理解（在某种程度上）为什么它们会有用。

我不知道免费 monad 用于什么或 monad 转换器库是什么。我也听说过mtl vs free monad 辩论，但我不确定它是什么，因为我在互联网上找不到任何关于此的讨论。

有人能解释一下这个争论是关于什么的吗？

我想用这样的类型创建一个自动机类型：

newtype Auto i o = Auto {runAuto :: i -> (o, Auto i o)}

我知道这是Automata 箭头的类型，但我不是在寻找箭头。我想让它成为一个 monad，所以大概它会有一个类型

newtype Auto i o a = ???? What goes here?

具有这样的功能：

yield :: o -> Auto i o i

因此，当我从 Auto monad 中调用“yield”时，“runAuto”函数返回由“yield”的参数和延续函数组成的对。当应用程序调用延续函数时，参数作为“yield”的结果在 monad 中返回。

我知道这将需要一些延续 monad 的风格，但尽管过去曾与延续争论不休，但我不知道如何编写这个代码。

我也知道这很像 Michael Snoyman 的Conduit monad，除了他将“yield”和“await”分开。这个 monad 必须为每个输入只有一个输出。

背景：我正在编写一些以复杂方式响应 GUI 事件的代码。我希望能够编写接受一系列输入的代码，而不是将其变成手动编码的状态机，以换取随着用户交互的进行而对屏幕进行更新。

编辑

这一切都被证明是微妙的错误。我写了 Petr Pudlák 在他的回复中建议的代码，它似乎有效，但“yield”操作总是产生前一个yield的输出。这很奇怪。

在盯着屏幕看了很久之后，我终于发现我需要把代码贴在这里。关键的区别在于 AutoF 类型。将下面的方法与 Petr 提出的方法进行比较。

import Control.Applicative
import Control.Monad
import Control.Monad.IO.Class
import Control.Monad.State.Class …

我正在hspec做一些基本的测试。

我有一个argsParser给定一些参数的函数，返回或更确切地说打印其有效性。

argsParser :: [String] -> IO ()
argsParser args | null args = print "no args provided"
                | not $ null args && length args < 2 = print "no file name provided"
                | length args > 2 == print "too many arguments"
                | otherwise = goAhead args

问题是我不确定如何IO ()与另一个进行比较IO ()。

我以为可能liftIO会有所帮助

x <- liftIO $ print "something"
y <- liftIO $ print "anything"

我懂了

x == y = …

类别理论中的Monads由三元组T,单位,平坦 defined定义.

class Monad t where
  map :: (a -> b) -> (t a -> t b) -- functorial action
  unit :: a -> t a
  flat :: t (t a) -> t a

class KleisliTriple t where
  unit :: a -> t a
  flatMap :: t a -> (a -> t b) -> t b

KleisliTriple由运营商展示结构:( flatMap或bind在Haskell中)由map和的组成flat.

但是,我总是认为在函数式编程中理解和实现Monad概念更加简单和容易,通过将结构与对象(例如flatUnit,unit和的组合)展平来构成函数flat.

在这种情况下,flatUnit(flatUnit(x)) = flatUnit(x).我实际上是用这种方式在JavaScript中实现的,并且使用flatUnit和 …