atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>Forec&#39;s Notes</title>
  
  <link href="/atom.xml" rel="self"/>
  
  <link href="http://forec.github.io/"/>
  <updated>2018-09-26T06:08:29.097Z</updated>
  <id>http://forec.github.io/</id>
  
  <author>
    <name>Forec</name>
    
  </author>
  
  <generator uri="http://hexo.io/">Hexo</generator>
  
  <entry>
    <title>HDFS 组织及工作</title>
    <link href="http://forec.github.io/2017/08/22/hadoop_knowledge/"/>
    <id>http://forec.github.io/2017/08/22/hadoop_knowledge/</id>
    <published>2017-08-22T08:16:16.000Z</published>
    <updated>2018-09-26T06:08:29.097Z</updated>
    
    <content type="html">&lt;blockquote&gt;
&lt;p&gt;Apache Hadoop 是一款支持数据密集型分布式应用程序并以 Apache 2.0 许可协议发布的开源软件框架。它支持在商品硬件构建的大型集群上运行的应用程序。Hadoop 是根据谷歌公司发表的 MapReduce 和 Google 文件系统的论文自行实现而成。所有的 Hadoop 模块都有一个基本假设，即硬件故障是常见情况，应该由框架自动处理。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;a id=&quot;more&quot;&gt;&lt;/a&gt;
&lt;h2 id=&quot;子项目&quot;&gt;&lt;a href=&quot;#子项目&quot; class=&quot;headerlink&quot; title=&quot;子项目&quot;&gt;&lt;/a&gt;子项目&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Hadoop Common&lt;/strong&gt;：在 0.20 及以前的版本中，包含 HDFS、MapReduce 和其他项目公共内容，从 0.21 开始 HDFS 和 MapReduce 被分离为独立的子项目，其余内容为 Hadoop Common   &lt;/li&gt;
&lt;li&gt;&lt;strong&gt;HDFS&lt;/strong&gt;：Hadoop Distributed File System  &lt;/li&gt;
&lt;li&gt;&lt;strong&gt;MapReduce&lt;/strong&gt;：并行计算框架，0.20 前使用 &lt;code&gt;org.apache.hadoop.mapred&lt;/code&gt; 旧接口，0.20 版本开始引入 &lt;code&gt;org.apache.hadoop.mapreduce&lt;/code&gt; 的新 API  &lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;HDFS-结构&quot;&gt;&lt;a href=&quot;#HDFS-结构&quot; class=&quot;headerlink&quot; title=&quot;HDFS 结构&quot;&gt;&lt;/a&gt;HDFS 结构&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;HDFS 是一个高度容错性的系统，适合部署在廉价的机器上。&lt;/li&gt;
&lt;li&gt;硬件错误是常态而不是异常，错误检测和快速、自动的恢复是HDFS最核心的架构目标。&lt;/li&gt;
&lt;li&gt;运行在 HDFS 上的应用需要 &lt;strong&gt;流式访问&lt;/strong&gt; 数据集，HDFS 的设计更多考虑了数据批处理，而不是用户交互处理。比之数据访问的低延迟问题，更关键的在于 &lt;strong&gt;数据访问的高吞吐量&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;移动计算比移动数据更划算&lt;/strong&gt;：一个应用请求的计算，离它操作的数据越近就越高效，HDFS 为应用提供了将它们自己移动到数据附近的接口。&lt;/li&gt;
&lt;li&gt;HDFS 采用 &lt;strong&gt;master/slave 结构&lt;/strong&gt;，一个 HDFS 集群由一个 Namenode 和一定数目的 Datanodes 组成。Namenode 是一个 &lt;strong&gt;中心服务器&lt;/strong&gt;，负责管理文件系统的命名空间以及客户端对文件的访问；集群中的 Datanode 一般是一个节点一个，负责管理它所在节点上的存储。HDFS 暴露了文件系统的命名空间，用户能够以文件的形式在上面存储数据。从内部看，一个文件其实被分成一个或多个数据块，这些块存储在一组 Datanode 上。Namenode 执行文件系统的命名空间操作，如打开、关闭、重命名文件或目录，它也&lt;strong&gt;负责确定数据块到具体 Datanode 节点的映射&lt;/strong&gt;。Datanode 负责处理文件系统客户端的读写请求，在 Namenode 的统一调度下进行数据块的创建、删除和复制。Namenode 是所有 HDFS 元数据的仲裁者和管理者，&lt;strong&gt;用户数据永远不会流过 Namenode&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;数据复制和副本&quot;&gt;&lt;a href=&quot;#数据复制和副本&quot; class=&quot;headerlink&quot; title=&quot;数据复制和副本&quot;&gt;&lt;/a&gt;数据复制和副本&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;HDFS 将&lt;strong&gt;每个文件存储成一系列的数据块&lt;/strong&gt;，除了最后一个，所有的数据块都是同样大小的。一个典型的数据块大小是 64MB，HDFS 中的文件总是按照 64MB 被切分成不同的块，每个块尽可能地存储于不同的 Datanode 中。为了容错，文件的所有数据块都会有副本，每个文件的数据块大小和副本系数都是可配置的，应用程序可以指定某个文件的副本数目。副本系数可以在文件创建的时候指定，也可以在之后改变。HDFS中的文件都是一次性写入的，并且严格要求在任何时候只能有一个写入者。&lt;/li&gt;
&lt;li&gt;Namenode 全权管理数据块的复制，它&lt;strong&gt;周期性地从集群中的每个 Datanode 接收心跳信号和块状态报告&lt;/strong&gt;。接收到心跳信号意味着该 Datanode 节点工作正常，块状态报告包含了一个该 Datanode 上所有数据块的列表。&lt;/li&gt;
&lt;li&gt;大型 HDFS 实例一般运行在跨越多个机架的计算机组成的集群上，不同机架上的两台机器之间的通讯需要经过交换机。在大多数情况下，同一个机架内的两台机器间的带宽会比不同机架的两台机器间的带宽大。通过 &lt;strong&gt;机架感知&lt;/strong&gt;（使用 API resolve 将 slave 的 DNS 名称（或IP地址）转换成机架id）Namenode可以确定每个 Datanode 所属的机架 id。一种简单但没有优化的策略是将副本存放在不同的机架上，这样可以有效防止当整个机架失效时数据的丢失，且允许读数据的时候充分利用多个机架的带宽。但这种策略的一个写操作需要传输数据块到多个机架，增加了写的代价。&lt;br&gt;大多数情况下，副本系数是3，HDFS 的存放策略是将 &lt;strong&gt;一个副本存放在本地机架的节点上，一个副本放在同一机架的另一个节点上，最后一个副本放在不同机架的节点上&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;HDFS 会&lt;strong&gt;尽量让读取程序读取离它最近的副本&lt;/strong&gt;。如果在读取程序的同一个机架上有一个副本，那么就读取该副本。如果一个 HDFS 集群跨越多个数据中心，那么客户端也将首先读本地数据中心的副本。&lt;/li&gt;
&lt;li&gt;Namenode 启动后会进入一个称为 &lt;strong&gt;安全模式&lt;/strong&gt; 的特殊状态。处于安全模式的 Namenode 不会进行数据块的复制，并从所有的 Datanode 接收心跳信号和块状态报告。块状态报告包括了某个 Datanode 所有的数据块列表，每个数据块都有一个指定的最小副本数。当 Namenode 确认某个数据块的副本数目达到这个最小值，那么该数据块就会被认为是副本安全的；在一定百分比（这个参数可配置）的数据块被 Namenode 检测确认是安全之后（加上一个额外的30秒等待时间）， Namenode 将退出安全模式状态。接下来它会确定还有哪些数据块的副本没有达到指定数目，并将这些数据块复制到其他 Datanode 上。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;元数据持久化&quot;&gt;&lt;a href=&quot;#元数据持久化&quot; class=&quot;headerlink&quot; title=&quot;元数据持久化&quot;&gt;&lt;/a&gt;元数据持久化&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;Namenode 上保存着 HDFS 的命名空间，对于任何对文件系统元数据产生修改的操作，Namenode 都会使用 &lt;code&gt;EditLog&lt;/code&gt; 事务日志记录下来。Namenode 在本地操作系统的文件系统中存储这个 &lt;code&gt;Editlog&lt;/code&gt;。整个文件系统的命名空间，包括数据块到文件的映射、文件的属性等，都存储在一个称为 &lt;code&gt;FsImage&lt;/code&gt; 的文件中，这个文件也放在 Namenode 所在的本地文件系统上。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Namenode 在内存中保存着整个文件系统的命名空间和文件数据块映射的映像&lt;/strong&gt;。这个关键的元数据结构设计得很紧凑，因此 4G 内存的 Namenode 足够支撑大量的文件和目录。当 Namenode &lt;strong&gt;启动时&lt;/strong&gt;，它从硬盘中读取 &lt;code&gt;Editlog&lt;/code&gt; 和 &lt;code&gt;FsImage&lt;/code&gt;，将所有 &lt;code&gt;Editlog&lt;/code&gt; 中的事务作用在内存中的 &lt;code&gt;FsImage&lt;/code&gt; 上，并将这个新版本的 &lt;code&gt;FsImage&lt;/code&gt; 从内存中保存到本地磁盘上，然后删除旧的 &lt;code&gt;Editlog&lt;/code&gt;，这个过程称为一个&lt;strong&gt;检查点&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;Datanode &lt;strong&gt;将 HDFS 数据以文件的形式存储在本地的文件系统中&lt;/strong&gt;，它并不知道有关 HDFS 文件的信息。它把&lt;strong&gt;每个HDFS数据块存储在本地文件系统的一个单独的文件中&lt;/strong&gt;。Datanode 并不在同一个目录创建所有的文件，而是用试探的方法来确定每个目录的最佳文件数目，并且在适当的时候创建子目录。在同一个目录中创建所有的本地文件并不是最优的选择，这是因为本地文件系统可能无法高效地在单个目录中支持大量的文件。当 Datanode 启动时，它会扫描本地文件系统，产生一个这些本地文件对应的所有 HDFS 数据块的列表，然后作为报告发送到 Namenode ，这个报告就是块状态报告。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;集群通讯和健壮性&quot;&gt;&lt;a href=&quot;#集群通讯和健壮性&quot; class=&quot;headerlink&quot; title=&quot;集群通讯和健壮性&quot;&gt;&lt;/a&gt;集群通讯和健壮性&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;客户端通过一个可配置的 &lt;strong&gt;TCP&lt;/strong&gt; 端口连接到 Namenode，通过 ClientProtocol 协议与 Namenode 交互。而 Datanode 使用 DatanodeProtocol 协议与 Namenode 交互。一个远程过程调用模型被抽象出来封装 ClientProtocol 和 Datanodeprotocol 协议。Namenode 不会主动发起 RPC，而是响应来自客户端或 Datanode 的 RPC 请求。&lt;/li&gt;
&lt;li&gt;三种出错情况是：&lt;strong&gt;Namenode 出错、Datanode 出错、网络割裂&lt;/strong&gt;。Datanode 出错和网络割裂可能导致一部分 Datanode 跟 Namenode 失去联系。Namenode 通过心跳信号的缺失来将近期不再发送心跳信号 Datanode 标记为宕机，不会再将新的 IO 请求发给它们，且任何存储在宕机 Datanode 上的数据将不再有效。这可能会引起一些数据块的副本系数低于指定值，Namenode 不断地检测这些需要复制的数据块，一旦发现就启动复制操作。&lt;/li&gt;
&lt;li&gt;HDFS 支持&lt;strong&gt;数据均衡策略&lt;/strong&gt;。如果某个 Datanode 节点上剩余空闲空间低于临界点，系统会自动地将数据从这个 Datanode 移动到其他空闲 Datanode。当对某个文件的请求突然增加，也可能启动一个计划创建该文件新的副本，并且同时重新平衡集群中的其他数据。&lt;/li&gt;
&lt;li&gt;当 HDFS 客户端创建一个新的 HDFS 文件时，会计算这个文件每个数据块的校验和，并&lt;strong&gt;将校验和作为一个单独的隐藏文件保存在同一个 HDFS 名字空间下&lt;/strong&gt;。当客户端获取文件内容后，它会检验从 Datanode 获取的数据跟相应的校验和文件中的校验和是否匹配，如果不匹配，客户端可以选择从其他 Datanode 获取该数据块的副本。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;FsImage&lt;/code&gt; 和 &lt;code&gt;Editlog&lt;/code&gt; 是 HDFS 的核心数据结构。如果这些文件损坏了，整个 HDFS 实例都将失效，因此 Namenode 可以配置成支持维护多个 &lt;code&gt;FsImage&lt;/code&gt; 和 &lt;code&gt;Editlog&lt;/code&gt; 的副本。Namenode 是 HDFS 集群中的 &lt;strong&gt;单点故障&lt;/strong&gt; 所在。如果 Namenode 机器故障，需要手工干预。也可以通过指定配置，在 Namenode 宕机时切换到 Secondary Namenode。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;数据组织&quot;&gt;&lt;a href=&quot;#数据组织&quot; class=&quot;headerlink&quot; title=&quot;数据组织&quot;&gt;&lt;/a&gt;数据组织&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;客户端缓存&lt;/strong&gt;：客户端创建文件的请求并没有立即发送给 Namenode。HDFS 客户端会先将文件数据缓存到本地的一个临时文件，应用程序的写操作被透明地重定向到这个临时文件。当这个临时文件累积的数据量超过一个数据块的大小，客户端才会联系 Namenode。Namenode 将文件名插入文件系统的层次结构中，并且分配一个数据块给它，然后返回 Datanode 的标识符和目标数据块给客户端。接着客户端将这块数据从本地临时文件上传到指定的 Datanode 上。当文件关闭时，在临时文件中剩余的没有上传的数据也会传输到指定的 Datanode 上，然后客户端告诉 Namenode 文件已关闭，此时 Namenode 才将文件创建操作提交到日志里进行存储。&lt;strong&gt;如果 Namenode 在文件关闭前宕机，该文件将丢失&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;流水线复制&lt;/strong&gt;：假设文件的副本系数设置为3，且客户端开始向第一个 Datanode 传输数据，第一个 Datanode 逐小块(4 KB)地接收数据，将每一部分写入本地仓库，并同时传输该部分到列表中第二个 Datanode 节点。第二个 Datanode 也以此类推同时传给第三个 Datanode。即，Datanode 流水线式地从前一个节点接收数据，并在同时转发给下一个节点。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;HDFS-使用&quot;&gt;&lt;a href=&quot;#HDFS-使用&quot; class=&quot;headerlink&quot; title=&quot;HDFS 使用&quot;&gt;&lt;/a&gt;HDFS 使用&lt;/h2&gt;&lt;h3 id=&quot;存储空间回收&quot;&gt;&lt;a href=&quot;#存储空间回收&quot; class=&quot;headerlink&quot; title=&quot;存储空间回收&quot;&gt;&lt;/a&gt;存储空间回收&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;当用户或应用程序删除某个文件时，HDFS 会将这个文件重命名转移到 &lt;code&gt;.Trash&lt;/code&gt; 目录。文件在 &lt;code&gt;.Trash&lt;/code&gt; 中保存的时间是可配置的（设置属性 &lt;code&gt;fs.trash.interval&lt;/code&gt;），超时后 Namenode 会将该文件从命名空间中删除，删除文件会使得该文件相关的数据块被释放，因此从用户删除文件到 HDFS 空闲空间的增加之间会有一定时间的延迟。&lt;/li&gt;
&lt;li&gt;当一个文件的副本系数被减小后，Namenode 会选择过剩的副本删除，并在下次心跳检测时将该信息传递给 Datanode。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;Secondary-NameNode&quot;&gt;&lt;a href=&quot;#Secondary-NameNode&quot; class=&quot;headerlink&quot; title=&quot;Secondary NameNode&quot;&gt;&lt;/a&gt;Secondary NameNode&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;因为 NameNode 只有在启动阶段才合并 &lt;code&gt;fsImage&lt;/code&gt; 和 &lt;code&gt;EditLog&lt;/code&gt;，所以日志文件可能会变得非常庞大，且下一次 NameNode 启动会花很长时间。&lt;/li&gt;
&lt;li&gt;Secondary NameNode 定期合并 &lt;code&gt;fsImage&lt;/code&gt; 和 &lt;code&gt;EditLog&lt;/code&gt;，将日志文件大小控制在一个限度下。因为内存需求和 NameNode 在一个数量级上，所以通常 Secondary NameNode 和 NameNode 运行在不同的机器上。Secondary NameNode 通过 &lt;code&gt;bin/start-dfs.sh&lt;/code&gt; 在`conf/masters 中指定的节点上启动。&lt;/li&gt;
&lt;li&gt;Secondary NameNode 的检查点进程启动，由两个配置参数控制：&lt;ul&gt;
&lt;li&gt;&lt;code&gt;fs.checkpoint.period&lt;/code&gt;：指定连续两次检查点的最大时间间隔，默认为 1 小时；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;fs.checkpoint.size&lt;/code&gt;：定义日志文件的最大值，一旦超过这个值会强制执行检查点，默认值是64MB。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Secondary NameNode 保存最新检查点的目录与 NameNode 的目录结构相同，NameNode 可以在需要的时候读取 Secondary NameNode 上的检查点镜像。如果 NameNode 上除了最新的检查点以外，所有的其他的历史镜像和日志文件都丢失了，则可以引入这个最新的检查点：&lt;ul&gt;
&lt;li&gt;在配置参数 &lt;code&gt;dfs.name.dir&lt;/code&gt; 指定的位置创建空目录；&lt;/li&gt;
&lt;li&gt;把检查点目录的位置赋值给配置参数 &lt;code&gt;fs.checkpoint.dir&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;启动 NameNode，并加上 &lt;code&gt;-importCheckpoint&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;按上述步骤，NameNode 会从 &lt;code&gt;fs.checkpoint.dir&lt;/code&gt; 目录读取检查点，并把它保存在 &lt;code&gt;dfs.name.dir&lt;/code&gt; 目录下。如果 &lt;code&gt;dfs.name.dir&lt;/code&gt; 目录下有合法的镜像文件，NameNode 会启动失败。NameNode 会检查 &lt;code&gt;fs.checkpoint.dir&lt;/code&gt; 目录下镜像文件的一致性，但是不会改动它。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;Map-Reduce&quot;&gt;&lt;a href=&quot;#Map-Reduce&quot; class=&quot;headerlink&quot; title=&quot;Map/Reduce&quot;&gt;&lt;/a&gt;Map/Reduce&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;一个 Map/Reduce 作业通常会把输入的数据集切分为若干独立的数据块，由 map 任务以完全并行的方式处理它们。框架会对 map 的输出先进行排序，然后把结果输入给 reduce 任务。通常作业的输入和输出都会被存储在文件系统中。整个框架负责任务的调度和监控，以及重新执行已经失败的任务。&lt;/li&gt;
&lt;li&gt;通常，&lt;strong&gt;Map/Reduce 框架和分布式文件系统是运行在一组相同的节点上的&lt;/strong&gt;，即计算节点和存储节点通常在一起。Map/Reduce 框架由一个单独的 master JobTracker 和每个集群节点一个 slave TaskTracker 组成。master 负责调度构成一个作业的所有任务，这些任务分布在不同的 slave 上，master 监控它们的执行，重新执行已经失败的任务，slave 仅负责执行由 master 指派的任务。&lt;/li&gt;
&lt;li&gt;应用程序通过提供 map 和 reduce 来实现 Mapper 和 Reducer 接口，它们组成作业的核心。Mapper 将输入键值对映射到一组中间格式的键值对集合，这种转换的中间格式记录集不需要与输入记录集的类型一致，一个给定的输入键值对可以映射成 0 个或多个输出键值对；Reducer 将与一个 key 关联的一组中间数值集归约为一个更小的数值集。&lt;strong&gt;Map 的数目通常是由输入数据的大小决定的&lt;/strong&gt;，一般就是所有输入文件的总块数。&lt;/li&gt;
&lt;li&gt;Reducer有3个主要阶段：shuffle、sort 和 reduce。&lt;ul&gt;
&lt;li&gt;Shuffle：Reducer 的输入就是 Mapper 已经排好序的输出。在这个阶段，框架通过 HTTP 为每个 Reducer 获得所有 Mapper 输出中与之相关的分块。&lt;/li&gt;
&lt;li&gt;Sort：框架按照 key 的值对 Reducer 的输入进行分组（不同 mapper 的输出中可能会有相同的key）。&lt;strong&gt;Shuffle 和 Sort 两个阶段是同时进行的&lt;/strong&gt;，map 的输出也是一边被取回一边被合并的。&lt;/li&gt;
&lt;li&gt;Reduce：框架为已分组的输入数据中的每个 &lt;code&gt;&amp;lt;key, (list of values)&amp;gt;&lt;/code&gt; 对调用一次 &lt;code&gt;reduce(WritableComparable, Iterator, OutputCollector, Reporter)&lt;/code&gt; 方法。Reduce任务的输出通常是通过调用 &lt;code&gt;OutputCollector.collect(WritableComparable, Writable)&lt;/code&gt; 写入文件系统的。Reducer的输出是没有排序的。Reduce的数目建议是 0.95 或 1.75 乘以 &lt;code&gt;(&amp;lt;no. of nodes&amp;gt; * mapred.tasktracker.reduce.tasks.maximum)&lt;/code&gt;。增加 Reduce 的数目会增加整个框架的开销，但可以改善负载均衡，降低由于执行失败带来的负面影响。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;p&gt;参考资料：&lt;a href=&quot;http://hadoop.apache.org/docs/r1.0.4/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Hadoop 0.18 中文文档&lt;/a&gt;    &lt;/p&gt;
&lt;p&gt;原创作品，允许转载，转载时无需告知，但请务必以超链接形式标明文章&lt;a href=&quot;http://blog.forec.cn/2017/08/22/hadoop_knowledge/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;原始出处&lt;/a&gt;(&lt;a href=&quot;http://blog.forec.cn/2017/08/22/hadoop_knowledge/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;http://blog.forec.cn/2017/08/22/hadoop_knowledge/&lt;/a&gt;) 、作者信息（&lt;a href=&quot;http://forec.cn/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Forec&lt;/a&gt;）和本声明。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;blockquote&gt;
&lt;p&gt;Apache Hadoop 是一款支持数据密集型分布式应用程序并以 Apache 2.0 许可协议发布的开源软件框架。它支持在商品硬件构建的大型集群上运行的应用程序。Hadoop 是根据谷歌公司发表的 MapReduce 和 Google 文件系统的论文自行实现而成。所有的 Hadoop 模块都有一个基本假设，即硬件故障是常见情况，应该由框架自动处理。&lt;/p&gt;
&lt;/blockquote&gt;
    
    </summary>
    
      <category term="大数据/分布式系统" scheme="http://forec.github.io/categories/%E5%A4%A7%E6%95%B0%E6%8D%AE-%E5%88%86%E5%B8%83%E5%BC%8F%E7%B3%BB%E7%BB%9F/"/>
    
    
      <category term="Hadoop" scheme="http://forec.github.io/tags/Hadoop/"/>
    
      <category term="分布式系统" scheme="http://forec.github.io/tags/%E5%88%86%E5%B8%83%E5%BC%8F%E7%B3%BB%E7%BB%9F/"/>
    
  </entry>
  
  <entry>
    <title>从鳄鱼蛋看 λ 演算</title>
    <link href="http://forec.github.io/2017/03/21/AlligatorEggs/"/>
    <id>http://forec.github.io/2017/03/21/AlligatorEggs/</id>
    <published>2017-03-21T15:42:42.000Z</published>
    <updated>2018-09-26T06:08:29.201Z</updated>
    
    <content type="html">&lt;blockquote&gt;
&lt;p&gt;这篇文章是 &lt;a href=&quot;http://worrydream.com/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Bret Victor&lt;/a&gt; 所著 &lt;a href=&quot;http://worrydream.com/#!/AlligatorEggs&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;《Alligator Eggs!》&lt;/a&gt; 的中文译文，已联系原作者取得授权。Bret Victor 在 2007 到 2011 年期间在苹果负责人机界面开发，参与设计了最初的 iPad，他的个人网站非常精美，文章也及其友好。更多关于他的信息可以参考维基百科上 &lt;a href=&quot;https://en.wikipedia.org/wiki/Bret_Victor&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Bret Victor 的词条&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;a id=&quot;more&quot;&gt;&lt;/a&gt;
&lt;blockquote&gt;
&lt;p&gt;This Article is the Chinese translation for &lt;a href=&quot;http://worrydream.com/#!/AlligatorEggs&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;&lt;em&gt;Alligator Eggs!&lt;/em&gt;&lt;/a&gt; (Written by &lt;a href=&quot;http://worrydream.com/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Bret Victor&lt;/a&gt;).&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&quot;准备材料&quot;&gt;&lt;a href=&quot;#准备材料&quot; class=&quot;headerlink&quot; title=&quot;准备材料&quot;&gt;&lt;/a&gt;准备材料&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;第一步&lt;/strong&gt;：将这个 &lt;a href=&quot;http://qiniu.forec.cn/alligator/alligators_colored.pdf&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;PDF 文件&lt;/a&gt; 打印到六种&lt;span style=&quot;color: #f00;&quot;&gt;不同&lt;/span&gt;&lt;span style=&quot;color: #0a0;&quot;&gt;颜色&lt;/span&gt;&lt;span style=&quot;color: #00f;&quot;&gt;的&lt;/span&gt;&lt;span style=&quot;color: #ea0;&quot;&gt;纸&lt;/span&gt;&lt;span style=&quot;color: #f0f;&quot;&gt;板&lt;/span&gt;上。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/materials_1.png&quot;&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;第二步&lt;/strong&gt;：将这个 &lt;a href=&quot;http://qiniu.forec.cn/alligator/alligators_colored.pdf&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;PDF 文件&lt;/a&gt; 打印到几张白纸上。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/materials_2.png&quot;&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;第三步&lt;/strong&gt;：把这些鳄鱼和鳄鱼蛋剪下来！&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/materials_3.png&quot;&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;零件&quot;&gt;&lt;a href=&quot;#零件&quot; class=&quot;headerlink&quot; title=&quot;零件&quot;&gt;&lt;/a&gt;零件&lt;/h2&gt;&lt;p&gt;下面这些是 &lt;strong&gt;饥饿的鳄鱼&lt;/strong&gt;（彩色的）：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/pieces_1.png&quot;&gt;&lt;br&gt;饥饿的鳄鱼 &lt;strong&gt;需要进食&lt;/strong&gt;。它们会吃掉任何在它们面前的东西！但是它们同时也是 &lt;strong&gt;负责任的&lt;/strong&gt; 鳄鱼，所以它们还需要守护自己的家庭。&lt;/p&gt;
&lt;p&gt;这些是 &lt;strong&gt;老鳄鱼&lt;/strong&gt;：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/pieces_2.png&quot;&gt;&lt;br&gt;老鳄鱼们并不需要进食，它们已经吃饱了，而它们生活的唯一目标就是保卫自己的家庭。&lt;/p&gt;
&lt;p&gt;这些是 &lt;strong&gt;蛋&lt;/strong&gt;：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/pieces_3.png&quot;&gt;&lt;br&gt;蛋会孵化出新的鳄鱼家庭！&lt;/p&gt;
&lt;h2 id=&quot;家庭&quot;&gt;&lt;a href=&quot;#家庭&quot; class=&quot;headerlink&quot; title=&quot;家庭&quot;&gt;&lt;/a&gt;家庭&lt;/h2&gt;&lt;p&gt;这是一个小家庭：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/families_1.png&quot;&gt;&lt;br&gt;一条绿色的鳄鱼守护着她绿色的蛋。&lt;/p&gt;
&lt;p&gt;这是一个稍大的家庭：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/families_2.png&quot;&gt;&lt;br&gt;一条绿鳄鱼和一条红鳄鱼在一起保护着一个绿色的鳄鱼蛋和一个红色的鳄鱼蛋。或者，你也可以这么理解：一条绿色的鳄鱼正在保护着一条红色的鳄鱼，而这条红色的鳄鱼正在看护着这些蛋。&lt;/p&gt;
&lt;p&gt;这是一个大家庭！&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/families_3.png&quot;&gt;&lt;br&gt;我们可以看到，各有一条黄色、绿色和红色的鳄鱼在守卫着这个家庭。它们守护着三个东西：一个绿色的鳄鱼蛋，一条老鳄鱼，以及一个红色的鳄鱼蛋。这条老鳄鱼还保护着一个黄色的鳄鱼蛋和一个绿色的鳄鱼蛋。&lt;br&gt;注意！鳄鱼蛋必须和它们保护者的颜色一致。换句话说，如果有一个蓝色的鳄鱼蛋，那就必须有一条蓝色的鳄鱼守护着它。&lt;/p&gt;
&lt;h2 id=&quot;进食&quot;&gt;&lt;a href=&quot;#进食&quot; class=&quot;headerlink&quot; title=&quot;进食&quot;&gt;&lt;/a&gt;进食&lt;/h2&gt;&lt;p&gt;现在事情开始变得复杂起来了。这是紧挨着的两个家庭：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eating_1.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;毫无疑问，绿色的鳄鱼正处于饥饿状态。无独有偶，有一个黄色的鳄鱼家庭就在她面前。看起来似乎很好吃！&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eating_2.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;我想你已经知道马上会发生什么事。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eating_3.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;不幸的是，绿色的鳄鱼有些高估自己的能力了。她吃得太多了！&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eating_4.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;这条绿色的鳄鱼去了鳄鱼天堂。但是，故事仍在继续。绿色鳄鱼死了之后，她所看护的绿色鳄鱼蛋开始孵化……&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eating_5.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;太神奇了，这个绿色鳄鱼蛋竟然孵化成了绿色鳄鱼刚刚吃掉的东西。这是生命的奇迹！&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eating_6.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;现在，它们又变成了一个家庭。这个家庭中有一条红鳄鱼守卫着一条黄鳄鱼和一个红鳄鱼蛋，而这条黄鳄鱼则守护着她的黄色鳄鱼蛋。&lt;/p&gt;
&lt;p&gt;这条黄色鳄鱼当然也需要进食，何况她的面前恰好有一个美味的红色鳄鱼蛋。让我们再重复一次……&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eating_7.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;可怜的鳄鱼。对她的食量来说，即便是一个鳄鱼蛋也难以消化！&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eating_8.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;这条黄色的鳄鱼死了…… 但是同时，黄色的鳄鱼蛋也开始孵化……&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eating_9.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;黄色的鳄鱼蛋孵化出了黄色鳄鱼吃掉的东西。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eating_10.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;现在已经没有任何鳄鱼有机会进食了，所以这个故事到这里可以停止了。&lt;/p&gt;
&lt;h2 id=&quot;进食规则&quot;&gt;&lt;a href=&quot;#进食规则&quot; class=&quot;headerlink&quot; title=&quot;进食规则&quot;&gt;&lt;/a&gt;进食规则&lt;/h2&gt;&lt;p&gt;上面所述的故事是这个游戏的第一条规则：&lt;strong&gt;进食规则&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;进食规则指的是，如果有一些紧挨着的家庭……&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eatingrule_1.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;那么最左上角的鳄鱼会吃掉她右侧的整个鳄鱼家庭。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eatingrule_2.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;之后，进食的这条鳄鱼会死掉。但如果这条鳄鱼正在守卫着任何和她颜色相同的鳄鱼蛋，那么 &lt;strong&gt;每个&lt;/strong&gt; 这样的鳄鱼蛋（与死去的鳄鱼颜色相同且被其守卫的）都会孵化出这条死去的鳄鱼刚刚吃过的东西。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eatingrule_3.png&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;颜色规则&quot;&gt;&lt;a href=&quot;#颜色规则&quot; class=&quot;headerlink&quot; title=&quot;颜色规则&quot;&gt;&lt;/a&gt;颜色规则&lt;/h2&gt;&lt;p&gt;继续上面的例子，橘黄色的鳄鱼吃掉了黄色的鳄鱼家庭，情况变成下面这样：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/eatingrule_4.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;现在，左上角的绿色鳄鱼想要吃掉她右侧的鳄鱼家庭。但是在此之前，我们得检查一下这是否符合 &lt;strong&gt;颜色规则&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;颜色规则说的是，如果一条鳄鱼准备吃掉一个鳄鱼家庭，并且有一种颜色在 &lt;strong&gt;两个家庭&lt;/strong&gt;（进食的鳄鱼所属的家庭和将要被吃掉的家庭） 中都出现了，我们就需要将其中一个家庭的这种颜色替换为其它颜色。&lt;/p&gt;
&lt;p&gt;上面的图片中，绿色和红色同时出现在第一、第二个家庭中。因此，我们将第二个家庭中所有的绿色替换为浅蓝色，所有的红色替换为黄色。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/colorrule_1.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;现在各个家庭间没有相同的颜色了，鳄鱼们已经饥渴难耐！动嘴吧！&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/colorrule_2.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;还可以吃！&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/colorrule_3.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;继续！&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/colorrule_4.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;直到没有东西可以被吃掉。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/colorrule_5.png&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;老鳄鱼&quot;&gt;&lt;a href=&quot;#老鳄鱼&quot; class=&quot;headerlink&quot; title=&quot;老鳄鱼&quot;&gt;&lt;/a&gt;老鳄鱼&lt;/h2&gt;&lt;p&gt;这个游戏还有一条与 &lt;strong&gt;老鳄鱼&lt;/strong&gt; 有关的额外规则：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/old_1.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;左上角的老鳄鱼并不会感到饥饿，她不需要吃任何东西，她的生命只会奉献给她的家庭。那么这个游戏该怎么继续下去呢？&lt;/p&gt;
&lt;p&gt;当需要守护的东西只剩最后一样的时候，老鳄鱼会撒手鳄寰。现在，左上角的老鳄鱼同时看护着一个绿色的家庭和一个红色的家庭，这些家庭还需要她去照顾。但是现在，绿色的鳄鱼需要进食了，于是它吃掉了右侧的红色家庭……&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/old_2.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;现在，老鳄鱼只看护着一个家庭。这个家庭可以照顾自己了，老鳄鱼失去了存在的意义，所以她很快离去。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/old_3.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;这就是 &lt;strong&gt;老龄规则&lt;/strong&gt;。当一条老鳄鱼只看管着（直接看管）一样东西时，她就该离开这个世界了。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/old_4.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;最后，红色的鳄鱼吃掉了黄色的家庭。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/old_5.png&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;游戏&quot;&gt;&lt;a href=&quot;#游戏&quot; class=&quot;headerlink&quot; title=&quot;游戏&quot;&gt;&lt;/a&gt;游戏&lt;/h2&gt;&lt;p&gt;游戏包含一系列谜题，目标是让玩家设计一个家庭，使这个家庭在进食 X 后能够产出 Y。举个例子：&lt;/p&gt;
&lt;p&gt;这是两个家庭，我们将左侧的家庭命名为 “True”，将右侧的家庭命名为 “False”：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/gameplay_1.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;这是一个名为 “Not” 的家庭：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/gameplay_2.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;当 “Not” 吃掉 “True” 的时候会产生 “False”，同样的，当 “Not” 吃掉 “False” 的时候会产生 “True”。那么，“Not” 中最底部的两个鳄鱼蛋应该是什么颜色呢？&lt;/p&gt;
&lt;p&gt;（我们需要完善一下颜色规则：如果两个家庭颜色不同，但具有相同的模式，即相同位置的鳄鱼/蛋在两个家庭中的颜色能够建立起一一映射，就认为这两个家庭是等价的。）&lt;/p&gt;
&lt;p&gt;这些谜题可以嵌入一些故事中。玩家必须依次解决谜题才能看到故事的发展。或者，这些谜题可以做成棋盘游戏。每个玩家通过选择鳄鱼死亡来解决到达目的地等问题。&lt;/p&gt;
&lt;h2 id=&quot;理论&quot;&gt;&lt;a href=&quot;#理论&quot; class=&quot;headerlink&quot; title=&quot;理论&quot;&gt;&lt;/a&gt;理论&lt;/h2&gt;&lt;p&gt;这个游戏实际表示了 &lt;strong&gt;无类型的 λ 演算&lt;/strong&gt; 。&lt;strong&gt;饥饿的鳄鱼&lt;/strong&gt; 是 λ 表示的抽象函数，&lt;strong&gt;老鳄鱼&lt;/strong&gt; 是括号，&lt;strong&gt;鳄鱼蛋&lt;/strong&gt; 是变量。&lt;strong&gt;进食规则&lt;/strong&gt; 对应着 β-规约，&lt;strong&gt;颜色规则&lt;/strong&gt; 对应着 α-变换。&lt;strong&gt;老龄规则&lt;/strong&gt; 指的是，如果一对括号仅仅包含着单个不可分割表达式，那这对括号就可以被去除。&lt;/p&gt;
&lt;h2 id=&quot;变换&quot;&gt;&lt;a href=&quot;#变换&quot; class=&quot;headerlink&quot; title=&quot;变换&quot;&gt;&lt;/a&gt;变换&lt;/h2&gt;&lt;p&gt;&lt;a href=&quot;http://osteele.com/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;奥利弗·斯蒂尔&lt;/a&gt;（Oliver Steele）指出，家庭角色对孩子的影响非常重要，这个游戏中的物品可以进一步变化为祖父母鳄鱼、鳄鱼家长和婴儿（蛋）等等。目前，变量名称是通过颜色表示的。这两者都是任意的，所以需要重命名/染色的规则去避免冲突。可以采用类似布鲁恩指数的替代方案，从而能够反应出生顺序和家庭关系。&lt;/p&gt;
&lt;p&gt;奥利弗还建议，孩子们也许不会喜欢家长去世这一说法，所以鳄鱼的死亡可以解释为离开。&lt;/p&gt;
&lt;p&gt;通过改变游戏规则，让饥饿的鳄鱼变得 &lt;strong&gt;贪婪&lt;/strong&gt;，并吃掉一切在它们右侧的东西，我们就可以表示 &lt;strong&gt;右结合&lt;/strong&gt; 的 λ 演算。和丘奇数、Y 组合子等相比，这种表示方法似乎去掉了许多老鳄鱼（括号）。不幸的是，这意味着当鳄鱼吃掉不止一样东西时，必须有老鳄鱼出生，同时也会产生一些其他问题。我仍然想找到一种让丘奇数（重复施用）看起来不那么丑陋的表示方法。&lt;/p&gt;
&lt;h2 id=&quot;示意图&quot;&gt;&lt;a href=&quot;#示意图&quot; class=&quot;headerlink&quot; title=&quot;示意图&quot;&gt;&lt;/a&gt;示意图&lt;/h2&gt;&lt;p&gt;我发现 “鳄鱼演算” 的原理比手动计算 λ 表达式来的更容易。我们将 λ 画做一条带嘴的直线。括号是一条不带嘴的直线。这是恒等（identity）函数：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/schematic_1.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;这是一些丘奇数：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/schematic_2.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;这是布尔型操作 AND 和 OR：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/schematic_3.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;Y 组合子：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/alligator/schematic_4.png&quot;&gt;&lt;/p&gt;
&lt;p&gt;我不知道它们 &lt;strong&gt;读&lt;/strong&gt; 起来是不是比标准符号更容易些，但我发现在有纸笔的情况下它们确实更容易 &lt;strong&gt;处理&lt;/strong&gt; 。想象一下，一个表达式吃掉另一个并将它在底部孵化。我不会再在一长串符号中迷失，忘掉该把哪个 λ 应用到哪个 λ 上。&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;英文原文链接：  &lt;a href=&quot;http://worrydream.com/#!/AlligatorEggs&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;&lt;em&gt;Alligator Eggs!&lt;/em&gt;&lt;/a&gt; (Written by &lt;a href=&quot;http://worrydream.com/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Bret Victor&lt;/a&gt;)     &lt;/p&gt;
&lt;p&gt;原创作品，允许转载，转载时无需告知，但请务必以超链接形式标明文章&lt;a href=&quot;http://blog.forec.cn/2017/03/21/AlligatorEggs/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;原始出处&lt;/a&gt;(&lt;a href=&quot;http://blog.forec.cn/2017/03/21/AlligatorEggs/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;http://blog.forec.cn/2017/03/21/AlligatorEggs/&lt;/a&gt;) 、作者信息（&lt;a href=&quot;http://forec.cn/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Forec&lt;/a&gt;）和本声明。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;blockquote&gt;
&lt;p&gt;这篇文章是 &lt;a href=&quot;http://worrydream.com/&quot;&gt;Bret Victor&lt;/a&gt; 所著 &lt;a href=&quot;http://worrydream.com/#!/AlligatorEggs&quot;&gt;《Alligator Eggs!》&lt;/a&gt; 的中文译文，已联系原作者取得授权。Bret Victor 在 2007 到 2011 年期间在苹果负责人机界面开发，参与设计了最初的 iPad，他的个人网站非常精美，文章也及其友好。更多关于他的信息可以参考维基百科上 &lt;a href=&quot;https://en.wikipedia.org/wiki/Bret_Victor&quot;&gt;Bret Victor 的词条&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
    
    </summary>
    
      <category term="Code" scheme="http://forec.github.io/categories/Code/"/>
    
    
      <category term="函数式编程" scheme="http://forec.github.io/tags/%E5%87%BD%E6%95%B0%E5%BC%8F%E7%BC%96%E7%A8%8B/"/>
    
  </entry>
  
  <entry>
    <title>右线性语言</title>
    <link href="http://forec.github.io/2017/03/19/formal-languages-and-automata3/"/>
    <id>http://forec.github.io/2017/03/19/formal-languages-and-automata3/</id>
    <published>2017-03-19T15:09:53.000Z</published>
    <updated>2018-09-26T06:08:29.070Z</updated>
    
    <content type="html">&lt;blockquote&gt;
&lt;p&gt;正则集、正则式，右线性文法，正则表达式与有限自动机之间的图示关系，右线性语言与有限自动机之间的关系。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;a id=&quot;more&quot;&gt;&lt;/a&gt;
&lt;h2 id=&quot;正则集和正则式&quot;&gt;&lt;a href=&quot;#正则集和正则式&quot; class=&quot;headerlink&quot; title=&quot;正则集和正则式&quot;&gt;&lt;/a&gt;正则集和正则式&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;正则集可用正则式表示。字母表 T 上的一个正则式和它表示的正则集可递归定义如下：&lt;ul&gt;
&lt;li&gt;ε 和 ∅ 都是正则式，分别表示的正则集是 {ε} 和空集 ∅；&lt;/li&gt;
&lt;li&gt;任意 a ∈ T 是正则式，他表示的正则集是 {a}（以上两条为原子正则式）；&lt;/li&gt;
&lt;li&gt;如果 A 和 B 是正则式，分别表示的正则集是 L(A) 和 L(B)，则 (A+B)、(A·B)、(A&lt;em&gt;) 也都是正则式，分别表示的正则集是 &lt;code&gt;L(A) ∪ L(B)&lt;/code&gt;、&lt;code&gt;L(A)L(B)&lt;/code&gt;、`L(A)&lt;/em&gt;&lt;code&gt;。操作的优先级为&lt;/code&gt;*（闭包） &amp;gt; ·（连接）&amp;gt; +（联合）`。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;仅由 &lt;strong&gt;有限次&lt;/strong&gt; 使用以上三步定义的表达式才是字母表 T 的正则式。如果两个正则式表示相同的正则集，则称两个正则式相等。&lt;/li&gt;
&lt;li&gt;假设 α、β、γ 都是正则式，则：&lt;ul&gt;
&lt;li&gt;&lt;code&gt;(α + β) + γ = α + (β + γ)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;(α · β) · γ = α · (β · γ)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;α + β = β + α&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;α + α = α&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;α · (β + γ) = (α · β) + (α · γ)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;(β + γ) · α = (β · α) + (γ · α)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;α + ∅= α&lt;/code&gt;（零元）&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;α · ∅ = ∅ · α = ∅&lt;/code&gt;（零元）&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;α · ε = ε · a = a&lt;/code&gt;（幺元）&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;(α*)* = α*&lt;/code&gt;（闭包）&lt;/li&gt;
&lt;li&gt;&lt;code&gt;α* = ε + α+&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;∅* = ε&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;注意：&lt;ul&gt;
&lt;li&gt;正则集是 T* 的子集；&lt;/li&gt;
&lt;li&gt;L+ 包含 ε 当且仅当 L 包含 ε；&lt;/li&gt;
&lt;li&gt;每个正则集至少对应一个正则式。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;右线性文法与正则&quot;&gt;&lt;a href=&quot;#右线性文法与正则&quot; class=&quot;headerlink&quot; title=&quot;右线性文法与正则&quot;&gt;&lt;/a&gt;右线性文法与正则&lt;/h2&gt;&lt;h3 id=&quot;右线性文法与正则式&quot;&gt;&lt;a href=&quot;#右线性文法与正则式&quot; class=&quot;headerlink&quot; title=&quot;右线性文法与正则式&quot;&gt;&lt;/a&gt;右线性文法与正则式&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;右线性文法（正则文法）与正则式具有等价性。&lt;/li&gt;
&lt;li&gt;求解规则：设 &lt;code&gt;x = αx + β, α ∈ T*, β ∈ (N∪T)*, x ∈ N&lt;/code&gt;，可解出 &lt;code&gt;x = α*β&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;例：&lt;code&gt;G = {N = {S, A, B}, T = {a, b}, P, S}&lt;/code&gt;，其中 P 包括以下规则：&lt;code&gt;S → aA, S → bB, S → b, A → bA, A → ε, B → bS&lt;/code&gt;。&lt;ul&gt;
&lt;li&gt;将 P 中的推导式联立，可得到 &lt;code&gt;S = aA + bB + b&lt;/code&gt;，&lt;code&gt;A =bA + ε&lt;/code&gt; 和 &lt;code&gt;B = bS&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;根据 &lt;code&gt;A = bA + ε&lt;/code&gt;，应用求解规则得到 &lt;code&gt;A = b*&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;将 &lt;code&gt;A = b*&lt;/code&gt;，&lt;code&gt;B = bS&lt;/code&gt; 代入，得到 &lt;code&gt;S = ab* + bbS + b&lt;/code&gt;，转换形式得到 &lt;code&gt;S = (bb)S + (ab* + b)&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;在此应用求解规则得到 &lt;code&gt;S = (bb)*(ab*+b)&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;右线性文法与正则集&quot;&gt;&lt;a href=&quot;#右线性文法与正则集&quot; class=&quot;headerlink&quot; title=&quot;右线性文法与正则集&quot;&gt;&lt;/a&gt;右线性文法与正则集&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;正则集是由右线性文法产生的语言，二者是等同的&lt;/strong&gt; ，按照上面定义的正则集都是右线性文法产生的语言。&lt;/li&gt;
&lt;li&gt;设字母表为 T。∅、{ε} 和 {a}（任意 a ∈ T）都是正则集，则 ∅、{ε} 和 {a} 都是右线性语言。它们分别对应的右线性文法是 &lt;code&gt;G∅ = ({S}, T, ∅, S)&lt;/code&gt;、&lt;code&gt;G{ε} = ({S}, T, {S → ε}, S)&lt;/code&gt; 以及 &lt;code&gt;G{a} = ({S}, {a}, {S → a}, S)&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;可证明，设字母表 T 上有右线性语言 L1 和 L2，则 L1∪L2、L1L2 和 L1* 都是右线性语言。&lt;ul&gt;
&lt;li&gt;证 L1 ∪ L2 为右线性语言：有右线性文法 &lt;code&gt;G = (N, T, P, S)&lt;/code&gt;，其中 &lt;code&gt;N = N1 ∪ N2 ∪ {S}&lt;/code&gt;，&lt;code&gt;P = P1 ∪ P2 ∪ {S → S1, S → S2}&lt;/code&gt;，S ∉ N1 ∪ N2，是一个新的非终结符；&lt;/li&gt;
&lt;li&gt;证 L1L2 为右线性语言：有右线性文法 &lt;code&gt;G = (N, T, P, S)&lt;/code&gt;，其中 N = N1 ∪ N2，S = S1，生成式 P 为：若 A → αB ∈ P1 则 A → αB ∈ P，若 A → α ∈ P1，则 A → αS2 ∈ P，P2 ⊆ P。&lt;/li&gt;
&lt;li&gt;证 L1* 是右线性语言：有右线性文法 &lt;code&gt;G = (N, T, P, S)&lt;/code&gt;，其中 N = N1 ∪ {S}，S ∉ N1，S 是一个新非终结符，生成式 P 定义为：若 A → αB ∈ P1 则 A → αB ∈ P，若 A → α ∈ P1 则 A → αS ∈ P 且 A → α ∈ P，且 P 中包括 {S → S1, S → ε}。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;正则表达式和有限自动机&quot;&gt;&lt;a href=&quot;#正则表达式和有限自动机&quot; class=&quot;headerlink&quot; title=&quot;正则表达式和有限自动机&quot;&gt;&lt;/a&gt;正则表达式和有限自动机&lt;/h2&gt;&lt;blockquote&gt;
&lt;p&gt;以下图片均来自王柏教授（北京邮电大学大数据科学与服务中心）的《形式语言与自动机》课件。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;ul&gt;
&lt;li&gt;有限自动机、右（左）线性文法和正则表达式都定义了同一种语言（正则语言）。&lt;/li&gt;
&lt;li&gt;由 DFA 构造等价的正则表达式（状态消去法）:&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src=&quot;http://qiniu.forec.cn/fla/fla-1.jpg&quot; width=&quot;500px&quot;&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;从 DFA 构造等价正则表达式的具体步骤如下：&lt;ul&gt;
&lt;li&gt;对每一终态 q，依次消去除 q 和初态 q0 之外的其它状态；&lt;/li&gt;
&lt;li&gt;若 q ≠ q0，最终可得到一般形式：&lt;code&gt;(R+ SU*T)*SU*&lt;/code&gt;，如下图中左侧的自动机；&lt;/li&gt;
&lt;li&gt;若 q = q0，最终可得到如图中右侧的自动机，对应正则式为 &lt;code&gt;R*&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;最终的正则表达式为 &lt;strong&gt;每一终态对应的正则表达式之和（联合）&lt;/strong&gt; 。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/fla/fla-2.jpg&quot;&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;从正则表达式构建等价的 ε-NFA，可根据如下几种基本组合子组合：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/fla/fla-3.jpg&quot; width=&quot;400px&quot;&gt;&lt;/li&gt;
&lt;li&gt;对于 &lt;code&gt;R+S&lt;/code&gt;、&lt;code&gt;RS&lt;/code&gt; 以及 &lt;code&gt;R*&lt;/code&gt;，分别为下图中从上到下三种连接方式：&lt;div&gt;&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/fla/fla-4.jpg&quot; width=&quot;250px&quot; style=&quot;display:inline&quot;&gt;&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/fla/fla-5.jpg&quot; width=&quot;250px&quot; style=&quot;display:inline&quot;&gt;&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/fla/fla-6.jpg&quot; width=&quot;250px&quot; style=&quot;display:inline&quot;&gt;&lt;br&gt;&lt;/div&gt;

&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;右线性文法与有限自动机&quot;&gt;&lt;a href=&quot;#右线性文法与有限自动机&quot; class=&quot;headerlink&quot; title=&quot;右线性文法与有限自动机&quot;&gt;&lt;/a&gt;右线性文法与有限自动机&lt;/h2&gt;&lt;h3 id=&quot;右线性文法-⇒-有限自动机&quot;&gt;&lt;a href=&quot;#右线性文法-⇒-有限自动机&quot; class=&quot;headerlink&quot; title=&quot;右线性文法 ⇒ 有限自动机&quot;&gt;&lt;/a&gt;右线性文法 ⇒ 有限自动机&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;设右线性文法 G = (N, T, P, S)，产生语言为 L(G)，则存在一个有限自动机 M 接受语言 L(M) = L(G)。&lt;/li&gt;
&lt;li&gt;构造：构造一个与 G 等价的 NFA M = (Q, T, δ, q0, F)，其中&lt;ul&gt;
&lt;li&gt;Q = N ∪ {H}，H 为新增状态，H ∉ N；&lt;/li&gt;
&lt;li&gt;q0 = S；&lt;/li&gt;
&lt;li&gt;当 S → ε ∈ P 时，F = {H, S}，否则 F = {H}；&lt;/li&gt;
&lt;li&gt;δ 的定义为：若 A → αB ∈ P 则 B ∈ δ(A, α)，若 A → α ∈ P 则 H ∈ δ(A, α)，且对任意输入有 δ(H, α) = ∅。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;例：G = ({S, B}, {α, β}, P, S)，其中 P 为 S → αB, B → αB | βS | α。&lt;ul&gt;
&lt;li&gt;令 NFA M = (Q, T, δ, q0, F)，Q = {S, B, H}，T = {α, β}，q0 = S，F = {H}；&lt;/li&gt;
&lt;li&gt;∵ S → αB，故 δ(S, α) 中包括 B；&lt;/li&gt;
&lt;li&gt;∵ B → αB，故 δ(B, α) 中包括 B；&lt;/li&gt;
&lt;li&gt;∵ B → βS，故 δ(B, β) 中包括 S；&lt;/li&gt;
&lt;li&gt;∵ B → α，故 δ(B, α) 中包括 H。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;有限自动机-⇒-右线性文法&quot;&gt;&lt;a href=&quot;#有限自动机-⇒-右线性文法&quot; class=&quot;headerlink&quot; title=&quot;有限自动机 ⇒ 右线性文法&quot;&gt;&lt;/a&gt;有限自动机 ⇒ 右线性文法&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;设 DFA M 接受的语言为 L(M)，则存在右线性文法 G，它产生的语言 L(G) = L(M)。&lt;/li&gt;
&lt;li&gt;构造：设 M = (Q, T, δ, q0, F)，则令 G = (N, T, P, S)，其中 &lt;ul&gt;
&lt;li&gt;N = Q，S = q0；&lt;/li&gt;
&lt;li&gt;若 δ(A, α) = B 且 B ∉ F 则 A → αB ∈ P；&lt;/li&gt;
&lt;li&gt;若 δ(A, α) = B 且 B ∈ F 则 A → α ∈ P，A → αB ∈ P。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;对于 NFA，可以转换为等价的 DFA 再做相应构造。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;右线性语言性质&quot;&gt;&lt;a href=&quot;#右线性语言性质&quot; class=&quot;headerlink&quot; title=&quot;右线性语言性质&quot;&gt;&lt;/a&gt;右线性语言性质&lt;/h2&gt;&lt;p&gt;TODO&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;专栏目录：&lt;a href=&quot;http://blog.forec.cn/columns/cs-basic.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;计算机理论基础&lt;/a&gt;&lt;br&gt;此专栏的上一篇文章：&lt;a href=&quot;http://blog.forec.cn/2017/03/18/formal-languages-and-automata2/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;有限自动机&lt;/a&gt;&lt;br&gt;此专栏的下一篇文章：暂无     &lt;/p&gt;
&lt;p&gt;参考资料：《形式语言与自动机》，王柏、杨娟编著，北京邮电大学出版社    &lt;/p&gt;
&lt;p&gt;原创作品，允许转载，转载时无需告知，但请务必以超链接形式标明文章&lt;a href=&quot;http://blog.forec.cn/2017/03/19/formal-languages-and-automata3/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;原始出处&lt;/a&gt;(&lt;a href=&quot;http://blog.forec.cn/2017/03/19/formal-languages-and-automata3/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;http://blog.forec.cn/2017/03/19/formal-languages-and-automata3/&lt;/a&gt;) 、作者信息（&lt;a href=&quot;http://forec.cn/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Forec&lt;/a&gt;）和本声明。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;blockquote&gt;
&lt;p&gt;正则集、正则式，右线性文法，正则表达式与有限自动机之间的图示关系，右线性语言与有限自动机之间的关系。&lt;/p&gt;
&lt;/blockquote&gt;
    
    </summary>
    
      <category term="计算机理论基础" scheme="http://forec.github.io/categories/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80/"/>
    
    
      <category term="自动机" scheme="http://forec.github.io/tags/%E8%87%AA%E5%8A%A8%E6%9C%BA/"/>
    
  </entry>
  
  <entry>
    <title>有限自动机</title>
    <link href="http://forec.github.io/2017/03/18/formal-languages-and-automata2/"/>
    <id>http://forec.github.io/2017/03/18/formal-languages-and-automata2/</id>
    <published>2017-03-18T13:41:32.000Z</published>
    <updated>2018-09-26T06:08:29.171Z</updated>
    
    <content type="html">&lt;blockquote&gt;
&lt;p&gt;确定的/非确定的有限自动机，带/不带 ε 转移的非确定有限自动机以及各自之间的等价性。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;a id=&quot;more&quot;&gt;&lt;/a&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;有限自动机（Finite State Automation）&lt;/strong&gt; ：&lt;strong&gt;状态&lt;/strong&gt; 是将事物区分开的一种标识，状态 + 输入 → 状态转移。&lt;ul&gt;
&lt;li&gt;具有 &lt;strong&gt;离散&lt;/strong&gt; 输入（输出，不必须）系统的一种数学模型，特殊情况下也可无输入；&lt;/li&gt;
&lt;li&gt;有限的状态；&lt;/li&gt;
&lt;li&gt;根据每次转换的后继状态数量可区分为 &lt;strong&gt;确定的&lt;/strong&gt; 有限自动机（DFA，后继状态唯一）和 &lt;strong&gt;不确定的&lt;/strong&gt; 有限自动机（NFA，后继状态有多个）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;确定的有限自动机&quot;&gt;&lt;a href=&quot;#确定的有限自动机&quot; class=&quot;headerlink&quot; title=&quot;确定的有限自动机&quot;&gt;&lt;/a&gt;确定的有限自动机&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;形式定义：DFA 是一个五元组，&lt;code&gt;M = (Q, T, δ, q0, F)&lt;/code&gt;：&lt;ul&gt;
&lt;li&gt;Q：有限的状态集合&lt;/li&gt;
&lt;li&gt;T：有限的输入字母表&lt;/li&gt;
&lt;li&gt;δ：转换函数，映射 Q × T → Q&lt;/li&gt;
&lt;li&gt;q0：初始状态，q0 ∈ Q&lt;/li&gt;
&lt;li&gt;F：终止状态集，F ⊆ Q&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;输入一个字符串时，对转换函数 δ 扩展：&lt;code&gt;δ&amp;#39; = Q × T* → Q&lt;/code&gt;，对任何 q ∈ Q，定义：&lt;ul&gt;
&lt;li&gt;&lt;code&gt;q&amp;#39;(q, ε) = q&lt;/code&gt; ：没有读到字符时，有限自动机状态不变&lt;/li&gt;
&lt;li&gt;对 a ∈ T 和 ω ∈ T*，有 &lt;code&gt;δ&amp;#39;(q, ωa) = δ(δ&amp;#39;(q, ω), a)&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;被 DFA 接收的字符串 ω 满足：&lt;code&gt;δ(q0, ω) = p, p ∈ F&lt;/code&gt;，即 &lt;strong&gt;输入结束后能够使 DFA 状态到达终态&lt;/strong&gt; 。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;格局&lt;/strong&gt; ：FSA 在某个时刻的工作状态可以用 &lt;code&gt;(q, ω)&lt;/code&gt; 表明，其中 ω 为待输入字符串，q 为当前状态。&lt;ul&gt;
&lt;li&gt;初始格局：&lt;code&gt;(q0, ω)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;终止格局：&lt;code&gt;(q, ε), q ∈ F&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;当 &lt;code&gt;δ(q, a)&lt;/code&gt; 含有 q1，则用格局形式写为 &lt;code&gt;(q, aω) |--- (q1, ω)&lt;/code&gt;，其中 ω ∈ T*，符号 &lt;code&gt;|---&lt;/code&gt; 表示从一个格局变换为另一个格局。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;不确定的有限自动机&quot;&gt;&lt;a href=&quot;#不确定的有限自动机&quot; class=&quot;headerlink&quot; title=&quot;不确定的有限自动机&quot;&gt;&lt;/a&gt;不确定的有限自动机&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;形式定义：NFA 是一个五元组，&lt;code&gt;M = (Q, T, δ, q0, F)&lt;/code&gt;，与 DFA 仅 δ 不同，NFA 的 δ 的映射范围为 &lt;code&gt;Q × T → 2^Q&lt;/code&gt;，即 NFA 在某个状态下读入一个字符时，可转换的后继状态是 Q 的一个子集。&lt;/li&gt;
&lt;li&gt;输入字符串时对 δ 扩展：&lt;ul&gt;
&lt;li&gt;对 ε ∈ T*，有 `δ’(q, ε) = {q}’；&lt;/li&gt;
&lt;li&gt;对任意 a ∈ T, ω ∈ T*，有 `δ’(q, ωa) = {p | 对 δ’(q, ω) 中的某个状态 r，且 p 在 δ(r, a) 内}；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;δ(P, ω) = ∪ δ(q, ω), q ∈ P, P ⊆ Q&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;NFA 接受的语言为 `L(M) = {ω | δ(q0, ω) 含 F 中的一个状态}。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;DFA-和-NFA-的等价性&quot;&gt;&lt;a href=&quot;#DFA-和-NFA-的等价性&quot; class=&quot;headerlink&quot; title=&quot;DFA 和 NFA 的等价性&quot;&gt;&lt;/a&gt;DFA 和 NFA 的等价性&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;DFA 是 NFA 的特例，NFA 必然能够接受 DFA 能接受的语言。&lt;/li&gt;
&lt;li&gt;从 NFA 构造等价的 DFA（&lt;strong&gt;子集构造法&lt;/strong&gt;）：&lt;ul&gt;
&lt;li&gt;设 L 为某个 NFA，&lt;code&gt;N = (QN, T, δN, q0, FN)&lt;/code&gt;，定义等价的 DFA 为 &lt;code&gt;M = (QD, T, δD, {q0}, FD)&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;定义的 DFA 中，&lt;code&gt;QD = {S | S ⊆ QN} = 2^Q&lt;/code&gt;，对 S ∈ QD 和 a ∈ T，有 &lt;code&gt;δD(S, a) = ∪ δN(q, a), q ∈ S&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;FD = {S | S ⊆ QN ∩ S ∩ FN ≠ ∅}&lt;/code&gt; （只要有一个在 F 中就可视为终止状态）；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;构造过程从 q0 开始，仅当某些状态已加入可达状态时，才加入 DFA 中&lt;/strong&gt;。最坏情况下由 NFA 构造的 DFA 状态数目为 2^|QN|。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;带-ε-转移的不确定的有限自动机&quot;&gt;&lt;a href=&quot;#带-ε-转移的不确定的有限自动机&quot; class=&quot;headerlink&quot; title=&quot;带 ε 转移的不确定的有限自动机&quot;&gt;&lt;/a&gt;带 ε 转移的不确定的有限自动机&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;有 ε 转换的 NFA 与无 ε 转换的 NFA 区别仅在于转换函数 δ 的不同，有 ε 转移的 NFA 在输入空串 ε（无输入）时也会引起状态转移，即 δ 是从 Q × (T ∪ {ε}) → 2^Q。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;ε-闭包（closure）&lt;/strong&gt;：&lt;ul&gt;
&lt;li&gt;状态 q 的 ε-闭包记为 ε-CLOSURE 或 ECLOSURE，定义为从 q 仅通过 ε 路径可以到达的状态（包括 q 自身）；&lt;/li&gt;
&lt;li&gt;状态子集 I 的 ε-闭包：&lt;code&gt;ε-CLOSURE(I) = ∪ ε-CLOSURE(q), q ∈ I&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;Ia：对状态子集 I ⊆ Q，任意 a ∈ T，&lt;code&gt;Ia = ε-CLOSURE(P), P = δ(I, a)&lt;/code&gt;，即 P 是从 I 中状态经过一条标 a 的边可以到达的状态集合。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;扩展定义 δ’：Q × T* → 2^Q，对任何 q ∈ Q，有：&lt;ul&gt;
&lt;li&gt;&lt;code&gt;δ&amp;#39;(q, ε) = ε-CLOSURE(q)&lt;/code&gt; &lt;/li&gt;
&lt;li&gt;&lt;code&gt;δ&amp;#39;(q, ωa) = ε-CLOSURE(P), P = {p | 对某些 r ∈ δ&amp;#39;(q, ω) 且 p ∈ δ(r, a)}&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;δ(q, a) ≠ δ’(q, a)，因为 δ(q, a) 仅表示由 q 出发，仅沿着 &lt;strong&gt;一条&lt;/strong&gt; 标 a 的路径能到达的状态，而 δ’(q, a) 表示经过标 a 或 ε 的路径得到状态集合的 ε-闭包，即 &lt;code&gt;δ&amp;#39;(q, ωa) = ε-CLOSURE(δ( δ&amp;#39;(q, ω), a ))&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;有-ε-转换的-NFA-和无-ε-转换的-NFA-等价&quot;&gt;&lt;a href=&quot;#有-ε-转换的-NFA-和无-ε-转换的-NFA-等价&quot; class=&quot;headerlink&quot; title=&quot;有 ε 转换的 NFA 和无 ε 转换的 NFA 等价&quot;&gt;&lt;/a&gt;有 ε 转换的 NFA 和无 ε 转换的 NFA 等价&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;ε-NFA 是无 ε 转移的 NFA 的一般情况。设 &lt;code&gt;M = (Q, T, δ, q0, F)&lt;/code&gt; 是一个 ε-NFA，可构造一个等价的无 ε 的 NFA：&lt;code&gt;M1 = (Q, T, S1, q0, F1)&lt;/code&gt;&lt;ul&gt;
&lt;li&gt;对任何 a ∈ T，&lt;code&gt;δ1(q, a) = δ&amp;#39;(q, a)&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;若 ε-CLORSURE(q0) ∩ F ≠ ∅，则 F1 = F ∪ {q0}，否则 F1 = F。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;构造方法：先确定 F，之后按照 &lt;code&gt;δ1(q, a) = δ&amp;#39;(q, a)&lt;/code&gt; 来确定生成式集合。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;p&gt;专栏目录：&lt;a href=&quot;http://blog.forec.cn/columns/cs-basic.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;计算机理论基础&lt;/a&gt;&lt;br&gt;此专栏的上一篇文章：&lt;a href=&quot;http://blog.forec.cn/2017/02/25/formal-languages-and-automata1/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;形式语言&lt;/a&gt;&lt;br&gt;此专栏的下一篇文章：&lt;a href=&quot;http://blog.forec.cn/2017/03/19/formal-languages-and-automata3/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;右线性语言&lt;/a&gt;      &lt;/p&gt;
&lt;p&gt;参考资料：《形式语言与自动机》，王柏、杨娟编著，北京邮电大学出版社    &lt;/p&gt;
&lt;p&gt;原创作品，允许转载，转载时无需告知，但请务必以超链接形式标明文章&lt;a href=&quot;http://blog.forec.cn/2017/03/18/formal-languages-and-automata2/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;原始出处&lt;/a&gt;(&lt;a href=&quot;http://blog.forec.cn/2017/03/18/formal-languages-and-automata2/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;http://blog.forec.cn/2017/03/18/formal-languages-and-automata2/&lt;/a&gt;) 、作者信息（&lt;a href=&quot;http://forec.cn/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Forec&lt;/a&gt;）和本声明。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;blockquote&gt;
&lt;p&gt;确定的/非确定的有限自动机，带/不带 ε 转移的非确定有限自动机以及各自之间的等价性。&lt;/p&gt;
&lt;/blockquote&gt;
    
    </summary>
    
      <category term="计算机理论基础" scheme="http://forec.github.io/categories/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80/"/>
    
    
      <category term="自动机" scheme="http://forec.github.io/tags/%E8%87%AA%E5%8A%A8%E6%9C%BA/"/>
    
  </entry>
  
  <entry>
    <title>三种实用 Monad</title>
    <link href="http://forec.github.io/2017/03/02/translation-adit-tum/"/>
    <id>http://forec.github.io/2017/03/02/translation-adit-tum/</id>
    <published>2017-03-02T10:24:20.000Z</published>
    <updated>2018-09-26T06:08:29.384Z</updated>
    
    <content type="html">&lt;blockquote&gt;
&lt;p&gt;这篇文章是 &lt;a href=&quot;https://github.com/egonSchiele&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Aditya Bhargava&lt;/a&gt; 所著 &lt;a href=&quot;http://adit.io/posts/2013-06-10-three-useful-monads.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;《Three Useful Monads》&lt;/a&gt; 的中文译文，已联系原作者取得授权。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;a id=&quot;more&quot;&gt;&lt;/a&gt;
&lt;blockquote&gt;
&lt;p&gt;This Article is the Chinese translation for &lt;a href=&quot;http://adit.io/posts/2013-06-10-three-useful-monads.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;&lt;em&gt;Three Useful Monads&lt;/em&gt;&lt;/a&gt; (Written by &lt;a href=&quot;https://github.com/egonSchiele&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Aditya Bhargava&lt;/a&gt;).&lt;/p&gt;
&lt;/blockquote&gt;
&lt;ul&gt;
&lt;li&gt;英文原文写于 2013 年 6 月 10 日。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;引文&quot;&gt;&lt;a href=&quot;#引文&quot; class=&quot;headerlink&quot; title=&quot;引文&quot;&gt;&lt;/a&gt;引文&lt;/h2&gt;&lt;blockquote&gt;
&lt;p&gt;在阅读本文之前，你应当了解 &lt;code&gt;Monad&lt;/code&gt; 的基本概念，否则请先阅读 &lt;a href=&quot;http://blog.forec.cn/2017/03/02/translation-adit-faamip/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;《图解 Functor, Applicative 和 Monad》&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;下图是函数 &lt;code&gt;half&lt;/code&gt;：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/half.png&quot;&gt;&lt;br&gt;我们可以将其连续应用多次：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;half&lt;/span&gt; . half $ &lt;span class=&quot;number&quot;&gt;8&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;=&amp;gt; &lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;结果与预期一致。现在你决定记录这个函数的执行过程：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/half_with_log.png&quot;&gt;&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;half&lt;/span&gt; x = (x `div` &lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;, &lt;span class=&quot;string&quot;&gt;&quot;I just halved &quot;&lt;/span&gt; ++ (show x) ++ &lt;span class=&quot;string&quot;&gt;&quot;!&quot;&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;看起来不错。如果我们想将其连续应用多次，又该怎么书写呢？我们无法直接使用 &lt;code&gt;half . half $ 8&lt;/code&gt;，因为应用一次 &lt;code&gt;half&lt;/code&gt; 的返回值已经变成了元组，我们无法对元组继续应用 &lt;code&gt;half&lt;/code&gt;。下图展示了我们实际期望的功能：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/half_chain.png&quot;&gt;&lt;br&gt;显然这个功能不会自己产生，我们必须自己实现：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;finalValue&lt;/span&gt; = (val2, log1 ++ log2)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt; (val1, log1) = half &lt;span class=&quot;number&quot;&gt;8&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;          (val2, log2) = half val1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;但是如果需要记录更多的函数呢？这里存在一个模式：我们希望将每个返回 &lt;code&gt;(Value, Log)&lt;/code&gt; 的函数 “串” 到一起。这其实是一种副作用，而 &lt;code&gt;Monad&lt;/code&gt; 刚好擅长处理这种副作用！&lt;/p&gt;
&lt;h2 id=&quot;Writer-Monad&quot;&gt;&lt;a href=&quot;#Writer-Monad&quot; class=&quot;headerlink&quot; title=&quot;Writer Monad&quot;&gt;&lt;/a&gt;Writer Monad&lt;/h2&gt;&lt;p&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/writer_monad_on_a_horse.png&quot;&gt;&lt;br&gt;&lt;code&gt;Writer Monad&lt;/code&gt; 非常酷炫。“老铁，让我来处理这波历史记录”，&lt;code&gt;Writer&lt;/code&gt; 这么说，“我会帮助你的代码恢复整洁，我还能帮你上天！”（原著这里为 “启动齐柏林飞艇”）。每个 &lt;code&gt;Writer&lt;/code&gt; 都包含一个历史记录并回传计算结果。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/writer_monad.png&quot;&gt;&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;typedef&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;data&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Writer&lt;/span&gt; w a = &lt;span class=&quot;type&quot;&gt;Writer&lt;/span&gt; &lt;span class=&quot;container&quot;&gt;&amp;#123; &lt;span class=&quot;title&quot;&gt;runWriter&lt;/span&gt; :: (&lt;span class=&quot;title&quot;&gt;a&lt;/span&gt;, &lt;span class=&quot;title&quot;&gt;w&lt;/span&gt;) &amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Writer&lt;/code&gt; 允许我们这么写代码：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;half&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;8&lt;/span&gt; &amp;gt;&amp;gt;= half&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;或者你可以用 &lt;code&gt;&amp;lt;=&amp;lt;&lt;/code&gt;，它实现了 &lt;code&gt;Monad&lt;/code&gt; 版本的函数复合：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;half&lt;/span&gt; &amp;lt;=&amp;lt; half $ &lt;span class=&quot;number&quot;&gt;8&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;非常接近 &lt;code&gt;half . half $ 8&lt;/code&gt; 的写法！一颗赛艇！&lt;br&gt;我们使用 &lt;code&gt;tell&lt;/code&gt; 来写入历史记录，用 &lt;code&gt;return&lt;/code&gt; 将一个普通的值放入 &lt;code&gt;Writer&lt;/code&gt; 的返回值。这是 &lt;code&gt;Writer&lt;/code&gt; 版本的 &lt;code&gt;half&lt;/code&gt; 函数：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;half&lt;/span&gt; :: &lt;span class=&quot;type&quot;&gt;Int&lt;/span&gt; -&amp;gt; &lt;span class=&quot;type&quot;&gt;Writer&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Int&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;half&lt;/span&gt; x = &lt;span class=&quot;keyword&quot;&gt;do&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;        tell (&lt;span class=&quot;string&quot;&gt;&quot;I just halved &quot;&lt;/span&gt; ++ (show x) ++ &lt;span class=&quot;string&quot;&gt;&quot;!&quot;&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;        return (x `div` &lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;新的 &lt;code&gt;half&lt;/code&gt; 会回传一个 &lt;code&gt;Writer&lt;/code&gt;：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/half_writer.png&quot;&gt;&lt;br&gt;&lt;code&gt;runWriter&lt;/code&gt; 能帮助我们取出 &lt;code&gt;Writer&lt;/code&gt; 封装的元组。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/run_writer.png&quot;&gt;&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;runWriter&lt;/span&gt; $ half &lt;span class=&quot;number&quot;&gt;8&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;=&amp;gt; (&lt;span class=&quot;number&quot;&gt;4&lt;/span&gt;, &lt;span class=&quot;string&quot;&gt;&quot;I just halved 8!&quot;&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;然而，真正牛逼的地方在于，我们现在可以用 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 把 &lt;code&gt;half&lt;/code&gt; 串起来了：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;runWriter&lt;/span&gt; $ half &lt;span class=&quot;number&quot;&gt;8&lt;/span&gt; &amp;gt;&amp;gt;= half&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;=&amp;gt; (&lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;, &lt;span class=&quot;string&quot;&gt;&quot;I just halved 8!I just halved 4!&quot;&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;下图说明了上面这行代码的原理：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/half_monad_chain.png&quot;&gt;&lt;br&gt;我们不需要写任何繁杂的代码，因为 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 知道如何将两个 &lt;code&gt;Writer&lt;/code&gt; 合并（做 &lt;code&gt;Monad&lt;/code&gt; 最重要的是整整齐齐了）！下面是 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 针对 &lt;code&gt;Writer&lt;/code&gt; 的完整定义：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/writer_bind_definition.png&quot;&gt;&lt;br&gt;其实这就是我们之前写过的样本代码，不过现在 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 帮助我们简化了。别忘了我们还有 &lt;code&gt;return&lt;/code&gt;，它将一个值放入 &lt;code&gt;Monad&lt;/code&gt; 中，对于 &lt;code&gt;Writer&lt;/code&gt; 而言其作用如下图：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/writer_return_definition.png&quot;&gt;&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;return&lt;/span&gt; val = &lt;span class=&quot;type&quot;&gt;Writer&lt;/span&gt; (val, &lt;span class=&quot;string&quot;&gt;&quot;&quot;&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;（&lt;strong&gt;注意&lt;/strong&gt;：这些定义 &lt;em&gt;可视作&lt;/em&gt; 正确的。实际的 &lt;code&gt;Writer Monad&lt;/code&gt; 允许将任何 &lt;code&gt;Monoid&lt;/code&gt; 类型作为 “历史记录”，而不仅限于字符串。这里我用字符串简化以帮助你理解。）&lt;br&gt;感谢 &lt;code&gt;Writer Monad&lt;/code&gt; ！&lt;/p&gt;
&lt;h2 id=&quot;Reader-Monad&quot;&gt;&lt;a href=&quot;#Reader-Monad&quot; class=&quot;headerlink&quot; title=&quot;Reader Monad&quot;&gt;&lt;/a&gt;Reader Monad&lt;/h2&gt;&lt;p&gt;假如你想将一些配置传递给许多函数，不妨试试 &lt;code&gt;Reader Monad&lt;/code&gt;！&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/reader_monad.png&quot;&gt;&lt;br&gt;&lt;code&gt;Reader Monad&lt;/code&gt; 允许你将一个值传递给所有幕后的函数。举个例子：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;greeter&lt;/span&gt; :: &lt;span class=&quot;type&quot;&gt;Reader&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;greeter&lt;/span&gt; = &lt;span class=&quot;keyword&quot;&gt;do&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    name &amp;lt;- ask&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    return (&lt;span class=&quot;string&quot;&gt;&quot;hello, &quot;&lt;/span&gt; ++ name ++ &lt;span class=&quot;string&quot;&gt;&quot;!&quot;&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;greeter&lt;/code&gt; 回传一个 &lt;code&gt;Reader Monad&lt;/code&gt;：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/greeter_reader.png&quot;&gt;&lt;br&gt;下面是 &lt;code&gt;Reader&lt;/code&gt; 的定义：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;typedef&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;data&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Reader&lt;/span&gt; r a = &lt;span class=&quot;type&quot;&gt;Reader&lt;/span&gt; &lt;span class=&quot;container&quot;&gt;&amp;#123;  &lt;span class=&quot;title&quot;&gt;runReader&lt;/span&gt; :: &lt;span class=&quot;title&quot;&gt;r&lt;/span&gt; -&amp;gt; &lt;span class=&quot;title&quot;&gt;a&lt;/span&gt; &amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Reader&lt;/code&gt; 的唯一字段是一个函数，&lt;code&gt;runReader&lt;/code&gt; 可以取出这个函数：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/run_reader.png&quot;&gt;&lt;br&gt;现在你可以给这个函数一些输入，它们将会被 &lt;code&gt;greeter&lt;/code&gt; 应用：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/run_reader_expanded.png&quot;&gt;&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;runReader&lt;/span&gt; greeter $ &lt;span class=&quot;string&quot;&gt;&quot;adit&quot;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;=&amp;gt; &lt;span class=&quot;string&quot;&gt;&quot;hello, adit!&quot;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;每当你使用 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 都会得到一个 &lt;code&gt;Reader&lt;/code&gt;，当你向该 &lt;code&gt;Reader&lt;/code&gt; 传入一个状态时，这个状态会被传递给 monad 中的每个函数。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/reader_bind_definition.png&quot;&gt;&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;m&lt;/span&gt; &amp;gt;&amp;gt;= k  = &lt;span class=&quot;type&quot;&gt;Reader&lt;/span&gt; $ \r -&amp;gt; runReader (k (runReader m r)) r&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Reader&lt;/code&gt; 有些复杂，不过复杂的才是最吼的。&lt;br&gt;&lt;code&gt;return&lt;/code&gt; 将一个值放入 &lt;code&gt;Reader&lt;/code&gt; ：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/reader_return_definition.png&quot;&gt;&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;return&lt;/span&gt; a = &lt;span class=&quot;type&quot;&gt;Reader&lt;/span&gt; $ \_ -&amp;gt; a&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;ask&lt;/code&gt; 将传入的状态回传：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;ask&lt;/span&gt; = &lt;span class=&quot;type&quot;&gt;Reader&lt;/span&gt; $ \x -&amp;gt; x&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;想了解更多关于 &lt;code&gt;Reader&lt;/code&gt; 的内容吗？你可以在 &lt;a href=&quot;https://gist.github.com/egonSchiele/5752172&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;这里&lt;/a&gt; 看到一个更长的例子（需翻墙）。&lt;/p&gt;
&lt;h2 id=&quot;State-Monad&quot;&gt;&lt;a href=&quot;#State-Monad&quot; class=&quot;headerlink&quot; title=&quot;State Monad&quot;&gt;&lt;/a&gt;State Monad&lt;/h2&gt;&lt;p&gt;&lt;code&gt;State Monad&lt;/code&gt; 是 &lt;code&gt;Reader Monad&lt;/code&gt; 最好的朋友：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/state_monad.png&quot;&gt;&lt;br&gt;她看起来和 &lt;code&gt;Reader Monad&lt;/code&gt; 非常像，只不过它既可读又可写。这是 &lt;code&gt;State&lt;/code&gt; 的定义：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;State&lt;/span&gt; s a = &lt;span class=&quot;type&quot;&gt;State&lt;/span&gt; &amp;#123; runState :: s -&amp;gt; (a, s) &amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/run_state_expanded.png&quot;&gt;&lt;br&gt;你可以使用 &lt;code&gt;get&lt;/code&gt; 获取状态，也可用 &lt;code&gt;put&lt;/code&gt; 改变状态。举个例子：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;greeter&lt;/span&gt; :: &lt;span class=&quot;type&quot;&gt;State&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;greeter&lt;/span&gt; = &lt;span class=&quot;keyword&quot;&gt;do&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    name &amp;lt;- get&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    put &lt;span class=&quot;string&quot;&gt;&quot;tintin&quot;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    return (&lt;span class=&quot;string&quot;&gt;&quot;hello, &quot;&lt;/span&gt; ++ name ++ &lt;span class=&quot;string&quot;&gt;&quot;!&quot;&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;runState&lt;/span&gt; greeter $ &lt;span class=&quot;string&quot;&gt;&quot;adit&quot;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;=&amp;gt; (&lt;span class=&quot;string&quot;&gt;&quot;hello, adit!&quot;&lt;/span&gt;, &lt;span class=&quot;string&quot;&gt;&quot;tintin&quot;&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;没毛病！&lt;code&gt;Reader&lt;/code&gt; 就像在说 “你无法改变我”，而 &lt;code&gt;State&lt;/code&gt; 则对改变持兹瓷态度。&lt;br&gt;&lt;code&gt;State&lt;/code&gt; 和 &lt;code&gt;Reader&lt;/code&gt; 的定义看起来非常相似：&lt;br&gt;&lt;code&gt;return&lt;/code&gt;：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/state_return_definition.png&quot;&gt;&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;return&lt;/span&gt; a = &lt;span class=&quot;type&quot;&gt;State&lt;/span&gt; $ \s -&amp;gt; (a, s)&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt;：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/state_bind_definition.png&quot;&gt;&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;m&lt;/span&gt; &amp;gt;&amp;gt;= k = &lt;span class=&quot;type&quot;&gt;State&lt;/span&gt; $ \s -&amp;gt; &lt;span class=&quot;keyword&quot;&gt;let&lt;/span&gt; (a, s&#39;) = runState m s&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                         &lt;span class=&quot;keyword&quot;&gt;in&lt;/span&gt; runState (k a) s&#39;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;h2 id=&quot;总结&quot;&gt;&lt;a href=&quot;#总结&quot; class=&quot;headerlink&quot; title=&quot;总结&quot;&gt;&lt;/a&gt;总结&lt;/h2&gt;&lt;p&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-tum/conclusion.png&quot;&gt;&lt;br&gt;&lt;code&gt;Writer&lt;/code&gt;、&lt;code&gt;Reader&lt;/code&gt;、&lt;code&gt;State&lt;/code&gt;。现在你已经将这三个强大的武器添加到你的兵器库了，请不遗余力地使用它们！&lt;/p&gt;
&lt;h2 id=&quot;参考资料&quot;&gt;&lt;a href=&quot;#参考资料&quot; class=&quot;headerlink&quot; title=&quot;参考资料&quot;&gt;&lt;/a&gt;参考资料&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;http://sigfpe.blogspot.com/2006/08/you-could-have-invented-monads-and.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Why Monads are useful&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;http://www.maztravel.com/haskell/readerMonad.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;A good explaination of the Reader monad&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;p&gt;英文原文链接： &lt;a href=&quot;http://adit.io/posts/2013-06-10-three-useful-monads.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;&lt;em&gt;Three Useful Monads&lt;/em&gt;&lt;/a&gt; （Written by &lt;a href=&quot;https://github.com/egonSchiele&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Aditya Bhargava&lt;/a&gt;）   &lt;/p&gt;
&lt;p&gt;原创作品，允许转载，转载时无需告知，但请务必以超链接形式标明文章&lt;a href=&quot;http://blog.forec.cn/2017/03/02/translation-adit-tum/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;原始出处&lt;/a&gt;(&lt;a href=&quot;http://blog.forec.cn/2017/03/02/translation-adit-tum/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;http://blog.forec.cn/2017/03/02/translation-adit-tum/&lt;/a&gt;) 、作者信息（&lt;a href=&quot;http://forec.cn/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Forec&lt;/a&gt;）和本声明。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;blockquote&gt;
&lt;p&gt;这篇文章是 &lt;a href=&quot;https://github.com/egonSchiele&quot;&gt;Aditya Bhargava&lt;/a&gt; 所著 &lt;a href=&quot;http://adit.io/posts/2013-06-10-three-useful-monads.html&quot;&gt;《Three Useful Monads》&lt;/a&gt; 的中文译文，已联系原作者取得授权。&lt;/p&gt;
&lt;/blockquote&gt;
    
    </summary>
    
      <category term="Code" scheme="http://forec.github.io/categories/Code/"/>
    
    
      <category term="Haskell" scheme="http://forec.github.io/tags/Haskell/"/>
    
      <category term="函数式编程" scheme="http://forec.github.io/tags/%E5%87%BD%E6%95%B0%E5%BC%8F%E7%BC%96%E7%A8%8B/"/>
    
  </entry>
  
  <entry>
    <title>图解 Functor, Applicative 和 Monad</title>
    <link href="http://forec.github.io/2017/03/02/translation-adit-faamip/"/>
    <id>http://forec.github.io/2017/03/02/translation-adit-faamip/</id>
    <published>2017-03-02T06:07:40.000Z</published>
    <updated>2018-09-26T06:08:28.911Z</updated>
    
    <content type="html">&lt;blockquote&gt;
&lt;p&gt;这篇文章是 &lt;a href=&quot;https://github.com/egonSchiele&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Aditya Bhargava&lt;/a&gt; 所著 &lt;a href=&quot;http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;《Functors, Applicatives, And Monads In Pictures》&lt;/a&gt; 的中文译文，已联系原作者取得授权。另一版本的中文译文由 &lt;a href=&quot;https://github.com/jiyinyiyong&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;题叶&lt;/a&gt; 翻译，可在&lt;a href=&quot;http://jiyinyiyong.github.io/monads-in-pictures/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;此处&lt;/a&gt;查看。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;a id=&quot;more&quot;&gt;&lt;/a&gt;
&lt;blockquote&gt;
&lt;p&gt;This Article is the Chinese translation for &lt;a href=&quot;http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;&lt;em&gt;Functors, Applicatives, And Monads In Pictures&lt;/em&gt;&lt;/a&gt; (Written by &lt;a href=&quot;https://github.com/egonSchiele&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Aditya Bhargava&lt;/a&gt;).&lt;/p&gt;
&lt;/blockquote&gt;
&lt;ul&gt;
&lt;li&gt;英文原文写于 2013 年 4 月 17 日。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;引文&quot;&gt;&lt;a href=&quot;#引文&quot; class=&quot;headerlink&quot; title=&quot;引文&quot;&gt;&lt;/a&gt;引文&lt;/h2&gt;&lt;p&gt;下图是一个简单的值：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/value.png&quot;&gt;&lt;br&gt;将一个函数应用到这个值上：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/value_apply.png&quot;&gt;&lt;br&gt;简直 Naive，让我们来扩展一个！假设一个值可以被放到上下文中。你可以把上下文想象成一个盒子，把值放入上下文的过程就如同把东西放到盒子里：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/value_and_context.png&quot;&gt;&lt;br&gt;现在再把一个函数应用到这个值上，&lt;strong&gt;根据不同的上下文&lt;/strong&gt;，我们将得到不同的结果。这就是 &lt;code&gt;Functor&lt;/code&gt;、&lt;code&gt;Applicative&lt;/code&gt;、&lt;code&gt;Monad&lt;/code&gt;、&lt;code&gt;Arrows&lt;/code&gt; 等概念的基础。就 &lt;code&gt;Maybe&lt;/code&gt; 这一型别来说，它定义了两种相关联的上下文：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/context.png&quot;&gt;&lt;br&gt;马上我们就会看到对 &lt;code&gt;Just a&lt;/code&gt; 和 &lt;code&gt;Nothing&lt;/code&gt; 应用一个函数的不同之处。在此之前，让我们先了解一下 &lt;code&gt;Functor&lt;/code&gt; !&lt;/p&gt;
&lt;h2 id=&quot;Functors&quot;&gt;&lt;a href=&quot;#Functors&quot; class=&quot;headerlink&quot; title=&quot;Functors&quot;&gt;&lt;/a&gt;Functors&lt;/h2&gt;&lt;p&gt;如果一个值被封装在上下文中，你会发现普通函数无法直接对其操作：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/no_fmap_ouch.png&quot;&gt;&lt;br&gt;这时 &lt;code&gt;fmap&lt;/code&gt; 就会发挥作用了！&lt;code&gt;fmap&lt;/code&gt; 能够和上下文谈笑风生，它对普通函数和被上下文包装的值施了一点魔法，让它们能够愉快相处。举个例子，你想把函数 &lt;code&gt;(+3)&lt;/code&gt; 应用到 &lt;code&gt;Just 2&lt;/code&gt; 上，那么只需要加上 &lt;code&gt;fmap&lt;/code&gt;：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; fmap (+&lt;span class=&quot;number&quot;&gt;3&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;5&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/fmap_apply.png&quot;&gt;&lt;br&gt;一颗赛艇！&lt;code&gt;fmap&lt;/code&gt; 向我们展示了它的威力！但是 &lt;code&gt;fmap&lt;/code&gt; 怎么知道如何应用一个函数呢？&lt;/p&gt;
&lt;h2 id=&quot;什么是-Functor&quot;&gt;&lt;a href=&quot;#什么是-Functor&quot; class=&quot;headerlink&quot; title=&quot;什么是 Functor&quot;&gt;&lt;/a&gt;什么是 Functor&lt;/h2&gt;&lt;p&gt;&lt;code&gt;Functor&lt;/code&gt; 是一个 &lt;a href=&quot;http://learnyouahaskell.com/types-and-typeclasses#typeclasses-101&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;类型类&lt;/a&gt;，这是它的定义：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/functor_def.png&quot;&gt;&lt;br&gt;任何型别，只要能用 &lt;code&gt;fmap&lt;/code&gt; 操作，就是一个 &lt;code&gt;Functor&lt;/code&gt;。下面这张图展示了 &lt;code&gt;fmap&lt;/code&gt; 各个参数的含义：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/fmap_def.png&quot;&gt;&lt;br&gt;我们之所以能够执行 &lt;code&gt;fmap (+3) (Just 2)&lt;/code&gt; ，是因为 &lt;code&gt;Maybe&lt;/code&gt; 也是一个 &lt;code&gt;Functor&lt;/code&gt; 。下面的定义指明了 &lt;code&gt;fmap&lt;/code&gt; 在面对 &lt;code&gt;Just&lt;/code&gt; 和 &lt;code&gt;Nothing&lt;/code&gt; 时的处理方式：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;instance&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Functor&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Maybe&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    fmap func (&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; val) = &lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; (func val)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    fmap func &lt;span class=&quot;type&quot;&gt;Nothing&lt;/span&gt; = &lt;span class=&quot;type&quot;&gt;Nothing&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;下图说明了执行 &lt;code&gt;fmap (+3) (Just 2)&lt;/code&gt; 的整个过程：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/fmap_just.png&quot;&gt;&lt;br&gt;假设你灵机一动，让 &lt;code&gt;fmap&lt;/code&gt; 把 &lt;code&gt;(+3)&lt;/code&gt; 应用到 &lt;code&gt;Nothing&lt;/code&gt; 上：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/fmap_nothing.png&quot;&gt;&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; fmap (+&lt;span class=&quot;number&quot;&gt;3&lt;/span&gt;) &lt;span class=&quot;type&quot;&gt;Nothing&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;Nothing&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/baozou.jpg&quot;&gt;&lt;br&gt;就像身经百战的董先森（原文为黑客帝国里的墨菲斯，我也不知作者这么比喻是为啥），&lt;code&gt;fmap&lt;/code&gt; 知道自己该做什么：从 &lt;code&gt;Nothing&lt;/code&gt; 开始就从 &lt;code&gt;Nothing&lt;/code&gt; 结束！这也是 &lt;code&gt;Maybe&lt;/code&gt; 类型存在的意义。我们通常使用类似如下的 Python 代码处理数据库：&lt;br&gt;&lt;figure class=&quot;highlight python&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;post = Post.find_by_id(&lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;if&lt;/span&gt; post:&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  &lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt; post.title&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;else&lt;/span&gt;:&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  &lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;None&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;用 &lt;code&gt;Haskell&lt;/code&gt; 可以写成 &lt;code&gt;fmap (getPostTitle) (findPost 1)&lt;/code&gt;。如果 &lt;code&gt;findPost&lt;/code&gt; 返回了一篇文章，我们就可以通过 &lt;code&gt;getPostTitle&lt;/code&gt; 获取其标题。如果 &lt;code&gt;findPost&lt;/code&gt; 返回了 &lt;code&gt;Nothing&lt;/code&gt;，我们当然也应该返回 &lt;code&gt;Nothing&lt;/code&gt;！是不是很简洁？&lt;code&gt;&amp;lt;$&amp;gt;&lt;/code&gt; 是 &lt;code&gt;fmap&lt;/code&gt; 的中缀版本，所以写成 &lt;code&gt;getPostTitle &amp;lt;$&amp;gt; (findPost 1)&lt;/code&gt; 也是允许的，并且这种写法更常见。&lt;/p&gt;
&lt;p&gt;再来看一个例子：把一个函数应用到 &lt;code&gt;List&lt;/code&gt; 上会发生什么呢？&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/fmap_list.png&quot;&gt;&lt;br&gt;&lt;code&gt;List&lt;/code&gt; 也是 &lt;code&gt;Functor&lt;/code&gt;！这是它的定义：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;instance&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Functor&lt;/span&gt; [] &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  fmap = map&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;我想你应该理解得差不多了，最后一个例子：如果把函数应用到另一个函数上呢，比如 &lt;code&gt;fmap (+3) (+1)&lt;/code&gt; ？&lt;/p&gt;
&lt;p&gt;这是一个函数：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/function_with_value.png&quot;&gt;&lt;br&gt;将某个函数应用到另一个函数：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/fmap_function.png&quot;&gt;&lt;br&gt;得到的结果是一个新函数！&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; &lt;span class=&quot;import&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;import&lt;/span&gt; Control.Applicative&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; &lt;span class=&quot;keyword&quot;&gt;let&lt;/span&gt; foo = fmap (+&lt;span class=&quot;number&quot;&gt;3&lt;/span&gt;) (+&lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; foo &lt;span class=&quot;number&quot;&gt;10&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;number&quot;&gt;15&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;由此可见，函数同样是 &lt;code&gt;Functor&lt;/code&gt;：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;instance&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Functor&lt;/span&gt; &lt;span class=&quot;container&quot;&gt;((-&amp;gt;)&lt;/span&gt; r) &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  fmap f g = f . g&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;函数的 &lt;code&gt;fmap&lt;/code&gt; 其实就是函数复合。&lt;/p&gt;
&lt;h2 id=&quot;Applicative&quot;&gt;&lt;a href=&quot;#Applicative&quot; class=&quot;headerlink&quot; title=&quot;Applicative&quot;&gt;&lt;/a&gt;Applicative&lt;/h2&gt;&lt;p&gt;&lt;code&gt;Applicative&lt;/code&gt; 将 &lt;code&gt;Functor&lt;/code&gt; 又提高了一个层次。与 &lt;code&gt;Functor&lt;/code&gt; 类似，&lt;code&gt;Applicative&lt;/code&gt; 中的值也被封装在上下文中：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/value_and_context.png&quot;&gt;&lt;br&gt;不同之处在于，现在函数也被封装到上下文中：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/function_and_context.png&quot;&gt;&lt;br&gt;&lt;code&gt;Control.Applicative&lt;/code&gt; 定义了 &lt;code&gt;&amp;lt;*&amp;gt;&lt;/code&gt;，它知道如何将一个 &lt;em&gt;包装在上下文中的&lt;/em&gt; 函数应用到 &lt;em&gt;包装在上下文的&lt;/em&gt; 值上。举个例子，&lt;code&gt;Just (+3) &amp;lt;*&amp;gt; Just 2 == Just 5&lt;/code&gt;：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/applicative_just.png&quot;&gt;&lt;br&gt;使用 &lt;code&gt;&amp;lt;*&amp;gt;&lt;/code&gt; 会产生很多有趣的情况，看看下面的 &lt;code&gt;List&lt;/code&gt; 会发生什么：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; [(*&lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;), (+&lt;span class=&quot;number&quot;&gt;3&lt;/span&gt;)] &amp;lt;*&amp;gt; [&lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;, &lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;, &lt;span class=&quot;number&quot;&gt;3&lt;/span&gt;]&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;[&lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;, &lt;span class=&quot;number&quot;&gt;4&lt;/span&gt;, &lt;span class=&quot;number&quot;&gt;6&lt;/span&gt;, &lt;span class=&quot;number&quot;&gt;4&lt;/span&gt;, &lt;span class=&quot;number&quot;&gt;5&lt;/span&gt;, &lt;span class=&quot;number&quot;&gt;6&lt;/span&gt;]&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/applicative_list.png&quot;&gt;&lt;br&gt;下面是一些 &lt;code&gt;Applicative&lt;/code&gt; 有而 &lt;code&gt;Functor&lt;/code&gt; 不具备的功能。如何将一个接收两个参数的函数应用到两个被封装的值呢？&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; (+) &amp;lt;$&amp;gt; (&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;5&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; (+&lt;span class=&quot;number&quot;&gt;5&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; &lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; (+&lt;span class=&quot;number&quot;&gt;5&lt;/span&gt;) &amp;lt;$&amp;gt; (&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;4&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;ERROR&lt;/span&gt; ??? &lt;span class=&quot;type&quot;&gt;WHAT&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;DOES&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;THIS&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;EVEN&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;MEAN&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;WHY&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;IS&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;THE&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;FUNCTION&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;WRAPPED&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;IN&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;A&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;JUST&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Applicative&lt;/code&gt;：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; (+) &amp;lt;$&amp;gt; (&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;5&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; (+&lt;span class=&quot;number&quot;&gt;5&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; &lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; (+&lt;span class=&quot;number&quot;&gt;5&lt;/span&gt;) &amp;lt;*&amp;gt; (&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;3&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;8&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Applicative&lt;/code&gt; 把 &lt;code&gt;Functor&lt;/code&gt; 丢到了一边。“我今天就教你们一点人生经验”，&lt;code&gt;Applicative&lt;/code&gt; 如是说，“在装备了 &lt;code&gt;&amp;lt;$&amp;gt;&lt;/code&gt; 和 &lt;code&gt;&amp;lt;*&amp;gt;&lt;/code&gt; 后，我可以接受任何函数，之后我把对应的封装值喂给它们，最后我就得到了一个封装好的值！哈哈哈哈哈！”&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; (*) &amp;lt;$&amp;gt; &lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;5&lt;/span&gt; &amp;lt;*&amp;gt; &lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;3&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;15&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;对了，这种模式可以用 &lt;code&gt;liftA2&lt;/code&gt; 简化：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; liftA2 (*) (&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;5&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;3&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;15&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;h2 id=&quot;Monad&quot;&gt;&lt;a href=&quot;#Monad&quot; class=&quot;headerlink&quot; title=&quot;Monad&quot;&gt;&lt;/a&gt;Monad&lt;/h2&gt;&lt;p&gt;如何学习 &lt;code&gt;Monad&lt;/code&gt;：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;在计算机科学专业取得博士学位。&lt;/li&gt;
&lt;li&gt;不学。因为这一节你根本用不到它！&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;code&gt;Functor&lt;/code&gt; 将一个普通函数应用到被封装的值上：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/fmap.png&quot;&gt;&lt;br&gt;&lt;code&gt;Applicative&lt;/code&gt; 将一个封装的函数应用到封装值上：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/applicative.png&quot;&gt;&lt;br&gt;&lt;code&gt;Monad&lt;/code&gt; 将一个 &lt;strong&gt;“接受一个普通值并回传一个被封装的值”&lt;/strong&gt; 的函数应用到一个被封装的值上，这一任务由函数 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; （读作 “bind”）完成。听起来似乎很拗口，让我们来看个例子吧，还是熟悉的 &lt;code&gt;Maybe&lt;/code&gt;：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/context.png&quot;&gt;&lt;br&gt;假设 &lt;code&gt;half&lt;/code&gt; 是只对偶数感兴趣的函数：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;half&lt;/span&gt; x = &lt;span class=&quot;keyword&quot;&gt;if&lt;/span&gt; even x&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;         &lt;span class=&quot;keyword&quot;&gt;then&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; (x `div` &lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;         &lt;span class=&quot;keyword&quot;&gt;else&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Nothing&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/half.png&quot;&gt;&lt;br&gt;如果给 &lt;code&gt;half&lt;/code&gt; 一个被封装的值会怎样？&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/half_ouch.png&quot;&gt;&lt;br&gt;这时我们需要用 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 把被封装的值挤到 &lt;code&gt;half&lt;/code&gt; 中。看看 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 的照片：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/plunger.jpg&quot;&gt;&lt;br&gt;再看看它的效果：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; &lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;3&lt;/span&gt; &amp;gt;&amp;gt;= half&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;Nothing&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; &lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;4&lt;/span&gt; &amp;gt;&amp;gt;= half&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;gt; &lt;span class=&quot;type&quot;&gt;Nothing&lt;/span&gt; &amp;gt;&amp;gt;= half&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;type&quot;&gt;Nothing&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;这其中究竟发生了什么？&lt;code&gt;Monad&lt;/code&gt; 是另一种类型类，这是它定义的一部分：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Monad&lt;/span&gt; m &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  (&amp;gt;&amp;gt;=) :: m a -&amp;gt; (a -&amp;gt; m b) -&amp;gt; m b&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;下图展示了 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 各个参数的意义：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/bind_def.png&quot;&gt;&lt;br&gt;下面的定义让 &lt;code&gt;Maybe&lt;/code&gt; 成为了 &lt;code&gt;Monad&lt;/code&gt;：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;instance&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Monad&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Maybe&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;type&quot;&gt;Nothing&lt;/span&gt; &amp;gt;&amp;gt;= func = &lt;span class=&quot;type&quot;&gt;Nothing&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;type&quot;&gt;Just&lt;/span&gt; val &amp;gt;&amp;gt;= func  = func val&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;来看看执行 &lt;code&gt;Just 3 &amp;gt;&amp;gt;= half&lt;/code&gt; 时发生了什么：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/monad_just.png&quot;&gt;&lt;br&gt;如果传入 &lt;code&gt;Nothing&lt;/code&gt; 就更容易了：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/monad_nothing.png&quot;&gt;&lt;br&gt;这些调用过程还可以被连起来，比如执行 &lt;code&gt;Just 20 &amp;gt;&amp;gt;= half &amp;gt;&amp;gt;= half &amp;gt;&amp;gt;= half&lt;/code&gt; 会得到 &lt;code&gt;Nothing&lt;/code&gt;：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/monad_chain.png&quot;&gt;&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/whoa.png&quot;&gt;&lt;br&gt;流弊！现在我们知道，&lt;code&gt;Maybe&lt;/code&gt; 既是 &lt;code&gt;Functor&lt;/code&gt;，又是 &lt;code&gt;Applicative&lt;/code&gt;，还是 &lt;code&gt;Monad&lt;/code&gt;。   &lt;/p&gt;
&lt;p&gt;再来看另一个例子：&lt;code&gt;IO Monad&lt;/code&gt;。&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/io.png&quot;&gt;    &lt;/p&gt;
&lt;p&gt;介绍三个函数先。  &lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;getLine&lt;/code&gt; 不接受参数并获取用户输入（&lt;code&gt;getLine :: IO String&lt;/code&gt;）：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/getLine.png&quot;&gt;    &lt;/li&gt;
&lt;li&gt;&lt;code&gt;readFile&lt;/code&gt; 接受一个字符串（文件路径）并返回文件的内容（&lt;code&gt;readFile :: FilePath -&amp;gt; IO String&lt;/code&gt;，&lt;code&gt;FilePath&lt;/code&gt; 是 &lt;code&gt;String&lt;/code&gt; 的别名）：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/readFile.png&quot;&gt;    &lt;/li&gt;
&lt;li&gt;&lt;code&gt;putStrLn&lt;/code&gt; 接受一个字符串并打印它（&lt;code&gt;putStrLn :: String -&amp;gt; IO ()&lt;/code&gt;）：&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/putStrLn.png&quot;&gt;    &lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这三个函数都接受一个正常的值（或者不接受值）并且回传一个被封装在 &lt;code&gt;IO Monad&lt;/code&gt; 中的值。我们可以用 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 把它们串起来！&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/monad_io.png&quot;&gt;&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;getLine&lt;/span&gt; &amp;gt;&amp;gt;= readFile &amp;gt;&amp;gt;= putStrLn&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;p&gt;Haskell 还为我们提供了 &lt;code&gt;do&lt;/code&gt;，它是 &lt;code&gt;Monad&lt;/code&gt; 的语法糖：&lt;br&gt;&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;foo&lt;/span&gt; = &lt;span class=&quot;keyword&quot;&gt;do&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    filename &amp;lt;- getLine&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    contents &amp;lt;- readFile filename&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    putStrLn contents&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;/p&gt;
&lt;h2 id=&quot;总结&quot;&gt;&lt;a href=&quot;#总结&quot; class=&quot;headerlink&quot; title=&quot;总结&quot;&gt;&lt;/a&gt;总结&lt;/h2&gt;&lt;ol&gt;
&lt;li&gt;实现了 &lt;code&gt;Functor&lt;/code&gt; 类型类的数据类型被称为 functor。&lt;/li&gt;
&lt;li&gt;实现了 &lt;code&gt;Applicative&lt;/code&gt; 类型类的数据类型被称为 applicative。&lt;/li&gt;
&lt;li&gt;实现了 &lt;code&gt;Monad&lt;/code&gt; 类型类的数据类型被称为 monad。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Maybe&lt;/code&gt; 实现了这三种类型类，所以它同时是 functor、applicative 和 monad。   &lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;它们三个之间的区别是什么呢？&lt;br&gt;&lt;img src=&quot;http://qiniu.forec.cn/adit-faamip/recap.png&quot;&gt;    &lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;functors&lt;/code&gt;&lt;/strong&gt; ：使用 &lt;code&gt;fmap&lt;/code&gt; 或 &lt;code&gt;&amp;lt;$&amp;gt;&lt;/code&gt; 把一个普通函数应用到被封装的值上&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;applicatives&lt;/code&gt;&lt;/strong&gt; ：使用 &lt;code&gt;&amp;lt;*&amp;gt;&lt;/code&gt; 或 &lt;code&gt;liftA&lt;/code&gt; 把一个被封装的函数应用到被封装的值上&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;monads&lt;/code&gt;&lt;/strong&gt; ：使用 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 或 &lt;code&gt;liftM&lt;/code&gt; 把一个接受普通值、回传封装值的函数应用到一个被封装的值上&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;亲爱的朋友（我觉得我们算是朋友了），现在你是否觉得 monad 是一个简单并聪明的概念呢？既然你已经读完了这篇 “科普文”，不如进一步了解一下 monad：LYAH 编写的 &lt;a href=&quot;http://learnyouahaskell.com/a-fistful-of-monads&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Monad 章节&lt;/a&gt; 中包含了许多我在本文中忽略的信息，他写的非常棒，我就不在此赘述了。&lt;/p&gt;
&lt;p&gt;更多与 Monad 相关的图文介绍，请看 &lt;a href=&quot;http://blog.forec.cn/2017/03/02/translation-adit-tum/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;三种实用 monad&lt;/a&gt;。&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;英文原文链接： &lt;a href=&quot;http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;&lt;em&gt;Functors, Applicatives, And Monads In Pictures&lt;/em&gt;&lt;/a&gt;  （Written by &lt;a href=&quot;https://github.com/egonSchiele&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Aditya Bhargava&lt;/a&gt;） &lt;/p&gt;
&lt;p&gt;原创作品，允许转载，转载时无需告知，但请务必以超链接形式标明文章&lt;a href=&quot;http://blog.forec.cn/2017/03/02/translation-adit-faamip/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;原始出处&lt;/a&gt;(&lt;a href=&quot;http://blog.forec.cn/2017/03/02/translation-adit-faamip/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;http://blog.forec.cn/2017/03/02/translation-adit-faamip/&lt;/a&gt;) 、作者信息（&lt;a href=&quot;http://forec.cn/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Forec&lt;/a&gt;）和本声明。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;blockquote&gt;
&lt;p&gt;这篇文章是 &lt;a href=&quot;https://github.com/egonSchiele&quot;&gt;Aditya Bhargava&lt;/a&gt; 所著 &lt;a href=&quot;http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html&quot;&gt;《Functors, Applicatives, And Monads In Pictures》&lt;/a&gt; 的中文译文，已联系原作者取得授权。另一版本的中文译文由 &lt;a href=&quot;https://github.com/jiyinyiyong&quot;&gt;题叶&lt;/a&gt; 翻译，可在&lt;a href=&quot;http://jiyinyiyong.github.io/monads-in-pictures/&quot;&gt;此处&lt;/a&gt;查看。&lt;/p&gt;
&lt;/blockquote&gt;
    
    </summary>
    
      <category term="Code" scheme="http://forec.github.io/categories/Code/"/>
    
    
      <category term="Haskell" scheme="http://forec.github.io/tags/Haskell/"/>
    
      <category term="函数式编程" scheme="http://forec.github.io/tags/%E5%87%BD%E6%95%B0%E5%BC%8F%E7%BC%96%E7%A8%8B/"/>
    
  </entry>
  
  <entry>
    <title>来看几种基本 Monad</title>
    <link href="http://forec.github.io/2017/03/01/talk-about-some-simple-monads/"/>
    <id>http://forec.github.io/2017/03/01/talk-about-some-simple-monads/</id>
    <published>2017-03-01T13:52:16.000Z</published>
    <updated>2018-09-26T06:08:29.431Z</updated>
    
    <content type="html">&lt;blockquote&gt;
&lt;p&gt;@Fallenwood 选修的 《Foundations of Programming Languages》 课程让我看的很手痒。整理一下基本的 Typeclass 和 Monad，准备跟随贵科步伐重新学习 Haskell。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;a id=&quot;more&quot;&gt;&lt;/a&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;只做整理不做总结，绝不写任何有关自己对 Monad 的理解。&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;基本-Typeclass&quot;&gt;&lt;a href=&quot;#基本-Typeclass&quot; class=&quot;headerlink&quot; title=&quot;基本 Typeclass&quot;&gt;&lt;/a&gt;基本 Typeclass&lt;/h2&gt;&lt;h3 id=&quot;Functor&quot;&gt;&lt;a href=&quot;#Functor&quot; class=&quot;headerlink&quot; title=&quot;Functor&quot;&gt;&lt;/a&gt;Functor&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Functor&lt;/code&gt; （&lt;code&gt;Data.Functor&lt;/code&gt;）类型类表明型别可以被 &lt;code&gt;map&lt;/code&gt; ，类型类声明为：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Functor&lt;/span&gt; f &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  fmap :: (a -&amp;gt; b) -&amp;gt; f a -&amp;gt; f b&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Functor&lt;/code&gt; 类型类定义中 &lt;code&gt;f&lt;/code&gt; 的 kind 是 &lt;code&gt;* -&amp;gt; *&lt;/code&gt;；&lt;code&gt;&amp;lt;$&amp;gt;&lt;/code&gt; 是 &lt;code&gt;fmap&lt;/code&gt; 的语法糖。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Functor&lt;/code&gt; 类型类需要遵守以下守则：&lt;ul&gt;
&lt;li&gt;&lt;code&gt;fmap id = id&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;fmap (f . g) = fmap f . fmap g&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;Applicative&quot;&gt;&lt;a href=&quot;#Applicative&quot; class=&quot;headerlink&quot; title=&quot;Applicative&quot;&gt;&lt;/a&gt;Applicative&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Applicative&lt;/code&gt; （&lt;code&gt;Control.Applicative&lt;/code&gt;）算是 &lt;code&gt;Functor&lt;/code&gt; 的加强版，将一个 “包装” 在某个抽象型别中的函数应用到对应型别的值中，类型类声明为：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;container&quot;&gt;(&lt;span class=&quot;type&quot;&gt;Functor&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;f&lt;/span&gt;)&lt;/span&gt; =&amp;gt; &lt;span class=&quot;type&quot;&gt;Applicative&lt;/span&gt; f &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  pure :: a -&amp;gt; f a&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  (&amp;lt;*&amp;gt;) :: f (a -&amp;gt; b) -&amp;gt; f a -&amp;gt; f b&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  (&amp;lt;*) :: f a -&amp;gt; f b -&amp;gt; f a&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  (*&amp;gt;) :: f a -&amp;gt; f b -&amp;gt; f b&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Applicative&lt;/code&gt; 类型类中定义的型别 &lt;code&gt;f&lt;/code&gt; 必须也是 &lt;code&gt;Functor&lt;/code&gt; 类型类的实例。&lt;code&gt;pure&lt;/code&gt; 函数将值包装到 &lt;code&gt;Applicative Functor&lt;/code&gt; 中。&lt;code&gt;&amp;lt;*&lt;/code&gt; 和 &lt;code&gt;*&amp;gt;&lt;/code&gt; 函数均有默认实现。&lt;/li&gt;
&lt;li&gt;对于一个纯粹的函数 &lt;code&gt;func :: a -&amp;gt; b&lt;/code&gt;，可以通过 &lt;code&gt;fmap&lt;/code&gt; 将其作用到一个 &lt;code&gt;Functor&lt;/code&gt; 类型类上，也可以通过 &lt;code&gt;pure&lt;/code&gt; 将 &lt;code&gt;func&lt;/code&gt; 提升到 &lt;code&gt;Applicative Functor&lt;/code&gt; 中，再利用 &lt;code&gt;&amp;lt;*&amp;gt;&lt;/code&gt; 将其运用到该类型类包装的值上。例如，&lt;code&gt;pure (+) &amp;lt;*&amp;gt; (Just 2) &amp;lt;*&amp;gt; (Just 3)&lt;/code&gt; 的结果是 &lt;code&gt;Just 5&lt;/code&gt;。可以利用 &lt;code&gt;&amp;lt;$&amp;gt;&lt;/code&gt; 这一语法糖简化为 &lt;code&gt;(+) &amp;lt;$&amp;gt; (Just 2) &amp;lt;*&amp;gt; (Just 3)&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Applicative&lt;/code&gt; 类型类需要遵守如下守则（必然也满足 &lt;code&gt;Functor Laws&lt;/code&gt;）：&lt;ul&gt;
&lt;li&gt;&lt;code&gt;pure f &amp;lt;*&amp;gt; x = fmap f x&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;pure id &amp;lt;*&amp;gt; x = x&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;pure (.) &amp;lt;*&amp;gt; u &amp;lt;*&amp;gt; v &amp;lt;*&amp;gt; w = u &amp;lt;*&amp;gt; (v &amp;lt;*&amp;gt; w)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;pure f &amp;lt;*&amp;gt; pure x = pure (f x)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;u &amp;lt;*&amp;gt; pure y = pure ($ y) &amp;lt;*&amp;gt; u&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;Monoid&quot;&gt;&lt;a href=&quot;#Monoid&quot; class=&quot;headerlink&quot; title=&quot;Monoid&quot;&gt;&lt;/a&gt;Monoid&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Monoid&lt;/code&gt; （&lt;code&gt;Data.Monoid&lt;/code&gt;）类型类的定义如下，它对应实例的型别 &lt;code&gt;m&lt;/code&gt; 的 kind 是 &lt;code&gt;*&lt;/code&gt;：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Monoid&lt;/span&gt; m &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  mempty :: m&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  mappend :: m -&amp;gt; m -&amp;gt; m&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  mconcat :: [m] -&amp;gt; m&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  mconcat = foldr mappend mempty&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Monoid&lt;/code&gt; 指群论中的半群，其需满足封闭性和右结合律。&lt;code&gt;Monoid&lt;/code&gt; 的名字看起来像是 &lt;code&gt;mono&lt;/code&gt; 和 &lt;code&gt;id&lt;/code&gt; 的组合，即 “单幺元”。这里的 &lt;code&gt;mempty&lt;/code&gt; 和下面 &lt;code&gt;MonadPlus&lt;/code&gt; 中的 &lt;code&gt;mzero&lt;/code&gt; 均为幺元。&lt;/li&gt;
&lt;li&gt;几种常见的 &lt;code&gt;Monoid&lt;/code&gt; 如： &lt;code&gt;List&lt;/code&gt;、&lt;code&gt;Any&lt;/code&gt;、&lt;code&gt;All&lt;/code&gt;、&lt;code&gt;Sum&lt;/code&gt;、&lt;code&gt;Product&lt;/code&gt;、&lt;code&gt;Ordering&lt;/code&gt;、&lt;code&gt;Maybe&lt;/code&gt; 等。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Monoid&lt;/code&gt; 需要遵守如下守则：&lt;ul&gt;
&lt;li&gt;&lt;code&gt;mappend mempty x = x&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;mappend x mempty = x&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;mappend (mappend x y) z = mappend x (mappend y z)&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Monoid&lt;/code&gt; 也应用在 &lt;code&gt;Foldable&lt;/code&gt; 类型类的 &lt;code&gt;foldMap&lt;/code&gt; 函数中。&lt;code&gt;foldMap&lt;/code&gt; 的型别声明为 &lt;code&gt;(Foldable t, Monoid m) =&amp;gt; (a -&amp;gt; m) -&amp;gt; t a -&amp;gt; m&lt;/code&gt;。可以为自定义类型实作 &lt;code&gt;Foldable&lt;/code&gt; 类型类，即可通过 &lt;code&gt;foldMap&lt;/code&gt; 对自定义类型的元素做 map over、折叠等操作。注意 &lt;code&gt;foldMap&lt;/code&gt; 和 &lt;code&gt;fmap&lt;/code&gt; 的区别在于 &lt;code&gt;foldMap&lt;/code&gt; 不会将函数返回值再次包装到原类型类中，而是包装到 &lt;code&gt;Monoid&lt;/code&gt; 中。举个例子，对于自定义类型 &lt;code&gt;data Tree a = Node a (Tree a) (Tree a) | Empty&lt;/code&gt;，要想确定树中有无小于 0 的元素，只需 &lt;code&gt;getAny $ foldMap (\x -&amp;gt; Any $ x &amp;lt; 0) tree&lt;/code&gt;，这里 &lt;code&gt;foldMap&lt;/code&gt; 把树中每个元素映射到 &lt;code&gt;Any Monoid&lt;/code&gt; 中。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;Monad&quot;&gt;&lt;a href=&quot;#Monad&quot; class=&quot;headerlink&quot; title=&quot;Monad&quot;&gt;&lt;/a&gt;Monad&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Monad&lt;/code&gt; （&lt;code&gt;Control.Monad&lt;/code&gt;）类型类定义如下：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Applicative&lt;/span&gt; m =&amp;gt; &lt;span class=&quot;type&quot;&gt;Monad&lt;/span&gt; m &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  (&amp;gt;&amp;gt;=) :: m a -&amp;gt; (a -&amp;gt; m b) -&amp;gt; m b&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  (&amp;gt;&amp;gt;) :: m a -&amp;gt; m b -&amp;gt; m b&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  x &amp;gt;&amp;gt; y = x &amp;gt;&amp;gt;= \_ -&amp;gt; y&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  return :: a -&amp;gt; m a&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  fail :: &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt; -&amp;gt; m a&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  fail msg = error msg&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Monad&lt;/code&gt; 的实例本身必须是 &lt;code&gt;Applicative&lt;/code&gt; 的实例。其类型类定义中已经默认实现了 &lt;code&gt;&amp;gt;&amp;gt;&lt;/code&gt; 和 &lt;code&gt;fail&lt;/code&gt;，定义实例时可以重写这些函数，也可以只实现 &lt;code&gt;return&lt;/code&gt; 和 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt;。&lt;code&gt;return&lt;/code&gt; 等价于 &lt;code&gt;pure&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;语法 &lt;code&gt;do&lt;/code&gt; 可帮助把一些 &lt;code&gt;Monad&lt;/code&gt; 操作连接在一起，其包裹的代码的每一行均为一个 &lt;code&gt;Monad&lt;/code&gt; 实例的值。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;List&lt;/code&gt; 的 &lt;code&gt;Monad&lt;/code&gt; 实例定义如下：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;instance&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Monad&lt;/span&gt; [] &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  return x = [x]&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  xs &amp;gt;&amp;gt;= f = concat (map f xs)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  fail _ = []&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;从 &lt;code&gt;List&lt;/code&gt; 实例定义可看出，&lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 类似过程式语言中的循环嵌套，即将 &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt; 左侧的 List 中的每个元素依次应用到右侧的函数上。List Comprehension 仅仅是它的语法糖，如 &lt;code&gt;[x | x &amp;lt;- [1..10], x&lt;/code&gt;mod&lt;code&gt;3 == 0]&lt;/code&gt; 等价于 &lt;code&gt;[1..10] &amp;gt;&amp;gt;= \x -&amp;gt; if x&lt;/code&gt;mod&lt;code&gt;3 == 0 then [x] else []&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Monad&lt;/code&gt; 需要遵守如下守则：&lt;ul&gt;
&lt;li&gt;&lt;code&gt;return x &amp;gt;&amp;gt;= f = f x&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;m &amp;gt;&amp;gt;= return = m&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;(m &amp;gt;&amp;gt;= f) &amp;gt;&amp;gt;= g = m &amp;gt;&amp;gt;= (\x -&amp;gt; f x &amp;gt;&amp;gt;= g)&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;MonadPlus&quot;&gt;&lt;a href=&quot;#MonadPlus&quot; class=&quot;headerlink&quot; title=&quot;MonadPlus&quot;&gt;&lt;/a&gt;MonadPlus&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;上面的 List Comprehension 也等价于 &lt;code&gt;[1..10] &amp;gt;&amp;gt;= \x -&amp;gt; guard (x&lt;/code&gt;mod&lt;code&gt;3 == 0) &amp;gt;&amp;gt; return x&lt;/code&gt;。这需要用到 &lt;code&gt;MonadPlus&lt;/code&gt; 类型类，它指同时表现为 &lt;code&gt;Monoid&lt;/code&gt; 的 &lt;code&gt;Monad&lt;/code&gt;，其定义为：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Monad&lt;/span&gt; m =&amp;gt; &lt;span class=&quot;type&quot;&gt;MonadPlus&lt;/span&gt; m &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  mzero :: m a&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  mplus :: m a -&amp;gt; m a -&amp;gt; m a&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;mzero&lt;/code&gt; 等价于 &lt;code&gt;mempty&lt;/code&gt;，&lt;code&gt;mplus&lt;/code&gt; 等价于 &lt;code&gt;mappend&lt;/code&gt;。 &lt;code&gt;guard&lt;/code&gt; 函数的定义如下。当 &lt;code&gt;guard&lt;/code&gt; 监察的 &lt;code&gt;Bool&lt;/code&gt; 变量为 &lt;code&gt;True&lt;/code&gt; 时，&lt;code&gt;return&lt;/code&gt; 会返回一个空 unit，否则 在 List Comprehension 例子中，&lt;code&gt;mzero = []&lt;/code&gt; 不会产生任何结果。 &lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;guard&lt;/span&gt; :: (&lt;span class=&quot;type&quot;&gt;MonadPlus&lt;/span&gt; m) =&amp;gt; &lt;span class=&quot;type&quot;&gt;Bool&lt;/span&gt; -&amp;gt; m ()&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;guard&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;True&lt;/span&gt; = return ()&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;guard&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;False&lt;/span&gt; = mzero&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;h2 id=&quot;常用-Monad&quot;&gt;&lt;a href=&quot;#常用-Monad&quot; class=&quot;headerlink&quot; title=&quot;常用 Monad&quot;&gt;&lt;/a&gt;常用 Monad&lt;/h2&gt;&lt;h3 id=&quot;Writer&quot;&gt;&lt;a href=&quot;#Writer&quot; class=&quot;headerlink&quot; title=&quot;Writer&quot;&gt;&lt;/a&gt;Writer&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Writer&lt;/code&gt; （&lt;code&gt;Control.Monad.Writer&lt;/code&gt;）的定义和 &lt;code&gt;Monad&lt;/code&gt; 实例定义如下，该模块并未导出其值构造子。&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;typedef&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;newtype&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Writer&lt;/span&gt; w a = &lt;span class=&quot;type&quot;&gt;Writer&lt;/span&gt; &lt;span class=&quot;container&quot;&gt;&amp;#123; &lt;span class=&quot;title&quot;&gt;runWriter&lt;/span&gt; :: (&lt;span class=&quot;title&quot;&gt;a&lt;/span&gt;, &lt;span class=&quot;title&quot;&gt;w&lt;/span&gt;) &amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;instance&lt;/span&gt; &lt;span class=&quot;container&quot;&gt;(&lt;span class=&quot;type&quot;&gt;Monoid&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;w&lt;/span&gt;)&lt;/span&gt; =&amp;gt; &lt;span class=&quot;type&quot;&gt;Monad&lt;/span&gt; &lt;span class=&quot;container&quot;&gt;(&lt;span class=&quot;type&quot;&gt;Writer&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;w&lt;/span&gt;)&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  return x = &lt;span class=&quot;type&quot;&gt;Writer&lt;/span&gt; (x, mempty)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  (&lt;span class=&quot;type&quot;&gt;Writer&lt;/span&gt; (x, v)) &amp;gt;&amp;gt;= f = &lt;span class=&quot;keyword&quot;&gt;let&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Writer&lt;/span&gt; (y, v&#39;) = f x &lt;span class=&quot;keyword&quot;&gt;in&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Writer&lt;/span&gt; (y, v `mappend` v&#39;)&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;可用 &lt;code&gt;tell&lt;/code&gt; 向 Writer 加入 log。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;gt-r&quot;&gt;&lt;a href=&quot;#gt-r&quot; class=&quot;headerlink&quot; title=&quot;((-&amp;gt;) r)&quot;&gt;&lt;/a&gt;((-&amp;gt;) r)&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;函数也是 &lt;code&gt;Monad&lt;/code&gt;，其实例为：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;instance&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Monad&lt;/span&gt; &lt;span class=&quot;container&quot;&gt;((-&amp;gt;)&lt;/span&gt; r) &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  return = const&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  g &amp;gt;&amp;gt;= f = \v -&amp;gt; f (g v) v&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;h3 id=&quot;Reader&quot;&gt;&lt;a href=&quot;#Reader&quot; class=&quot;headerlink&quot; title=&quot;Reader&quot;&gt;&lt;/a&gt;Reader&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Reader&lt;/code&gt; （对函数 Monad 的一种包装）：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;typedef&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;newtype&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Reader&lt;/span&gt; s a = &lt;span class=&quot;type&quot;&gt;Reader&lt;/span&gt;&lt;span class=&quot;container&quot;&gt;&amp;#123; &lt;span class=&quot;title&quot;&gt;runReader&lt;/span&gt; :: &lt;span class=&quot;title&quot;&gt;s&lt;/span&gt; -&amp;gt; &lt;span class=&quot;title&quot;&gt;a&lt;/span&gt; &amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;instance&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Monad&lt;/span&gt; &lt;span class=&quot;container&quot;&gt;(&lt;span class=&quot;type&quot;&gt;Reader&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;s&lt;/span&gt;)&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  return x = &lt;span class=&quot;type&quot;&gt;Reader&lt;/span&gt; (const x)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  m &amp;gt;&amp;gt;= k = &lt;span class=&quot;type&quot;&gt;Reader&lt;/span&gt; $ \r -&amp;gt; runReader (k (runReader m r)) r&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;h3 id=&quot;State&quot;&gt;&lt;a href=&quot;#State&quot; class=&quot;headerlink&quot; title=&quot;State&quot;&gt;&lt;/a&gt;State&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;State&lt;/code&gt; （&lt;code&gt;Control.Monad.State&lt;/code&gt;）常用来表示状态迁移，代表了改变状态的操作：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;typedef&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;newtype&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;State&lt;/span&gt; s a = &lt;span class=&quot;type&quot;&gt;State&lt;/span&gt;&lt;span class=&quot;container&quot;&gt;&amp;#123;&lt;span class=&quot;title&quot;&gt;runState&lt;/span&gt; :: &lt;span class=&quot;title&quot;&gt;s&lt;/span&gt; -&amp;gt; (&lt;span class=&quot;title&quot;&gt;a&lt;/span&gt;, &lt;span class=&quot;title&quot;&gt;s&lt;/span&gt;)&amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;instance&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Monad&lt;/span&gt; &lt;span class=&quot;container&quot;&gt;(&lt;span class=&quot;type&quot;&gt;State&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;s&lt;/span&gt;)&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  return x = &lt;span class=&quot;type&quot;&gt;State&lt;/span&gt; $ \s -&amp;gt; (x, s)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;  (&lt;span class=&quot;type&quot;&gt;State&lt;/span&gt; h) &amp;gt;&amp;gt;= f = &lt;span class=&quot;type&quot;&gt;State&lt;/span&gt; $ \s -&amp;gt; &lt;span class=&quot;keyword&quot;&gt;let&lt;/span&gt; (a, newState) = h s&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                                      (&lt;span class=&quot;type&quot;&gt;State&lt;/span&gt;  g) = f a&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                                  &lt;span class=&quot;keyword&quot;&gt;in&lt;/span&gt; g newState&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;hr&gt;
&lt;p&gt;原创作品，允许转载，转载时无需告知，但请务必以超链接形式标明文章&lt;a href=&quot;http://blog.forec.cn/2017/03/01/talk-about-some-simple-monads/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;原始出处&lt;/a&gt;(&lt;a href=&quot;http://blog.forec.cn/2017/03/01/talk-about-some-simple-monads/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;http://blog.forec.cn/2017/03/01/talk-about-some-simple-monads/&lt;/a&gt;) 、作者信息（&lt;a href=&quot;http://forec.cn/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Forec&lt;/a&gt;）和本声明。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;blockquote&gt;
&lt;p&gt;@Fallenwood 选修的 《Foundations of Programming Languages》 课程让我看的很手痒。整理一下基本的 Typeclass 和 Monad，准备跟随贵科步伐重新学习 Haskell。&lt;/p&gt;
&lt;/blockquote&gt;
    
    </summary>
    
      <category term="Code" scheme="http://forec.github.io/categories/Code/"/>
    
    
      <category term="Haskell" scheme="http://forec.github.io/tags/Haskell/"/>
    
      <category term="函数式编程" scheme="http://forec.github.io/tags/%E5%87%BD%E6%95%B0%E5%BC%8F%E7%BC%96%E7%A8%8B/"/>
    
  </entry>
  
  <entry>
    <title>形式语言</title>
    <link href="http://forec.github.io/2017/02/25/formal-languages-and-automata1/"/>
    <id>http://forec.github.io/2017/02/25/formal-languages-and-automata1/</id>
    <published>2017-02-25T15:33:13.000Z</published>
    <updated>2018-09-26T06:08:29.234Z</updated>
    
    <content type="html">&lt;blockquote&gt;
&lt;p&gt;这个寒假遇到的一些问题让我想起之前形式语言与自动机的内容，程序执行的本质是状态的变化，我觉得有必要将这部分理论捡起来，需要的时候方便自己回忆。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;a id=&quot;more&quot;&gt;&lt;/a&gt;
&lt;h2 id=&quot;概念整理&quot;&gt;&lt;a href=&quot;#概念整理&quot; class=&quot;headerlink&quot; title=&quot;概念整理&quot;&gt;&lt;/a&gt;概念整理&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;形式语言&lt;/strong&gt; 是形式化描述的 &lt;strong&gt;字母表&lt;/strong&gt; 上的 &lt;strong&gt;字符串&lt;/strong&gt; 的集合。&lt;em&gt;字母表&lt;/em&gt; 为字符的有限集合，多用 &lt;code&gt;T&lt;/code&gt; 表示；&lt;em&gt;字符串&lt;/em&gt; 指字母表中的字符构成的 &lt;strong&gt;有限&lt;/strong&gt; 序列。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;自动机&lt;/strong&gt; 接受一定的输入，执行一定的动作，产生一定的结果。使用状态迁移描述整个过程。例如可实现一个用于识别字符串的自动机系统，根据输入的字符串解析形式语言。&lt;strong&gt;状态&lt;/strong&gt; 是一个标识，用于区分自动机在不同时刻的状况；自动机的本质是 &lt;strong&gt;根据状态、输入和规则决定下一个状态&lt;/strong&gt; （状态迁移）。&lt;/li&gt;
&lt;li&gt;有限自动机可以认为是由一个带有读写头的有限控制器和一条写有字符的输入带组成。&lt;/li&gt;
&lt;li&gt;关系：&lt;table&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;形式语言&lt;/td&gt;&lt;td&gt;非限定性语言&lt;/td&gt;&lt;td&gt;上下文有关语言&lt;/td&gt;&lt;td&gt;上下文无关语言&lt;/td&gt;&lt;td&gt;正则语言&lt;/td&gt;&lt;/tr&gt;&lt;br&gt;&lt;tr&gt;&lt;td&gt;自动机&lt;/td&gt;&lt;td&gt;图灵机&lt;/td&gt;&lt;td&gt;线性有界自动机&lt;/td&gt;&lt;td&gt;下推式存储自动机&lt;/td&gt;&lt;td&gt;有限自动机&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;

&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;语言及文法&quot;&gt;&lt;a href=&quot;#语言及文法&quot; class=&quot;headerlink&quot; title=&quot;语言及文法&quot;&gt;&lt;/a&gt;语言及文法&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;字符串的运算：字符串 &lt;code&gt;ω&lt;/code&gt; 的长度记为 &lt;code&gt;|ω|&lt;/code&gt;， &lt;code&gt;ω&lt;/code&gt; 的逆记为 &lt;code&gt;ω^T&lt;/code&gt;。字符串的 &lt;strong&gt;连接&lt;/strong&gt; 满足结合律，且有 &lt;code&gt;εω = ωε = ω&lt;/code&gt;，&lt;code&gt;|ω1ω2| = |ω1| + |ω2|&lt;/code&gt;。空串 &lt;code&gt;ε&lt;/code&gt; 是任何串的前/后缀和字串。&lt;/li&gt;
&lt;li&gt;字母表的 &lt;strong&gt;幂运算&lt;/strong&gt;：设 T 为字母表，n∈N。&lt;ol&gt;
&lt;li&gt;T0 = {ε}&lt;/li&gt;
&lt;li&gt;设 x∈T(n-1)，a∈T，则 ax∈Tn&lt;/li&gt;
&lt;li&gt;Tn 中的元素只能由 (1) 和 (2) 构成&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;闭包&lt;/strong&gt;（*）：&lt;code&gt;T* = Σ Tk (k = 0..n) = T0 ∪ T1 ∪ ... ∪ Tn&lt;/code&gt;，闭包（+）：&lt;code&gt;T+ = Σ Tk (k = 1..n)&lt;/code&gt;，即 &lt;code&gt;T* = T+ ∪ {ε}&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;语言&lt;/strong&gt;：T 为字母表，任何集合 L ⊆ T* 是字母表 T 上的一个语言。&lt;ul&gt;
&lt;li&gt;积运算：L1 与 L2 的积是 L1 和 L2 中字符串相连的集合，不满足交换律&lt;/li&gt;
&lt;li&gt;幂运算：&lt;code&gt;L0 = {ε}, Ln = L · L(n-1) = L(n-1) · L (n ≥ 1)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;∅&lt;/code&gt; 表示不存在任何句子的语言，&lt;code&gt;{ε}&lt;/code&gt; 表示仅存在空句子的语言&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;文法&lt;/strong&gt;：用来定义语言的数学模型称为文法。&lt;ul&gt;
&lt;li&gt;语言 L 为有限集合：通过列举表示&lt;/li&gt;
&lt;li&gt;语言 L 为无限集合，通过文法产生系统或机器识别系统&lt;/li&gt;
&lt;li&gt;元语言：描述语言的语言，文法是一种元语言&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;BNF（巴科斯范式）&lt;/strong&gt;：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight gherkin&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;variable&quot;&gt;&amp;lt;数字&amp;gt;&lt;/span&gt; ::= 0 |&lt;span class=&quot;string&quot;&gt; 1 &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; 2 &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; .. &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; 9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;lt;字母&amp;gt; ::= A &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; B &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; C &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; .. &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; Z &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; a &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; b &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; c &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; .. &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; z&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;lt;标识符&amp;gt; ::= &amp;lt;字母&amp;gt; &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; &amp;lt;标识符&amp;gt;&amp;lt;字母&amp;gt; &lt;/span&gt;|&lt;span class=&quot;string&quot;&gt; &amp;lt;标识符&amp;gt;&amp;lt;数字&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Chomsky 文法体系&lt;/strong&gt;：任何一种文法必包含有：两个不同的有限符号集合（终结符号集合 N 和非终结符号集合 T）；一个形式化规则的有限集合 P （又称生成式集合）；一个起始符 S。&lt;/li&gt;
&lt;li&gt;文法的 &lt;strong&gt;形式定义&lt;/strong&gt; ：文法 G 是一个四元组，&lt;code&gt;G = (N, T, P, S)&lt;/code&gt;。其中 N ∩ T = ∅；P 为形式为 &lt;code&gt;α → β&lt;/code&gt; 的生成式 &lt;strong&gt;有限&lt;/strong&gt; 集合，且 &lt;code&gt;α ∈ (N∪T)* N+ (N∪T)*&lt;/code&gt;，&lt;code&gt;β ∈ (N∪T)*&lt;/code&gt;；S 是起始符，S ∈ N。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;推导和句型&quot;&gt;&lt;a href=&quot;#推导和句型&quot; class=&quot;headerlink&quot; title=&quot;推导和句型&quot;&gt;&lt;/a&gt;推导和句型&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;直接推导：&lt;code&gt;G = (N, T, P, S)&lt;/code&gt;，有 &lt;code&gt;A → β&lt;/code&gt; 是 P 中的生成式，α 和 γ 均属于 &lt;code&gt;(N ∪ T)*&lt;/code&gt;，则 &lt;code&gt;αAγ ⇒ αβγ&lt;/code&gt; 称 αAγ 直接导出 αβγ，或者说 αβγ 是 αAγ 的直接推导；&lt;/li&gt;
&lt;li&gt;推导序列：&lt;code&gt;α = α0 ⇒ α1 ⇒ ... ⇒ αn&lt;/code&gt; 是长度为 n 的推导序列，&lt;code&gt;α = α0&lt;/code&gt; 是长度为 0 的推导序列。对 α 推导出 α’，记为 &lt;code&gt;α ⇒(*, G) α&amp;#39;&lt;/code&gt;，若 α 推导出 α’ 用了长度大于 0 的推导序列，则记为 &lt;code&gt;α ⇒(+, G) α&amp;#39;&lt;/code&gt;。推导序列的每一步都会产生一个字符串，这些字符串称为 &lt;strong&gt;句型&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;字符串 &lt;code&gt;α&lt;/code&gt; 是文法 G 的句型，当且仅当 &lt;code&gt;S ⇒(*, G) α&lt;/code&gt;，且 &lt;code&gt;α ∈ (N ∪ T)*&lt;/code&gt;。句型包含 &lt;strong&gt;句子&lt;/strong&gt;，ω 是 G 的句子，当且仅当 &lt;code&gt;S ⇒(*, G) ω&lt;/code&gt; 且 &lt;code&gt;ω ∈ T*&lt;/code&gt;，即必须由起始符集合 S 推导出，并且由终结符集合构成的。&lt;/li&gt;
&lt;li&gt;例：括号匹配语言，定义集合基本元素 &lt;code&gt;()&lt;/code&gt;，递归产生其他句子：若 S 为合法串，则 &lt;code&gt;(S)&lt;/code&gt; 和 &lt;code&gt;SS&lt;/code&gt; 均合法。故 P 中包含三种生成式：&lt;code&gt;S → (); S → (S); S → SS&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;Chomsky-文法体系分类&quot;&gt;&lt;a href=&quot;#Chomsky-文法体系分类&quot; class=&quot;headerlink&quot; title=&quot;Chomsky 文法体系分类&quot;&gt;&lt;/a&gt;Chomsky 文法体系分类&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;0 型文法：无限制文法 ⇒ 无限制语言，递归可枚举语言（图灵机）&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;1 型文法&lt;/strong&gt;：上下文有关文法，CSG ⇒ 上下文有关语言，CSL（线性有界自动机，LBA）&lt;ul&gt;
&lt;li&gt;生成式形式：&lt;code&gt;α → β&lt;/code&gt;，其中 &lt;code&gt;|α| ≤ |β|, β ∈ (N ∪ T)+, α ∈ (N ∪ T)* N+ (N ∪ T)*&lt;/code&gt;，即满足生成式的 &lt;strong&gt;左侧短于右侧&lt;/strong&gt; ，且 &lt;strong&gt;不包含 &lt;code&gt;A → ε&lt;/code&gt;&lt;/strong&gt; 。&lt;/li&gt;
&lt;li&gt;应用：过程式语言调用时形参与实参的一致性检查。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;2 型文法&lt;/strong&gt;：上下文无关文法，CFG ⇒ 上下文无关语言，CEL（下推自动机，PDA）&lt;ul&gt;
&lt;li&gt;生成式形式：&lt;code&gt;A → B&lt;/code&gt;，其中 &lt;code&gt;A ∈ N, β ∈ (N ∪ T)*&lt;/code&gt;，可以包含 &lt;code&gt;A → ε&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;每个生成式左侧都是 &lt;strong&gt;单个非终结符&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;3 型文法&lt;/strong&gt;：正则文法 ⇒ 正则语言（有限自动机，FSA）&lt;ul&gt;
&lt;li&gt;左线性文法：&lt;code&gt;A → Bω&lt;/code&gt; 或 &lt;code&gt;A → ω&lt;/code&gt;，其中 &lt;code&gt;A, B ∈ N, ω ∈ T*&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;右线性文法：&lt;code&gt;A → ωB&lt;/code&gt; 或 &lt;code&gt;A → ω&lt;/code&gt;，其中 &lt;code&gt;A, B ∈ N, ω ∈ T*&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;已知语言求特定文法，得到的文法不是唯一的。&lt;/li&gt;
&lt;li&gt;几种文法之间关系：&lt;ul&gt;
&lt;li&gt;0 型：无限制，包括 1、2、3 型文法；&lt;/li&gt;
&lt;li&gt;1 型：不允许 A → ε，包含不含 A → ε 的 2、3 型文法&lt;/li&gt;
&lt;li&gt;2 型：包含 3 型文法&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;p&gt;专栏目录：&lt;a href=&quot;http://blog.forec.cn/columns/cs-basic.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;计算机理论基础&lt;/a&gt;&lt;br&gt;此专栏的上一篇文章：无&lt;br&gt;此专栏的下一篇文章：&lt;a href=&quot;http://blog.forec.cn/2017/03/18/formal-languages-and-automata2/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;有限自动机&lt;/a&gt;    &lt;/p&gt;
&lt;p&gt;参考资料：《形式语言与自动机》，王柏、杨娟编著，北京邮电大学出版社    &lt;/p&gt;
&lt;p&gt;原创作品，允许转载，转载时无需告知，但请务必以超链接形式标明文章&lt;a href=&quot;http://blog.forec.cn/2017/02/25/formal-languages-and-automata1/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;原始出处&lt;/a&gt;(&lt;a href=&quot;http://blog.forec.cn/2017/02/25/formal-languages-and-automata1/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;http://blog.forec.cn/2017/02/25/formal-languages-and-automata1/&lt;/a&gt;) 、作者信息（&lt;a href=&quot;http://forec.cn/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Forec&lt;/a&gt;）和本声明。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;blockquote&gt;
&lt;p&gt;这个寒假遇到的一些问题让我想起之前形式语言与自动机的内容，程序执行的本质是状态的变化，我觉得有必要将这部分理论捡起来，需要的时候方便自己回忆。&lt;/p&gt;
&lt;/blockquote&gt;
    
    </summary>
    
      <category term="计算机理论基础" scheme="http://forec.github.io/categories/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80/"/>
    
    
      <category term="自动机" scheme="http://forec.github.io/tags/%E8%87%AA%E5%8A%A8%E6%9C%BA/"/>
    
  </entry>
  
  <entry>
    <title>用 Haskell 实现解释器</title>
    <link href="http://forec.github.io/2017/02/14/talk-about-interpreter/"/>
    <id>http://forec.github.io/2017/02/14/talk-about-interpreter/</id>
    <published>2017-02-14T12:38:16.000Z</published>
    <updated>2018-09-26T06:08:29.212Z</updated>
    
    <content type="html">&lt;blockquote&gt;
&lt;p&gt;这篇文章主要基于王垠早年发过的文章&lt;a href=&quot;http://www.yinwang.org/blog-cn/2012/08/01/interpreter&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;《怎样写一个解释器》&lt;/a&gt;，我参考了 Racket 版本的 R2 解释器，并用 Haskell 实现 &lt;code&gt;H2Lang&lt;/code&gt; 的简单解释器，较 R2 的功能做了一点改进。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;a id=&quot;more&quot;&gt;&lt;/a&gt;
&lt;h2 id=&quot;代码的表示&quot;&gt;&lt;a href=&quot;#代码的表示&quot; class=&quot;headerlink&quot; title=&quot;代码的表示&quot;&gt;&lt;/a&gt;代码的表示&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;王垠的 R2 解释器用 Racket 实现，Racket 可以很容易地用 &lt;code&gt;&amp;#39;(op e1 e1)&lt;/code&gt; 的形式表示 S-expr，并且 lambda 表达式也可以复用。&lt;a href=&quot;http://fallenwood.github.io/2017/02/04/writing-a-simple-lisp/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Fallenwood&lt;/a&gt; 也用 Python 实现了一个类似的 Lisp 解释器，他将操作符和表达式均以列表的形式存储，利用了 Python 的动态类型。知乎上 “&lt;a href=&quot;https://www.zhihu.com/question/20115358&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;如何写 Lisp 解释器&lt;/a&gt;” 这个问题下，答主 &lt;a href=&quot;https://www.zhihu.com/people/be5invis/answers&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Belleve&lt;/a&gt; 给出了 JS 实现的 Lisp 解释器，并实现了 &lt;code&gt;call/cc&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;Haskell 是静态类型，没法把动态类型列表迭代那一套搬过来，因此基本思路和王垠文章中所述类似。为了方便起见，我声明新的类型，并用字符串表示值操作符：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;11&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;typedef&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;data&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; = &lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Float&lt;/span&gt;       |&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           &lt;span class=&quot;type&quot;&gt;Boolean&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Bool&lt;/span&gt;      |&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           &lt;span class=&quot;type&quot;&gt;String&#39;&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt;    |&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           &lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt;      |&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           &lt;span class=&quot;type&quot;&gt;Error&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt;      |&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           &lt;span class=&quot;type&quot;&gt;Op&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; |&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           &lt;span class=&quot;type&quot;&gt;Lambda&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt;    |&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           &lt;span class=&quot;type&quot;&gt;If&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt;    |&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           &lt;span class=&quot;type&quot;&gt;Let&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt;   |&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           &lt;span class=&quot;type&quot;&gt;Closure&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Env&lt;/span&gt;   |&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           &lt;span class=&quot;type&quot;&gt;Call&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;deriving&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Show&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;在上面的型别声明中，提供了三种类型的数据（&lt;code&gt;Float&lt;/code&gt;、&lt;code&gt;Bool&lt;/code&gt; 和 &lt;code&gt;String&lt;/code&gt;），以及变量（&lt;code&gt;Param&lt;/code&gt;）、错误信息（&lt;code&gt;Error&lt;/code&gt;）、运算式（&lt;code&gt;Op&lt;/code&gt;）、函数（&lt;code&gt;Lambda&lt;/code&gt;）、条件表达式（&lt;code&gt;If&lt;/code&gt;）、绑定（&lt;code&gt;Let&lt;/code&gt;）、闭包（&lt;code&gt;Closure&lt;/code&gt;）和函数调用（&lt;code&gt;Call&lt;/code&gt;）。&lt;/li&gt;
&lt;li&gt;出于方便考虑，只支持了二元运算符，这从 &lt;code&gt;Exp&lt;/code&gt; 的声明中也能看出。如果想支持一元运算符，最简单的方式是增加型别的值构造子，并修改解释器的模式匹配；如果想支持多元运算符，可以绑定嵌套。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Closure&lt;/code&gt; 值构造子有一个参数为 &lt;code&gt;Env&lt;/code&gt;，它用于维护闭包内表达式所处的环境的副本。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;变量、值的绑定&quot;&gt;&lt;a href=&quot;#变量、值的绑定&quot; class=&quot;headerlink&quot; title=&quot;变量、值的绑定&quot;&gt;&lt;/a&gt;变量、值的绑定&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;有了上述型别，简单的值可以通过对应的值构造子产生，如 &lt;code&gt;Value 2.34&lt;/code&gt;、&lt;code&gt;Boolean True&lt;/code&gt;、&lt;code&gt;String&amp;#39; &amp;quot;test&amp;quot;&lt;/code&gt; 等。&lt;/li&gt;
&lt;li&gt;变量与值的绑定通过类似 &lt;code&gt;Data.Map&lt;/code&gt; 的结构，因为值和函数、运算等都可归一为表达式 &lt;code&gt;Exp&lt;/code&gt;，因此用一个 &lt;code&gt;[(String, Exp)]&lt;/code&gt; 的 list 存放对当前代码区域可见的变量-值绑定，称之为环境。函数 ·extEnv` 扩展已有的环境。&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;typedef&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;type&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;Env&lt;/span&gt; = [&lt;span class=&quot;container&quot;&gt;(&lt;span class=&quot;type&quot;&gt;String&lt;/span&gt;, &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt;)&lt;/span&gt;]&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;extEnv&lt;/span&gt; :: &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt; -&amp;gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; -&amp;gt; &lt;span class=&quot;type&quot;&gt;Env&lt;/span&gt; -&amp;gt; &lt;span class=&quot;type&quot;&gt;Env&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;extEnv&lt;/span&gt; x v env = (x, v) : env&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;需要查找变量时，在当前环境中检查有无对应的键。因为 &lt;code&gt;extEnv&lt;/code&gt; 将后绑定的变量插入到环境的头部，因此可以屏蔽先插入的同名变量，从而模拟出变量的就近原则。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;运算符的计算&quot;&gt;&lt;a href=&quot;#运算符的计算&quot; class=&quot;headerlink&quot; title=&quot;运算符的计算&quot;&gt;&lt;/a&gt;运算符的计算&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;为了保持解释器主体部分简短，我将运算符的计算提取成单独的函数。其大致结构如下：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;calc&lt;/span&gt; :: &lt;span class=&quot;type&quot;&gt;String&lt;/span&gt; -&amp;gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; -&amp;gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; -&amp;gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;calc&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;+&quot;&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; v1&#39;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; v2&#39;)      = &lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; (v1&#39; + v2&#39;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;calc&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;-&quot;&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; v1&#39;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; v2&#39;)      = &lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; (v1&#39; - v2&#39;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;calc&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;*&quot;&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; v1&#39;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; v2&#39;)      = &lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; (v1&#39; * v2&#39;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;calc&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;/&quot;&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; v1&#39;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; v2&#39;)      = &lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; (v1&#39; / v2&#39;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;calc&lt;/span&gt; ...... &lt;span class=&quot;comment&quot;&gt;-- other patterns&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;为了支持 &lt;code&gt;String&amp;#39;&lt;/code&gt; 和 &lt;code&gt;Boolean&lt;/code&gt; 类型的计算，&lt;code&gt;calc&lt;/code&gt; 函数必须为每种类型均增加模式匹配。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;函数声明和调用&quot;&gt;&lt;a href=&quot;#函数声明和调用&quot; class=&quot;headerlink&quot; title=&quot;函数声明和调用&quot;&gt;&lt;/a&gt;函数声明和调用&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Exp&lt;/code&gt; 型别有一个 &lt;code&gt;Lambda&lt;/code&gt; 值构造子用来声明函数，解释器遇到 &lt;code&gt;Lambda&lt;/code&gt; 表达式时，会将其转化为 &lt;code&gt;Closure&lt;/code&gt; 值类型，即将该函数所处的环境保存下来，这么做的目的与 Lexical Scoping 和 Dynamic Scoping 有关。这一点在王垠的文章中讲的很清楚，这里简单提一下。Lexical Scoping，中文为静态域或者词法定界，Dynamic Scoping 为动态作用域，举个例子，&lt;code&gt;let x = 2 in (let f = \y-&amp;gt; x * y in (let x = 4 in (f 3)))&lt;/code&gt;，如果结果为 6 就是 Lexical Scoping，结果为 12 就是 Dynamic Scoping。Dynamic Scoping 会带来很多意想不到的后果，因此要想实现静态域，就要在函数定义时保存其所处的环境，并在函数调用时从该环境中提取变量绑定。&lt;/li&gt;
&lt;li&gt;实现的 &lt;code&gt;H2Lang&lt;/code&gt; 解释器会在匹配到 &lt;code&gt;Lambda&lt;/code&gt; 表达式时将其转化为闭包：&lt;code&gt;interp s@(Lambda _ _) env = Closure s env&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;为了方便区分普通表达式和函数调用，我在 &lt;code&gt;Exp&lt;/code&gt; 的型别中声明了 &lt;code&gt;Call&lt;/code&gt; 值构造子，它将两个表达式组合到一起，并认定第一个表达式代表函数，第二个表达式代表某个变量或者值。因为多元函数可以用柯里化不断简化，因此解释器就不做处理了，在调用时可以通过 &lt;code&gt;Call&lt;/code&gt; 的嵌套实现。&lt;/li&gt;
&lt;li&gt;当解释器匹配到 &lt;code&gt;Call e1 e2&lt;/code&gt; 时，根据当前环境递归调用解释器计算出 &lt;code&gt;e2&lt;/code&gt; 最终的表达式，假设 &lt;code&gt;e1&lt;/code&gt; 匹配了 &lt;code&gt;Closure (Lambda (Param x) e) env&amp;#39;)&lt;/code&gt;，则将计算出 &lt;code&gt;e2&lt;/code&gt; 的结果绑定到变量 &lt;code&gt;x&lt;/code&gt;，并计算函数的值。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;解释器&quot;&gt;&lt;a href=&quot;#解释器&quot; class=&quot;headerlink&quot; title=&quot;解释器&quot;&gt;&lt;/a&gt;解释器&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;解释器的主体代码如下，完整代码在 &lt;a href=&quot;https://github.com/Forec/learn/blob/master/2017.1/haskell-interpreter/h2lang.hs&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;h2lang.hs&lt;/a&gt;：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;11&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;12&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;13&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;14&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;15&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;16&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;17&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;18&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;19&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;20&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;21&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;22&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;23&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;24&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;25&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;26&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;interp&lt;/span&gt; :: &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt; -&amp;gt; &lt;span class=&quot;type&quot;&gt;Env&lt;/span&gt; -&amp;gt; &lt;span class=&quot;type&quot;&gt;Exp&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;interp&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; x) env = fromMaybe (&lt;span class=&quot;type&quot;&gt;Error&lt;/span&gt; (&lt;span class=&quot;string&quot;&gt;&quot;undefined variable&quot;&lt;/span&gt; ++ x)) (lookup x env)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;interp&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; x) _ = &lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; x&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;interp&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Boolean&lt;/span&gt; x) _ = &lt;span class=&quot;type&quot;&gt;Boolean&lt;/span&gt; x&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;interp&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;String&#39;&lt;/span&gt; x) _ = &lt;span class=&quot;type&quot;&gt;String&#39;&lt;/span&gt; x&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;interp&lt;/span&gt; s@(&lt;span class=&quot;type&quot;&gt;Lambda&lt;/span&gt; _ _) env = &lt;span class=&quot;type&quot;&gt;Closure&lt;/span&gt; s env&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;interp&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Let&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; x) e1 e2) env = interp e2 (extEnv x (interp e1 env) env)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;interp&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Op&lt;/span&gt; op e1 e2) env = &lt;span class=&quot;keyword&quot;&gt;let&lt;/span&gt; v1 = interp e1 env&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                               v2 = interp e2 env&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                           &lt;span class=&quot;keyword&quot;&gt;in&lt;/span&gt; calc op v1 v2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;interp&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;If&lt;/span&gt; cond e1 e2) env = &lt;span class=&quot;keyword&quot;&gt;let&lt;/span&gt; c = interp cond env&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                             &lt;span class=&quot;keyword&quot;&gt;in&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;case&lt;/span&gt; c &lt;span class=&quot;keyword&quot;&gt;of&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                               &lt;span class=&quot;type&quot;&gt;Error&lt;/span&gt; _       -&amp;gt; &lt;span class=&quot;type&quot;&gt;Error&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;syntax error&quot;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                               &lt;span class=&quot;type&quot;&gt;Boolean&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;False&lt;/span&gt; -&amp;gt; interp e2 env&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                               _             -&amp;gt; interp e1 env&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;interp&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Call&lt;/span&gt; e1 e2) env = &lt;span class=&quot;keyword&quot;&gt;case&lt;/span&gt; v2 &lt;span class=&quot;keyword&quot;&gt;of&lt;/span&gt; &lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                            &lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; _   -&amp;gt; callExp&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                            &lt;span class=&quot;type&quot;&gt;Boolean&lt;/span&gt; _ -&amp;gt; callExp&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                            &lt;span class=&quot;type&quot;&gt;String&#39;&lt;/span&gt; _ -&amp;gt; callExp&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                            _         -&amp;gt; &lt;span class=&quot;type&quot;&gt;Error&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;syntax error&quot;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;where&lt;/span&gt; &lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;      v2 = interp e2 env&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;      col = interp e1 env&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;      callExp = &lt;span class=&quot;keyword&quot;&gt;case&lt;/span&gt; col &lt;span class=&quot;keyword&quot;&gt;of&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                (&lt;span class=&quot;type&quot;&gt;Closure&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Lambda&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; x) e) env&#39;) -&amp;gt; interp e (extEnv x v2 env&#39;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;                _                                   -&amp;gt; &lt;span class=&quot;type&quot;&gt;Error&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;syntax error&quot;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;效果：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight haskell&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;11&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;12&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;13&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;14&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;15&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;h2&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Let&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;x&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;) &lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;      (&lt;span class=&quot;type&quot;&gt;Let&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;f&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Lambda&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;y&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Op&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;*&quot;&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;x&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;y&quot;&lt;/span&gt;)))&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;         (&lt;span class=&quot;type&quot;&gt;Let&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;x&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;4&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;            (&lt;span class=&quot;type&quot;&gt;Call&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;f&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;3&lt;/span&gt;)))))&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;-- Value 6.0&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;h2&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Let&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;x&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;3.9&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Op&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;/&quot;&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;x&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;4.32&lt;/span&gt;)))&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;-- Value 0.9027778&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;h2&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Let&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;x&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;8.75&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Op&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;&amp;gt;=&quot;&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Param&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;x&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;7&lt;/span&gt;)))&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;-- Boolean True&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;h2&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Op&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;==&quot;&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Boolean&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;True&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Boolean&lt;/span&gt; &lt;span class=&quot;type&quot;&gt;False&lt;/span&gt;))&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;-- Boolean False&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;h2&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Op&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;++&quot;&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;String&#39;&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;test&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;String&#39;&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot; case&quot;&lt;/span&gt;))&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;-- String&#39; &quot;test case&quot;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;title&quot;&gt;h2&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;If&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Op&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;&amp;gt;=&quot;&lt;/span&gt; (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;2.3&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;Value&lt;/span&gt; (-&lt;span class=&quot;number&quot;&gt;2.754&lt;/span&gt;))) (&lt;span class=&quot;type&quot;&gt;String&#39;&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;Yes&quot;&lt;/span&gt;) (&lt;span class=&quot;type&quot;&gt;String&#39;&lt;/span&gt; &lt;span class=&quot;string&quot;&gt;&quot;No&quot;&lt;/span&gt;))&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;-- String&#39; &quot;Yes&quot;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;hr&gt;
&lt;p&gt;参考资料：  &lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;http://www.yinwang.org/blog-cn/2012/08/01/interpreter&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;王垠 - 怎样写一个解释器&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://fallenwood.github.io/2017/02/04/writing-a-simple-lisp/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Fallenwood - 怎样写一个解释器&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;http://norvig.com/lispy.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;(How to Write a (Lisp) Interpreter (in Python))&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.zhihu.com/question/20115358&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;知乎 - 如何写 Lisp 解释器&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;原创作品，允许转载，转载时无需告知，但请务必以超链接形式标明文章&lt;a href=&quot;http://blog.forec.cn/2017/02/14/talk-about-interpreter/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;原始出处&lt;/a&gt;(&lt;a href=&quot;http://blog.forec.cn/2017/02/14/talk-about-interpreter/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;http://blog.forec.cn/2017/02/14/talk-about-interpreter/&lt;/a&gt;) 、作者信息（&lt;a href=&quot;http://forec.cn/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Forec&lt;/a&gt;）和本声明。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;blockquote&gt;
&lt;p&gt;这篇文章主要基于王垠早年发过的文章&lt;a href=&quot;http://www.yinwang.org/blog-cn/2012/08/01/interpreter&quot;&gt;《怎样写一个解释器》&lt;/a&gt;，我参考了 Racket 版本的 R2 解释器，并用 Haskell 实现 &lt;code&gt;H2Lang&lt;/code&gt; 的简单解释器，较 R2 的功能做了一点改进。&lt;/p&gt;
&lt;/blockquote&gt;
    
    </summary>
    
      <category term="Code" scheme="http://forec.github.io/categories/Code/"/>
    
    
      <category term="Haskell" scheme="http://forec.github.io/tags/Haskell/"/>
    
  </entry>
  
  <entry>
    <title>HMM 关键词检索</title>
    <link href="http://forec.github.io/2017/02/06/talk-about-hmm/"/>
    <id>http://forec.github.io/2017/02/06/talk-about-hmm/</id>
    <published>2017-02-06T08:22:30.000Z</published>
    <updated>2018-09-26T06:08:29.413Z</updated>
    
    <content type="html">&lt;blockquote&gt;
&lt;p&gt;记一下 HMM 的一些总是忘记的名词和计算过程。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;a id=&quot;more&quot;&gt;&lt;/a&gt;
&lt;h2 id=&quot;HMM&quot;&gt;&lt;a href=&quot;#HMM&quot; class=&quot;headerlink&quot; title=&quot;HMM&quot;&gt;&lt;/a&gt;HMM&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;离散一阶马尔可夫链：系统在 t 时刻状态只和其在 t-1 时刻的状态相关。&lt;/li&gt;
&lt;li&gt;马尔可夫模型：随机过程独立于时间 t，且状态转移概率 &lt;code&gt;Σ a_ij = 1 (j=1..N)&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;HMM 可观察到的事件是状态的随机函数，状态转移过程隐蔽（马尔可夫链），事件是一般随机过程。一个随机事件由观察值序列 &lt;code&gt;O = O_1, O_2, .., O_T&lt;/code&gt; 表示，该事件背后隐藏着实际的状态序列 &lt;code&gt;Q = q_1, q_2, .., q_T&lt;/code&gt;。HMM 的关键在于将两个序列联系起来，用可观察明字符组成的观察序列去表征由离散隐状态组成的状态序列（路径）。&lt;/li&gt;
&lt;li&gt;HMM 要求满足马尔可夫性假设（状态构成一阶马尔可夫链）、不动性假设（状态和具体时间无关）以及输出独立性假设（输出，也就是观察到的值仅与背后的状态有关）。&lt;/li&gt;
&lt;li&gt;HMM 由五元组 &lt;code&gt;λ = (N, M, A, B, π)&lt;/code&gt; 描述：&lt;ul&gt;
&lt;li&gt;&lt;code&gt;N = {q_1, q_2, .., q_N}&lt;/code&gt;：有限状态集合&lt;/li&gt;
&lt;li&gt;&lt;code&gt;M = {v_1, v_2, .., v_M}&lt;/code&gt;：有限观察值集合&lt;/li&gt;
&lt;li&gt;&lt;code&gt;A = {a_ij}&lt;/code&gt;：状态转移概率矩阵&lt;/li&gt;
&lt;li&gt;&lt;code&gt;B = {b_jk}, b_jk = P(O_t = v_k | q_t = Sj)&lt;/code&gt;：观察值概率分布矩阵&lt;/li&gt;
&lt;li&gt;&lt;code&gt;π = π_i&lt;/code&gt;：初始状态概率分布&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;给定 HMM 模型 &lt;code&gt;λ = (A, B, π)&lt;/code&gt;，观察序列通过状态的不断转移和 &lt;code&gt;B&lt;/code&gt; 矩阵产生，初始根据 &lt;code&gt;π&lt;/code&gt; 选择 &lt;code&gt;q_1&lt;/code&gt;，根据状态转移概率生成 &lt;code&gt;q_t&lt;/code&gt;，并根据 &lt;code&gt;q_t = i&lt;/code&gt; 和 &lt;code&gt;b_ik&lt;/code&gt; 生成 &lt;code&gt;O_t = v_k&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;对于给定模型 &lt;code&gt;λ = (π, A, B)&lt;/code&gt;，令 &lt;code&gt;O = O_1, O_2, .., O_T&lt;/code&gt; 为观察值序列，三个基本问题及解决方案：&lt;ul&gt;
&lt;li&gt;评估问题（前向算法）：对于给定模型，求任意观察值序列的概率 &lt;code&gt;P(O | λ)&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;解码问题（韦特比算法）：对于给定模型和观察值序列，求可能性最大的状态序列 &lt;code&gt;maxQ{P(Q | O, λ)}&lt;/code&gt;，也称 Q 为最优路径。即有效选择 “最优” 状态序列以尽量好地解释观察序列。&lt;/li&gt;
&lt;li&gt;学习问题（向前向后算法）：给定观察值序列，调整 &lt;code&gt;λ&lt;/code&gt; 使该观察值序列出现的概率 &lt;code&gt;P(O | λ)&lt;/code&gt; 最大。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;前向算法&quot;&gt;&lt;a href=&quot;#前向算法&quot; class=&quot;headerlink&quot; title=&quot;前向算法&quot;&gt;&lt;/a&gt;前向算法&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;α(t, i) = P(o_1, o_2, .., o_T, q_t = S_i | λ)&lt;/code&gt; 指 “在时刻 t，得到 t 之前的所有明符号序列，且时刻 t 的状态是 S_i” 这一事件的概率。&lt;ul&gt;
&lt;li&gt;&lt;code&gt;α(1, i) = P(o_1, q_1 = S_i | λ) = π(i)b(i, o_1)&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;递推：`α(t+1, j) = [Σ α(t, i) · a(i, j), i=1..N] × b(j, o_t+1)；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;α(T, i) = P(o_1, .., o_T, q_T = S_i | λ)&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;P(O | λ) = Σ α(T, i), (i = 1..N)&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;Viterbi-算法&quot;&gt;&lt;a href=&quot;#Viterbi-算法&quot; class=&quot;headerlink&quot; title=&quot;Viterbi 算法&quot;&gt;&lt;/a&gt;Viterbi 算法&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;算法和卷积码的韦特比解码同名，因为本质就一样。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;δ(t, i)&lt;/code&gt; 为在 1..t 时刻按照状态序列 &lt;code&gt;q_1, .., q_t&lt;/code&gt; 且 &lt;code&gt;q_t = S_i&lt;/code&gt; 能够产生出 &lt;code&gt;o_1, o_2, .., o_t&lt;/code&gt; 的最大概率，即 &lt;code&gt;δ(t, i) = max{ P(q_1, .., q_t-1, q_t = Si, o_1, .., o_t | λ) }&lt;/code&gt;。序列 &lt;code&gt;o&lt;/code&gt; 和系统 &lt;code&gt;λ&lt;/code&gt; 都是确定的，&lt;code&gt;max&lt;/code&gt; 根据序列 &lt;code&gt;q&lt;/code&gt; 的变动选取最优解。&lt;/li&gt;
&lt;li&gt;记忆变量：&lt;code&gt;φ(t, i)&lt;/code&gt; 记录概率最大路径上当前状态的前一个状态。&lt;/li&gt;
&lt;li&gt;初始化：&lt;code&gt;δ(1, i) = π(i)b(i, O_1)&lt;/code&gt;，&lt;code&gt;φ(1, i) = 0&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;递推 ：&lt;code&gt;δ(t, j) = max{δ(t-1, j) × a_ji} × b(i, O_t), 2 ≤ t ≤ T, 1 ≤ i ≤ N&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;终止：&lt;code&gt;p* = max{δ(T, i)}&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;路径回溯：&lt;code&gt;q* = φ(t+1, q*_t+1), t = T-1, T-2, .., 1&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;向前向后算法&quot;&gt;&lt;a href=&quot;#向前向后算法&quot; class=&quot;headerlink&quot; title=&quot;向前向后算法&quot;&gt;&lt;/a&gt;向前向后算法&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;最大似然估计无法解决学习问题，因为 HMM 中的状态序列为隐变量，无法被观察到。EM 算法由交替的 “期望” 过程（E）和 “极大似然估计” 过程（M）组成，E 过程从条件期望中构造完全数据的似然函数值，M 过程利用参数的统计量重新估计概率模型的参数，使训练数据对数似然最大。&lt;/li&gt;
&lt;li&gt;初始化：满足概率条件的情况下随机给 &lt;code&gt;π_i&lt;/code&gt;、&lt;code&gt;a_ij&lt;/code&gt; 和 &lt;code&gt;b_jk&lt;/code&gt; 赋值，得模型 &lt;code&gt;λ_0&lt;/code&gt;，设 &lt;code&gt;i = 0&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;E 过程：由 &lt;code&gt;λ_i&lt;/code&gt; 根据下面公式计算期望值 &lt;code&gt;ε(t, i, j)&lt;/code&gt;（给定模型和观察序列，在时间 t 位于状态 &lt;code&gt;S_i&lt;/code&gt;，时间 t+1 位于状态 &lt;code&gt;S_j&lt;/code&gt; 的概率） 和 &lt;code&gt;γ(t, i)&lt;/code&gt;（给定模型和观察序列，在时间 t 位于状态 i 的概率），E 过程的期望是根据上一个 M 过程重估后的模型计算的；&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight gcode&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;ε&lt;span class=&quot;comment&quot;&gt;(t, i, j)&lt;/span&gt; = P&lt;span class=&quot;comment&quot;&gt;(q_t = S_i, q_t+1 = S_j | O, λ)&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           = P&lt;span class=&quot;comment&quot;&gt;(q_t = S_i, q_t+1 = S_j, O | λ)&lt;/span&gt; / P&lt;span class=&quot;comment&quot;&gt;(O | λ)&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           = α&lt;span class=&quot;comment&quot;&gt;(t, i)&lt;/span&gt;· a&lt;span class=&quot;comment&quot;&gt;(i, j)&lt;/span&gt; · b&lt;span class=&quot;comment&quot;&gt;(j, O_t+1)&lt;/span&gt; · β&lt;span class=&quot;comment&quot;&gt;(t+1, j)&lt;/span&gt; / P&lt;span class=&quot;comment&quot;&gt;(O | λ)&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;           = α&lt;span class=&quot;comment&quot;&gt;(t, i)&lt;/span&gt;· a&lt;span class=&quot;comment&quot;&gt;(i, j)&lt;/span&gt; · b&lt;span class=&quot;comment&quot;&gt;(j, O_t+1)&lt;/span&gt; · β&lt;span class=&quot;comment&quot;&gt;(t+1, j)&lt;/span&gt; / &amp;#123;Σi Σj α&lt;span class=&quot;comment&quot;&gt;(t, i)&lt;/span&gt; · a&lt;span class=&quot;comment&quot;&gt;(i, j)&lt;/span&gt; · b&lt;span class=&quot;comment&quot;&gt;(j, O_t+1)&lt;/span&gt; · β&lt;span class=&quot;comment&quot;&gt;(t+1, j)&lt;/span&gt; &amp;#125;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;γ&lt;span class=&quot;comment&quot;&gt;(t, i)&lt;/span&gt; = Σj ε&lt;span class=&quot;comment&quot;&gt;(t, i, j)&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;M 过程：根据 E 过程得出的期望值，根据下面公式重新估计 &lt;code&gt;πi&lt;/code&gt;，&lt;code&gt;a_ij&lt;/code&gt; 和 &lt;code&gt;b_jk&lt;/code&gt;，得到模型 &lt;code&gt;λ_i+1&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight gcode&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;π&lt;span class=&quot;comment&quot;&gt;(i)&lt;/span&gt; = P&lt;span class=&quot;comment&quot;&gt;(q_1 = S_i)&lt;/span&gt; = γ&lt;span class=&quot;comment&quot;&gt;(1, i)&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;a&lt;span class=&quot;comment&quot;&gt;(i, j)&lt;/span&gt; = &amp;#123;Σt ε&lt;span class=&quot;comment&quot;&gt;(t, i, j)&lt;/span&gt;&amp;#125; / &amp;#123;Σt γ&lt;span class=&quot;comment&quot;&gt;(t, i)&lt;/span&gt;&amp;#125;, t = &lt;span class=&quot;number&quot;&gt;1.&lt;/span&gt;.T&lt;span class=&quot;number&quot;&gt;-1&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;b&lt;span class=&quot;comment&quot;&gt;(j, k)&lt;/span&gt; = &amp;#123;Σt γ&lt;span class=&quot;comment&quot;&gt;(t, j)&lt;/span&gt; × δ&lt;span class=&quot;comment&quot;&gt;(O_t, v_k)&lt;/span&gt;&amp;#125; / &amp;#123;Σt γ&lt;span class=&quot;comment&quot;&gt;(t, j)&lt;/span&gt;&amp;#125;, t = &lt;span class=&quot;number&quot;&gt;1.&lt;/span&gt;.T&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;重复 E、M 过程直到模型收敛。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;问题&quot;&gt;&lt;a href=&quot;#问题&quot; class=&quot;headerlink&quot; title=&quot;问题&quot;&gt;&lt;/a&gt;问题&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;前向算法、Viterbi 和 Baum-Welch 算法的概率值连续乘法运算容易下溢。&lt;/li&gt;
&lt;li&gt;前向算法中每步运算都可以乘一个比例因子 &lt;code&gt;c(t)&lt;/code&gt;，如下：&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;highlight stylus&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;α(t+&lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;, j) = [Σ α(t, i) · &lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;title&quot;&gt;a&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(i, j)&lt;/span&gt;&lt;/span&gt;, i=&lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;..N] × &lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;title&quot;&gt;b&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(j, o_t+&lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;α&lt;span class=&quot;string&quot;&gt;&#39;(t+1, j) = c(t) × [Σ α(t, i)&#39;&lt;/span&gt; · &lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;title&quot;&gt;a&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(i, j)&lt;/span&gt;&lt;/span&gt;, i=&lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;..N] × &lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;title&quot;&gt;b&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(j, o_t+&lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;title&quot;&gt;c&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(t)&lt;/span&gt;&lt;/span&gt; = &lt;span class=&quot;number&quot;&gt;1&lt;/span&gt; / Σ α(t, i) , &lt;span class=&quot;tag&quot;&gt;i&lt;/span&gt; = &lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;..N&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;ul&gt;
&lt;li&gt;Viterbi 算法可以将概率值取对数（乘积化为对数求和）。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;相关链接&quot;&gt;&lt;a href=&quot;#相关链接&quot; class=&quot;headerlink&quot; title=&quot;相关链接&quot;&gt;&lt;/a&gt;相关链接&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.zhihu.com/question/20962240&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;逼乎 “如何用通俗易懂的例子解释 HMM”&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;http://blog.csdn.net/ppn029012/article/details/8923501&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;我邮学长 Nong Bloody 的博客&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;http://www.hankcs.com/ml/hidden-markov-model.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;hankcs 的隐马模型笔记&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;p&gt;原创作品，允许转载，转载时无需告知，但请务必以超链接形式标明文章&lt;a href=&quot;http://blog.forec.cn/2017/02/06/talk-about-hmm/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;原始出处&lt;/a&gt;(&lt;a href=&quot;http://blog.forec.cn/2017/02/06/talk-about-hmm/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;http://blog.forec.cn/2017/02/06/talk-about-hmm/&lt;/a&gt;) 、作者信息（&lt;a href=&quot;http://forec.cn/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;Forec&lt;/a&gt;）和本声明。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;blockquote&gt;
&lt;p&gt;记一下 HMM 的一些总是忘记的名词和计算过程。&lt;/p&gt;
&lt;/blockquote&gt;
    
    </summary>
    
      <category term="计算机理论基础" scheme="http://forec.github.io/categories/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80/"/>
    
    
      <category term="Algorithms" scheme="http://forec.github.io/tags/Algorithms/"/>
    
      <category term="机器学习" scheme="http://forec.github.io/tags/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/"/>
    
  </entry>
  
</feed>