《Haskell趣学指南》笔记之 Monad

最新推荐文章于 2023-02-09 21:19:56 发布
最新推荐文章于 2023-02-09 21:19:56 发布
阅读量182 收藏
点赞数
原文链接：https://juejin.im/post/5cd70fe951882567d96bec4d
版权

monad 是加强版的 applicative 函子。

我现在有点忘了什么是 applicative 函子，所以我先复习一下。

复习

函子（Functor 类型类）

支持 fmap 的类型就是函子，比如 Maybe fmap 的定义是 (a -> b) -> f a -> f b 其意义是把一个容器里的值，经过一个函数加工一下，然后放回一样的容器里。

Applicative 类型类

支持 pure 和 <*> 的类型就是 applicative 的实例，比如 Maybe pure 的定义是 a -> f a，其作用是把一个值装进容器里 <*> 的定义是 f (a -> b) -> f a -> f b 其意义跟 fmap 很相似，区别在于那个函数也在容器里。

但是有些时候容器比喻并不那么有用，比如「(->) r 也是 Application 的实例」那里。

换个角度再说一遍

假设一，我们有

  • 类型为 A 的普通值
  • 普通函数 A -> B
  • 想得到类型为 B 的返回值

那么用直接调用普通函数即可。

假设二，我们有

  • 类型为 Maybe A 的奇特值
  • 普通函数 A -> B
  • 想得到类型为 Maybe B 的返回值

那么我们就要求 Maybe 满足 fmap 的条件，然后调用 fmap 和普通函数

ghci> fmap (++ "!") (Just "wisdom")
Just "wisdom!"
ghci> fmap (++ "!") Nothing
Nothing
复制代码

假设三，我们有

  • 类型为 Maybe A 的奇特值
  • 奇特函数 Maybe (A -> B)
  • 想得到类型为 Maybe B 的返回值

那么我们就要求 Maybe 满足 pure 和 <*>，然后调用 <*> 和奇特函数

ghci> Just (+3) *> Just 3 
Just 6
ghci> Nothing <*> Just "greed"
Nothing
ghci> Just ord <*> Nothing
Nothing
-- pure 的意义是让普通函数也能用
-- max <$> 等价于 pure max <*>
ghci> max <$> Just 3 <*> Just6
Just 6
ghci> max <$> Just 3 <*> Nothing
Nothing
复制代码

假设四，我们有

  • 类型为 Maybe A 的奇特值
  • 函数 A -> Maybe B（如果函数是 A -> B，那么很容易变成 A -> Maybe B，因为 B -> Maybe B 很容易实现）
  • 想得到类型为 Maybe B 的返回值

这就是 Monad 要解决的问题。

怎么做到这一点呢？我们还是以 Maybe 为例子（因为 Maybe 实际上确实是 monad）。

先把问题简化一下：

  • 类型为 A 的普通值
  • 函数 A -> Maybe B
  • 想得到类型为 Maybe B 的返回值

这就很简单了，直接调用函数即可。

接下来考虑如果把参数从「类型为 A 的普通值」改为「类型为 Maybe A 的奇特值」，我们需要额外做什么事情。

很显然，如果参数是 Just A，就取出 A 值调用函数；如果参数是 Nothing，就返回 Nothing。

所以实现如下：

applyMaybe :: Maybe a -> (a -> Maybe b) -> Maybe b 
applyMaybe Nothing f = Nothing
applyMaybe (Just x) f = f x
复制代码

Haskell 把 applyMaybe 叫做 >>=。

Monad 类型类的定义

class Monad m where
    return :: a -> m a  -- 跟 pure 一样
    
    (>>=) :: m a -> (a -> m b) -> m b
    
    -- 书上说先不用管下面的 >> 和 fail
    (>>)  :: m a -> m b -> m b
    x >> y =   x >>= \_ -> y 
    
    fail :: String -> m a
    fail msg = error msg
    
复制代码

理论上一个类型成为 Monad 的实例之前，应该先成为 Applicative 的实例，就如同 class (Functor f) => Applicative f where 一样。 但是这里的 class Monad 并没有出现 (Applicative m) 是为什么呢？

书上说是因为「在Haskell设计之初，人们没有考虑到applicative函子会这么有用」。好吧，我信了。

Maybe 是 Monad 的实例

instance Monad Maybe where
    return x = Just x
    Nothing >>= f = Nothing
    Just x >>= f = f x
    fail _ = Nothing
复制代码

用一下

ghci> return "WHAT" :: Maybe String
Just "WHAT"
ghci> Just 9 >>= \x -> return (x*10) -- 注意 return 不是退出
Just 90
ghci> Nothing >>= \x -> return (x*10)
Nothing
复制代码

Monad 有什么意义？

上文说道

假设四，我们有

  • 类型为 Maybe A 的奇特值
  • 函数 A -> Maybe B
  • 想得到类型为 Maybe B 的返回值

这就是 Monad 要解决的问题。

那我们为什么要研究这个问题？

书上举了一个例子，我这里简述一下。

参数 Maybe A 有两个可能，一是 Just A，而是 Nothing。

我们把 Just A 看成是成功的 A，把 Nothing 看成是失败。

那么函数 A -> Maybe B 就是能够对成功的 A 进行处理的一个函数，它的返回值是成功的 B 或者失败。

如果还有一个函数 B -> Maybe C，就可以继续处理成功的 B 了。

这很像 Promise ！

  • 参数为 Promise<User>
  • 函数为 User -> Promise<Role>（大部分时候我们的函数是 User -> Role，但是要把 Role 变成 Promise<Role> 很简单，Promise.resolve 就能做到）
  • 然后我们就可以把上面两个东西连起来，得到 Promsie<Role> 了！

但是注意我没有说 Promise 就是 Monad，我目前还不知道到底是不是。

对应的 Haskell 代码就像这样

return A >>= AToMaybeB >>= BToMaybeC >>= CToMaybeD 
复制代码

对应的 JS 代码

PromiseUser.then(UserToRole).then(RoleToElse)
复制代码

do 语法

普通函数里有

let x=3; y="!" in show x ++ y
复制代码

如果把 x 和 y 都放到 Maybe 里，然后用 >>= 连起来，是这样

Just 3 >>= (\x -> 
    Just "!" >>= (\y -> 
        Just (show x ++ y )))
复制代码

为了免去这种麻烦的写法，我们可以用 do

foo :: Maybe String
foo = do
    x <- Just 3
    y <- Just "!"
    Just (show x++y )
复制代码

所以 do 只是把 monad 值串起来的语法罢了。（没错 IO 也是 monad）

do 要求里面每一行 <- 的右边都是一个 monad 值。上例中每一行都是一个 Maybe 值。

模式匹配与 fail

justH :: Maybe Char
justH = do
    (x:xs) <- Just "hello"
    return x
复制代码

最终 justH 的值是 Just 'h'。 但是如果模式匹配失败了会怎么办？

wopwop :: Maybe Char
wopwop = do
    (x:xs) <- Just ""
    return x
复制代码

"" 是一个空的列表，没有办法得到 x，那么就会调用 monal 的 fail，fail 的默认实现是

fail :: (Monad m) => String -> m a
fail msg = error msg
-- 但是 Maybe 的 fail 是这样实现的
fail _ = Nothing
复制代码

所以如果匹配失败，会得到 Nothing，以避免程序崩溃，这很巧妙。

列表是 Monad

instance Monad [] where
    return x         = [x]
    xs >>= f        = concat (map f xs)
    fail _            = []
复制代码

使用示例：

ghci> [3,4,5] >>= \x -> [x,x]
[3,-3,4,-4,5,-5]
ghci> [] >>= \x -> ["bad","mad","rad"]
[]
ghci> [1,2,3] >>= \x -> []
[]
ghci> [1,2] >>= \n -> ['a','b'] >>= \ch -> return(n,ch)
[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
-- 用 do 改写
listOfTuples :: [(Int,Char)]
listOfTuples = do
    n<-[1,2]
    ch<-['a','b']
    return (n,ch)
复制代码

monad 定律

Haskell 无法检查一个类型是否满足 monad 定律，需要开发者自己确保。

  1. 左单位元律——return x >>= f 的值必须和 f x 一样
  2. 右单位元律——m >>= return 和 m 的值必须一样
  3. 结合律——（m >>= f） >>= g 和 m >>= (\x -> f x >>= g) 一样

转载于:https://juejin.im/post/5cd70fe951882567d96bec4d

weixin_34391445
关注
Haskell 中的 Monad 和 IO
m0_52748043的博客
12-01 637
对于 Haskell 初学者来说，Monad 和 IO 或许是掌握 Haskell 之路上的第一大难关。本文将会以尽量浅显的方式介绍 Monad 和 IO 背后的原理和设计思想，希望能够给 Haskell 初学者们一些思考与启发。 本文假设您对函数式编程有一定的理解，因为这是讨论 Monad 和 IO 的理论基础。同时，本文会使用到一些 Haskell 基础语法，比如函数类型定义等。 本文需要您对偏函数和柯里化（currying）有所了解。如果您对此不了解，您可以参考网络上的其它文章。为了减轻读者的理解负担
Haskell趣学指南---文字版.pdf
03-14
在《Haskell趣学指南》这本书中，作者M.Lipovaca提供了学习Haskell的全面指导，从零开始到深入理解函数式编程的高级特性，循序渐进地带读者进入Haskell编程的世界。书中详细介绍了Haskell的语法、数据类型、函数的...
haskell monad
u013015430的专栏
11-18 665
Monad 是一个从 Applicative functors 很自然的一个演进结果。对于他们我们主要考量的点是：如果你有一个具有 context 的值 m a，你能如何把他丢进一个只接受普通值 a 的函数中，并回传一个具有 context 的值？也就是说，你如何套用一个型态为 a -> m b 的函数至 m a？基本上，我们要求的函数是： (>>=) :: (Monad m) => m
Haskell 的 Monad
charvl的博客
11-07 323
Functor 定义 定义如下： class Functor f where fmap :: (a ->b) -> f a -> f b 其中，fmap 需要遵守以下两个约束： -- Identity fmap id == id -- Composition fmap (f . g) == fmap f . fmap g 注：<$> 就是 fmap ​ 相关的例子 Maybe 是如何实现 Functor 的： instance Functor Maybe where
Haskell Monad （上）
叶玄青的博客
05-04 1367
函数式编程中的单子(Monad) 说到pure functional programming，实在是绕不过去Monad的。 pure function的特点 往往用函数式编程的思路写了几个程序之后就会遇到一个问题：针对具有状态更新的程序，似乎总是不太好处理。由于语言的纯粹性，相同的输入总是返回一样的值，所以如果在计算过程中需要更新一个状态，就要去显式地把状态作为参数传递给函数，并显式地构...
Haskell学习笔记4 -- Monad
weixin_54634208的博客
04-30 257
如果一个函数接收的是一个普通的值，然后返回一个盒子 怎么将这个函数应用在一个盒子上，并得到一个单独的盒子呢？ (>>=) :: Monad m => m a -> (a -> m b) -> m b >>=先接收一个装有值的盒子 (f a)，然后是一个特殊的接受值返回盒子的函数 ((a -> f b)) 最后返回一个盒子 (f b) Just 1 >>= \x -> Just (x+3) 先将盒子中的值 1 取出来，然后传入
Haskell趣学指南（台译版）
04-09
Haskell趣学指南（台译版）Haskell趣学指南（台译版）Haskell趣学指南（台译版）
B10-Haskell趣学指南.pdf
09-10
本文将基于《Haskell趣学指南》一书的目录，详细解析Haskell的各个方面，包括基础语法、类型系统、递归、高阶函数、模块系统、自定义类型和类型类、输入输出处理、函数式编程思维、以及高阶函数等特性。 ### 第一章...
haskell Monad 2 Write monad
u013015430的专栏
11-19 626
= f x in (y,log ++ newLog)
haskell中的Monad小记
weixin_43479599的博客
03-17 617
Haskell 中的Monad 小记 monad基本上可以解释为实现了lift,bind操作的类型类。具体解释可以参考wikipidia上的定义 Monad构成自三个部份： 类型构造子 MMM，建造一个单子类型MT[b]M\quad T[b]MT[b] 类型转换子，经常叫做unit或return，将一个对象x嵌入到Monad中： unit(x) :: x -> Monad x 组合子，典型的叫做bind（约束变量的那个bind），并表示为中缀算子(>>=)，去包装一个Mona
Haskell 状态Monad (State Monad)的理解
天涯爱生活
12-07 2362
1、State s a数据类型 State s a是一种用来封装状态处理函数（又叫：状态处理器）：\s -> (a,s’)的数据结构，因为State封装的是一个状态处理器(state processor)而不是状态s本身，所以称State为State类型(type)是不准确的。 newtype State s a = State { runState :: s -> (a,s) } -...
Haskell：从Maybe Monad理解Monad
WinterShiver
12-26 585
Haskell：从Maybe Monad理解Monad 文章目录Haskell：从Maybe Monad理解MonadMonad的原始定义Maybe的Monad实现理解>>=总结 Monad的原始定义 -- Monad的原始定义 class Monad m where return :: a -> m a (>>=) :: m a -> (a -...
haskell程序员如何理解monad?
最新发布
weixin_35757191的博客
02-09 104
对于 Haskell 程序员来说，理解 Monad 需要先了解一些基础知识，比如函数式编程和类型系统。 一种常见的理解 Monad 的方法是将其视为一种计算模式，它提供了组合多个计算过程的能力，使得程序员能够以简洁的方式处理需要关注的复杂性，如状态管理、错误处理、I/O 等。 更简单地说，Monad 是一种在 Haskell 中的数据类型，它允许您定义序列化的计算操作，并确保这些操作在组合时遵循正...
Haskell 的 IO 和Monad
kirsten111111的博客
08-20 641
• Haskell 将“惰性求值”扩展到 IO，例如，如果您要求读取整个文件 Haskell 仅在需要时从其中读取数据。• 如果您允许在函数体内进行这样的操作，那么您永远无法确定给定相同的参数，该函数将始终返回相同的值。Haskell 强制在处理 i/o 的函数之间进行清晰的分离，允许“纯粹”的动作和功能，它们是定义。• 您只能在 IO a 的函数中使用返回类型为 IO a 的现有函数（例如 getLine）• 本质上，IO 函数隐含地将“世界状态”作为输入并返回新的世界状态作为输出的一部分。
Haskell：初识 Maybe 和 Monad
程序猿视角
11-27 5465
到了我这个年龄，很少对某些发明感到好奇了。但是阅读了 Haskell 的 Maybe 类型，确实让我感到 Haskell 语言设计实在奇妙。这还得从 Haskell 的 IO 操作谈起。 前一段时间学习了 IO 操作，发现和 IO 相关的程序设计非常类似 C 语言。当时感觉 Haskell 面对有状态系统设计的时候，最终还是黔驴技穷，不得不回归传统程序设计。 然而在学习 Maybe 类型的时候，触及到了 Haskell 的 Monad 机制。才知道，原来 IO 类型和 Maybe 类型一样，只不
《Haskell趣学指南》
weixin_33978044的博客
01-08 205
《Haskell趣学指南》 基本信息 原书名：Learn You a Haskell for Great Good!: A Beginner's Guide 原出版社： No Starch Press 作者： (斯洛文尼亚)Miran Lipovaca    译者：李亚舟 宋方睿 丛书名：新锐编程语言集萃 出版社：人民邮电出版社 ISBN：9787115335593 上架时间：2...
Haskell趣学指南：从入门到精通
"趣学Haskell，这是一本中文繁体的Haskell入门教程，适合对函数式编程感兴趣的读者，特别是有命令式编程语言背景的初学者。教程内容涵盖Haskell的基础到进阶概念，包括类型系统、语法、递归、高阶函数、模块、自定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值