表示性语义是建立在建模语言的基础上，通过构建域来构成可表示性值。 函数式程序员使用术语值来描述基于语言重写规则的计算的收敛性。它的操作语义。

在1中，有两种语言的清晰度:

被建模的那个，目标语言 建模的语言，元语言

2、由于对象和元语言的紧密性，它们可能会被混淆。

作为一名语言实现者，我发现我需要经常记住这个区别。

所以Reddy教授，我可以这样解释你吗?

在函数式编程和语义的上下文中，术语引用 透明度不是指的透明。

如果你对词源感兴趣(比如。为什么这个概念有这个特殊的名字)，看看我关于这个主题的博客文章。这个术语来自哲学家/逻辑学家奎因。

The term "referential transparency" comes from analytical philosophy, the branch of philosophy that analyzes natural language constructs, statements and arguments based on the methods of logic and mathematics. In other words, it is the closest subject outside computer science to what we call programming language semantics. The philosopher Willard Quine was responsible for initiating the concept of referential transparency, but it was also implicit in the approaches of Bertrand Russell and Alfred Whitehead.

就其核心而言，“参考透明度”是一个非常简单明了的概念。“指涉物”一词在分析哲学中用来谈论一个表达所指代的事物。它与我们在编程语言语义中所说的“意义”或“外延”大致相同。以Andrew Birkett的博客文章为例，“苏格兰的首都”指的是爱丁堡市。这是“referent”的一个简单例子。

一个句子中的上下文是“引用透明的”，如果用另一个引用同一实体的术语替换该上下文中的一个术语不会改变其含义。例如

苏格兰议会在苏格兰首都开会。

意思和

苏格兰议会在爱丁堡开会。

因此，“苏格兰议会在……开会”是一个指涉透明的上下文。我们可以把“苏格兰的首府”换成“爱丁堡”而不改变它的意思。换句话说，上下文只关心术语所指的内容，而不关心其他内容。也就是说，上下文是“引用透明的”。

另一方面，在句子中，

自1999年以来，爱丁堡一直是苏格兰的首府。

我们不能做这样的替换。如果我们这样做，我们会得到“Edinburgh has been Edinburgh since 1999”，这是一个疯狂的说法，并且不能传达与原句子相同的意思。所以，“Edinburgh has been…”“自1999年以来”是指不透明的(指透明的反义词)。显然，它关心的东西比这个词所指的东西更重要。是什么?

像“苏格兰的首都”这样的词被称为“限定名词”，在很长一段时间里，它们并没有让逻辑学家和哲学家感到头痛。Russell和Quine把它们整理出来，说它们实际上不是“指涉的”，也就是说，认为上面的例子是用来指实体的是错误的。理解“爱丁堡自1999年以来一直是苏格兰的首都”的正确方法是说

苏格兰自1999年以来就有了首都，那就是爱丁堡。

这个句子不能变成一个疯狂的句子。问题解决了!奎因的观点是，自然语言是混乱的，或至少是复杂的，因为它是为了方便实际使用而设计的，但哲学家和逻辑学家应该通过正确的方式理解它们，从而使它们变得清晰。参考透明度是一种工具，用于带来这种意义的清晰度。

What does all this have to do with programming? Not very much, actually. As we said, referential transparency is a tool to be used in understanding language, i.e., in assigning meaning. Christopher Strachey, who founded the field of programming language semantics, used it in his study of meaning. His foundational paper "Fundamental concepts in programming languages" is available on the web. It is a beautiful paper and everybody can read and understand it. So, please do so. You will be much enlightened. He introduces the term "referential transparency" in this paragraph:

One of the most useful properties of expressions is that called by Quine referential transparency. In essence this means that if we wish to find the value of an expression which contains a sub-expression, the only thing we need to know about the sub-expression is its value. Any other features of the sub-expression, such as its internal structure, the number and nature of its components, the order in which they are evaluated or the colour of the ink in which they are written, are irrelevant to the value of the main expression.

The use of "in essence" suggests that Strachey is paraphrasing it in order to explain it in simple terms. Functional programmers seem to understand this paragraph in their own way. There are 9 other occurrences of "referential transparency" in the paper, but they don't seem to bother about any of the others. In fact, the whole paper of Strachey is devoted to explaining the meaning of imperative programming languages. But, today, functional programmers claim that imperative programming languages are not referentially transparent. Strachey would be turning in his grave.

We can salvage the situation. We said that natural language is "messy, or at least complicated" because it is made to be convenient for practical use. Programming languages are the same way. They are "messy, or at least complicated" because they are made to be convenient for practical use. That does not mean that they need to confuse us. They just have to be understood the right way, using a meta language that is referentially transparent so that we have clarity of meaning. In the paper I cited, Strachey does exactly that. He explains the meaning of imperative programming languages by breaking them down into elementary concepts, never losing clarity anywhere. An important part of his analysis is to point out that expressions in programming languages have two kinds of "values", called l-values and r-values. Before Strachey's paper, this was not understood and confusion reigned supreme. Today, the definition of C mentions it routinely and every C programmer understands the distinction. (Whether the programmers in other languages understand it equally well is hard to say.)

Both Quine and Strachey were concerned with the meaning of language constructions that involve some form of context-dependence. For example, our example "Edinburgh has been the capital of Scotland since 1999" signifies the fact that "capital of Scotland" depends on the time at which it is being considered. Such context-dependence is a reality, both in natural languages and programming languages. Even in functional programming, free and bound variables are to be interpreted with respect to the context in which they appear in. Context dependence of any kind blocks referential transparency in some way or the other. If you try to understand the meaning of terms without regard to the contexts they depend on, you would again end up with confusion. Quine was concerned with the meaning of modal logic. He held that modal logic was referentially opaque and it should be cleaned up by translating it into a referentially transparent framework (e.g., by regarding necessity as provability). He largely lost this debate. Logicians and philosophers alike found Kripke's possible world semantics to be perfectly adequate. Similar situation also reigns with imperative programming. State-dependence explained by Strachey and store-dependence explained by Reynolds (in a manner similar to Kripke's possible world semantics) are perfectly adequate. Functional programmers don't know much of this research. Their ideas on referential transparency are to be taken with a large grain of salt.

[Additional note: The examples above illustrate that a simple phrase such as "capital of Scotland" has multiple levels of meaning. At one level, we might be talking about the capital at the current time. At another level, we might talking about all possible capitals that Scotland might have had through the course of time. We can "zoom into" a particular context and "zoom out" to span all contexts quite easily in normal practice. The efficiency of natural language makes use of our ability to do so. Imperative programming languages are efficient in very much the same way. We can use a variable x on the right hand side of an assignment (the r-value) to talk about its value in a particular state. Or, we might talk about its l-value which spans all states. People are rarely confused by such things. However, they may or may not be able to precisely explain all the layers of meaning inherent in language constructs. All such layers of meaning are not necessarily 'obvious' and it is a matter of science to study them properly. However, the inarticulacy of ordinary people to explain such layered meanings doesn't imply that they are confused about them.]

下面的一个单独的“后记”将这个讨论与函数式编程和命令式编程的关注点联系起来。

参考透明度是计算机科学中使用的一个术语。它起源于数学逻辑，但在计算机科学中具有广泛的应用和有效的含义。

它的意思是:可以被其结果替换而不改变其含义的结构(如函数)。

在通常使用中，它与纯表达式相似，但并不完全等效。纯表达式完全由其他纯表达式组成。引用透明表达式可能在内部是不纯的，例如在其计算过程中使用可变状态，但在表达式整体之外没有副作用。

所有纯函数，根据它们的构造，都是指涉透明的，但不一定相反。

许多语言特性都支持不纯引用透明性，比如Haskell中的ST单表，c++中的构造变量和某些lambdas。

有时引用透明性是强制的，而其他时候程序员必须自己保证它。

引用透明函数是只依赖于其输入的函数。

表示性语义是建立在建模语言的基础上，通过构建域来构成可表示性值。 函数式程序员使用术语值来描述基于语言重写规则的计算的收敛性。它的操作语义。

在1中，有两种语言的清晰度:

被建模的那个，目标语言 建模的语言，元语言

2、由于对象和元语言的紧密性，它们可能会被混淆。

作为一名语言实现者，我发现我需要经常记住这个区别。

所以Reddy教授，我可以这样解释你吗?

在函数式编程和语义的上下文中，术语引用 透明度不是指的透明。