如何让一个免费的monad解释器递归？
要让一个免费的monad解释器递归，可以通过以下步骤实现：
- 确定解释器的基本结构：一个免费的monad解释器通常由一个解释函数和一个递归函数组成。解释函数负责解释每个语句，并返回解释结果，递归函数负责处理递归调用。
- 定义解释函数：解释函数根据语句的类型进行匹配，并执行相应的操作。对于非递归语句，直接返回结果；对于递归语句，调用递归函数进行处理。
- 定义递归函数：递归函数负责处理递归调用。它接收一个递归语句和一个环境变量作为参数，并根据递归语句的条件进行递归调用或终止递归。
- 实现递归调用：在递归函数中，根据递归语句的条件，可以使用递归调用来实现递归。递归调用时，需要更新环境变量，并传递给下一次递归调用。
- 测试解释器：编写测试用例，验证解释器的正确性和递归功能。
下面是一个示例代码，演示如何实现一个免费的monad解释器递归：
# 定义解释函数
def interpret(statement, environment):
if statement.type == 'non_recursive':
return statement.value
elif statement.type == 'recursive':
return recursive_call(statement, environment)
# 定义递归函数
def recursive_call(statement, environment):
if statement.condition:
# 更新环境变量
new_environment = update_environment(statement, environment)
# 递归调用
return interpret(statement.recursive_statement, new_environment)
else:
# 终止递归
return statement.value
# 测试解释器
environment = {}
statement = NonRecursiveStatement('non_recursive', 'Hello World')
result = interpret(statement, environment)
print(result) # 输出：Hello World
recursive_statement = RecursiveStatement('recursive', 'Hello', True)
statement = NonRecursiveStatement('non_recursive', recursive_statement)
result = interpret(statement, environment)
print(result) # 输出：Hello在上述示例中，我们定义了一个解释函数interpret和一个递归函数recursive_call。解释函数根据语句的类型进行匹配，并执行相应的操作。递归函数根据递归语句的条件进行递归调用或终止递归。通过测试用例，我们可以验证解释器的正确性和递归功能。
请注意，上述示例代码仅为演示目的，实际实现中可能需要根据具体需求进行适当的修改和扩展。
相关·内容
1回答
我见过人们用解释器谈论免费Monad，特别是在数据访问的背景下。这个图案是什么？我什么时候可以用它？它是如何工作的，我将如何实现它？
我理解(从这这样的帖子中)，它是关于将模型与数据访问分离的。它与著名的储存库模式有何不同？他们似乎有同样的动机。
浏览 0提问于2014-06-02得票数 102
回答已采纳
3回答
、和在Clojure中对Monad做了一些杰出的工作。
我的问题是-它能做在克洛尔的免费Monad吗？
来自一篇关于Scala的文章：
data Free f r = Free (f (Free f r)) | Pure r
这是对应的Scala示例
sealed abstract class Free[S[+_], +A](implicit S: Functor[S]) {
final def map[B](f: A => B): Free[S, B] =
flatMap(a => Return(f(a)))
final def flatMap[B](f: A
浏览 4提问于2013-11-24得票数 7
回答已采纳
我有一个由FreeT生成的标准解释器monad转换器的简化版本
data InteractiveF p r a = Interact p (r -> a)
type Interactive p r = FreeT (InteractiveF p r)
p是“提示符”，而r是“环境”...one使用如下方式运行：
runInteractive :: Monad m => (p -> m r) -> Interactive p r m a -> m a
runInteractive prompt iact = do
ran <- runFreeT iact
浏览 0提问于2015-03-20得票数 7
回答已采纳
我正在尝试将中的IResult monad解构为几个片段。这是IResult
data IResult t r = Fail t [String] String
| Partial (t -> IResult t r)
| Done t r
这感觉应该是影响、“偏爱”和失败的组合。如果故障仅表示为Either ([String], String)，则偏好可能是
data Partiality t a = Now a | Later (t -> Partiality t a)
instance Monad (Par
浏览 1提问于2013-03-04得票数 11
回答已采纳
2回答
这个请求响应类型有标准的抽象吗？
、、、、
我有以下类型：
data S req rsp = Done rsp | Next req (rsp -> S req rsp)
其思想是将其用作网络通信的纯表示形式，即：
... Next GetUser $ \uid -> Next (Login uid) $ \success -> Done success
然后用一些不纯的函数eval来评估。
这是什么(如果有的话)？据我所知，这不是一支独角兽，也不是一支箭。它似乎介于流/管道/自动机/fsm和延续单体之间。这让我觉得这类事情可能有更好的表现，但又是什么呢？
浏览 2提问于2016-10-23得票数 3
回答已采纳
我有一个用Scala编写的Playframework应用程序。正如您可能预期的那样，它的主要功能是响应用户请求。典型的请求流：
解析输入并找出用户希望我们做什么
从db、AWS等收集外部资源(相对较慢的异步IO调用)。
当IO调用返回时，执行一系列函数(其中一些函数长时间运行，一些函数不运行)，这些函数执行用户要求的任何操作，最终产生一些输出。
将输出转换为HTTP响应并将其返回给用户。
让主要函数返回未来SomeResult的缺点是什么，即使该函数不做长时间运行的工作？(在这些情况下，我们只需使用Future.successful或等效于将值提升到未来。)
一个好处是，它可以让我们很容易地写
浏览 0提问于2017-06-07得票数 1
回答已采纳
1回答
我已经学习了函子和单子的定义，但除了定义之外，我仍然找不出它们之间的区别。我读过一些关于这个问题的答案，在上有一个评论说
函子接受纯函数(和函数式值)，而monad则采用Kleisli箭头，即返回单值(和一元值)的函数。因此，您可以链接两个单曲，而第二个单曲可以依赖于前一个单曲的结果。你不能用函子做这个。
这个评论很有趣，让我读到了它们的不同之处。但我还有一些问题。
为什么函子不能使用前一个函数的结果？既然fmap :: (a -> b) -> f a -> f b，当我用一个纯函数运行fmap时，我可以得到一个f a -> f b函数，f b依赖于f a，结果是否意
浏览 9提问于2022-10-27得票数 2
回答已采纳
要将IO函数添加到用Haskell编写的编程语言解释器中，我基本上有两个选项：
修改整个解释器以在IO monad中运行。
让可由解释程序调用的运行时函数使用unsafePerformIO。
前者对我来说是个坏主意--这实际上是否定了任何纯度的好处，因为在程序中几乎所有的地方都有IO。我目前还大量使用ST，并且必须修改大量的程序才能实现这一点，因为我无法同时使用ST和IO (?)。
后者让我感到紧张--正如函数名所述，它是不安全的，但我认为在这种情况下，它可能是合理的。特别是：
此更改所涉及的代码数量将非常小。
在计算解释表达式期间，在控制点处使用seq显式地对可执行I
浏览 1提问于2016-06-25得票数 2
我正在学习Haskell，我今天的目标是用逻辑编写一个函数sizeOf :: FilePath -> IO Integer (计算文件或文件夹的大小)
如果path是一个文件，则System.Directory.getFileSize path
如果path是一个目录，那么获取它的内容列表，递归地在它们上运行这个函数，并对结果进行sum
如果它不是文件或目录，那么return 0
下面是我如何在Ruby中实现它的方法(Ruby：map的参数相当于\d -> size_of d，reduce :+是foldl (+) 0，任何结束?的函数都返回bool，返回是隐式
浏览 2提问于2016-12-24得票数 5
回答已采纳
1回答
使用免费Monad实现一个词法器
、、、、
我正在考虑的一个用例，这将是一个简单的词汇DSL。到目前为止，我想出了一些原始的操作：
data LexF r where
POP :: (Char -> r) -> LexF r
PEEK :: (Char -> r) -> LexF r
FAIL :: LexF r
...
instance Functor LexF where
...
type Lex = Free LexF
我遇到的问题是，我希望有一个CHOICE原语来描述尝试执行一个解析器的操作，以及在失败的情况下返回另一个解析器的操作。有点像CHOICE :: LexF r -&g
浏览 3提问于2021-01-24得票数 2
回答已采纳
我正在制作一个函数readUntil，它从用户那里读取代码行。当一行的f返回True时，读取停止。然后将这些行作为列表返回(返回True的行不包括在该列表中)。这是我目前所拥有的(一些真正的原始/伪代码，打扰一下)：
readUntil :: (String -> Bool) -> IO [String]
readUntil f = fmap reverse (go []) where
go xs = do
x <- getLine
if f = True then return xs
else go (x : xs)
浏览 0提问于2018-04-21得票数 0
1回答
作为练习，我决定编写一个滑动拼图解算器(比如8个拼图或15个拼图)。现在，解决方案就在那里，它正在工作，但我现在面临的问题是运行时。我想请求一些帮助来优化解决方案(如果可能的话)。我很有兴趣看看可以采取哪些步骤来提高他们的Haskell程序的性能。
我的实现可以在这里找到：
示例输入文件：
4
5 4 3 8
9 2 6 1
0 13 14 7
15 11 10 12
如果您在分析器下运行它，您将看到我们生成的数据量约为9 9Gb。“有问题的”函数是manhattan和boardDistance。我现在不知道如何处理这些函数来优化它们(如果可能的话)。寻求您的帮助！
引用“
浏览 0提问于2014-07-11得票数 3
2回答
下面的简单函数迭代地应用一个给定的一元函数，直到它到达Nothing，此时它返回最后一个非空值。它能满足我的需要，我也明白它是如何工作的。
lastJustM :: (Monad m) => (a -> m (Maybe a)) -> a -> m a
lastJustM g x = g x >>= maybe (return x) (lastJustM g)
作为我在Haskell的自我教育的一部分，我正在尽可能地避免显式递归(或至少理解)。在这种情况下，似乎应该有一个简单的非显式递归解决方案，但我很难弄清楚。
我不想要像 of takeWhile这样的东
浏览 5提问于2010-05-18得票数 10
回答已采纳
1回答
我听过几次这个词，但我还是不知道所谓的“自由人”到底是什么。这个名字让我想到了“免费单曲”，但我看不出它们到底是怎么回事。我在hackage上找到了一些库：，但是这个例子对我没有多大帮助。
我一点也不明白这个想法，因此我看不出有什么好的用途。我还想知道，比起免费的单片和经典的mtl栈，它们有什么优势。
浏览 0提问于2019-09-02得票数 20
回答已采纳
我最近一直在花时间去理解FP的概念，尤其是免费的monad。我想我很好地理解了免费monads背后的想法，但出现了一个问题。
我已经使用Doobie有一段时间了，它是建立在免费monads之上的。对我来说，将不同的代数组合在一起(使用余积)是有意义的，包括doobie。在测试代数时，人们通常会创建一个测试解释器。但是对于像Doobie这样的现有库(它的代数有点大)，我需要自己创建一个测试解释器吗？对我来说，在这一点上使用免费的monad会给出很多样板代码。此外，如果方法是错误的，我希望得到一些反馈。
也许是一个更常见的问题，但您倾向于使用它们的用例是什么？您是使用它们来构建几乎每个FP应用程序
浏览 2提问于2017-08-01得票数 0
2回答
结合自由类型
、、
最近，我从包中自学了关于 monad的知识，但遇到了一个问题。我想为不同的库提供不同的免费单元组，本质上我想为不同的环境构建DSL，但我也希望能够将它们结合在一起。例如：
{-# LANGUAGE DeriveFunctor #-}
module TestingFree where
import Control.Monad.Free
data BellsF x
= Ring x
| Chime x
deriving (Functor, Show)
type Bells = Free BellsF
data WhistlesF x
= PeaWhistle
浏览 3提问于2014-01-28得票数 18
回答已采纳
假设我们想要构建一个类型，它表示一个典型的操作，比如说，一个无锁算法：
newtype IntPtr = IntPtr { ptr :: Int } deriving (Eq, Ord, Show)
data Op r where
OpRead :: IntPtr -> Op Int
OpWrite :: IntPtr -> Int -> Op ()
OpCAS :: IntPtr -> Int -> Int -> Op Bool
理想情况下，我们希望使用一个方便的do-notation来表示该模型中的一些算法，例如(出于美学原因假设相应的
浏览 1提问于2018-05-29得票数 4
回答已采纳
1回答
我正在做一个项目，其中包括一个数据库访问层。很正常真的。在之前的一个项目中，一位合作者鼓励我使用Free概念作为数据库层，所以我做到了。现在我正试图在我的新项目中决定我得到了什么。
在上一个项目中，我有一个API，看起来很像这样。
saveDocument :: RawDocument -> DBAction ()
getDocuments :: DocumentFilter -> DBAction [RawDocument]
getDocumentStats :: DBAction [(DocId, DocumentStats)]
等二十多个这样的公共活动。为了支持它们，我使用了
浏览 0提问于2014-05-20得票数 39
回答已采纳
下面的Haskell代码是一个简单的“控制台IO”DSL：
data Ap a = Ap { runAp :: ApStep a }
data ApStep a =
ApRead (String -> Ap a)
| ApReturn a
| ApWrite String (Ap a)
ioRead k = Ap $ ApRead k
ioReturn a = Ap $ ApReturn a
ioWrite s k = Ap $ ApWrite s k
ioWriteLn s = ioWrite (s ++ "\n")
浏览 4提问于2013-11-30得票数 8
回答已采纳
2回答
我正在尝试构建以下类型的Monad实例：
data CmdY ρ η ω = CmdY (Reader ρ ((Stream (Of CmdSpec) η ω)))
其中Stream和Of来自streaming包中的Streaming。
我已经成功地编写了Functor Applicative实例：
instance (Monad η) => Functor (CmdY ρ η) where
fmap :: (α -> β) -> CmdY ρ η α -> CmdY ρ η β
fmap f (CmdY a) = CmdY $ (fmap f) <$&g
浏览 11提问于2018-07-19得票数 1
回答已采纳
1回答
带变体的Haskell一元解析器
、、、、
我的问题是如何将递归的F代数风格的递归类型定义与一元/应用式解析器结合起来，从而扩展到实际的编程语言。
我刚刚从下面的Expr定义开始：
data ExprF a = Plus a a |
Val Integer deriving (Functor,Show)
data Rec f = In (f (Rec f))
type Expr = Rec ExprF
我正试图将它与一个使用变体的解析器结合起来：
ana :: Functor f => (a -> f a) -> a -> Rec f
ana psi x = In $ fmap (a
浏览 6提问于2021-06-10得票数 5
回答已采纳
Haskell wiki上的页面定义了将函数器实例转换为自由monad的函数：
inj :: Functor f => f a -> Free f a
inj fa = Roll $ fmap Return fa
然后，假设inj [1,2,3]具有类型(Num t) => Free [] t。如何定义一个函数来将类似inj [1,2,3]的内容返回给[1,2,3]
浏览 3提问于2011-06-03得票数 8
回答已采纳
1回答
猫中Monad变形金刚的一些定义。
EitherT[F_，A，B]是F[EitherA，B]的一个轻量级包装器，它可以方便地将其中之一和Fs组合在一起。为了使用EitherT，首先将F、A和B的值转换为EitherT，然后使用组合子组合生成EitherT值。OptionT[F_，A]是F[OptionA]上的轻型包装器。从技术上讲，这是一个可供选择的单台转换器，但你不需要知道这意味着什么才能有用。与直接使用OptionT相比，使用F[OptionA]更方便。
我理解这个概念，甚至看到了一些有趣的话题：
我理解“读者Monad”，以及Kleisli是如何泛化的。
我不明白的是下面这句话，
浏览 3提问于2020-10-10得票数 1
回答已采纳
我正在使用下面的代码(取自这个)懒惰地编码列表：
import Data.Binary
newtype Stream a = Stream { unstream :: [a] }
instance Binary a => Binary (Stream a) where
put (Stream []) = putWord8 0
put (Stream (x:xs)) = putWord8 1 >> put x >> put (Stream xs)
问题是解码实现并不是懒惰的：
get = do
t <- g
浏览 0提问于2012-07-28得票数 7
回答已采纳
我正在探索Haskell中的选项，这些选项可以让我将业务逻辑从底层系统的技术实现中分离出来。例如，在web服务器的上下文中，将web服务器如何处理它接收到的信息与读取和写入数据库的方式分开。要做这样的事情，有很多选择，但有两个特别引起了我的注意:免费的Monad和传递能力记录作为论据。我很难看清一个比另一个的利弊是什么。
一个代码片段来说明我要说的内容：
module Lib where
import qualified Control.Monad.Free as FreeMonad
data MyGadt x
= Read (String -> x)
| Write Str
浏览 2提问于2019-05-11得票数 7
回答已采纳
1回答
我正在构建一个小型DSL使用免费单。
我希望能够在我的DSL中拥有多态函数。
我想要建立的一个例子是：
{-# LANGUAGE TemplateHaskell #-}
import Control.Monad.Free.Church
data Queue a = Queue a
data MyDsl next =
NewQueue (Queue a -> next) |
WriteToQueue (Queue a) a next
makeFree ''MyDsl
testProgram :: F MyDsl
testProgram
浏览 10提问于2016-08-03得票数 6
回答已采纳
MaybeT被定义为
newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) }
而且，MaybeT m也是Monad类的一个实例，函数return定义如下
return = MaybeT . return . Just
但是我读到了"It would also have been possible (though arguably less readable) to write return = MaybeT . return . return"，这让我很困惑。
return = MaybeT . return . re
浏览 0提问于2014-11-08得票数 2
回答已采纳
我有一个非常典型的设置，在IO monad中有一组函数可以抛出错误。到目前为止，我一直在通过模式匹配处理单链末尾的错误，该模式匹配runErrorT的任一结果：
replLisp :: LispScope -> String -> IO String
replLisp s input = do
result <- runErrorT (evalLisp s input)
return $ either (id) (show) result
现在我想在我的Hacked小方案中添加一些错误处理，但是我很难让类型检查器高兴。
如何使用catchError？举一两个例子会有
浏览 1提问于2011-04-14得票数 3
回答已采纳
我以前曾想过，实现的部分目标是避免这个问题，所以也许我在做一些明显愚蠢的事情？
以下是一些代码：
// Stack overflow
import scalaz._
sealed trait Command[T]
case class Wait(ms: Long) extends Command[Unit]
case object Evaluator extends (Command ~> Id.Id) {
override def apply[T](cmd: Command[T]) = cmd match {
case Wait(t) => Thread
浏览 3提问于2015-04-15得票数 8
回答已采纳
1回答
我正在使用machines库，我有三个Processes foo :: Process a b
bar :: Process b a
baz :: Process b c 我想把它们组合起来，使bar和baz都使用foo的输出作为输入。此外，这也是我正在努力解决的部分，我想将bar的输出反馈到foo中，形成一个循环。有什么关于如何做的提示吗？
浏览 12提问于2021-04-06得票数 3
有没有一个标准的(或者至少是常用的)包，里面有一个用于FIFO队列的monad？我不久前在一篇文章中读到了，我已经用过它几次了，但我不想再重新实现轮子(它很有趣，但效率很低)。
浏览 0提问于2011-09-22得票数 5
回答已采纳
1回答
在和Mark的示例中，我第一次看到了作为构建纯代码和IO代码之间边界的一种方法的免费monads。我的基本理解是，一个免费的monad允许您构建一个程序(一个抽象语法树- AST)的纯函数，然后翻译成一系列不纯的过程调用。因此，此解释器将AST的纯操作转换为一元IO操作序列。
我想知道这是否重复了Haskell运行时已经在使用IO monad所做的工作。如果我认为IO不是什么特别的东西，而是一个普通的Monad，它的绑定函数>>=通过IO中的所有一元操作来序列“真实世界”的状态，那么这个排序本身并不提供任何计算(正如出色的答案中对免费Monad的解释)。然后，我可以将所有IO操作(
浏览 8提问于2020-05-15得票数 10
回答已采纳
1回答
这是我第一次接触Monad Transformers，所以答案可能是显而易见的。
假设我在一个StateT MyMonad MyType类型的do块中，我想让另一个相同类型的函数修改状态并返回一个MyMonad MyType类型的值。我怎样才能做到这一点呢？我认为示例在guessSession中显示了它，但我似乎不能理解如何应用它！
浏览 2提问于2012-01-20得票数 5
回答已采纳
我正在学习Haskell，我想让用户输入x号到控制台中，并将这些数字存储在数组中，这些数字可以传递给我的函数。
不幸的是，不管我尝试了什么，它都不起作用，下面是我的代码：
-- Int Array
intArray :: Int -> IO [Int]
intArray 0 = []
intArray x = do
str <- getLine
nextInt <- intArray (x - 1)
let int = read str :: Int
return int:nextInt
-- Main Function
main = do
浏览 0提问于2015-03-13得票数 4
回答已采纳
1回答
我对函数式编程很陌生。然而，我读到了关于免费Monad的文章，我正在尝试在一个玩具项目中使用它。在这个项目中，我建模了股票的投资组合领域。正如许多书中所建议的，我为PortfolioService定义了一个代数，为PortfolioRepository定义了一个代数。
我想在PortfolioRepository代数和解释器的定义中使用Free。现在，我还没有用自由单子来定义PortfolioService代数。
但是，如果这样做，在PortfolioService解释器中，由于使用的单数不同，所以不能使用PortfolioRepository的代数。例如，我不能使用monad Either[
浏览 3提问于2021-01-09得票数 1
回答已采纳
我试图永远重复IO操作，但将一次执行的结果提供给下一次。如下所示：
-- poorly named
iterateM :: Monad m => (a -> m a) -> a -> m b
iterateM f a = f a >>= iterateM f
Hoogle似乎对我没有帮助，但我看到很多功能看起来非常接近我想要的功能，但似乎没有一个功能组合在一起就是我想要的。
浏览 4提问于2012-05-29得票数 7
回答已采纳
3回答
我想在尾递归函数中转换genEdges函数。
genEdges :: Int -> Node -> IO [Edge]
genEdges n origin | n == 0 = return []
| otherwise = do
edge <- genRandEdge origin
edges <- genEdges (n-1) (snd edge)
return $ edge : edges
我是说
浏览 4提问于2013-09-27得票数 0
回答已采纳
5回答
给出一个免费的单播DSL，例如：
data FooF x = Foo String x
| Bar Int x
deriving (Functor)
type Foo = Free FooF
和一个用于Foo的随机解释器
printFoo :: Foo -> IO ()
printFoo (Free (Foo s n)) = print s >> printFoo n
printFoo (Free (Bar i n)) = print i >> printFoo n
在我看来，应该可以在printFoo的每一次迭代中插入一些内容
浏览 1提问于2013-12-13得票数 21
回答已采纳
1回答
我正在尝试使用monad阅读器来处理Scala中的依赖注入。我最近开始学习Scala，所以我在这里给出的代码不能编译，但我希望我的问题变得清晰。首先，假设我们的应用程序允许用户更改它的密码。首先，我创建了一个简单的case类User，并在伴生对象上添加了一个changePassword方法：
case class User (id:Int, username:String, password:String)
object User {
def changePassword (oldPassword:String, newPassword:String, user:User) = {
浏览 0提问于2014-03-28得票数 3
1回答
我是新手haskell，在lernning parsec lib中有一个例子：
nesting :: Parser Int
nesting = do{ char '('
; n <- nesting
; char ')'
; m <- nesting
; return (max (n+1) m)
}
<|> return 0
那么n或m是什么？为什么n和m是int且大于0？
浏览 4提问于2011-03-23得票数 1
1回答
我正在尝试让下面的代码正常工作。这是一个有限状态机，我在其中传入一个函数作为下一个状态。使用r调用该函数，并返回一个结果列表+下一个函数的状态。继续调用，直到列表用完，并返回结果的串联。monad是一个错误monad，允许我在需要时抛出错误。
fsm f [] = return []
fsm f (r:rs) = do
(xs, f') <- f r
rest <- fsm f' rs
return $ xs ++ rest
错误是：
Occurs check: cannot construct the infinite ty
浏览 0提问于2013-03-19得票数 6
回答已采纳
如果我有一个用于理解的scala，列表如下
def getList: List[A]
def doSomeStuff(a: A): List[B]
for {
a <- getList
x <- doSomeStuff(a)
} yield x
我在Intellij中使用调试器逐步进行了调试，调试器足够智能，不会进入List类的内部map/flatMap实现。我可以检查getList和doSomeStuff调用，而不用考虑在后台工作的monad管道。
然而，当我实现我自己的monad时，调试器的行为方式并不相同，它直接介入并显示了monad实现的所有核心。虽然这对于初始调
浏览 3提问于2017-09-14得票数 0
在Haskell中，Writer和WriterT有什么不同？一个比另一个更受欢迎吗？
浏览 0提问于2011-10-03得票数 10
回答已采纳
2回答
在Haskell的中，有一个被称为的例子
f 0 acc = return (reverse acc)
f n acc = do
v <- getLine
f (n-1) (v : acc)
尽管命令式符号让我们相信它是尾递归的，但它一点也不明显(至少对我来说是这样)。如果我们去糖do我们得到
f 0 acc = return (reverse acc)
f n acc = getLine >>= \v -> f (n-1) (v : acc)
重写第二行将导致
f n acc = (>>=) getLine (\v -> f (n-
浏览 3提问于2012-11-14得票数 28
回答已采纳
2回答
尾递归和scalaz承诺
、、、
我目前正在使用Scalaz非阻塞期货。诺言。我正在努力让下面的函数成为尾递归函数：
@tailrec
private def repeat( res: Promise[I] ):Promise[I] =
res map p flatMap {
(b:Boolean) =>
if( b ) repeat( res flatMap f ) else res
}
其中p是类型为I=>Boolean的谓词，f是类型为I=>Promise[I]的并发函数。
该方法在没有注释的情况下编译。
有什么提示吗？谢谢
浏览 2提问于2011-05-09得票数 3
回答已采纳
1回答
单片变压器的解剖
、、
我试着学习单台变压器，基于标准的Haskell库(mtl？变形金刚？不知道我下载的Haskell平台-7.4.1附带的是哪一个)。
我认为我注意到的是每个单台转换器定义的公共结构：
基本类型(“基本”)
- Monad instance
变压器类型(“BaseT”)
- Monad instance
- MonadTrans instance
- MonadIO instance
变压器类(“MonadBase”)
- some operations
- instances for other 'BaseT's
例如，对于Writ
浏览 2提问于2012-11-28得票数 10
1回答
我正在解决haskell wikibook上的一个问题，我完全被困住了。他们要求“将单章中兔子入侵的例子概括为任意几代人”。
兔子入侵示例的描述：
“很容易将熟悉的列表处理功能合并到一元码中。考虑一下这个例子:兔子平均每窝养六只，其中一半将是雌性。从一只母兔开始，我们可以模拟每一代母猪的数量(即在兔子长大并拥有自己的窝后，新工具包的数量)：”
Prelude> let generation = replicate 3
Prelude> ["bunny"] >>= generation
["bunny","bunny",&#
浏览 4提问于2019-10-04得票数 2
回答已采纳
1回答
为什么在Control.Monad.Reader中有一个“读取器”和一个“Control.Monad.Reader”？包文档讨论Reader，然后直接进入MonadReader文档，没有任何解释。这些单元组之间有什么区别？读这些参考书让我非常困惑。有趣的是，Haskell wikibook的Reader页面还没有写好！
浏览 4提问于2016-09-07得票数 5
回答已采纳
1回答
在的第12页，它写道：“容器的一个突出的例子是列表数据类型。列表可以用列表的长度和列表中的函数映射位置来表示”。
起初，我认为这个容器上的自由单子是同构的列表单。
但是在第12页上，它写到，“列表单an不是自由单an，因为列表单an不是与自由单an的一个实例同构的”。
那么，上述容器上的免费单片是什么？同构的是什么？为什么它不是同构的列表单？它能用商来表示同构吗？
浏览 5提问于2022-02-22得票数 9
回答已采纳
有人能演示一下如何在阅读器monad中使用snap monad吗？Monad transformers把我搞糊涂了。(或者，我会很高兴地接受有关monad transformers的教程的建议，以及了解并最终摸索它们的方法。)
编辑:糟糕；忘了说明我实际上想做什么，而不是请求帮助做一件具体的事情。战略，而不是战术。我特别希望在所有处理程序之间共享一个数据库连接/池，而不必在指定路由时显式传递该数据库连接/池。看起来阅读器monad将是实现这一目标的方法。
浏览 0提问于2011-02-07得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
