Apa itu transparansi referensial?

Saya telah melihatnya dalam paradigma imperatif

f (x) + f (x)

mungkin tidak sama dengan:

2 * f (x)

Tetapi dalam paradigma fungsional itu harus sama. Saya telah mencoba untuk mengimplementasikan kedua kasus dalam Python dan Skema , tetapi bagi saya mereka terlihat cukup mudah sama.

Apa yang akan menjadi contoh yang bisa menunjukkan perbedaan dengan fungsi yang diberikan?

Transparansi referensial, disebut fungsi, menunjukkan bahwa Anda dapat menentukan hasil penerapan fungsi itu hanya dengan melihat nilai argumennya. Anda dapat menulis fungsi yang secara transparan transparan dalam bahasa pemrograman apa pun, misalnya Python, Skema, Pascal, C.

Di sisi lain, dalam sebagian besar bahasa Anda juga dapat menulis fungsi yang tidak transparan secara referensial. Misalnya, fungsi Python ini:

counter = 0

def foo(x):
  global counter

  counter += 1
  return x + counter

sebenarnya tidak transparan, pada kenyataannya panggilan

foo(x) + foo(x)

dan

2 * foo(x)

akan menghasilkan nilai yang berbeda, untuk argumen apa pun x. Alasan untuk ini adalah bahwa fungsi menggunakan dan memodifikasi variabel global, oleh karena itu hasil setiap doa tergantung pada keadaan yang berubah ini, dan tidak hanya pada argumen fungsi.

Haskell, sebuah bahasa yang sepenuhnya fungsional, secara ketat memisahkan evaluasi ekspresi di mana fungsi - fungsi murni diterapkan dan yang selalu transparan secara referensi, dari pelaksanaan tindakan (pemrosesan nilai-nilai khusus), yang tidak transparan secara referensial, yaitu melaksanakan tindakan yang sama dapat dilakukan setiap kali hasil berbeda.

Jadi, untuk fungsi Haskell

f :: Int -> Int

dan bilangan bulat apa pun x, selalu benar itu

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

Contoh tindakan adalah hasil dari fungsi perpustakaan getLine:

getLine :: IO String

Sebagai hasil dari evaluasi ekspresi, fungsi ini (sebenarnya konstan) pertama-tama menghasilkan nilai tipe murni IO String. Nilai dari tipe ini adalah nilai seperti yang lain: Anda bisa menyebarkannya, meletakkannya di struktur data, menyusunnya menggunakan fungsi khusus, dan sebagainya. Misalnya, Anda dapat membuat daftar tindakan seperti:

[getLine, getLine] :: [IO String]

Tindakan khusus karena Anda dapat memberitahu runtime Haskell untuk menjalankannya dengan menulis:

main = <some action>

Dalam hal ini, ketika program Haskell Anda dimulai, runtime berjalan melalui tindakan terikat maindan mengeksekusinya , mungkin menghasilkan efek samping. Oleh karena itu, eksekusi tindakan tidak transparan secara referensial karena mengeksekusi aksi yang sama dua kali dapat menghasilkan hasil yang berbeda tergantung pada apa yang didapat runtime sebagai input.

Berkat sistem tipe Haskell, sebuah aksi tidak pernah dapat digunakan dalam konteks di mana tipe lain diharapkan, dan sebaliknya. Jadi, jika Anda ingin menemukan panjang string, Anda dapat menggunakan lengthfungsi:

length "Hello"

akan kembali 5. Tetapi jika Anda ingin menemukan panjang string dibaca dari terminal, Anda tidak dapat menulis

length (getLine)

karena Anda mendapatkan kesalahan tipe: lengthmengharapkan input dari daftar jenis (dan sebuah String, memang, daftar) tetapi getLinemerupakan nilai tipe IO String(suatu tindakan). Dengan cara ini, sistem tipe memastikan bahwa nilai aksi seperti getLine(yang pelaksanaannya dilakukan di luar bahasa inti dan yang mungkin transparan non-referensial) tidak dapat disembunyikan di dalam nilai tipe non-tindakan jenis Int.

EDIT

Untuk menjawab pertanyaan yang ada, berikut ini adalah program Haskell kecil yang membaca garis dari konsol dan mencetak panjangnya.

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

Tindakan utama terdiri dari dua subaksi yang dieksekusi berurutan:

1. getlinedari jenis IO String,
2. yang kedua dibangun dengan mengevaluasi fungsi putStrLntipe String -> IO ()pada argumennya.

Lebih tepatnya, aksi kedua dibangun oleh

1. mengikat linenilai yang dibaca oleh tindakan pertama,
2. mengevaluasi fungsi-fungsi murni length(menghitung panjang sebagai integer) dan kemudian show(mengubah integer menjadi sebuah string),
3. membangun tindakan dengan menerapkan fungsi putStrLnpada hasil show.

Pada titik ini, tindakan kedua dapat dijalankan. Jika Anda mengetik "Halo", itu akan mencetak "5".

Perhatikan bahwa jika Anda mendapatkan nilai dari suatu tindakan menggunakan <-notasi, Anda hanya dapat menggunakan nilai itu di dalam tindakan lain, misalnya Anda tidak bisa menulis:

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

karena show (length line)bertipe Stringsedangkan notasi mensyaratkan bahwa suatu tindakan ( getLinebertipe IO String) diikuti oleh tindakan lain (misalnya putStrLn (show (length line))bertipe IO ()).

EDIT 2

Definisi Jörg W Mittag tentang transparansi referensial lebih umum daripada definisi saya (saya telah meningkatkan jawabannya). Saya telah menggunakan definisi terbatas karena contoh dalam pertanyaan ini berfokus pada nilai balik fungsi dan saya ingin menggambarkan aspek ini. Namun, RT secara umum merujuk pada makna keseluruhan program, termasuk perubahan keadaan global dan interaksi dengan lingkungan (IO) yang disebabkan oleh evaluasi ekspresi. Jadi, untuk definisi umum yang benar, Anda harus merujuk ke jawaban itu.

def f(x): return x()

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

Namun, bukan itu yang dimaksud Transparansi Referensial. RT berarti bahwa Anda dapat mengganti ekspresi apa pun dalam program dengan hasil mengevaluasi ekspresi itu (atau sebaliknya) tanpa mengubah arti program.

Ambil, misalnya, program berikut:

def f(): return 2

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

Program ini transparan secara referensial. Saya bisa mengganti satu atau kedua kejadian f()dengan 2dan masih akan bekerja sama:

def f(): return 2

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

atau

def f(): return 2

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

atau

def f(): return 2

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

semua akan berperilaku sama.

Sebenarnya, saya curang. Saya harus bisa mengganti panggilan printdengan nilai kembalinya (yang tidak ada nilai sama sekali) tanpa mengubah arti program. Namun, jelas, jika saya hanya menghapus dua printpernyataan, makna program akan berubah: sebelumnya, ia mencetak sesuatu ke layar, setelah itu tidak. I / O tidak transparan secara referensi.

Aturan praktis yang sederhana adalah: jika Anda dapat mengganti setiap ekspresi, sub-ekspresi atau panggilan subrutin dengan nilai balik dari ekspresi, sub-ekspresi atau panggilan subrutin di mana saja dalam program, tanpa program mengubah artinya, maka Anda memiliki referensi transparansi. Dan apa artinya ini, secara praktis adalah bahwa Anda tidak dapat memiliki I / O, tidak dapat memiliki keadaan yang dapat berubah, tidak dapat memiliki efek samping. Dalam setiap ekspresi, nilai ekspresi harus semata-mata bergantung pada nilai-nilai bagian penyusun ekspresi. Dan dalam setiap panggilan subrutin, nilai balik harus sepenuhnya bergantung pada argumen.

Sebagian dari jawaban ini diambil langsung dari tutorial yang belum selesai tentang pemrograman fungsional , yang dihosting di akun GitHub saya:

Suatu fungsi dikatakan transparan transparan jika diberi parameter input yang sama, selalu menghasilkan output yang sama (nilai balik). Jika seseorang mencari raison d'être untuk pemrograman fungsional murni, transparansi referensial adalah kandidat yang baik. Ketika bernalar dengan rumus-rumus dalam aljabar, aritmatika, dan logika, sifat ini - yang juga disebut substitusi sama dengan sama - adalah sangat penting sehingga biasanya diterima begitu saja ...

Pertimbangkan contoh sederhana:

x = 42

Dalam bahasa fungsional murni, sisi kiri dan kanan tanda sama dengan dapat disubstitusikan untuk satu sama lain. Artinya, tidak seperti dalam bahasa seperti C, notasi di atas benar-benar menegaskan kesetaraan. Konsekuensi dari ini adalah bahwa kita dapat alasan tentang kode program seperti persamaan matematika.

Dari Haskell wiki :

Komputasi murni menghasilkan nilai yang sama setiap kali dipanggil. Properti ini disebut transparansi referensial dan memungkinkan untuk melakukan penalaran yang sama pada kode ...

Untuk kontras ini, jenis operasi yang dilakukan oleh bahasa mirip C kadang-kadang disebut sebagai tugas destruktif .

Istilah murni sering digunakan untuk menggambarkan properti ekspresi, yang relevan dengan diskusi ini. Agar suatu fungsi dianggap murni,

• itu tidak diperbolehkan untuk menunjukkan efek samping, dan
• itu harus transparan referensial.

Menurut metafora kotak hitam, yang ditemukan di banyak buku teks matematika, fungsi internal sepenuhnya tertutup dari dunia luar. Efek samping adalah ketika suatu fungsi atau ekspresi melanggar prinsip ini - yaitu, prosedur diizinkan untuk berkomunikasi dengan beberapa cara dengan unit program lain (misalnya untuk berbagi dan bertukar informasi).

Singkatnya, transparansi referensial adalah suatu keharusan bagi fungsi untuk berperilaku seperti benar , fungsi matematika juga dalam semantik bahasa pemrograman.