什么是参照透明性？

我已经看到在命令式范式中

f（x）+ f（x）

可能与以下内容不同：

2 * f（x）

但是在功能范式中应该相同。我曾尝试在Python和Scheme中实现这两种情况，但对我来说，它们看起来非常简单。

有什么例子可以指出与给定功能的区别？

引用透明性，指的是一个函数，表示您只能通过查看其参数的值来确定应用该函数的结果。您可以使用任何编程语言（例如Python，Scheme，Pascal，C）编写参照透明函数。

另一方面，在大多数语言中，您也可以编写非参照透明的函数。例如，以下Python函数：

counter = 0

def foo(x):
  global counter

  counter += 1
  return x + counter

不是参照透明的，实际上是在调用

foo(x) + foo(x)

和

2 * foo(x)

对于任何参数，都会产生不同的值x。这样做的原因是该函数使用并修改了全局变量，因此每次调用的结果都取决于此变化的状态，而不仅取决于函数的参数。

Haskell中，一个纯粹的功能语言，严格分离表达的评价，其中纯函数被应用，并且其总是引用透明，从动作执行（特殊值的处理），这是不引用透明，即执行相同的动作可以在每个时间结果不同。

因此，对于任何Haskell函数

f :: Int -> Int

和任何整数x，总是这样

2 * (f x) == (f x) + (f x)

一个动作的例子是库函数的结果getLine：

getLine :: IO String

作为表达式评估的结果，此函数（实际上是一个常量）首先产生type的纯值IO String。这种类型的值是与其他值一样的值：您可以传递它们，将它们放入数据结构中，使用特殊函数进行组合，等等。例如，您可以列出如下操作：

[getLine, getLine] :: [IO String]

动作是特殊的，您可以通过编写以下代码来告知Haskell运行时执行它们：

main = <some action>

在这种情况下，启动Haskell程序时，运行时将遍历绑定的动作main并执行该动作，可能会产生副作用。因此，动作执行不是参照透明的，因为两次执行相同的动作会产生不同的结果，具体取决于运行时输入的内容。

得益于Haskell的类型系统，操作永远不能在需要其他类型的上下文中使用，反之亦然。因此，如果要查找字符串的长度，可以使用以下length函数：

length "Hello"

将返回5。但是，如果您要查找从终端读取的字符串的长度，则无法写

length (getLine)

因为您收到类型错误：length期望输入类型为list（而字符串实际上是一个列表），但它getLine是类型的值IO String（动作）。这样，类型系统确保不会将type getLine（的执行值在核心语言之外执行，并且可能是非参照透明的）动作值隐藏在type的非动作值中Int。

编辑

为了回答突出问题，这是一个小的Haskell程序，该程序从控制台读取一行并打印其长度。

main :: IO () -- The main program is an action of type IO ()
main = do
          line <- getLine
          putStrLn (show (length line))

主要动作由两个子动作组成，这些子动作顺序执行：

1. getline型IO String，
2. 第二种是通过评估其参数上putStrLn的type 函数来构造的String -> IO ()。

更确切地说，第二个动作是由

1. 绑定line到第一个操作读取的值，
2. 评估纯函数length（将长度计算为整数），然后show（将整数转换为字符串），
3. 通过将函数应用putStrLn到结果来建立动作show。

此时，可以执行第二个动作。如果您键入“ Hello”，它将打印“ 5”。

请注意，如果使用<-表示法从某个操作中获取一个值，则只能在另一个操作中使用该值，例如，您不能编写：

main = do
          line <- getLine
          show (length line) -- Error:
                             -- Expected type: IO ()
                             --   Actual type: String

因为show (length line)具有类型，String而do表示法则要求一个操作（getLine类型IO String）后面跟随另一个操作（例如putStrLn (show (length line))类型IO ()）。

编辑2

约尔格·米塔格（JörgW Mittag）对参照透明的定义比我的定义更为笼统（我赞成他的回答）。我使用了一个受限制的定义，因为问题中的示例着重于函数的返回值，并且我想说明这一方面。但是，RT通常是指整个程序的含义，包括对全局状态的更改以及由于评估表达式而导致的与环境（IO）的交互。因此，对于正确的一般定义，您应该参考该答案。

def f(x): return x()

from random import random
f(random) + f(random) == 2*f(random)
# => False

但是，这不是引用透明性的含义。RT表示您可以在不改变程序含义的情况下，用评估该表达式的结果来替换该程序中的任何表达式（反之亦然）。

以下面的程序为例：

def f(): return 2

print(f() + f())
print(2)

该程序是参照透明的。我可以用替换一个或两个出现f()的地方2，它仍然可以正常工作：

def f(): return 2

print(2 + f())
print(2)

要么

def f(): return 2

print(f() + 2)
print(2)

要么

def f(): return 2

print(2 + 2)
print(f())

都将表现相同。

好吧，实际上，我被骗了。我应该能够print用其返回值（根本没有值）替换对的调用，而无需更改程序的含义。但是，很明显，如果我只删除这两个print语句，程序的含义将发生变化：之前，它在屏幕上打印了一些内容，之后则没有。I / O不是参照透明的。

简单的经验法则是：如果可以在程序中的任何位置用该表达式，子表达式或子例程的返回值替换任何表达式，子表达式或子例程的调用，而无需更改程序的含义，则您具有引用透明度。实际上，这意味着您不能拥有任何I / O，不能具有任何可变状态，不能具有任何副作用。在每个表达式中，表达式的值必须仅取决于表达式组成部分的值。并且在每个子例程调用中，返回值必须仅取决于参数。

这个答案的一部分直接取自我的GitHub帐户上托管的未完成的函数式编程教程：

如果函数在给定相同的输入参数的情况下始终产生相同的输出（返回值），则称该函数为参照透明的。如果正在寻找纯函数式编程的理由，那么引用透明性是一个很好的选择。当用代数，算术和逻辑中的公式进行推理时，此属性（也称为“等于等于”的替代性）从根本上非常重要，因此通常认为这是理所当然的……

考虑一个简单的例子：

x = 42

在纯函数式语言中，等号的左手边和右手边可通过两种方式彼此替代。也就是说，与诸如C之类的语言不同，上述表示法确实声明了相等性。这样的结果是我们可以像数学方程式一样推理程序代码。

从Haskell Wiki：

每次调用时，纯计算都会产生相同的值。此属性称为参照透明性，可以对代码进行方程式推理。

与此相反，有时将由类C语言执行的操作类型称为破坏性分配。

术语“ 纯”通常用于描述与该讨论相关的表达式的属性。对于被认为是纯函数，

• 不允许出现任何副作用，并且
• 它必须是参照透明的。

根据许多数学教科书中发现的黑匣子隐喻，函数的内部与外界完全隔离。副作用是函数或表达式违反此原理时-即，允许该过程以某种方式与其他程序单元进行通信（例如，共享和交换信息）。

总而言之，在程序设计语言的语义中，引用透明性对于使函数的行为像true一样是必须的，数学函数也是如此。