ความโปร่งใสอ้างอิงคืออะไร?

ฉันได้เห็นว่าในกระบวนทัศน์ที่จำเป็น

f (x) + f (x)

อาจไม่เหมือนกับ:

2 * f (x)

แต่ในกระบวนทัศน์การทำงานมันควรจะเหมือนกัน ฉันได้ลองใช้ทั้งสองกรณีใน Python และSchemeแต่สำหรับฉันแล้วพวกเขาดูตรงไปตรงมาเหมือนกัน

อะไรคือตัวอย่างที่สามารถชี้ให้เห็นความแตกต่างกับฟังก์ชั่นที่ให้

Referential transparent หรือที่อ้างอิงถึงฟังก์ชั่นบ่งชี้ว่าคุณสามารถกำหนดผลลัพธ์ของการใช้ฟังก์ชันนั้นได้โดยดูที่ค่าของอาร์กิวเมนต์ คุณสามารถเขียนฟังก์ชันโปร่งใสแบบอ้างอิงได้ในภาษาการเขียนโปรแกรมเช่น Python, Scheme, Pascal, C

ในอีกหลายภาษาคุณสามารถเขียนฟังก์ชั่นที่ไม่อ้างอิงแบบโปร่งใสได้ ตัวอย่างเช่นฟังก์ชัน Python นี้:

counter = 0

def foo(x):
  global counter

  counter += 1
  return x + counter

ไม่อ้างอิงโปร่งใสในความเป็นจริงโทร

foo(x) + foo(x)

และ

2 * foo(x)

xจะผลิตค่าที่แตกต่างกันสำหรับการโต้แย้งใด ๆ เหตุผลนี้เป็นเพราะฟังก์ชั่นใช้และแก้ไขตัวแปรทั่วโลกดังนั้นผลลัพธ์ของการเรียกแต่ละครั้งขึ้นอยู่กับสถานะการเปลี่ยนแปลงนี้และไม่เพียง แต่ในการโต้แย้งฟังก์ชั่น

Haskell เป็นภาษาที่ใช้งานได้จริงโดยแยกการประเมินนิพจน์ที่ใช้ฟังก์ชั่น pureอย่างชัดเจนและโปร่งใสซึ่งอ้างอิงจากการดำเนินการ (การประมวลผลของค่าพิเศษ) ซึ่งไม่โปร่งใสอ้างอิงเช่นการดำเนินการเดียวกันสามารถมีได้ทุกครั้ง ผลลัพธ์ที่แตกต่าง

ดังนั้นสำหรับฟังก์ชั่นใด ๆ ของ Haskell

f :: Int -> Int

และจำนวนเต็มใด ๆxมันเป็นความจริงเสมอ

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

ตัวอย่างของการกระทำคือผลลัพธ์ของฟังก์ชันไลบรารีgetLine:

getLine :: IO String

อันเป็นผลมาจากการประเมินผลการแสดงออกของฟังก์ชั่นนี้ (ที่จริงคงที่) IO Stringครั้งแรกของทุกผลิตค่าบริสุทธิ์จากประเภท ค่าของประเภทนี้คือค่าที่เหมือนกัน: คุณสามารถผ่านไปมาวางไว้ในโครงสร้างข้อมูลเขียนโดยใช้ฟังก์ชั่นพิเศษและอื่น ๆ ตัวอย่างเช่นคุณสามารถสร้างรายการของการกระทำเช่นนั้น:

[getLine, getLine] :: [IO String]

การดำเนินการเป็นสิ่งพิเศษที่คุณสามารถบอกให้รันไทม์ Haskell เพื่อดำเนินการได้โดยการเขียน:

main = <some action>

ในกรณีนี้เมื่อโปรแกรม Haskell ของคุณเริ่มทำงานรันไทม์จะดำเนินการผ่านการดำเนินการที่เชื่อมโยงmainและดำเนินการซึ่งอาจทำให้เกิดผลข้างเคียง ดังนั้นการดำเนินการแอคชั่นจึงไม่โปร่งใสเนื่องจากการดำเนินการแอ็คชันเดียวกันสองครั้งสามารถสร้างผลลัพธ์ที่แตกต่างกันขึ้นอยู่กับสิ่งที่รันไทม์ได้รับเป็นอินพุต

ต้องขอบคุณระบบประเภทของ Haskell จึงไม่สามารถใช้การกระทำในบริบทที่คาดว่าจะมีประเภทอื่นและในทางกลับกัน ดังนั้นหากคุณต้องการค้นหาความยาวของสตริงคุณสามารถใช้lengthฟังก์ชัน:

length "Hello"

จะส่งคืน 5. แต่ถ้าคุณต้องการค้นหาความยาวของสตริงที่อ่านจากเทอร์มินัลคุณไม่สามารถเขียนได้

length (getLine)

เนื่องจากคุณได้รับข้อผิดพลาดประเภท: lengthคาดว่าอินพุตของรายการประเภท (และสตริงคือแท้จริงรายการ) แต่getLineเป็นค่าประเภทIO String(การกระทำ) วิธีนี้จะช่วยให้มั่นใจระบบการพิมพ์ที่มีมูลค่าการกระทำเช่นgetLine(ที่มีการดำเนินการจะดำเนินการนอกภาษาหลักและซึ่งอาจจะไม่ใช่ referentially โปร่งใส) Intไม่สามารถที่ซ่อนอยู่ภายในค่าที่ไม่ใช่การกระทำของประเภท

แก้ไข

เพื่อตอบคำถาม exizt ต่อไปนี้เป็นโปรแกรม Haskell ขนาดเล็กที่อ่านบรรทัดจากคอนโซลและพิมพ์ความยาว

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

การดำเนินการหลักประกอบด้วยสองการโต้ตอบที่ดำเนินการตามลำดับ:

1. getlineประเภทIO String,
2. ที่สองคือการสร้างโดยการประเมินฟังก์ชั่นputStrLnของประเภทString -> IO ()บนการโต้แย้ง

แม่นยำยิ่งกว่าการกระทำที่สองถูกสร้างขึ้นโดย

1. ผูกพันlineกับค่าที่อ่านโดยการกระทำแรก
2. การประเมินฟังก์ชั่นแท้length(คำนวณความยาวเป็นจำนวนเต็ม) แล้วshow(เปลี่ยนจำนวนเต็มเป็นสตริง)
3. การสร้างการดำเนินการโดยใช้ฟังก์ชั่นเพื่อผลมาจากการputStrLnshow

ณ จุดนี้การดำเนินการที่สองสามารถดำเนินการได้ หากคุณพิมพ์ "Hello" ระบบจะพิมพ์ "5"

โปรดทราบว่าหากคุณได้รับค่าจากการกระทำโดยใช้<-สัญกรณ์คุณสามารถใช้ค่านั้นในการดำเนินการอื่นเช่นคุณไม่สามารถเขียน:

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

เพราะshow (length line)มีประเภทStringในขณะที่เครื่องหมายต้องกำหนดว่าการกระทำ ( getLineประเภทIO String) ตามด้วยการกระทำอื่น (เช่นputStrLn (show (length line))ประเภทIO ())

แก้ไข 2

คำจำกัดความความโปร่งใสในการอ้างอิงของJörg W Mittag นั้นกว้างกว่าของฉันมาก (ฉันตอบคำตอบของเขาแล้ว) ฉันได้ใช้คำจำกัดความที่ถูก จำกัด เพราะตัวอย่างในคำถามมุ่งเน้นไปที่ค่าส่งคืนของฟังก์ชั่นและฉันต้องการแสดงแง่มุมนี้ อย่างไรก็ตาม RT โดยทั่วไปหมายถึงความหมายของโปรแกรมทั้งหมดรวมถึงการเปลี่ยนแปลงสถานะโลกและการโต้ตอบกับสภาพแวดล้อม (IO) ที่เกิดจากการประเมินการแสดงออก ดังนั้นสำหรับคำจำกัดความทั่วไปที่ถูกต้องคุณควรอ้างถึงคำตอบนั้น

def f(x): return x()

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

อย่างไรก็ตามนั่นไม่ใช่ความโปร่งใส Referential Transparency RT หมายความว่าคุณสามารถแทนที่นิพจน์ใด ๆในโปรแกรมด้วยผลลัพธ์ของการประเมินนิพจน์นั้น (หรือกลับกัน) โดยไม่เปลี่ยนความหมายของโปรแกรม

ยกตัวอย่างเช่นโปรแกรมต่อไปนี้:

def f(): return 2

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

โปรแกรมนี้มีความโปร่งใสในการอ้างอิง ฉันสามารถแทนที่หนึ่งหรือทั้งสองเหตุการณ์f()ด้วย2และจะยังคงทำงานเหมือนเดิม:

def f(): return 2

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

หรือ

def f(): return 2

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

หรือ

def f(): return 2

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

จะทำตัวเหมือนเดิม

ที่จริงฉันโกง ฉันควรจะสามารถแทนที่การเรียกprintด้วยค่าที่ส่งคืน (ซึ่งไม่มีค่าเลย) โดยไม่เปลี่ยนความหมายของโปรแกรม อย่างไรก็ตามชัดเจนถ้าฉันเพิ่งลบทั้งสองprintงบความหมายของโปรแกรมจะเปลี่ยน: ก่อนมันพิมพ์บางสิ่งบางอย่างไปที่หน้าจอหลังจากที่มันไม่ได้ I / O ไม่อ้างอิงอย่างโปร่งใส

กฎง่ายๆคือ: ถ้าคุณสามารถแทนที่การแสดงออกใด ๆ การแสดงออกย่อยหรือการเรียกรูทีนย่อยด้วยค่าตอบแทนของการแสดงออกนั้นการแสดงออกย่อยหรือการเรียกรูทีนย่อยที่ใดก็ได้ในโปรแกรมโดยไม่มีโปรแกรมเปลี่ยนความหมายของมันแล้วคุณมีการอ้างอิง ความโปร่งใส และสิ่งนี้หมายความว่าการพูดในทางปฏิบัติคือคุณไม่สามารถมี I / O ใด ๆ ไม่สามารถมีสถานะที่เปลี่ยนแปลงไม่ได้ไม่มีผลข้างเคียงใด ๆ ในทุกนิพจน์ค่าของนิพจน์ต้องขึ้นอยู่กับค่าของส่วนต่าง ๆ ของนิพจน์เท่านั้น และในการเรียกรูทีนย่อยทุกครั้งค่าส่งคืนจะต้องขึ้นอยู่กับอาร์กิวเมนต์เท่านั้น

บางส่วนของคำตอบนี้นำมาโดยตรงจากบทช่วยสอนที่ยังไม่เสร็จเกี่ยวกับการเขียนโปรแกรมใช้งานได้โฮสต์บนบัญชี GitHub ของฉัน:

ฟังก์ชั่นได้รับการกล่าวถึงว่ามีความโปร่งใสในการอ้างอิงหากได้รับพารามิเตอร์อินพุตเดียวกันจะสร้างเอาต์พุตเดียวกันเสมอ (ค่าส่งคืน) หากใครกำลังมองหา raison d'êtreสำหรับการเขียนโปรแกรมการทำงานที่บริสุทธิ์ความโปร่งใสในการอ้างอิงเป็นตัวเลือกที่ดี เมื่อให้เหตุผลกับสูตรในพีชคณิตคณิตศาสตร์และตรรกะคุณสมบัตินี้ - เรียกอีกอย่างว่าการแทนของเท่ากับเท่ากับ - เป็นสิ่งสำคัญพื้นฐานที่มักจะได้รับ ...

ลองพิจารณาตัวอย่างง่ายๆ:

x = 42

ในภาษาที่ใช้งานได้จริงด้านซ้ายและด้านขวาของเครื่องหมายเท่ากับจะถูกแทนที่ซึ่งกันและกันทั้งสองวิธี นั่นคือซึ่งแตกต่างจากในภาษาเช่น C, สัญกรณ์ดังกล่าวข้างต้นยืนยันความเท่าเทียมกันอย่างแท้จริง ผลที่ตามมาคือเราสามารถให้เหตุผลเกี่ยวกับรหัสโปรแกรมเช่นเดียวกับสมการทางคณิตศาสตร์

จากHaskell wiki :

การคำนวณแบบบริสุทธิ์ให้ค่าเดียวกันทุกครั้งที่เรียกใช้ คุณสมบัตินี้เรียกว่าความโปร่งใสในการอ้างอิงและทำให้เป็นไปได้ในการดำเนินการให้เหตุผลที่เท่าเทียมกันในรหัส ...

เพื่อความคมชัดนี้ประเภทของการดำเนินงานที่ดำเนินการโดย C-เช่นภาษาบางครั้งจะเรียกว่าได้รับมอบหมายทำลาย

คำที่บริสุทธิ์มักใช้เพื่ออธิบายคุณสมบัติของนิพจน์ที่เกี่ยวข้องกับการสนทนานี้ สำหรับฟังก์ชั่นที่จะถือว่าบริสุทธิ์

• ไม่อนุญาตให้แสดงผลข้างเคียงใด ๆ และ
• มันจะต้องโปร่งใส referential

ตามคำอุปมาดำที่พบในตำราคณิตศาสตร์จำนวนมาก internals ของฟังก์ชั่นจะถูกปิดผนึกอย่างสมบูรณ์จากโลกภายนอก ผลข้างเคียงคือเมื่อฟังก์ชั่นหรือการแสดงออกละเมิดหลักการนี้ - นั่นคือขั้นตอนได้รับอนุญาตให้สื่อสารในทางใดทางหนึ่งกับหน่วยโปรแกรมอื่น ๆ (เช่นเพื่อแบ่งปันและแลกเปลี่ยนข้อมูล)

โดยสรุปความโปร่งใสในการอ้างอิงเป็นสิ่งจำเป็นสำหรับฟังก์ชั่นที่จะทำตัวเหมือนจริงฟังก์ชั่นทางคณิตศาสตร์ยังอยู่ในความหมายของภาษาการเขียนโปรแกรม