¿Qué es la transparencia referencial?

Lo he visto en paradigmas imperativos

f (x) + f (x)

podría no ser lo mismo que:

2 * f (x)

Pero en un paradigma funcional debería ser lo mismo. He tratado de implementar ambos casos en Python y Scheme , pero para mí se ven bastante directos.

¿Cuál sería un ejemplo que pudiera señalar la diferencia con la función dada?

La transparencia referencial, referida a una función, indica que puede determinar el resultado de aplicar esa función solo observando los valores de sus argumentos. Puede escribir funciones referencialmente transparentes en cualquier lenguaje de programación, por ejemplo, Python, Scheme, Pascal, C.

Por otro lado, en la mayoría de los idiomas también puede escribir funciones transparentes no referenciales. Por ejemplo, esta función de Python:

counter = 0

def foo(x):
  global counter

  counter += 1
  return x + counter

no es referencialmente transparente, de hecho llama

foo(x) + foo(x)

y

2 * foo(x)

producirá diferentes valores, para cualquier argumento x. La razón de esto es que la función usa y modifica una variable global, por lo tanto, el resultado de cada invocación depende de este estado cambiante, y no solo del argumento de la función.

Haskell, un lenguaje puramente funcional, separa estrictamente la evaluación de expresiones en la que se aplican funciones puras y que siempre es referencialmente transparente, de la ejecución de la acción (procesamiento de valores especiales), que no es referencialmente transparente, es decir, ejecutar la misma acción puede tener cada vez que Resultado diferente.

Entonces, para cualquier función de Haskell

f :: Int -> Int

y cualquier número entero x, siempre es cierto que

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

Un ejemplo de una acción es el resultado de la función de biblioteca getLine:

getLine :: IO String

Como resultado de la evaluación de expresiones, esta función (en realidad una constante) produce en primer lugar un valor puro de tipo IO String. Los valores de este tipo son valores como cualquier otro: puede pasarlos, colocarlos en estructuras de datos, componerlos usando funciones especiales, etc. Por ejemplo, puede hacer una lista de acciones de esta manera:

[getLine, getLine] :: [IO String]

Las acciones son especiales, ya que puede indicarle al tiempo de ejecución de Haskell que las ejecute escribiendo:

main = <some action>

En este caso, cuando se inicia su programa Haskell, el tiempo de ejecución recorre la acción vinculada mainy la ejecuta , posiblemente produciendo efectos secundarios. Por lo tanto, la ejecución de la acción no es referencialmente transparente porque ejecutar la misma acción dos veces puede producir resultados diferentes dependiendo de lo que el tiempo de ejecución obtenga como entrada.

Gracias al sistema de tipos de Haskell, una acción nunca se puede usar en un contexto donde se espera otro tipo, y viceversa. Entonces, si desea encontrar la longitud de una cadena, puede usar la lengthfunción:

length "Hello"

devolverá 5. Pero si desea encontrar la longitud de una cadena leída desde el terminal, no puede escribir

length (getLine)

porque obtiene un error de tipo: lengthespera una entrada de la lista de tipos (y una Cadena es, de hecho, una lista) pero getLinees un valor de tipo IO String(una acción). De esta manera, el sistema de tipos asegura que un valor de acción como getLine(cuya ejecución se lleva a cabo fuera del lenguaje central y que puede ser transparente no referencial) no puede ocultarse dentro de un valor de tipo de no acción Int.

EDITAR

Para responder a una pregunta exizt, aquí hay un pequeño programa Haskell que lee una línea desde la consola e imprime su longitud.

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

La acción principal consta de dos subacciones que se ejecutan secuencialmente:

1. getlinede tipo IO String,
2. el segundo se construye evaluando la función putStrLnde tipo String -> IO ()en su argumento.

Más precisamente, la segunda acción es construida por

1. vinculante lineal valor leído por la primera acción,
2. evaluar las funciones puras length(calcular la longitud como un entero) y luego show(convertir el entero en una cadena),
3. construyendo la acción aplicando la función putStrLnal resultado de show.

En este punto, se puede ejecutar la segunda acción. Si ha escrito "Hola", imprimirá "5".

Tenga en cuenta que si obtiene un valor de una acción usando la <-notación, solo puede usar ese valor dentro de otra acción, por ejemplo, no puede escribir:

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

porque show (length line)tiene tipo Stringmientras que la notación do requiere que una acción ( getLinede tipo IO String) sea seguida por otra acción (por ejemplo, putStrLn (show (length line))de tipo IO ()).

EDITAR 2

La definición de Jörg W Mittag de transparencia referencial es más general que la mía (he votado su respuesta). He usado una definición restringida porque el ejemplo en la pregunta se enfoca en el valor de retorno de las funciones y quería ilustrar este aspecto. Sin embargo, RT en general se refiere al significado de todo el programa, incluidos los cambios en el estado global y las interacciones con el entorno (IO) causadas por la evaluación de una expresión. Entonces, para una definición correcta y general, debe referirse a esa respuesta.

def f(x): return x()

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

Sin embargo, eso no es lo que significa Transparencia referencial. RT significa que puede reemplazar cualquier expresión en el programa con el resultado de evaluar esa expresión (o viceversa) sin cambiar el significado del programa.

Tomemos, por ejemplo, el siguiente programa:

def f(): return 2

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

Este programa es referencialmente transparente. Puedo reemplazar una o ambas ocurrencias de f()con 2y todavía funcionará igual:

def f(): return 2

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

o

def f(): return 2

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

o

def f(): return 2

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

Todos se comportarán igual.

Bueno, en realidad, hice trampa. Debería poder reemplazar la llamada a printcon su valor de retorno (que no tiene ningún valor) sin cambiar el significado del programa. Sin embargo, claramente, si solo elimino las dos printdeclaraciones, el significado del programa cambiará: antes, imprimió algo en la pantalla, después no lo hace. I / O no es referencialmente transparente.

La regla general es: si puede reemplazar cualquier expresión, subexpresión o llamada de subrutina con el valor de retorno de esa expresión, subexpresión o llamada de subrutina en cualquier parte del programa, sin que el programa cambie su significado, entonces tiene referencial transparencia. Y lo que esto significa, prácticamente hablando, es que no puede tener ninguna E / S, no puede tener ningún estado mutable, no puede tener ningún efecto secundario. En cada expresión, el valor de la expresión debe depender únicamente de los valores de las partes constituyentes de la expresión. Y en cada llamada de subrutina, el valor de retorno debe depender únicamente de los argumentos.

Parte de esta respuesta se toma directamente de un tutorial inacabado sobre programación funcional , alojado en mi cuenta de GitHub:

Se dice que una función es referencialmente transparente si, dados los mismos parámetros de entrada, siempre produce la misma salida (valor de retorno). Si se busca una razón de ser para la programación funcional pura, la transparencia referencial es un buen candidato. Cuando se razona con fórmulas en álgebra, aritmética y lógica, esta propiedad, también llamada sustituibilidad de iguales por iguales, es tan fundamental que generalmente se da por sentado ...

Considere un ejemplo simple:

x = 42

En un lenguaje funcional puro, el lado izquierdo y derecho del signo igual son sustituibles entre sí en ambos sentidos. Es decir, a diferencia de un lenguaje como C, la notación anterior realmente afirma una igualdad. Una consecuencia de esto es que podemos razonar sobre el código del programa al igual que las ecuaciones matemáticas.

De la wiki de Haskell :

Los cálculos puros producen el mismo valor cada vez que se invocan. Esta propiedad se llama transparencia referencial y hace posible realizar un razonamiento equitativo en el código ...

Para contrastar esto, el tipo de operación realizada por lenguajes tipo C a veces se denomina asignación destructiva .

El término puro se usa a menudo para describir una propiedad de expresiones, relevante para esta discusión. Para que una función se considere pura,

• no está permitido exhibir ningún efecto secundario, y
• debe ser referencialmente transparente.

De acuerdo con la metáfora de la caja negra, que se encuentra en numerosos libros de texto matemáticos, los elementos internos de una función están completamente sellados del mundo exterior. Un efecto secundario es cuando una función o expresión viola este principio, es decir, el procedimiento puede comunicarse de alguna manera con otras unidades del programa (por ejemplo, compartir e intercambiar información).

En resumen, la transparencia referencial es imprescindible para que las funciones se comporten como verdaderas funciones matemáticas también en la semántica de los lenguajes de programación.