解构而不是.bind()在Arrow Monad理解中不起作用
解构和.bind()都是 JavaScript 中用于操作函数和对象的方法。在 Arrow Monad 理解中，解构是一种语法操作，而 .bind() 是一种函数操作。
- 解构（Destructuring）：
- 概念：解构是一种从数组或对象中提取值并赋值给变量的语法操作。它可以让我们快速、方便地访问和使用数组或对象中的数据。
- 分类：在 JavaScript 中，解构可以分为数组解构和对象解构两种类型。
- 优势：使用解构可以简化代码，并提高代码的可读性和可维护性。它能够快速地提取需要的值，并赋值给变量，避免了繁琐的手动赋值过程。
- 应用场景：解构在很多场景下都能提高代码的效率，例如从函数返回的数组或对象中提取需要的值、交换变量的值、获取嵌套对象中的值等。
- 推荐的腾讯云相关产品和产品介绍链接地址：目前腾讯云并没有直接与解构相关的产品或服务。
- .bind()：
- 概念：.bind() 是 JavaScript 中的一个函数方法，它用于创建一个新函数，并将其中的 this 值绑定到指定的对象。通过使用 .bind()，我们可以确保函数在调用时具有特定的上下文环境。
- 分类：.bind() 方法属于函数对象的方法，可以应用于所有 JavaScript 函数。
- 优势：使用 .bind() 可以确保函数在调用时具有特定的上下文环境，避免了 this 值的错误引用。这对于需要在不同上下文中使用同一个函数时非常有用。
- 应用场景：.bind() 可以用于绑定函数的执行上下文，例如在事件处理程序中绑定正确的 this 值、创建函数的柯里化版本等。
- 推荐的腾讯云相关产品和产品介绍链接地址：目前腾讯云并没有直接与 .bind() 方法相关的产品或服务。
总结：在 Arrow Monad 理解中，解构和 .bind() 都是 JavaScript 中用于操作函数和对象的方法。解构用于从数组或对象中提取值并赋值给变量，可以简化代码，并提高代码的可读性和可维护性。而 .bind() 方法用于创建一个新函数，并将其中的 this 值绑定到指定的对象，确保函数在调用时具有特定的上下文环境。它们在不同的场景下有不同的优势和应用场景。
相关·内容
2回答
我刚接触过Arrow，并试图建立我的心理模型，了解它的效果系统是如何工作的，特别是它如何利用Kotlin的suspend系统。我非常模糊的理解如下:如果有人能确认、澄清或纠正它，那就太好了：
由于Kotlin不支持高级类型，所以将应用程序和单子实现为类型类是很麻烦的。相反，arrow从Kotlin的挂起机制提供的延续原语中派生出所有Arrow的一元类型的monad功能(绑定和返回)。这样对吗？特别是，短路行为(例如，对于nullable或either)是作为分隔的延续来实现的。我不太明白Kotlin的悬置机器的哪一个特点在这里发挥作用。
如果上面的内容大致正确，我有两个后续问题:我应该如何包含
浏览 7提问于2022-01-31得票数 4
回答已采纳
1回答
我只是了解了类型构造函数和高级类型的状态，现在我正在尝试理解Monad。以下是Monad特性在scalaz中的外观
trait Monad[F[_]] extends Applicative[F] with Bind[F] { self =>
////
override def map[A,B](fa: F[A])(f: A => B) = bind(fa)(a => point(f(a)))
//The rest is omitted
}
问题是，我不理解为什么Monad是一个更高的类型？我们有标准的List[T]，Option[T]单簧管，它们不是较高的类
浏览 2提问于2017-09-28得票数 7
回答已采纳
Control.Parallel.Strategies ( )的源代码包含定义为：
data Eval a = Done a
它具有以下Monad实例：
instance Monad Eval where
return x = Done x
Done x >>= k = k x -- Note: pattern 'Done x' makes '>>=' strict
注意bind定义中的注释。为什么这句话是真的？我对严格性的理解是，只有当一个函数必须“知道”它的论点时，它才是严格的。在这里，bind只应用k到x，因此在我看来
浏览 2提问于2012-08-06得票数 2
回答已采纳
4回答
我试图制定一个单一的定义，而不需要数学术语或Haskell来理解。
monad是否可以被认为是一个函数，它接受一个值并封装它，使其满足特定的接口和行为约束，而这些约束在功能风格中是有用的？
接口约束是：
它有一个类型构造函数来定义它的类型(这是什么？)
二、它具有一个单位函数，它将一个值转换为相应的一元类型。
三、它有一个"bind“方法，它接受一个monad，一个接受某种类型并返回monad的函数(这是另一个monad吗？)，并返回monad。
行为上的制约因素是：
一.左身份
Monad(x).bind(fn) == Monad(fn(x)); // for all x, fn
二
浏览 0提问于2016-07-05得票数 6
回答已采纳
1回答
OCaml中的状态单数
、、、、
我试图在OCaml中实现状态monad (作为练习)。我的实现如下所示：
module type MONAD_BUILDER =
sig
type 'a t
val return : 'a -> 'a t
val bind : 'a t -> ('a -> 'b t) -> 'b t
end;;
module MonadBuilder = functor (M: MONAD_BUILDER) ->
struct
let ( >>= ) = M.bind
let return
浏览 2提问于2011-05-01得票数 15
回答已采纳
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回答
这是对我上一个问题的的后续。
假设我需要使用函数def f(a:A, leftNeighbors:List[A]): B将List[A]的每个项目a:A映射到b:B，并生成List[B]。
显然，我不能只调用列表上的map，但我可以使用列表拉链。拉链是在列表中移动的光标。它提供对当前元素(focus)及其邻居的访问。
现在我可以用def f'(z:Zipper[A]):B = f(z.focus, z.left)替换我的f，并将这个新函数f'传递给Zipper[A]的cobind方法。
cobind的工作原理如下:它使用拉链调用f'，然后移动拉链，使用新的“移动的”拉链
浏览 22提问于2014-06-03得票数 113
回答已采纳
1回答
我试图用更实际的方法来理解单子和单子座之间的关系。如果这个问题没有意义的话，我会提前道歉，我还在挣扎。
例如，假设我有：
trait Monoid[T] {
def zero: T
def combine: (T,T) => T
}
以及(来自)：
trait Monad[+M[_]] {
def unit[A](a: A): M[A]
def bind[A, B](m: M[A])(f: A => M[B]): M[B]
}
是否有一种关系可以建立在Monad和Monad特征之间，比如我可以把Monad当作Monad(假设我正确地理解Monad是Monad的特例)
浏览 0提问于2017-01-09得票数 5
回答已采纳
2回答
在Scalaz中，每个Monad实例都自动是Applicative的一个实例。
implicit val listInstance = new Monad[List] {
def point[A](a: => A) = List(a)
def bind[A, B](fa: List[A])(f: A => List[B]) = fa flatMap f
}
List(2) <*> List((x: Int) => x + 1) // Works!
另一个例子：Arrow自动是一个Profunctor。
但是，在Haskell中，我必须一次又一次地为每个A
浏览 2提问于2015-04-02得票数 9
回答已采纳
2回答
C++中的Monad接口
、、、
我目前正在学习一些haskell，并开始弄清楚monads是如何工作的。因为我规范了代码C++，并且我认为单一模式(正如我现在所理解的那样)在C++中使用也是非常棒的，例如用于期货等，
我想知道是否有一种方法来实现接口或基类，以便对派生类型强制执行函数bind和return的正确重载(由于名称不同而不是C++的返回)？
为了更清楚地说明我在想什么：
考虑到我们有以下非会员功能：
auto foo(const int x) const -> std::string;
和一个成员函数bar，它对不同的类具有不同的重载：
auto bar() const -> const *Monad&
浏览 4提问于2016-09-27得票数 23
回答已采纳
我想定义应用函子的深度嵌套。例如，如下所示：
{-# LANGUAGE TypeOperators #-}
import Control.Monad.Trans.Cont
import Control.Arrow (Kleisli (..))
import Data.Aeson
import Data.Aeson.Types
import Data.Functor.Compose
import Data.Functor
type Configurator = Kleisli Parser Value
type Allocator = ContT () IO
type Validator =
浏览 3提问于2021-10-27得票数 5
回答已采纳
1回答
我正在试图理解国家单子，我必须承认我非常困惑。我创建了一个计算表达式，并添加了许多print语句，这样我就可以跟踪何时调用谁。
type State<'st,'a> =
| Ok of 'a * 'st
| Error of string
and StateMonadBuilder() =
member b.Return(x) = printfn "100 Return %A" x; fun s -> Ok (x, s)
member b.ReturnFrom(x) = printfn "
浏览 9提问于2017-01-17得票数 4
回答已采纳
1回答
这个奇怪的单元组是怎么工作的？
、、、、
这可能是一个很难回答的问题，但我在Haskell中使用了bind操作符，我遇到了一种使用它重复字符串的方法。
[1..3] >>= const "Hey"
-- Yields "HeyHeyHey"
[1..3] >>= return "Hey"
-- Also yields the same result
我理解>>= (\_ -> return "Hey")如何产生["Hey", "Hey", "Hey"]，但我不明白为什么(\_ -&g
浏览 3提问于2017-06-23得票数 1
回答已采纳
查看Haskell的标准库，我们可以看到：
newtype StateT s m a = StateT { runStateT :: s -> m (a, s) }
newtype WrappedMonad m a = WrapMonad { unwrapMonad :: m a }
newtype Sum a = Sum { getSum :: a }
显然，(至少)有三个不同的前缀用于在newtype中展开一个值: un-，run-和get-。(此外，run(和get)将下一个字母大写，而un-则不大写。)这似乎让人困惑。
有什么原因吗，还是说这只是一件历史性的事情？
如果我设计
浏览 0提问于2012-10-12得票数 5
回答已采纳
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
bind :: Monad m => m a -> (a -> m b) -> m b
--你怎么用>=>写bind
我非常困惑，我理解这两种方法是如何工作的，但我甚至无法开始。
我尝试了以下所有选择：
bind1 a b = (b a)
bind2 a b = (a >=> b)
bind3 a b = (b >=> a)
bind4 a b = (a b)
但是每一
浏览 4提问于2022-02-25得票数 2
2回答
我试图通过在Javascript中实现Applicative和Monad的函数实例来提高对它们的理解。我对哈斯克尔的了解是有限的，我希望我的问题是有意义的。
以下是我在Javascript中为fmap、Applicative和Monad类型分类类实现的Functor、<*>和>>=的实现：
const fmap = f => g => x => f(g(x)); // B combinator
const apply = f => g => x => f(x) (g(x)); // S combinator
const bind =
浏览 7提问于2016-10-19得票数 9
回答已采纳
1回答
我读过布伦特·约尔盖( )的“Typeclassopedia”，发现“函子象形文字”与图1所示的“范畴等级”是相互依存的。
根据作者的说法，ArrowApply == Monad，特别是前一个类实例只是一个类型类实例，当
“我们希望能够从中间结果中计算出一个箭头，并使用这个计算箭头继续计算。这是ArrowApply给我们的能力。”
但我们如何把这些东西放在一起呢？我的意思是在Monad和Arrow中都有一些流控制功能(比如if和else vs. ArrowChoice，或者forM vs. ArrowLoop)，而在Monad中有些功能似乎“缺失”( (***)、(|||)或fir
浏览 0提问于2011-12-03得票数 17
回答已采纳
3回答
我正在尝试编写seq-m和error-m，以便对可能返回错误的内容进行列表理解。我的输出具有意想不到的类型，但除此之外，它实际上似乎是合理的。我已经分解了下面的代码，但这里也有一个。
下面是我的单调业务逻辑
def get_loan(name):
m_qualified_amounts = (
bind(get_banks(name), lambda bank:
bind(get_accounts(bank, name), lambda account:
bind(get_balance(bank, account),
浏览 0提问于2012-04-08得票数 10
回答已采纳
2回答
我有一个问题，在chrome和IE上获取事件"keypress“。在firefox上，它运行得很好。
function bind_input_keypress ($this) {
$($this).bind('input', function() {
$($this).css('width',$($this).val().length*5.5+20);
})
$($this).bind('keypress',function(e) {
/* delete last extra.
浏览 0提问于2013-08-14得票数 1
2回答
我正在尝试将Haskell核心库的Arrow转换为F# (我认为这是一个很好的练习，可以更好地理解Arrow和F#，并且我可能能够在我正在进行的项目中使用它们)。然而，由于范式的差异，直接翻译是不可能的。Haskell使用类型类来表达这些内容，但我不确定F#构造的最佳方法是用F#的习惯用法映射类型类的功能。我有一些想法，但我认为最好把它带到这里，看看什么是最接近功能的。
表示tl；：如何将类型类( Haskell成语)转换为F#惯用代码？
感谢那些接受我的长篇大论的人：
这段来自Haskell标准库的代码就是我试图翻译的一个例子：
class Category cat where
id
浏览 4提问于2010-10-27得票数 43
回答已采纳
2回答
我无法理解Dot (函数组合)和bind (>>=)之间的区别。
如果我理解的话，这两种方法将一个函数的前一个结果作为新函数。
那么有什么不同呢？
浏览 0提问于2019-11-22得票数 2
6回答
我正在学习单簧管，我有几个问题。
这就是我现在的处境。请纠正我错的地方。
>>=符号是一个infix运算符。Infix运算符是一个函数，它接受两个参数(左侧和右侧)并返回一个值。
>>=符号称为绑定运算符，并具有签名Monad m => m t -> (t -> m u) -> m u。然而，这些类型在这里似乎并不是一排排的。我们得到一个m t类型的值，第二个参数是一个接受t的函数。(我不知道如何将这些点连接起来。)
这必须意味着绑定函数可以从m中删除m t，以便获取t并将其传递给函数。
以下是我的问题：
是将m从m t中
浏览 10提问于2009-10-25得票数 11
回答已采纳
根据Arrow的Javadoc，在monad上有三种绑定方式： /**
* All possible approaches to running [Kind] in the context of [Fx]
*
* ```
* fx {
* val one = just(1).bind() // using bind
* val (two) = just(one + 1) // using destructuring
* val three = !just(two + 1) // yelling at it
* }
* ```
*/ 第一个和最后一个都工作得很好
浏览 28提问于2020-11-08得票数 1
回答已采纳
1回答
我正在努力更好地理解Monad，目前我正在研究中的写Monad
我不理解似乎由两种类型组成的类型声明，也不理解它的类型约束。
在这些例子中，它们具体说明：
newtype Writer w a = Writer { runWriter :: (a, w) }
instance (Monoid w) => Monad (Writer w) where
return x = Writer (x, mempty)
(Writer (x,v)) >>= f = let (Writer (y, v')) = f x in Writer (y, v
浏览 7提问于2022-11-12得票数 0
回答已采纳
3回答
作为一名功能良好的Javascript开发人员，我对Haskell的理解非常模糊，我真的很难理解像monad这样的Haskell成语。当我查看函数实例的>>=时
(>>=) :: (r -> a) -> (a -> (r -> b)) -> r -> b
instance Monad ((->) r) where
f >>= k = \ r -> k (f r) r
// Javascript:
及其在Javascript中的应用
const bind = f => g => x =>
浏览 11提问于2016-11-07得票数 2
回答已采纳
1回答
我试图实现一个简单的玻璃钢后端，为我自己的利益。
我决定使用纯函数:所以，核心中没有IO。该方案是基于信号转换器实现的。
我已经尝试过两种方法：
newtype SF a b = SF { listen :: [a] -> [b] }
和
newtype SF a b = SF { run :: a -> (b, SF a b) }
(名字不对，对不起)
这两种方法都可以使fold/integrate :: (a -> b -> b) -> b -> SF a b组合器用于信号集成。
这两种方法都有一个问题:似乎不可能创建一个有效的ArrowApply/
浏览 2提问于2014-03-27得票数 4
回答已采纳
1回答
我使用箭头-kt库，并且我试图在相同的范围内使用Either和IO来理解。
假设我有下一段代码：
IO.monad().binding {
val ans: Either<Error, Data> = someFunctionThatReturnsEitherWrappedInIO().bind()
}
现在，我想在ans上使用绑定
val data: Data = ans.bind() // My intent
是否有可能在第一段代码的范围内执行此操作？
目前，我正试图在IO绑定的范围内嵌套一个Either绑定，但我不确定这是一个好做法：
IO.monad().bindi
浏览 1提问于2018-12-12得票数 6
回答已采纳
我试着把joinArr :: ??? a => a r (a r b) -> a r b写下来。我想出了一个使用app的解决方案，从而将a缩小到ArrowApply的范围：
joinArr :: ArrowApply a => a r (a r b) -> a r b
joinArr g = g &&& Control.Category.id >>> app
是否有可能将此函数写入箭头？
我猜不是。
在定义Control.Monad.join类型类：m >>= k = join $ k <$> m时，&g
浏览 1提问于2020-06-23得票数 4
我正试图通过在线图书来了解Haskell。
据我所知，到目前为止，我已经能够理解Monad，直到我进入介绍的章节。
但是，提交并声称是状态类型的Monad实现的代码(我还无法在Hoogle中找到它)似乎对我来说太难处理了。
首先，我不明白它背后的逻辑，即它为什么要起作用，作者是如何看待这一技术的。(也许可以提出相关的文章或白皮书？)
在第4行，建议函数f接受1参数。
然而，在下面的几行我们会看到pop，它不需要参数！
关于第1点，作者试图用一个函数来代表国家的目的是什么。
任何帮助理解正在发生的事情都是非常感谢的。
编辑
与之相关的人，
下面的答案彻底地回答了我的问题。
不
浏览 12提问于2012-04-19得票数 23
回答已采纳
1回答
我很难理解JavaScript中的单元函数。特别是因为让我“获取”monads (或者至少是我认为)的东西是承诺对象，以及then总是如何返回一个新的承诺，而不管您传递给then的函数是什么，据我所知，这相当于haskell中的bind或>>=。这对我来说完全是有意义的，因为它可以确保你所有的功能都在“单一宇宙”中执行。
让我感到震惊的是道格拉斯·克罗克福德的“单簧管和性腺”的演讲。在他的实现中，bind直接返回转换函数的结果，而不检查结果本身是否是单变量。这与returns的then方法相冲突，因为then总是返回新的承诺。
其中一个想法是举升法。他的实现确实确保了'li
浏览 3提问于2016-03-19得票数 16
2回答
函子继承
、、
请允许我举一个冗长的例子：
module type MONAD = sig
type ('r, 'a) t
val return : 'a -> ('r, 'a) t
val bind : ('r, 'a) t -> ('a -> ('r, 'b) t) -> ('r, 'b) t
end
module MonadOps (Monad : MONAD) = struct
include Monad
type ('r, 'a) monad
浏览 6提问于2012-12-12得票数 2
回答已采纳
1回答
>>在Haskell中的正确使用
、、、、
刚刚被介绍给Haskell的monads，用>>遇到了一些障碍。
>>=对我来说是有意义的，因为我可以从前奏曲中得到以下内容：
Prelude> Just 1 >>= (\ x -> Just (x+1))
Just 2
我的理解是，>>和bind是一样的，但是只有当函数对其参数是常数时才使用。但当我试着用前奏曲做这件事时：
Prelude> Just 1 >> (\_ -> Just 10)
<interactive>:7:12: error:
• Couldn't match expe
浏览 5提问于2017-10-04得票数 1
回答已采纳
我正在尝试理解Haskell monads并编写了这个测试程序，它按预期编译和工作：
divide :: Int -> Int -> Either String Int
divide _ 0 = Left "Divide by zero error
divide numerator denom = Right (numerator `div` denom)
processNumsMonadically :: Int -> Int -> Either String Int
processNumsMonadically n d = divide n d >&
浏览 2提问于2015-03-29得票数 0
回答已采纳
1回答
我需要创建一个按钮，将在智能手机上的网站滚动视图。点击后，视图应该向下滚动，测量窗口高度应该滚动多远；html：
<div class="sSite">
<a class="arrow"><img/></a>
<ul>
<li><img/></li>
<li><img/></li>
<li><img/></li>
<li><img/&g
浏览 1提问于2014-10-02得票数 0
这是问题的后续问题。
下面是我想要理解的代码(来自)：
object io {
sealed trait IO[A] {
def unsafePerformIO: A
}
object IO {
def apply[A](a: => A): IO[A] = new IO[A] {
def unsafePerformIO = a
}
}
implicit val IOMonad = new Monad[IO] {
def pure[A](a: => A): IO[A] = IO(a)
def bind[A,B
浏览 0提问于2011-09-14得票数 5
回答已采纳
2回答
在研究了Haskell中的monad之后，我想知道我是否可以自己定义一个monad，而不需要使用已经定义的类型。
我不想让Monad成为Functor的一个实例，我只想用它自己的fmap函数定义一个monad (我还想更改一些函数名，比如return，并将其称为unit)。
monad可以由bind运算符(>>=)和函数return定义，但也可以用return和join来定义，因为最后一个函数可以用bind运算符：join m = m >>= id来表示。因此，可以(从技术上)用return和join来定义monad，而不是其他任何东西。函数fmap是必需的(以及Fun
浏览 4提问于2015-12-30得票数 0
回答已采纳
1回答
状态单时环
、、、
这个问题是由提出的。我理解这个示例(ListBuilder)，但是我还不能为我的状态单元创建一个while循环。对于我来说，不清楚的是如何bind while循环的主体，因为迭代是一个接一个的迭代。
谢谢。
/////////////////////////////////////////////////////////////////////////////////////
// Definition of the state
//////////////////////////////////////////////////////////////////////////////////
浏览 0提问于2014-01-27得票数 4
回答已采纳
1回答
我想知道scala Either是否真的是一个范畴理论意义上的Monad？我知道Monad应该有bind和return方法。那么Either的bind是什么？
浏览 3提问于2014-11-24得票数 5
回答已采纳
我尝试将下面的代码添加到~/.tmux.conf中，这样我就可以使用Shift+arrow键在窗口之间跳转，但不起作用。
bind -n S-Left previous-window
bind -n S-Right next-window
这不在vim下，正如我在stackoverflow中回答的其他qns中看到的那样。即使我试着用它来跨窗格导航，它也不起作用。但是，如果我使用Alt+arrow键，它就像一个护身符。
有什么方法可以让Shift+arrow映射正常工作吗？
浏览 10提问于2020-05-21得票数 1
这是一个函数：(T) => \/E，U
我可以把这类函数转换成Kleisli。
def kleisli[E,T,U](c: T => \/[E,U]) = Kleisli[({type λ[+α] = \/[E, α]})#λ, T, U](c)
这使我可以组合和flatMap，组合这些功能。
val positive = (t: Int) => if (t > 0) \/-(t) else -\/("Negative")
val even = (t: Int) => if (t % 2 == 0) \/-(t) else -\/(&#
浏览 2提问于2014-10-21得票数 2
回答已采纳
我在C#中看到的大多数monads示例都是这样编写的：
public static Identity<B> Bind<A, B>(this Identity<A> a, Func<A, Identity<B>> func) {
return func(a.Value);
}
例如，请参见。
问题是，要求func返回Identity<B>有什么意义？如果我使用以下定义：
public interface IValue<A> {
public IValue<B> Bind<B>
浏览 0提问于2011-10-20得票数 17
回答已采纳
注意:虽然本问题中的代码涉及函数式编程/monads等，但并不是关于函数式编程(我也不认为这个问题应该有与函数式编程相关的标签，等等)。相反，--我问的是JavaScript原型__的使用情况。
码源
我正在看道格拉斯·克罗克福德( Douglas )的视频，名为“单簧管和性腺”( YouTube，或)。他在JavaScript中包含了一个monad的演示实现，如下所示。
monad 对象及其原型
在他的代码中，他使用Object.create(null)创建了一个真正空的对象，并将其作为最终monad对象的原型。他将bind方法附加到monad对象本身，但是以后使用lift附加到monad的
浏览 0提问于2016-11-03得票数 5
回答已采纳
我是一个tmux用户，个人喜欢使用alt+arrow的开关窗格。但是，在vscode中，它不起作用。甚至我也尝试删除默认的键绑定以防止重叠。
我试着绑定到alt+u/h/j/k，它工作得很好。我认为vscode中的alt+arrow键绑定存在问题。有没有我没有找到的设置，或者是一个bug？
keybinding.json - vscode
{
"key": "alt+up",
"command": "-workbench.action.terminal.focusPreviousPane",
浏览 2提问于2020-02-10得票数 3
import Control.Monad
data Logger l a = Logger {runLogger :: (IO (),a,l)}
iologger :: (Show l)=> l->a->(a->b)->Logger l b
iologger l a f = Logger (print l,f a,l)
instance (Show l)=>Monad (Logger l) where
return a = iologger (show "") a id
logger>>=f = let (_,va
浏览 1提问于2018-01-20得票数 0
回答已采纳
3回答
好吧，所以我不是一个Haskell程序员，但是我对Haskell背后的许多想法非常感兴趣，并且正在研究学习它。但我被困在了第一步:我似乎不能把头绕在单子上，这似乎是相当基本的。我知道有很多问题需要解释，所以我会更具体地解释困扰我的是什么：
我读了这篇优秀的文章()，并认为我完全理解Monad。然后我在单子上阅读了维基百科的条目，并看到了以下内容：
多态型(M )→(t→M)→(M)的绑定操作，Haskell由infix运算符>>=表示。它的第一个参数是一个一元类型的值，第二个参数是从第一个参数的底层类型映射到另一个一元类型的函数，其结果是另一个一元类型。
好的，在我引用的那篇文章
浏览 5提问于2011-11-02得票数 39
回答已采纳
2回答
因为下面的代码会阻塞：
do
x <- foo
y <- bar
return x + y
去糖化成以下形式：
foo >>= (\x -> bar >>= (\y -> return x + y))
这里不是\x -> ...和y -> ...的实际延续吗？
我想知道是否有一种方法可以在bind的定义中捕获延续，但我不能正确地使用类型。即：
data Pause a = Pause a | Stop
instance Monad Pause where
return x = Stop
m >>= k
浏览 0提问于2012-07-06得票数 4
回答已采纳
3回答
所以我终于明白了为什么Applicative在表示并行执行时非常有用，而Monad在表示顺序执行时非常有用。
也就是说，我也知道Monad比Applicative更强大，所以我可以用bind函数来表示ap函数吗？
换句话说..。我可以用Monads来表示并行执行吗？
浏览 5提问于2017-10-17得票数 2
我已经创建了一个在Monad中是多态的函数，它需要使用，而不是依赖于这个Monad存在的类型类实例。它看起来是这样的：
fun <M> M.logic(...): Kind<M, String>
where M: MonadReader<M, Dependency>,
M: Effect<M> =
fx.monad() {
val dependency = ask().bind()
val response = effect { ...using dependency here..
浏览 17提问于2020-02-08得票数 0
回答已采纳
我尝试从Employee ID字段中获取值，并将其添加到JSON中的对象属性employee：{id:}中。JSON中的其他元素工作得很好，这是我无法理解的嵌套元素。 这是为员工提交工时记录卡的应用程序。后端如果是用java编写的。我已经编写并测试了API。现在只想用React编写一些UI代码。 import { Component } from "react";
import {Form, Row, Col, Button} from 'react-bootstrap';
import axios from 'axios';
class T
浏览 7提问于2021-07-09得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
