Haskell/序言：IO，一个应用函子

序言：IO，一个应用函子

单子

序言：IO，一个应用函子
 理解单子
 Maybe
List
do 符号
 IO
State
Alternative 和 MonadPlus
单子变换器

函子的出现是本书发展过程中的一个分水岭。在本序言中，我们将开始揭示这些原因，为本书接下来的几章奠定基础。虽然我们在这里使用的代码示例非常简单，但我们将利用它们引入几个新的重要概念，这些概念将在本书的后面章节中重新审视和进一步发展。因此，我们建议你以轻松的节奏学习本章，这将为你思考每一步的含义以及在 GHCi 中尝试代码示例留出空间。

场景 1 : `Applicative`

我们的初始示例将使用 Text.Read 模块提供的函数 readMaybe。

GHCi> :m +Text.Read
GHCi> :t readMaybe
readMaybe :: Read a => String -> Maybe a

readMaybe 提供了一种简单的方法将字符串转换为 Haskell 值。如果提供的字符串具有正确的格式，可以被读取为类型为 a 的值，则 readMaybe 会将转换后的值包装在 Just 中；否则，结果为 Nothing。

GHCi> readMaybe "3" :: Maybe Integer
Just 3
GHCi> readMaybe "foo" :: Maybe Integer
Nothing
GHCi> readMaybe "3.5" :: Maybe Integer
Nothing
GHCi> readMaybe "3.5" :: Maybe Double
Just 3.5

注意

为了使用 readMaybe，我们需要指定我们要读取的类型。大多数情况下，这可以通过类型推断和我们代码中的签名来完成。然而，有时，直接添加一个类型注释比编写一个完整的签名更方便。例如，在上面的第一个示例中，readMaybe "3" :: Maybe Integer 中的 :: Maybe Integer 表明 readMaybe "3" 的类型为 Maybe Integer。

我们可以使用 readMaybe 来编写一个类似于简单输入和输出章节中程序的程序，该程序

通过命令行获取用户提供的字符串；
尝试将其读取为数字（我们使用 Double 作为类型）；以及
如果读取成功，则打印你的数字乘以 2；否则，打印一条解释性消息并重新开始。

注意

在继续之前，我们建议你尝试编写这个程序。除了 readMaybe 之外，你可能会发现 getLine、putStrLn 和 show 很有用。如果你需要回顾如何从控制台读取和打印，请查看简单输入和输出章节。

这是一个可能的实现

import Text.Read

interactiveDoubling = do
    putStrLn "Choose a number:"
    s <- getLine
    let mx = readMaybe s :: Maybe Double
    case mx of
        Just x -> putStrLn ("The double of your number is " ++ show (2*x))
        Nothing -> do
            putStrLn "This is not a valid number. Retrying..."
            interactiveDoubling

GHCi> interactiveDoubling 
Choose a number:
foo
This is not a valid number. Retrying...
Choose a number:
3
The double of your number is 6.0

简洁明了。这个解决方案的一个变体可能会利用 Maybe 是一个 Functor 的事实，从而在 case 语句中解包 mx 之前将值加倍

interactiveDoubling = do
    putStrLn "Choose a number:"
    s <- getLine
    let mx = readMaybe s :: Maybe Double
    case fmap (2*) mx of
        Just d -> putStrLn ("The double of your number is " ++ show d)
        Nothing -> do
            putStrLn "This is not a valid number. Retrying..."
            interactiveDoubling

在这种情况下，这样做没有真正的优势。但请记住这种可能性。

函子中的应用

现在，让我们做一些稍微复杂的事情：使用 readMaybe 读取两个数字并打印它们的和（我们建议你在继续之前也尝试编写这个程序）。

这是一个解决方案

interactiveSumming = do
    putStrLn "Choose two numbers:"
    sx <- getLine
    sy <- getLine
    let mx = readMaybe sx :: Maybe Double
        my = readMaybe sy
    case mx of
        Just x -> case my of
            Just y -> putStrLn ("The sum of your numbers is " ++ show (x+y))
            Nothing -> retry
        Nothing -> retry
    where
    retry = do
        putStrLn "Invalid number. Retrying..."
        interactiveSumming

GHCi> interactiveSumming
Choose two numbers:
foo
4
Invalid number. Retrying...
Choose two numbers:
3
foo
Invalid number. Retrying...
Choose two numbers:
3
4
The sum of your numbers is 7.0

interactiveSumming 有效，但写起来有点烦人。特别是嵌套的 case 语句不太美观，并且使代码的可读性降低。如果有一种方法可以在解包它们之前对数字求和，类似于我们在 interactiveDoubling 的第二个版本中对 fmap 所做的操作，我们就可以只使用一个 case

-- Wishful thinking...
    case somehowSumMaybes mx my of
        Just z -> putStrLn ("The sum of your numbers is " ++ show z)
        Nothing -> do
            putStrLn "Invalid number. Retrying..."
            interactiveSumming

但我们应该用什么来代替 somehowSumMaybes 呢？fmap 就足够了。虽然 fmap (+) 能够很好地将 (+) 部分应用于 Maybe 包装的值...

GHCi> :t (+) 3
(+) 3 :: Num a => a -> a
GHCi> :t fmap (+) (Just 3)
fmap (+) (Just 3) :: Num a => Maybe (a -> a)

... 但我们不知道如何将包装在 Maybe 中的函数应用于第二个值。为此，我们需要一个具有以下签名的函数...

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b

... 它将被这样使用

GHCi> fmap (+) (Just 3) <*> Just 4
Just 7

然而，此示例中的 GHCi 提示并不是空想：(<*>) 确实存在，如果你在 GHCi 中尝试它，它实际上会起作用！如果我们使用 fmap 的中缀别名 (<$>)，这个表达式看起来更简洁

GHCi> (+) <$> Just 3 <*> Just 4
Just 7

(<*>) 的实际类型比我们刚刚写的更通用。检查它...

GHCi> :t (<*>)
(<*>) :: Applicative f => f (a -> b) -> f a -> f b

... 为我们介绍了一个新的类型类：Applicative，即应用函子的类型类。为了进行初步解释，我们可以说，应用函子是一个支持在函子内应用函数的函子，因此允许对部分应用（以及因此对多个参数的函数）进行流畅的使用。所有 Applicative 的实例都是 Functor，除了 Maybe 之外，还有许多其他常见的 Functor 也是 Applicative。

这是 Maybe 的 Applicative 实例

instance Applicative Maybe where
    pure                  = Just
    (Just f) <*> (Just x) = Just (f x)
    _        <*> _        = Nothing

(<*>) 的定义实际上非常简单：如果两个值都不是 Nothing，则将函数 f 应用于 x，并用 Just 包装结果；否则，返回 Nothing。请注意，该逻辑与 interactiveSumming 的嵌套 case 语句所做的逻辑完全等效。

请注意，除了 (<*>) 之外，上面的实例中还有一个方法 pure

GHCi> :t pure
pure :: Applicative f => a -> f a

pure 接收一个值，并以默认的、简单的方式将其带入函子。对于 Maybe，简单的方式相当于用 Just 包装值——非简单的方式将是丢弃值并返回 Nothing。使用 pure，我们可以将上面的三加四的示例改写为...

GHCi> (+) <$> pure 3 <*> pure 4 :: Num a => Maybe a
Just 7

... 甚至

GHCi> pure (+) <*> pure 3 <*> pure 4 :: Num a => Maybe a
Just 7

就像 Functor 类有一些指定了合理实例应该如何工作的定律一样，Applicative 也有一个定律集。这些定律规定了通过 pure 将值“简单地”带入函子的方式。由于本书的这一部分有很多内容，所以我们现在不会讨论这些定律；但是，我们将在不久的将来重新审视这个重要主题。

注意

无论如何，如果你好奇，请随意浏览应用函子章节并阅读其“应用函子定律”小节。如果你选择去那里，你也可以看一下“ZipList”部分，它提供了一个额外的常见应用函子的示例，可以仅使用我们目前所学到的知识来理解。

为了总结，这里是一个使用 (<*>) 增强后的 interactiveSumming 版本

interactiveSumming = do
    putStrLn "Choose two numbers:"
    sx <- getLine
    sy <- getLine
    let mx = readMaybe sx :: Maybe Double
        my = readMaybe sy
    case (+) <$> mx <*> my of
        Just z -> putStrLn ("The sum of your numbers is " ++ show z)
        Nothing -> do
            putStrLn "Invalid number. Retrying..."
            interactiveSumming

场景 2 : `IO`

在上面的示例中，我们一直将 getLine 等 I/O 操作视为理所当然。我们现在发现自己处于一个适宜的时刻，可以重新审视在许多章节之前提出的一个问题：getLine 的类型是什么？

回到简单输入和输出章节，我们看到这个问题的答案是

GHCi> :t getLine
getLine :: IO String

使用我们自那时以来所学到的知识，我们现在可以看出 IO 是一个具有一个类型变量的类型构造器，在 getLine 的情况下，该类型变量恰好被实例化为 String。然而，这并没有触及问题的核心：IO String 到底是什么意思，它与普通的 String 有什么区别呢？

引用透明性

Haskell 的一个关键特性是所有我们可以编写的表达式都是引用透明的。这意味着我们可以用任何表达式的值来替换任何表达式，而不会改变程序的行为。例如，考虑这个非常简单的程序

addExclamation :: String -> String
addExclamation s = s ++ "!"

main = putStrLn (addExclamation "Hello")

它的行为完全不出所料

GHCi> main
Hello!

鉴于addExclamation s = s ++ "!"，我们可以重写main，使其不再提及addExclamation。我们只需在addExclamation定义的右侧将s替换为"Hello"，然后将addExclamation "Hello"替换为结果表达式。正如广告所说，程序行为不会改变

GHCi> let main = putStrLn ("Hello" ++ "!")
GHCi> main
Hello!

引用透明确保了这种替换方式是有效的。这种保证扩展到任何 Haskell 程序中的任何地方，这在很大程度上使程序更容易理解，并且更容易预测其行为。

现在，假设getLine的类型是String。在这种情况下，我们可以将它用作addExclamation的参数，如下所示

-- Not actual code.
main = putStrLn (addExclamation getLine)

但是，在这种情况下，一个新问题会出现：如果getLine是一个String，它是哪个String？没有令人满意的答案：它可以是"Hello"、"Goodbye"，或者用户选择在终端输入的任何其他内容。然而，替换getLine为任何String都会破坏程序，因为用户将无法再在终端输入字符串。因此，getLine具有String类型将破坏引用透明性。所有其他 I/O 操作也是如此：它们的返回值是不透明的，因为不可能事先知道它们，因为它们依赖于程序外部的因素。

拨开迷雾

正如getLine所示，I/O 操作存在一个基本的非确定性。为了保持引用透明性，必须尊重这种非确定性。在 Haskell 中，这是通过IO类型构造函数来实现的。getLine是一个IO String意味着它不是任何实际的String，而是对将在程序执行时才会实现的String的占位符，以及对将确实交付此String的承诺（在getLine的情况下，是通过从终端中吸取它来实现）。因此，当我们操作IO String时，我们是在为这个未知的String一旦出现将要做什么制定计划。有许多方法可以做到这一点。在本节中，我们将考虑其中两种方法；我们将在接下来的几章中添加第三种方法。

处理一个实际上不存在的值的想法起初可能看起来很奇怪。但是，我们已经讨论过至少一个与它并不完全相同的例子，而没有眨一下眼睛。如果mx是一个Maybe Double，那么fmap (2*) mx会将值加倍如果它在那里，并且无论值是否实际存在，它都能正常工作。^[1] Maybe a和IO a都隐含地表明，由于不同的原因，在访问类型为a的相应值时存在一层间接性。既然如此，就不足为奇的是，与Maybe一样，IO是一个Functor，其中fmap是最基本的方式来跨越间接性。

首先，我们可以利用IO是一个Functor的事实，用更紧凑的东西来替换上一节末尾的interactiveSumming中的let定义

interactiveSumming :: IO ()
interactiveSumming = do
    putStrLn "Choose two numbers:"
    mx <- readMaybe <$> getLine -- equivalently: fmap readMaybe getLine
    my <- readMaybe <$> getLine
    case (+) <$> mx <*> my :: Maybe Double of
        Just z -> putStrLn ("The sum of your numbers is " ++ show z)
        Nothing -> do
            putStrLn "Invalid number. Retrying..."
            interactiveSumming

readMaybe <$> getLine可以理解为“一旦getLine交付一个字符串，无论它是什么，都将readMaybe应用于它”。引用透明性没有受到损害：readMaybe <$> getLine背后的值与getLine一样不透明，并且它的类型（在本例中是IO (Maybe Double)）阻止我们用任何确定的值（例如，Just 3）来替换它，因为这会违反引用透明性。

除了是一个Functor之外，IO也是一个Applicative，它为我们提供了第二种方法来操作 I/O 操作传递的值。我们将用一个interactiveConcatenating操作来演示它，该操作与interactiveSumming在精神上相似。第一个版本就在下面。你能预测如何用(<*>)来简化它吗？

interactiveConcatenating :: IO ()
interactiveConcatenating = do
    putStrLn "Choose two strings:"
    sx <- getLine
    sy <- getLine
    putStrLn "Let's concatenate them:"
    putStrLn (sx ++ sy)

这是一个利用(<*>)的版本

interactiveConcatenating :: IO ()
interactiveConcatenating = do
    putStrLn "Choose two strings:"
    sz <- (++) <$> getLine <*> getLine
    putStrLn "Let's concatenate them:"
    putStrLn sz

(++) <$> getLine <*> getLine是一个 I/O 操作，它由两个其他 I/O 操作（两个getLine）组成。当它被执行时，这两个 I/O 操作被执行，它们传递的字符串被连接起来。需要注意的重要一点是，(<*>)在它组合的操作之间保持了一致的执行顺序。执行顺序在处理 I/O 时很重要——这种情况不胜枚举，但作为开场白，请考虑以下问题：如果我们在上面的示例中用(take 3 <$> getLine)替换第二个getLine，哪个在终端输入的字符串将被缩短到三个字符？

由于(<*>)尊重操作顺序，它提供了一种顺序执行它们的途径。特别是，如果我们只对顺序感兴趣，并不关心第一个操作的结果，我们可以使用\_ y -> y来丢弃它

GHCi> (\_ y -> y) <$> putStrLn "First!" <*> putStrLn "Second!"
First!
Second!

这种常用的模式有一个专门的操作符：(*>)。

u *> v = (\_ y -> y) <$> u <*> v

GHCi> :t (*>)
(*>) :: Applicative f => f a -> f b -> f b
GHCi> putStrLn "First!" *> putStrLn "Second!"
First!
Second!

它可以很容易地应用于interactiveConcatenating示例

interactiveConcatenating :: IO ()
interactiveConcatenating = do
    putStrLn "Choose two strings:"
    sz <- (++) <$> getLine <*> getLine
    putStrLn "Let's concatenate them:" *> putStrLn sz

或者，更进一步

interactiveConcatenating :: IO ()
interactiveConcatenating = do
    sz <- putStrLn "Choose two strings:" *> ((++) <$> getLine <*> getLine)
    putStrLn "Let's concatenate them:" *> putStrLn sz

注意，每个(*>)都替换了do块中的一个神奇的换行符，这些换行符使操作一个接一个地执行。事实上，这就是替换换行符的全部内容：它们只是(*>)的语法糖。

早些时候，我们说过，一个 functor 为访问其内部的值添加了一层间接性。这个观察的另一面是，间接性是由一个上下文引起的，值是在这个上下文中找到的。对于IO来说，间接性在于值只有在程序执行时才会确定，而上下文由用于生成这些值的指令序列组成（在getLine的情况下，这些指令相当于“从终端吸取一行文本”）。从这个角度来看，(<*>)获取两个 functor 值，并将内部的值和上下文本身结合起来。在IO的情况下，组合上下文意味着将一个 I/O 操作的指令追加到另一个 I/O 操作的指令，从而对操作进行排序。

开始的结束

本章有点像旋风！让我们回顾一下我们在本章中讨论的关键点

Applicative是应用 functor的Functor的子类，应用 functor 是支持函数应用而不会离开 functor 的 functor。
Applicative的(<*>)方法可以用作fmap对多个参数的泛化。
IO a不是类型为a的具体值，而是对将在程序执行时才会实现的a值的占位符，以及通过某种方式传递此值的承诺。这使得即使在处理 I/O 操作时也能保持引用透明性。
IO是一个 functor，更具体地说，它是Applicative的一个实例，它提供了一种方法来修改 I/O 操作生成的值，尽管存在非确定性。
一个 functor 值可以看作是由一个上下文中的值组成。(<$>)操作符（即，fmap）会穿过上下文来修改底层的值。(<*>)操作符会将两个 functor 值的上下文和底层值都结合起来。
在IO的情况下，(<*>)以及密切相关的(*>)通过对 I/O 操作进行排序来组合上下文。
do块的作用很大程度上只是为(*>)提供语法糖。