了解 Haskell 中的纯函数和副作用 - putStrLn

Question

最近，我开始学习 Haskell，因为我想拓宽我对函数式编程的知识，我必须说到目前为止我真的很喜欢它。 我目前使用的资源是 Pluralsight 上的课程“Haskell Fundamentals Part 1”。 不幸的是，我在理解讲师关于以下代码的一段特别引述时遇到了一些困难，希望你们能对这个话题有所了解。

随附代码

helloWorld :: IO ()
helloWorld = putStrLn "Hello World"

main :: IO ()
main = do
    helloWorld
    helloWorld
    helloWorld

报价单

如果你在一个 do-block 中有多次相同的 IO 动作，它将被多次运行。 所以这个程序打印了 3 次字符串 'Hello World'。 这个例子有助于说明putStrLn不是一个有副作用的函数。 我们调用putStrLn函数一次来定义helloWorld变量。 如果putStrLn有打印字符串的副作用，它只会打印一次并且在主 do 块中重复的helloWorld变量不会有任何效果。

在大多数其他编程语言中，这样的程序只会打印一次“Hello World”，因为在调用putStrLn函数时会发生打印。 这种微妙的区别经常会绊倒初学者，所以想一想，并确保你理解为什么这个程序打印 'Hello World' 3 次，以及如果putStrLn函数将打印作为副作用，它为什么只打印一次.

我不明白的

对我来说，字符串 'Hello World' 被打印三遍似乎是很自然的。 我认为helloWorld变量（或函数？）是一种稍后调用的回调。 我不明白的是，如果putStrLn有副作用，它会导致字符串只打印一次。 或者为什么它只会在其他编程语言中打印一次。

假设在 C# 代码中，我认为它看起来像这样：

C# （小提琴）

using System;

public class Program
{
    public static void HelloWorld()
    {
        Console.WriteLine("Hello World");
    }

    public static void Main()
    {
        HelloWorld();
        HelloWorld();
        HelloWorld();
    }
}

我确信我忽略了一些非常简单的东西或误解了他的术语。 任何帮助将不胜感激。

编辑：

谢谢大家的答案！ 您的回答帮助我更好地理解了这些概念。 我认为它尚未完全点击，但我将来会重新讨论该主题，谢谢！

Answer 1

如果我们将helloWorld定义为局部变量，可能更容易理解作者的意思：

main :: IO ()
main = do
  let helloWorld = putStrLn "Hello World!"
  helloWorld
  helloWorld
  helloWorld

您可以将其与此类似 C# 的伪代码进行比较：

void Main() {
  var helloWorld = {
    WriteLine("Hello World!")
  }
  helloWorld;
  helloWorld;
  helloWorld;
}

即在 C# WriteLine是一个过程，它打印其参数并且不返回任何内容。 在 Haskell 中， putStrLn是一个函数，它接受一个字符串，并为您提供一个操作，该操作将在执行时打印该字符串。 这意味着写作之间绝对没有区别

do
  let hello = putStrLn "Hello World"
  hello
  hello

和

do
  putStrLn "Hello World"
  putStrLn "Hello World"

话虽如此，在这个例子中，差异并不是特别大，所以如果你不太明白作者在本节中试图得到的内容，现在就继续。

如果将它与 python 进行比较，效果会更好

hello_world = print('hello world')
hello_world
hello_world
hello_world

这里的关键是，在Haskell的IO动作是不需要被包裹在进一步的“回调”或诸如此类的事做“实”的价值观，以防止它们在执行-更确切地说，只有这样，才能做到让他们执行IS把它们放在一个特定的地方（即在main内的某个地方或从main产生的线程）。

这也不仅仅是一个客厅技巧，它最终会对您编写代码的方式产生一些有趣的影响（例如，这是 Haskell 并不真正需要您熟悉的任何常见控制结构的部分原因使用命令式语言，并且可以在函数方面做任何事情），但我又不会太担心这个（像这样的类比并不总是立即点击）

Answer 2

如果您使用实际执行某些操作的函数而不是helloWorld ，则可能更容易看到所描述的差异。 考虑以下几点：

add :: Int -> Int -> IO Int
add x y = do
  putStrLn ("I am adding " ++ show x ++ " and " ++ show y)
  return (x + y)

plus23 :: IO Int
plus23 = add 2 3

main :: IO ()
main = do
  _ <- plus23
  _ <- plus23
  _ <- plus23
  return ()

这将打印 3 次“我正在添加 2 和 3”。

在 C# 中，您可以编写以下内容：

using System;

public class Program
{
    public static int add(int x, int y)
    {
        Console.WriteLine("I am adding {0} and {1}", x, y);
        return x + y;
    }

    public static void Main()
    {
        int x;
        int plus23 = add(2, 3);
        x = plus23;
        x = plus23;
        x = plus23;
        return;
    }
}

哪个只会打印一次。

Answer 3

如果putStrLn "Hello World"的评估有副作用，那么 message 只会打印一次。

我们可以使用以下代码来近似该场景：

import System.IO.Unsafe (unsafePerformIO)
import Control.Exception (evaluate)

helloWorld :: ()
helloWorld = unsafePerformIO $ putStrLn "Hello World"

main :: IO ()
main = do
    evaluate helloWorld
    evaluate helloWorld
    evaluate helloWorld

unsafePerformIO执行IO操作并“忘记”它是一个IO操作，将其从由IO操作组合强加的通常顺序中解脱出来，并根据惰性求值的变幻莫测让效果发生（或不发生）。

evaluate采用纯值并确保在评估结果IO操作时评估该值 - 对我们来说它将是，因为它位于main的路径中。 我们在这里使用它来将某些值的评估与程序的执行联系起来。

此代码仅打印一次“Hello World”。 我们将helloWorld视为一个纯粹的值。 但这意味着它将在所有evaluate helloWorld调用之间共享。 那么为何不？ 毕竟是纯值，为什么要不必要地重新计算呢？ 第一个evaluate动作“弹出”“隐藏”效果，后面的动作只评估结果() ，不会引起任何进一步的影响。

Answer 4

有一个细节需要注意：在定义helloWorld只调用一次putStrLn函数。 在main函数中，您只需使用该putStrLn "Hello, World"的返回值三次。

讲师说putStrLn调用没有副作用，这是真的。 但是看看helloWorld的类型 - 它是一个 IO 操作。 putStrLn只是为您创建它。 稍后，您将其中 3 个与do块链接以创建另一个 IO 操作 - main 。 稍后，当您执行程序时，将运行该操作，这就是副作用所在。

位于 this- monads基础的机制。 这个强大的概念允许您使用一些副作用，例如以不直接支持副作用的语言进行打印。 您只需链接一些操作，该链将在您的程序开始时运行。 如果你想认真地使用 Haskell，你需要深入理解这个概念。