请澄清Reader Monad类型的行为
Reader Monad是一种在函数式编程中常用的设计模式，用于处理依赖注入和环境依赖的问题。它允许我们在函数中传递一个共享的只读环境，并且可以在需要的时候访问该环境中的值。
Reader Monad的行为可以总结为以下几点：
- 环境依赖：Reader Monad允许我们将环境依赖作为参数传递给函数，而不是通过全局变量或者显式传递的方式。这样可以更好地控制函数的依赖关系，提高代码的可测试性和可维护性。
- 只读环境：Reader Monad中的环境是只读的，即在函数中无法修改环境中的值。这样可以确保函数的纯粹性，避免副作用的产生。
- 函数组合：Reader Monad支持函数的组合操作，可以将多个依赖环境的函数组合成一个更复杂的函数。这样可以提高代码的可复用性和可扩展性。
- 延迟计算：Reader Monad中的计算是延迟执行的，即只有在需要的时候才会真正执行计算。这样可以提高性能，避免不必要的计算。
- 错误处理：Reader Monad可以处理环境依赖的错误情况。通过在Monad中引入错误处理的机制，可以更好地处理异常情况，提高代码的健壮性。
Reader Monad在实际应用中有很多场景，例如：
- 配置管理：可以使用Reader Monad来管理应用程序的配置信息，将配置信息作为环境依赖传递给各个函数。
- 认证和授权：可以使用Reader Monad来处理认证和授权的逻辑，将用户信息和权限信息作为环境依赖传递给需要进行认证和授权的函数。
- 日志记录：可以使用Reader Monad来处理日志记录的逻辑，将日志配置和日志记录器作为环境依赖传递给需要进行日志记录的函数。
腾讯云提供了一系列与云计算相关的产品，其中包括与Reader Monad相关的产品。具体推荐的产品和产品介绍链接如下：
- 云函数（Serverless）：腾讯云云函数是一种无服务器计算服务，可以帮助开发者更方便地编写和管理函数。通过云函数，可以轻松实现基于Reader Monad的函数式编程模式。了解更多：云函数产品介绍
- 云数据库 TencentDB：腾讯云数据库 TencentDB 是一种高性能、可扩展的云数据库服务，支持多种数据库引擎。可以将数据库连接信息作为Reader Monad的环境依赖，实现数据库访问的函数式编程。了解更多：云数据库 TencentDB 产品介绍
- 云存储 COS：腾讯云对象存储（Cloud Object Storage，COS）是一种安全、高可靠、低成本的云存储服务，可以存储和访问任意类型的数据。可以将存储桶信息作为Reader Monad的环境依赖，实现对云存储的函数式编程。了解更多：云存储 COS 产品介绍
请注意，以上推荐的产品仅作为示例，实际选择产品时应根据具体需求进行评估和选择。
相关·内容
1回答
我在学习分类理论。我理解reader的概念，它甚至很容易实现：
case class Reader[DEP, A](g: DEP => A) {
def apply(dep: DEP): A = g(dep)
def map[B](f: A => B): Reader[DEP, B] = Reader(dep => f(apply(dep)))
def flatMap[B](f: A => Reader[DEP, B]): Reader[DEP, B] = Reader(dep => f(apply(dep)) apply dep)
}
但是，我在
浏览 1提问于2017-02-05得票数 2
回答已采纳
2回答
内隐式强制？
、、
我不明白为什么这段代码是错误的：
error1 :: ErrorT String (ReaderT Int IO) Int
error1 = asks id
fyi，asks有以下类型：
asks :: Monad m => (r -> a) -> ReaderT r m a
另一方面，我能够理解，这段代码是错误的：
reader1 :: ReaderT Int IO Int
reader1 = asks id
id具有a -> a类型，并且有一个用于IO的Monad实例，因此编译器可以推断该类型。这对我来说很清楚。
ErrorT是newtype和状态，(在关于新类型的
浏览 5提问于2014-11-07得票数 2
回答已采纳
1回答
为什么在Control.Monad.Reader中有一个“读取器”和一个“Control.Monad.Reader”？包文档讨论Reader，然后直接进入MonadReader文档，没有任何解释。这些单元组之间有什么区别？读这些参考书让我非常困惑。有趣的是，Haskell wikibook的Reader页面还没有写好！
浏览 4提问于2016-09-07得票数 5
回答已采纳
虽然我理解读者monad的实现，但我给出了以下两种最突出的方法：
case class Reader[R, A](run: R => A)
def readerMonad[R] = new Monad[({type f[x] = Reader[R,x]})#f] {
def unit[A](a: => A): Reader[R, A] = Reader(_ => a)
override def flatMap[A,B](st: Reader[R, A])(f: A => Reader[R, B]): Reader[R, B] =
Read
浏览 0提问于2020-10-02得票数 3
2回答
我正在尝试编写我自己的monad transformer，在堆栈中使用多个具有不同类型的相同monad transformer是有意义的。这个问题可以用读者monad来说明。
reader monad是作为保存给定类型的只读上下文的一种方式提供的
ex1 :: Reader Bool Bool
ex1 = ask
或
ex2 :: Reader Char Bool
ex2 = pure True
monad转换器允许对下划线monad的限制较少的假设
ex3 :: (MonadReader Bool m) => m Bool
ex3 = ask
但是，如果我想要一个以上的只读环境，该怎么
浏览 0提问于2019-01-12得票数 4
2回答
我在理解“读者Monad”时有困难。从我读过的所有地方来看，我的理解是它允许将一个变量(读取模式)共享给不同的函数。下面是计算和相同的两个函数的实现(抱歉，对于错误的函数名称)，一个有Reader，一个没有它。我没有得到使用Reader的好处。
module Moreunderstanding where
import Control.Monad.Reader
computation :: Reader Int Int
computation = do
a <- ask
b <- asks square
return (a + b)
square :: I
浏览 0提问于2017-03-24得票数 1
module Main (main) where
import Control.Monad.Reader
p1 :: String -> IO ()
p1 = putStrLn . ("Apple "++)
p2 :: String -> IO ()
p2 = putStrLn . ("Pear "++)
main :: IO ()
main = do
p1 "x"
p2 "y"
r "z"
r :: String -> IO ()
r = do
p1
浏览 0提问于2012-12-14得票数 1
回答已采纳
我使用ReaderT Monad转换器通过执行IO的几个函数从我的主要函数中传播我的配置数据。最终需要数据的函数不执行任何IO。我有一个解决办法：
import Control.Monad.Reader
type Configuration = String
funNoIO :: Reader Configuration String
funNoIO = do
config <- ask
return $ config ++ "!"
funIO :: ReaderT Configuration IO String
funIO = do
con
浏览 0提问于2015-02-08得票数 3
回答已采纳
如何使用Reader/ReaderT对列表类型使用ask，例如，[(Int, Int)]，然后在list monad (为ask编辑的类型)中执行计算？
我的坏代码如下所示，为了清晰起见，缩短了代码：
attempt :: Int -> Int -> ReaderT [(Int,Int)] [] [[Int]]
attempt start end =
do (s0, e0) <- ask
return [0]
为了让您了解我要做的事情，下面是相同的函数，使用list monad，而不是Reader：
paths :: [(Int, Int)] -> I
浏览 4提问于2014-06-12得票数 4
回答已采纳
我正在尝试理解阅读器monad，我遵循这个答案，它有这个例子：
import Control.Monad.Reader
data GameState = NotOver | FirstPlayerWin | SecondPlayerWin | Tie
data Game position
= Game {
getNext :: position -> [position],
getState :: position -> GameState
}
getNext' :: position -&
浏览 7提问于2021-05-17得票数 1
我了解到Monad.Reader实际上是一个函数的封装，即：
newtype Reader r a = Reader { runReader :: r -> a }
它是Monad的一个例子，
instance Monad (Reader r) where
return a = Reader $ \_ -> a
m >>= k = Reader $ \r -> runReader (k (runReader m r)) r
相反，我知道(->)也是一个Monad，
instance Monad ((->) r) where
r
浏览 2提问于2015-03-05得票数 8
回答已采纳
3回答
我试图理解读者的单曲，但似乎无法理解bind (>>=)在这个单曲中所做的事情。
下面是我分析的实现：
newtype Reader e a = Reader { runReader :: (e -> a) }
instance Monad (Reader e) where
return a = Reader $ \e -> a
(Reader r) >>= f = Reader $ \e -> runReader (f (r e)) e
我的第一个问题是，为什么Reader部分应用在bind的左侧？(Read
浏览 0提问于2018-01-21得票数 2
回答已采纳
1回答
我现在正在报道阅读器monad，我遇到了runReader
newtype Reader e a = Reader {runReader :: (e -> a)}
我知道这里的数据构造函数Reader允许将两种不同的类型(e和a)传递到类型构造函数Reader中，该类型构造函数使用记录语法来包含一个在e和a上操作的函数runReader ::。
我正在尝试实现一个测试：
newtype Test a b = Test {runTest :: (a -> b)}
如何开始创建runTest的实现
浏览 2提问于2017-02-07得票数 0
回答已采纳
为什么在内部monad transformer环境中，除了IO之外，不需要使用lift来执行函数？我的意思是，如果我在WriterT上使用StateT，在ReaderT上使用WriterT，为什么我可以这样做呢？
tell $ {- any code here for the Writer -}
foo <- asks {- This for the reader -}
and so on...
而不是
lift $ tell $ {- code ... -}
...
有什么特别的解释吗?或者这只是Monad Transformers的编写方式？
浏览 0提问于2013-06-20得票数 6
回答已采纳
1回答
我正在读关于的scalaz示例。下面是一段代码：
scala> def myName(step: String): Reader[String, String] = Reader {step + ", I am " + _}
myName: (step: String)scalaz.Reader[String,String]
scala> def localExample: Reader[String, (String, String, String)] = for {
a <- myName("First")
浏览 4提问于2015-08-25得票数 0
我想做的是在Reader monad的基础上做一个应用函数，它可以做这样的事情：
data MyData = Int Int
get2Sum :: Reader [Int] Int
get2Sum = do
myData <- ask
let fst2 = take 2 myData
case length fst2 of
2 -> return $ sum fst2
_ -> return 0
myDataFromApplicative = MyData <$> get2Sum <*> ge
浏览 0提问于2012-10-24得票数 6
回答已采纳
斯卡拉兹
Kleisli[F, A, B]是A => F[B]的包装器。
ReaderT[F, A, B] --读取器--只是Kleisli[F, A, B]的别名。
Reader[A, B] monad是ReaderT的一个专门化，它具有identity monad Idtype Reader[A, B] = ReaderT[Id, A, B]。
这仅仅是巧合，还是有一些更深层次的原因导致Kleisli、ReaderT和Reader在Scalaz中同构？
浏览 1提问于2015-03-24得票数 19
回答已采纳
2回答
如果我检查kind of Maybe，就会得到以下结果：
λ> :k Maybe
Maybe :: * -> *
现在，如果我检查一下Monad的类型，就会得到以下结果：
λ> :k Monad
Monad :: (* -> *) -> Constraint
Constraint在那里是什么?为什么需要它？为什么不只是这个* -> *？
浏览 3提问于2015-04-08得票数 9
回答已采纳
我想要能够写作
x :: Eff (reader :: Reader Int, maybe :: Maybe) Int
x = do
config <- ask -- configuration from (Reader Int) monad
just config -- using (Maybe) Monad
runX :: Int
runX = runPure (runMaybe doIfNothing (runReader 6 x)) -- outputs: 6
使用Eff Monad
使用Eff可以做到这一点吗
如果不使用Eff，我们如何才能使其正常工作
浏览 3提问于2017-04-11得票数 0
建议使用Reader来处理BlazeHtml的实际模板，但没有说明应该如何做到这一点。我试着遵循这个建议。结果让我很困惑。
为了举例说明，假设我有一个简单的用户类型，并且我希望使用单独的函数组合我的HTML，一个函数用于布局，另一个函数用于显示用户信息的HTML页面的一部分。如果我使用Reader，它看起来是这样的：
data User = User {
username :: Text
, userId :: nt
} deriving (Show)
userBox :: Reader User Html
userBox = do
user <- ask
re
浏览 4提问于2013-12-23得票数 5
回答已采纳
2回答
我搞不懂为什么这段代码可以在有类型提示的情况下编译，但在没有类型提示的情况下却不能编译。不应该有任何实例歧义(只有一个实例)。
class Monad m => FcnDef β m | β -> m where
def :: String -> β -- takes a name
instance Monad m => FcnDef (m α -> m α) m where
def s body = body
dummyTest :: forall m. Monad m => m ()
dummyTest = def "dumm
浏览 0提问于2011-08-29得票数 5
回答已采纳
在我的业务领域-金融机构的后台IT -软件组件携带全局配置，记录其进度，出现某种错误处理/计算短路，这是非常常见的……可以由Haskell中的Reader，Writer，或者可能是monad之类的东西很好地建模，并与monad transformers组合在一起。
但似乎有一些缺点: monad转换器背后的概念相当棘手和难以理解，monad转换器导致非常复杂的类型签名，并且它们会造成一些性能损失。
所以我想知道:在处理上面提到的那些常见任务时，monad transformers是不是最好的实践？
浏览 2提问于2010-05-04得票数 54
回答已采纳
在用monad变压器构建一个用于编写库的monad堆栈时，我遇到了一个关于它的行为的问题。
以下代码不会传递类型检查器：
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Foo (FooM, runFooM, foo) where
import Control.Applicative
import Control.Monad.Reader
newtype FooM m a = FooM { runFooM :: ReaderT Int m a }
deriving (Functor, Applicative, Monad, Mona
浏览 3提问于2014-08-29得票数 1
回答已采纳
我已经编写了一个Haskell类型类，使用(a -> m _)形式的类型声明它的实例会很方便，其中m是(* -> *)类型，比如monad，而_是一个不饱和的插槽。我知道如何编写newtype X a m b = X (a -> m b)，以及如何为X a m声明实例。但是，如果可能的话，我正在寻找的是使用裸的、未包装的->类型。
如果你想声明(a -> _)形式的类型的实例，那么你可以这样写：
instance Foo a ((->) a) where ...
但我不知道如何/是否可以使用(a -> m _)形式的类型。我猜我希望在实例声明中组合类型
浏览 4提问于2016-06-19得票数 1
2回答
我有一个带有半群元素的Reader模式：
runFunction :: Reader Env Element
runFunction = do
a <- getA
b <- getB
c <- getC
return $ a <> b <> c
在哪里getA :: Reader Env Element。
有没有办法：
runFunction = do
getA
getB
getC
我觉得我看到了很多这种模式，在这种模式下，我必须把一元调用链接起来，它们最终会变成一个单一的元素。
注意:我不想做getA >>=
浏览 7提问于2020-08-19得票数 3
回答已采纳
1回答
我想为计算创建一个简单的包装器。内置的scala (TraversableLike)对我来说已经足够了。他们已经有语法糖了。从某种角度来看，scala的集合特征是偶然的单体。还有由库拉兹图书馆提供的单元组。
有什么用的案例受益于复杂类型的类黄玉单片？什么功能是不可行的内置单，并表明需要斯卡拉兹？
一些澄清。
这个问题不是神圣的战争继承和类型类。我的问题是关于提供scalaz的基础设施。不是任何具有类型类方法的库，但是这里提到了库。它稍微使事情复杂化。此外，它还有许多在scala集合库中没有匹配的实用程序类。因为它是一个藏书库，而不是一元论。因此，问题是关于scalaz提供的附加功能。在哪种情
浏览 3提问于2015-06-10得票数 3
1回答
因此，我在Haskell中有一个函数，为了问这个问题，我简化了它：
import Data.Foldable
import Data.Set
myFn :: Int -> Set Int
myFn a
| a <= 0 = singleton 1
| otherwise = foldMap helper (myFn (a - 1))
helper :: Int -> Set Int
helper a = insert (a + 2) (singleton a)
main :: IO ()
main = print . Data.Set.toList $ myFn
浏览 2提问于2014-11-01得票数 2
回答已采纳
我对polysemy库做了一些实验，并喜欢使用KVStore k v，这是键值存储的简单抽象。现在我想知道我将如何定义类似的效果‘mtl风格’。我对这个话题很陌生，而且我还没有发现很多关于如何使用单台变压器设计应用程序的信息。我也没有发现任何Monad处理这种效果，除了monad-persistent，它似乎有点过分，因为我试图解决的简单问题。
我目前的方法是定义这个类型：
class Monad m => KVStore k v m where
insert :: v -> k -> m ()
delete :: k -> m ()
lookup :: k
浏览 5提问于2022-08-04得票数 2
回答已采纳
在“为伟大的美好而给你一个哈斯克尔！”作者声称Applicative IO实例的实现方式如下：
instance Applicative IO where
pure = return
a <*> b = do
f <- a
x <- b
return (f x)
我可能错了，但return和do-specific结构(一些含糖的绑定(>>=) )似乎都来自Monad IO。假设这是正确的，我的实际问题是：
为什么Applicative IO 的实现依赖于 Monad IO functions/c
浏览 8提问于2011-07-03得票数 10
回答已采纳
好了，我已经知道如何使用包实现Reader (和ReaderT，未显示)：
{-# LANGUAGE GADTs, ScopedTypeVariables #-}
import Control.Monad.Operational
data ReaderI r a where
Ask :: ReaderI r r
type Reader r a = Program (ReaderI r) a
ask :: Reader r r
ask = singleton Ask
runReader :: forall r a. Reader r a -> r -> a
runR
浏览 4提问于2013-03-15得票数 9
回答已采纳
1回答
目前我在使用monad transformers时遇到了一些困难。我正在定义一些不同的非确定性关系，这些关系利用了转换器。不幸的是，我很难理解如何清晰地从一个有效的模型转换到另一个有效的模型。
假设这些关系是"foo“和"bar”。假设"foo“与As相关，Bs与Cs相关；假设"bar”与Bs相关，Cs与Ds相关。我们将根据"foo“来定义"bar”。更有趣的是，这些关系的计算将以不同的方式失败。(由于bar关系依赖于foo关系，因此它的失败案例是一个超集。)因此，我给出了以下类型定义：
data FooFailure = FooFailure
浏览 0提问于2013-05-15得票数 7
回答已采纳
我是Haskell的新手。现在，我正在尝试更全面地理解Reader Monad。它的目的和用法似乎更清晰了。但在Haskell中，当查看:t reader函数的类型时，我看到了reader :: MonadReader r m => (r -> a) -> m a。这个类型约束是什么意思？当我试图构建Reader时，例如
let myR = reader (\x -> x + 10)
我看到了错误
<interactive>:21:11:
No instance for (MonadReader a0 m0) arising from a use of `r
浏览 5提问于2016-08-30得票数 1
1回答
假设我们有代码(<: Monad[F]不像预期的那样工作)：
class External[F[_] <: Monad[F] : Concurrent](implicit proxy: Proxy[F]) { ... }
class Proxy[F[_] <: Monad[F]](implicit storage: Storage, async: Async[F]) {
def get(key: String): F[Option[Entry]] = {
async.blocking(storage.get(key))
}
}
我希望F[_]是一个Monad
浏览 1提问于2021-10-24得票数 2
回答已采纳
1回答
我围绕(Reader+Writer+State) monad的使用构造了一个计算：
newtype Problem a = Problem { unProblem :: RWS MyEnv MyLog MyState a }
deriving ({- lots of typeclasses -})
计算是一步一步地建立起来的，它是通过组装形式的基本计算来实现的。
foo :: a -> Problem b
然而，有时，子计算不需要RWS单机的全部能力。例如，考虑
bar :: c -> State MyState d
我想使用bar作为Pro
浏览 1提问于2016-08-28得票数 2
回答已采纳
1回答
我的印象是，a类型的每个值都可以用连续传递样式中的秩2多态类型newtype Id a = Id {runId :: forall r. (a -> r) -> r }来描述。因此，我派生了以下类型来相应地定义Reader：
newtype Reader e a = Reader {runReader :: forall r. ((e -> a) -> r) -> r}
然后我尝试构造一个这种类型的值并运行它：
reader f = Reader (\k -> k f) -- where is f's argument?
runReader (rea
浏览 15提问于2018-02-09得票数 1
回答已采纳
7回答
我是haskell，函数式语言和monads的新手。
一个月来，我一直在玩这个游戏；我读过，还在玩snap，试图让我的haskell网站。
但是有件事困扰着我:单体的抽象。如果我理解正确的话，monads就是可以排序的“数据容器”。例如，我可以用">>=“来”解压“它，并且会为我做更多的”幕后“工作，这样如果我没有单一的定义，我就必须猜测它是如何被解压的。
例如：
我们有一个列表单，解压它将对它的元素排序。
[1,2,3] >>= return . (+1) -- gives back [2,3,4]
或者像这些例子中的作者那样更复杂的单曲：
或者我可能有一个w
浏览 4提问于2013-09-10得票数 6
回答已采纳
1回答
所以我试着问一个一般的"“问题，似乎要么这个问题太笼统，无法回答，要么不可能调试这些问题。-}
在这个特别的日子里，困扰我的问题是一个中等规模的，复杂的程序。我已经设法把它归结为一个相当小的核，但仍然出了问题。我们开始：
{-#
LANGUAGE
GADTs, MultiParamTypeClasses,
FlexibleInstances, FlexibleContexts, RankNTypes,
KindSignatures
#-}
module Minimal where
-------------------------------------
浏览 0提问于2016-05-09得票数 1
回答已采纳
2回答
我在Reader Monad中有代码，以便将文件句柄作为不可见的参数传递到Reader链中。
在writeMail中，我正在尝试创建一个读取器，当使用runReader运行时，它会产生IO ()输出，该输出本身就是一系列IO monad的结果
writeMail :: Reader Handle (IO ())
writeMail mail = do
wmh <- writeMailHeaders mail
wmb <- writeMailBody mail
return $ wmh >>= \_ -> wmb
然而，我发现只有IO链中的最后一个，即wmb，在
浏览 1提问于2013-11-15得票数 0
当我通读了LYAH的最后一章并与会面时，我给自己布置了一个任务，让它成为State monad，这样源代码看起来就会更清晰：
manipList = do
goForward
goForward
goBack
同时，我想通过利用Writer monad来记录这个过程，但我不知道如何将这两个monad组合在一起。
我的解决方案是在状态中保留一个字符串，我的源代码是
import Control.Monad
import Control.Monad.State
type ListZipper a = ([a], [a])
-- move focus forward, p
浏览 3提问于2012-09-08得票数 9
回答已采纳
1回答
混淆ReaderT定义
、、、
作为一个练习，我重新实现了一些常见的monads及其相应的转换器；下面是我定义的一些类型：
newtype Writer w a = Writer { runWriter :: (w, a) }
newtype WriterT w m a = WriterT { runWriterT :: m (Writer w a) }
newtype Maybe a = Just a | Nothing
newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) }
当我得到它时，一个变压器在外部单m中“包装”一个单块；遵循这种直觉，我尝
浏览 14提问于2022-06-17得票数 4
回答已采纳
为了澄清这个问题:它是关于monad类型类的优点(而不仅仅是它的实例没有统一类)。
在阅读了许多参考资料(见下文)之后，我得出结论，实际上，monad类是为了解决只存在 one，但是大而关键的问题：是在上下文的类型上的函数的‘链接’。因此，著名的句子“单子是可编程的分号”。事实上，单播可以被看作是。
我坚持monad 类(被理解为其他类型的通用接口)与实例化类(因此，“一元类型”)之间的区别。
我知道monad类本身只解决了操作符的链接问题，主要是因为它只要求其类型实例具有bind >>=和return，并告诉我们它们必须如何运行。另外，编译器极大地帮助为一元类型提供do表示法。
浏览 3提问于2014-01-21得票数 30
回答已采纳
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
回答已采纳
为什么要编译这段代码？
--sequence_mine :: Monad m => [m a] -> m [a]
sequence_mine [] = return []
sequence_mine (elt:l) = do
e <- elt
sl <- sequence l
return (e:sl)
注意:我有意注释掉了这里的类型声明。但是，即使没有类型声明，代码仍然可以编译，并且看起来像预期的那样工作--这让我感到惊讶。
据我所知，这一行应该出现歧义：
return (e:sl)
原因是Haskell不应该知道我们返回的是哪种类型的monad。为什么它
浏览 11提问于2019-03-26得票数 5
回答已采纳
我正在为和 monad转换器寻找。
相关的定义如下：
newtype ReaderT k r m a :: forall k. * -> (k -> *) -> k -> *
type Reader r = ReaderT * r Identity
我不明白*在定义中做了什么。特别是，我正在尝试从ReaderT派生一个新的monad，使用IO作为基础monad，并对r值进行类约束。
我不确定为什么会有第四个输入到ReaderT (k)，以及当它在那个位置放一个*时，Reader会如何处理这个值。
浏览 7提问于2017-08-15得票数 6
回答已采纳
1回答
我正在尝试创建一个管道，它将通过管道源从HTTP流数据。以下是我到目前为止所拥有的：
import qualified Network.HTTP.Client.Conduit as CC
getStream :: String -> IO (ConduitM () BS.ByteString IO ())
getStream url = do
req <- parseUrl url
return $ CC.withResponse req $ \res -> do
responseBody res $= (awaitForever $ \bytes -&g
浏览 7提问于2016-04-30得票数 1
回答已采纳
我有下面的代码，它使用Reader monad进行配置，还必须处理IO[Option[String]]，最后我在encode函数中使用了阶梯式的代码。
我如何为Reader和OptionT制定一个单值转换器，以避免我的encode函数中丑陋的嵌套for解释？
def encode(fileName: String): Reader[Config, IO[Unit]] = for {
ffmpegWrapper <- findFfmpegWrapper
ffmpegBin <- findFfmpeg
} yield (for {
w <- ffmpegWra
浏览 7提问于2013-06-12得票数 11
回答已采纳
4回答
我正在寻找一种更简洁/更惯用的编写getAorB的方式
getAorB = do
a <- getA
case a of
Just _ -> return a
Nothing -> getB
这是不是已经作为库函数存在于某个地方？
请注意，liftM2 (<|>) getA getB与以下内容相同：
do a <- getA
b <- getB
return $ a <|> b
这与getAorB不同，因为即使getA返回Just，bind也总是在getB上调用。
浏览 0提问于2015-07-08得票数 2
在学习Reader时，我发现它被定义为：
newtype Reader r a = Reader { runReader :: r -> a }
instance Monad (Reader r) where
return a = Reader $ \_ -> a
m >>= k = Reader $ \r -> runReader (k (runReader m r)) r
我想知道为什么使用函数作为构造函数参数而不是使用其他东西，比如元组：
newtype Reader r a = Reader { runReader :: (r, a) }
i
浏览 5提问于2017-02-18得票数 4
回答已采纳
1回答
我试图创建一个看起来很像state的东西，但也包含了一个谓词列表以及与之相关的状态转换函数。我设想的计算的基本步骤如下：
Foo (state, [(pred, t)]) >>= f。将f应用于s，生成s'。然后将每个谓词应用于s'。对于匹配的每个谓词，按顺序将关联的转换函数应用于状态。例如，假设[(p1, t1), (p2, t2), (p3, t3)]、f和s。如果f s生成s'后，p1 s'和p3 s'都返回True，则将执行t1 s'生成s''，然后执行t3 s''生成s''&#
浏览 3提问于2013-10-21得票数 2
回答已采纳
我用Haskell编写了一个基本的CRUD应用程序，使用的是图书馆的仆人和Opaleye。
用于设置API端点的服务程序和将数据存储在DB中的Opaleye。
假设有一个端点GET /users，它返回DB中所有用户的列表，以及另一个端点POST /user，它创建一个新用户并将其保存在DB中。
程序首先启动到DB的连接，然后将这个连接作为参数传递给这些API端点函数(使用服务设置)作为参数。
有人建议我，更好的方法是使用Reader并将连接存储在环境中。
我能够做到这一点，但我不明白为什么Reader是共享环境的首选方式，而不是直接传递论点。
作为Haskell的初学者，我可以使用Monad
浏览 0提问于2018-06-15得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
