在涉及到函数式编程中的单子（Monads）后，这种特性是否真的使一个语言变得纯粹，或者它只是计算机系统在现实世界中推理的另一种“get out of jail free card”，超出了黑板数学的范畴？
编辑：
这并不是某些人所说的煽动争端，而是一个真正的问题。我希望有人可以给我提供证据，证明它是纯粹的。
此外，我将与其他不太纯的函数式语言以及使用良好设计的一些面向对象语言进行比较，并评估它们的纯度。到目前为止，在我极其有限的函数式编程世界中，我仍然没有理解单子的纯度。不过你会很高兴知道，我喜欢不可变性的概念，因为它在保持纯度方面更加重要。
请看下面的迷你语言：
data Action = Get (Char -> Action) | Put Char Action | End
Get f 的意思是：读取一个字符 c，并执行动作 f c。
Put c a 的意思是：写入字符 c，并执行动作 a。
下面是一个程序，它会打印出 "xy"，然后要求输入两个字母并将它们以相反的顺序打印出来：
Put 'x' (Put 'y' (Get (\a -> Get (\b -> Put b (Put a End)))))
conditionally p = Get (\a -> if a == 'Y' then p else End)
这是一个类型为Action -> Action的程序，它需要一个程序并提供另一个程序，在执行前需要询问确认。下面是另一个例子：
printString = foldr Put End
String -> Action的函数，它接受一个字符串并返回一个程序，该程序会写入该字符串，例如：Put 'h' (Put 'e' (Put 'l' (Put 'l' (Put 'o' End))))。
Haskell中的IO也是类似的。虽然执行需要执行副作用，但你可以以纯粹的方式构建复杂的程序，而不必执行它们。你正在计算程序的描述（IO操作），而不是实际执行它们。
在像C这样的语言中，您可以编写一个函数void execute(Action a)来实际执行程序。在Haskell中，您通过编写main = a来指定该操作。编译器创建一个执行该操作的程序，但您没有其他执行操作的方法（除了脏技巧）。
显然，Get和Put不是唯一的选项，您可以将许多其他API调用添加到IO数据类型中，例如对文件或并发性进行操作。
添加结果值
现在考虑以下数据类型。
data IO a = Get (Char -> Action) | Put Char Action | End a
前面提到的Action类型相当于IO ()，即一个始终返回"unit"（可视为"void"）的IO值。
这个类型与Haskell IO非常相似，只不过在Haskell中，IO是一个抽象数据类型（你无法访问其定义，仅能使用一些方法）。
这些是带有结果的IO操作。一个类似于这样的值：
Get (\x -> if x == 'A' then Put 'B' (End 3) else End 4)
类型为IO Int，对应于一个C程序：
int f() {
char x;
scanf("%c", &x);
if (x == 'A') {
printf("B");
return 3;
} else return 4;
}
评估和执行
评估和执行是有区别的。您可以评估任何Haskell表达式并获得一个值；例如，将2 + 2 :: Int评估为4 :: Int。只有类型为IO a的Haskell表达式才能被执行。这可能会产生副作用；执行Put 'a' (End 3)将字母a放在屏幕上。如果您评估一个IO值，就像这样：
if 2+2 == 4 then Put 'A' (End 0) else Put 'B' (End 2)
你将获得：
Put 'A' (End 0)
但是没有副作用 - 你只进行了一次评估，这是无害的。
你会如何翻译？
bool comp(char x) {
char y;
scanf("%c", &y);
if (x > y) { //Character comparison
printf(">");
return true;
} else {
printf("<");
return false;
}
}
如何将其转换为IO值？
首先，我们需要修复一些字符，比如 'v'。现在 comp('v') 是一个IO操作，它会将给定的字符与 'v' 进行比较。同样地，comp('b') 是一个IO操作，它会将给定的字符与 'b' 进行比较。通常情况下，comp 是一个接受字符并返回IO操作的函数。
作为一个C程序员，你可能会认为 comp('b') 是一个布尔值。在C语言中，评估和执行是相同的（即它们意味着相同的事情，或者同时发生）。但在Haskell中不是这样的。 comp('b') 评估 为一些IO操作，该操作在 执行 后返回一个布尔值。（确切地说，它评估为上面的代码块，只是将 'b' 替换为 x。）
comp :: Char -> IO Bool
comp x = Get (\y -> if x > y then Put '>' (End True) else Put '<' (End False))
comp 'b' 的评估结果为Get (\y -> if 'b' > y then Put '>' (End True) else Put '<' (End False))。这在数学上也是有意义的。在C中，int f() 是一个函数。对于数学家来说，这是没有意义的-一个没有参数的函数？函数的目的是接受参数。函数int f()应该等价于int f。但实际上并不是这样，因为C语言中的函数将数学函数和IO操作混合在一起。这些IO值是第一类的。就像你可以有一个包含整数元组的列表的列表[[(0,2),(8,3)],[(2,8)]]一样，你也可以使用IO构建复杂的值。 (Get (\x -> Put (toUpper x) (End 0)), Get (\x -> Put (toLower x) (End 0)))
:: (IO Int, IO Int)
一个IO操作的元组：第一个操作读取一个字符并将其转换为大写后打印，第二个操作读取一个字符并返回其小写形式。
Get (\x -> End (Put x (End 0))) :: IO (IO Int)
一个读取字符 x 并结束的 IO 值，返回一个将 x 写入屏幕的 IO 值。
Haskell 有特殊的函数，可以轻松操作 IO 值。例如：
sequence :: [IO a] -> IO [a]
这个函数接受一个 IO 操作列表，并返回一个按顺序执行它们的 IO 操作。
单子
单子是一些组合子（比如上面的 conditionally），它们允许您更结构化地编写程序。有一个类型为的组合函数
IO a -> (a -> IO b) -> IO b
给定一个IO a和一个函数a -> IO b，返回类型为IO b的值。如果将第一个参数写成C函数a f()，第二个参数写成b g(a x)，则它将返回g(f(x))的程序。根据上述Action / IO的定义，您可以自己编写该函数。
请注意，单子对于纯度并不是必需的-您始终可以像我上面那样编写程序。
纯度
有关纯度的重要事情是引用透明性，并区分评估和执行。
在Haskell中，如果您有f x+f x，则可以将其替换为2*f x。在C中，f(x)+f(x)通常不等同于2*f(x)，因为f可能会在屏幕上打印某些内容或修改x。
由于纯度，编译器具有更大的自由度，可以更好地进行优化。它可以重新排列计算，而在C中，它必须考虑是否改变了程序的含义。
do a <- f x; b <- f x; return (a+b)。有一个高阶函数可以做到这一点：liftM2 (+) (f x) (f x)。 - sdcvvcputStr "hello" >> putStr "world"，就像您不能将列表[1,2]重新排列为[2,1]一样。不过，如果[1,2]或putStr "hello" >> putStr "world"是复杂计算的结果，则可以优化该计算，并且指导这些优化的原则相同，无论您是计算列表还是IO操作。例如，f x + f x可以优化为2 * f x，而在C语言中，您必须知道f没有副作用。 - sdcvvcAction），而不是调用函数的副作用。换句话说，原因不是“因为它不纯”，而是“因为它改变了非交换操作>>的顺序”。 - sdcvvc重要的是要理解，单子本身并没有什么特别之处-因此它们绝对不代表在这方面的“出狱卡”。实现或使用单子不需要编译器（或其他）魔法，它们在Haskell的纯函数环境中定义。特别地，sdcvvc已经展示了如何以纯函数方式定义单子，而不需要任何实现后门。
vector<char> read(filepath_t)
pair<vector<char>, world_t> read(world_t, filepath_t)
这实际上是每个Haskell IO操作的工作方式。
现在我们有了一个IO的纯模型。谢天谢地。如果我们不能做到这一点，那么Lambda演算和图灵机可能不是等价的形式化方法，那么我们就需要解释一些问题。我们还没有完成，但我们面临的两个问题很容易：
world_t结构中放什么？每一粒沙子、每一片草、每一颗心碎和每一个金色日落的描述？
我们有一个非正式的规则，只使用一次世界——在每个IO操作之后，我们抛弃使用它的世界。然而，由于所有这些世界都在飘荡，我们注定会把它们搞混。
第一个问题很容易解决。只要我们不允许检查世界，就不需要为其存储任何内容。我们只需要确保新的世界不等于以前的任何一个世界（否则编译器可能会狡猾地优化掉一些产生世界的操作，就像在C++中有时会做的那样）。有许多处理这个问题的方法。
至于世界混淆的问题，我们希望将世界传递隐藏在一个库中，这样就没有办法接触到世界，因此也就没有办法混淆它们。事实证明，单子是隐藏计算中的“侧通道”的一种很好的方法。于是就有了IO单子。
一段时间以前，Haskell邮件列表上问过像你这样的问题，我在那里更详细地讨论了“侧通道”。以下是Reddit线程（其中链接到我的原始电子邮件）：
http://www.reddit.com/r/haskell/comments/8bhir/why_the_io_monad_isnt_a_dirty_hack/
main = putStrLn "Hello"的值是一个动作，它会打印“hello”，如果有人正在编译它并执行它。执行该动作的肮脏技巧在Haskell之外。在Haskell中，您无法执行操作（IO），只能计算操作并希望外部事物为您执行它。 - mb14>>= 时，它检查是 Left（异常）还是 Right（正常值）。虽然它与命令式编程中的异常非常相似，但它是纯的。IO monad 做同样的事情。尝试向我的答案中添加 Throw 和 Catch 功能。你似乎对 monad 有相当强烈的看法，但还没有完全理解它们 - 这很糟糕！ - sdcvvcHaskell是真正的纯函数式编程语言吗？
从绝对意义上来说：不是。
你运行程序的固态图灵机器——无论是Haskell还是其他语言——都是一个具有状态和效应的设备。为了让任何程序使用其所有“特性”，程序将不得不使用状态和效应。
至于那个带有贬义的术语所归属的所有其他“含义”：
在一台最显著特征是状态的机器上假定一种无状态的计算模型，似乎是一个奇怪的想法，至少可以这么说。模型和机器之间的差距很大，因此弥合起来非常昂贵。没有硬件支持功能可以抹去这个事实：这仍然是一个不好的实践想法。
这也被函数式语言的支持者们认识到了。他们以各种巧妙的方式引入了状态（和变量）。纯函数式的特性已经被牺牲和妥协了。旧的术语变得具有欺骗性。
使用单子类型是否真的使语言纯粹？
不是。这只是使用类型来划分：
你也可以像Clean一样使用唯一性类型...
IO类型的描述：IO类型用作与外部世界交互的操作（动作）的标记。 IO类型是抽象的：用户看不到任何构造函数。 IO是Monad和Functor类的实例。”IO是神奇的（具有实现但没有表示）[…]”
作为抽象类型，IO类型绝不是一个“免费出狱卡”——需要复杂的模型来解释Haskell中I/O的工作方式。更多详情请参见：
fixIO的语义》（The semantics of fixIO）这并非一直如此 - Haskell 最初拥有一个至少部分可见的 I/O 机制；最后一个拥有它的语言版本是 Haskell 1.2。当时，main 的类型为：
main :: [Response] -> [Request]
main :: Dialogue
where:
type Dialogue = [Response] -> [Request]
然而，Response和 Request虽然是庞大的数据类型，但却十分谦逊：
IO, return, (>>=)等的真正定义现在是针对每个Haskell实现具体而言的。I/O不是一个特别活跃的研究领域，但仍然在发现新的方法...
Haskell语言可能会有一个引用透明的I/O模型，这个模型不会引起太多争议...
import Control.Concurrent
import System.IO as IO
import Data.IORef as IOR
import Control.Monad.STM
import Control.Concurrent.STM.TVar
limit = 150000
threadsCount = 50
-- Don't talk about purity in Haskell when we have race conditions
-- in unlocked memory ... PURE language don't need LOCKING because
-- there isn't any mutable state or another side effects !!
main = do
hSetBuffering stdout NoBuffering
putStr "Lock counter? : "
a <- getLine
if a == "y" || a == "yes" || a == "Yes" || a == "Y"
then withLocking
else noLocking
noLocking = do
counter <- newIORef 0
let doWork =
mapM_ (\_ -> IOR.modifyIORef counter (\x -> x + 1)) [1..limit]
threads <- mapM (\_ -> forkIO doWork) [1..threadsCount]
-- Sorry, it's dirty but time is expensive ...
threadDelay (15 * 1000 * 1000)
val <- IOR.readIORef counter
IO.putStrLn ("It may be " ++ show (threadsCount * limit) ++
" but it is " ++ show val)
withLocking = do
counter <- atomically (newTVar 0)
let doWork =
mapM_ (\_ -> atomically $ modifyTVar counter (\x ->
x + 1)) [1..limit]
threads <- mapM (\_ -> forkIO doWork) [1..threadsCount]
threadDelay (15 * 1000 * 1000)
val <- atomically $ readTVar counter
IO.putStrLn ("It may be " ++ show (threadsCount * limit) ++
" but it is " ++ show val)