Minh bạch tham chiếu là gì?

Tôi đã thấy rằng trong các mô hình mệnh lệnh

f (x) + f (x)

có thể không giống như:

2 * f (x)

Nhưng trong một mô hình chức năng thì nó phải giống nhau. Tôi đã cố gắng thực hiện cả hai trường hợp trong Python và Scheme , nhưng đối với tôi chúng trông khá đơn giản giống nhau.

Điều gì sẽ là một ví dụ có thể chỉ ra sự khác biệt với hàm đã cho?

Độ trong suốt tham chiếu, được tham chiếu đến một hàm, chỉ ra rằng bạn có thể xác định kết quả của việc áp dụng hàm đó chỉ bằng cách xem xét các giá trị của các đối số của nó. Bạn có thể viết các hàm trong suốt tham chiếu trong bất kỳ ngôn ngữ lập trình nào, ví dụ Python, Scheme, Pascal, C.

Mặt khác, trong hầu hết các ngôn ngữ, bạn cũng có thể viết các hàm không tham chiếu trong suốt. Ví dụ: hàm Python này:

counter = 0

def foo(x):
  global counter

  counter += 1
  return x + counter

không tham chiếu minh bạch, trong thực tế gọi

foo(x) + foo(x)

và

2 * foo(x)

sẽ tạo ra các giá trị khác nhau, cho bất kỳ đối số x. Lý do cho điều này là hàm sử dụng và sửa đổi một biến toàn cục, do đó kết quả của mỗi lần gọi phụ thuộc vào trạng thái thay đổi này, và không chỉ dựa vào đối số của hàm.

Haskell, một ngôn ngữ chức năng thuần túy, tách biệt nghiêm ngặt việc đánh giá biểu thức trong đó các hàm thuần túy được áp dụng và luôn minh bạch, từ thực thi hành động (xử lý các giá trị đặc biệt), không minh bạch về mặt tham chiếu, tức là thực hiện cùng một hành động có thể có mỗi lần kết quả khác nhau.

Vì vậy, đối với bất kỳ chức năng Haskell

f :: Int -> Int

và bất kỳ số nguyên nào x, nó luôn luôn đúng

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

Một ví dụ về một hành động là kết quả của chức năng thư viện getLine:

getLine :: IO String

Kết quả của việc đánh giá biểu thức, hàm này (thực sự là một hằng số) trước hết tạo ra một giá trị thuần của kiểu IO String. Các giá trị của loại này là các giá trị như bất kỳ giá trị nào khác: bạn có thể chuyển chúng xung quanh, đặt chúng vào cấu trúc dữ liệu, soạn chúng bằng các hàm đặc biệt, v.v. Ví dụ: bạn có thể tạo một danh sách các hành động như vậy:

[getLine, getLine] :: [IO String]

Các hành động đặc biệt ở chỗ bạn có thể yêu cầu thời gian chạy Haskell thực thi chúng bằng cách viết:

main = <some action>

Trong trường hợp này, khi chương trình Haskell của bạn được khởi động, bộ thực thi sẽ chuyển qua hành động bị ràng buộc mainvà thực thi nó, có thể tạo ra các hiệu ứng phụ. Do đó, thực thi hành động không minh bạch về mặt tham chiếu vì thực hiện cùng một hành động hai lần có thể tạo ra các kết quả khác nhau tùy thuộc vào thời gian chạy làm đầu vào.

Nhờ hệ thống loại của Haskell, một hành động không bao giờ có thể được sử dụng trong bối cảnh mà loại khác được mong đợi và ngược lại. Vì vậy, nếu bạn muốn tìm độ dài của chuỗi, bạn có thể sử dụng lengthhàm:

length "Hello"

sẽ trả về 5. Nhưng nếu bạn muốn tìm độ dài của chuỗi được đọc từ thiết bị đầu cuối, bạn không thể viết

length (getLine)

bởi vì bạn nhận được một lỗi loại: lengthmong đợi một đầu vào của danh sách loại (và thực tế, một chuỗi là một danh sách) nhưng getLinelà một giá trị của loại IO String(một hành động). Theo cách này, hệ thống loại đảm bảo rằng một giá trị hành động như getLine(thực hiện được thực hiện bên ngoài ngôn ngữ cốt lõi và có thể không trong suốt tham chiếu) không thể được ẩn bên trong giá trị loại không hành động Int.

CHỈNH SỬA

Để trả lời câu hỏi exizt, đây là một chương trình Haskell nhỏ đọc một dòng từ bảng điều khiển và in độ dài của nó.

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

Hành động chính bao gồm hai giao dịch được thực hiện tuần tự:

1. getlineloại IO String,
2. cái thứ hai được xây dựng bằng cách đánh giá chức năng putStrLncủa kiểu String -> IO ()trên đối số của nó.

Chính xác hơn, hành động thứ hai được xây dựng bởi

1. ràng buộc linevới giá trị được đọc bởi hành động đầu tiên,
2. đánh giá các hàm thuần túy length(tính độ dài dưới dạng số nguyên) và sau đó show(biến số nguyên thành chuỗi),
3. xây dựng hành động bằng cách áp dụng chức năng putStrLncho kết quả của show.

Tại thời điểm này, hành động thứ hai có thể được thực thi. Nếu bạn đã gõ "Xin chào", nó sẽ in "5".

Lưu ý rằng nếu bạn nhận được một giá trị từ một hành động bằng cách sử dụng <-ký hiệu, bạn chỉ có thể sử dụng giá trị đó bên trong một hành động khác, ví dụ: bạn không thể viết:

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

bởi vì show (length line)có loại Stringtrong khi ký hiệu không yêu cầu một hành động ( getLineloại IO String) được theo sau bởi một hành động khác (ví dụ như putStrLn (show (length line))loại IO ()).

CHỈNH SỬA 2

Định nghĩa về tính minh bạch tham chiếu của Jörg W Mittag chung chung hơn của tôi (tôi đã nêu lên câu trả lời của anh ấy). Tôi đã sử dụng một định nghĩa hạn chế vì ví dụ trong câu hỏi tập trung vào giá trị trả về của các hàm và tôi muốn minh họa khía cạnh này. Tuy nhiên, RT nói chung đề cập đến ý nghĩa của toàn bộ chương trình, bao gồm các thay đổi về trạng thái toàn cầu và tương tác với môi trường (IO) gây ra bằng cách đánh giá một biểu thức. Vì vậy, để có một định nghĩa chung, chính xác, bạn nên tham khảo câu trả lời đó.

def f(x): return x()

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

Tuy nhiên, đó không phải là ý nghĩa của tính minh bạch tham chiếu. RT có nghĩa là bạn có thể thay thế bất kỳ biểu thức nào trong chương trình bằng kết quả đánh giá biểu thức đó (hoặc ngược lại) mà không thay đổi ý nghĩa của chương trình.

Lấy ví dụ, chương trình sau:

def f(): return 2

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

Chương trình này là minh bạch tham khảo. Tôi có thể thay thế một hoặc cả hai lần xuất hiện của f()với 2và nó vẫn sẽ làm việc như nhau:

def f(): return 2

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

hoặc là

def f(): return 2

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

hoặc là

def f(): return 2

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

tất cả sẽ hành xử như nhau.

Vâng, thực sự, tôi đã lừa dối. Tôi sẽ có thể thay thế cuộc gọi printbằng giá trị trả về của nó (hoàn toàn không có giá trị) mà không thay đổi ý nghĩa của chương trình. Tuy nhiên, rõ ràng, nếu tôi chỉ loại bỏ hai printcâu lệnh, ý nghĩa của chương trình sẽ thay đổi: trước đó, nó đã in một cái gì đó lên màn hình, sau khi nó không. I / O không tham chiếu minh bạch.

Nguyên tắc đơn giản là: nếu bạn có thể thay thế bất kỳ biểu thức, biểu thức con hoặc lệnh gọi chương trình con nào bằng giá trị trả về của biểu thức đó, biểu thức con hoặc cuộc gọi chương trình con ở bất cứ đâu trong chương trình, mà không có chương trình thay đổi ý nghĩa của nó, thì bạn có tham chiếu minh bạch. Và điều này có nghĩa là, thực tế mà nói là bạn không thể có bất kỳ I / O nào, không thể có bất kỳ trạng thái đột biến nào, không thể có bất kỳ tác dụng phụ nào. Trong mọi biểu thức, giá trị của biểu thức phải phụ thuộc hoàn toàn vào các giá trị của các bộ phận cấu thành của biểu thức. Và trong mỗi lệnh gọi chương trình con, giá trị trả về phải phụ thuộc hoàn toàn vào các đối số.

Các phần của câu trả lời này được lấy trực tiếp từ một hướng dẫn chưa hoàn thành về lập trình chức năng , được lưu trữ trên tài khoản GitHub của tôi:

Một hàm được gọi là trong suốt tham chiếu nếu nó, được đưa ra cùng một tham số đầu vào, luôn tạo ra cùng một đầu ra (giá trị trả về). Nếu một người đang tìm kiếm một nhà tù cho lập trình chức năng thuần túy, tính minh bạch tham chiếu là một ứng cử viên tốt. Khi suy luận với các công thức về đại số, số học và logic, tính chất này - còn được gọi là tính thay thế của đẳng thức cho bằng - rất quan trọng về cơ bản mà nó thường được coi là ...

Hãy xem xét một ví dụ đơn giản:

x = 42

Trong một ngôn ngữ chức năng thuần túy, phía bên trái và bên phải của dấu bằng có thể thay thế cho nhau theo cả hai cách. Đó là, không giống như trong một ngôn ngữ như C, ký hiệu trên thực sự khẳng định sự bình đẳng. Một hậu quả của điều này là chúng ta có thể suy luận về mã chương trình giống như các phương trình toán học.

Từ wiki Haskell :

Các tính toán thuần túy mang lại giá trị như nhau mỗi lần chúng được gọi. Thuộc tính này được gọi là tính minh bạch tham chiếu và có thể tiến hành lập luận tương đương trên mã ...

Để tương phản điều này, loại hoạt động được thực hiện bởi các ngôn ngữ giống như C đôi khi được gọi là một nhiệm vụ phá hủy .

Thuật ngữ thuần túy thường được sử dụng để mô tả một thuộc tính của biểu thức, có liên quan đến cuộc thảo luận này. Đối với một chức năng được coi là thuần túy,

• nó không được phép thể hiện bất kỳ tác dụng phụ nào, và
• nó phải được minh bạch tham khảo.

Theo phép ẩn dụ hộp đen, được tìm thấy trong nhiều sách giáo khoa toán học, các hàm bên trong của một hàm hoàn toàn bị tách khỏi thế giới bên ngoài. Tác dụng phụ là khi một chức năng hoặc biểu thức vi phạm nguyên tắc này - nghĩa là, quy trình được phép giao tiếp theo cách nào đó với các đơn vị chương trình khác (ví dụ: để chia sẻ và trao đổi thông tin).

Tóm lại, tính minh bạch tham chiếu là điều bắt buộc để các hàm hoạt động như đúng , các hàm toán học cũng có trong ngữ nghĩa của các ngôn ngữ lập trình.