Comments on: Why do they call it: Referentially transparent

By: Uday Reddy

Uday Reddy — Sun, 25 Mar 2012 09:34:54 +0000

Very clear and honest post. Well done! The subject of “referential transparency” is quite complex, but the wooliness that people use to talk about doesn’t help any one understand it any better. Thanks for clarifying the issues.

By: Greg McIntyre

Greg McIntyre — Thu, 11 Mar 2010 13:19:29 +0000

Hurray for this blog entry. *like button*

By: ajs

ajs — Thu, 11 Mar 2010 02:14:40 +0000

Well, Quine was talking about natural language and its relation to philosophy, but he also wrote about logic and philosophy. In particular, your “contexts” are functions, in the mathematical sense. (Note that if “x is blah” and “y is blah” is the same sentence, then x is y, as a string of symbols.) Equivalently, they’re formulae/proofs, in a logic of some kind. You sort of skimmed over that part, but acknowledged it — the semantics of interpretation (the part where you check if the sentence you constructed from a context and value “is true”) remain the same under substitution of equivalents. That’s it. This is the connection.

Functional programming languages have a different model of interpretation, but it’s not so different from a proof language. The biggest difference is the mechanism used to quantify over objects by property. Strongly typed functional languages use primarily use types to categorize objects. Logic languages sort objects by the predicates they satisfy. And these approaches are pretty obviously equivalent. A type represents a set of objects that satisfy some predicates/proofs/functions. It is the extension of a predicate.

Heck, both of these approaches are equivalent to constructive set theory, under the same form of trivial transformation.

By: Jan

Jan — Thu, 13 Nov 2008 03:56:14 +0000

Interesting article. I don’t understand why choose such a name to describe ‘referencially transparent’ too until now

By: Tom

Tom — Wed, 12 Nov 2008 22:45:13 +0000

I don’t know if this is in any sense useful or insightful or just stupid, but anyway, here’s how I think of it: the special thing about, say, the typed lambda calculus (and hence Haskell) is that its types completely coincide with its notion of computation; the type “integer” means (just, completely) “a computation that results in an integer”, and you need to use a different type (i.e. a monadic one) for a computation that does something more subtle. To me that’s where the notion of transparency (or else “substitutability”) comes from: in these languages, the type tells you everything interesting about the computation, and so if you replace a computational value with an equal one (therefore of the same type), you’re guaranteed to have not changed anything interesting.

Hence the basic reason that “languages like Java and C++” don’t have this property is that their types aren’t strong enough to capture everything about a computation; values only tell part of the story — state in these languages, for example, proceeds entirely outside of the remit of the type system — and the comparisons between values in these languages have that blindness baked in, so it’s a category error to look at “foo()” and say that’s the same as “42″ in a computational sense. Those values don’t contain enough information to decide whether they’re equal and therefore substitutable.

Erm, I’m not sure I’ve said anything here, really! I mention it only because you managed to write a whole blog post about Haskell without saying anything about types, which is an astonishing piece of cunning.