Referans şeffaflık nedir?

Bunu zorunlu paradigmalarda gördüm

f (x) + f (x)

aynı olmayabilir:

2 * f (x)

Ancak işlevsel bir paradigmada aynı olması gerekir. Her iki vakayı da Python ve Scheme'de uygulamaya çalıştım , ama benim için de aynı şekilde basit görünüyorlar.

Verilen fonksiyonla farkı gösterebilecek bir örnek ne olurdu?

Bir fonksiyona atıfta bulunulan referans şeffaflığı, bu fonksiyonu uygulamanın sonucunu sadece argümanlarının değerlerine bakarak belirleyebileceğinizi belirtir. Referans olarak saydam işlevleri herhangi bir programlama dilinde yazabilirsiniz, örneğin Python, Scheme, Pascal, C

Öte yandan, çoğu dilde referans olarak saydam olmayan işlevler de yazabilirsiniz. Örneğin, bu Python işlevi:

counter = 0

def foo(x):
  global counter

  counter += 1
  return x + counter

aslında referans olarak saydam değildir, aslında

foo(x) + foo(x)

ve

2 * foo(x)

Herhangi bir argüman için farklı değerler üretecektir x. Bunun nedeni, işlevin global bir değişkeni kullanması ve değiştirmesidir, bu nedenle her çağrının sonucu, yalnızca işlevin argümanına değil, bu değişen duruma bağlıdır.

Tamamen işlevsel bir dil olan Haskell, saf işlevlerin uygulandığı ve her zaman referans olarak şeffaf olan ifade değerlendirmesini kesin olarak ayırır , eylem yürütmesinden (özel değerlerin işlenmesi), referans olarak saydam olmayan, yani aynı işlemi yürütmek her seferinde bir farklı sonuç

Yani, herhangi bir Haskell işlevi için

f :: Int -> Int

ve herhangi bir tamsayı x, her zaman doğrudur

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

Bir eylem örneği, kütüphane işlevinin sonucudur getLine:

getLine :: IO String

İfade değerlendirmesi sonucunda, bu işlev (aslında bir sabit) her şeyden önce saf türde bir değer üretir IO String. Bu türdeki değerler, diğerleri gibi değerlerdir: bunları etrafa aktarabilir, veri yapılarına koyabilir, özel fonksiyonlar kullanarak oluşturabilir ve benzeri işlemleri yapabilirsiniz. Örneğin, bunun gibi eylemlerin bir listesini yapabilirsiniz:

[getLine, getLine] :: [IO String]

Eylemler, Haskell çalışma zamanına bunları yazarak yürütmelerini söyleyebilmeniz için özeldir:

main = <some action>

Bu durumda, Haskell programınız başlatıldığında, çalışma zamanı muhtemelen yan etkiler oluşturarak, ona bağlı eylemi yürütürmain ve yürütür . Bu nedenle, eylem yürütme başvuru açısından saydam değildir, çünkü aynı eylemi iki kez yürütmek, çalışma zamanının girdi olarak aldığı duruma bağlı olarak farklı sonuçlar üretebilir.

Haskell'in tip sistemi sayesinde, hiçbir zaman başka bir tipin beklendiği bir bağlamda asla kullanılamaz ve bunun tersi de geçerlidir. Bu nedenle, bir dize uzunluğunu bulmak istiyorsanız, lengthişlevi kullanabilirsiniz :

length "Hello"

5 döndürür. Ancak terminalden okunan bir dizgenin uzunluğunu bulmak istiyorsanız, yazamazsınız.

length (getLine)

çünkü bir tür hatası alıyorsunuz: lengthbir tür listesinin girişini bekliyor (ve bir Dize, aslında bir listedir) ancak getLinetürün bir değeridir IO String(bir eylem). Bu şekilde, tip sistemi getLine(yürütülmesi çekirdek dilin dışında gerçekleştirilir ve referans olarak saydam olmayan) bir işlem değerinin, işlem dışı bir değerin içine gizlenememesini sağlar Int.

DÜZENLE

Exizt sorusuna cevap vermek için, işte konsoldan bir satır okuyan ve uzunluğunu basan küçük bir Haskell programı.

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

Ana eylem, sırayla yürütülen iki alt bölümden oluşur:

1. getlineÇeşidi IO String,
2. ikinci bir fonksiyonu değerlendirilerek oluşturulur putStrLnÇeşidi String -> IO ()argüman ile.

Daha doğrusu, ikinci eylem inşa

1. lineilk eylem tarafından okunan değere bağlanma ,
2. saf fonksiyonların değerlendirilmesi length(tamsayı olarak uzunluk hesaplamak) ve sonra show(tamsayıyı bir dizgeye çevirmek),
3. eylemini putStrLnsonucuna fonksiyon uygulayarak oluşturmak show.

Bu noktada, ikinci eylem gerçekleştirilebilir. "Merhaba" yazdıysanız, "5" yazacaktır.

Notu kullanarak bir işlemden bir değer elde <-ederseniz, bu değeri yalnızca başka bir işlem içinde kullanabileceğinizi unutmayın, örneğin:

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

çünkü show (length line)tipe Stringsahipken, gösterimde bir eylemin ( getLinetürden IO String) başka bir eylemin (örneğin putStrLn (show (length line))türden IO ()) takip edilmesini gerektirdiği halde vardır .

EDIT 2

Jörg W Mittag'ın referandum şeffaflığı tanımı benimkinden daha genel (onun cevabını aştım). Kısıtlı bir tanım kullandım çünkü sorudaki örnek fonksiyonların geri dönüş değerine odaklandı ve bu yönü açıklamak istedim. Bununla birlikte, genel olarak RT, bir ifadenin değerlendirilmesinden kaynaklanan küresel duruma yapılan değişiklikler ve çevre ile etkileşimler (IO) de dahil olmak üzere tüm programın anlamını ifade eder. Bu nedenle, doğru, genel bir tanım için, bu cevaba başvurmalısınız.

def f(x): return x()

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

Bununla birlikte, Referans Şeffaflık'ın anlamı bu değildir . RT , programın anlamını değiştirmeden bu ifadeyi değerlendirmenin sonucu olarak programdaki herhangi bir ifadeyi değiştirebileceğiniz anlamına gelir.

Örneğin, aşağıdaki programı uygulayın:

def f(): return 2

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

Bu program referans olarak şeffaftır. Ben birini veya her iki tekrarlarını yerini alabilir f()ile 2ve yine aynı şekilde çalışacaktır:

def f(): return 2

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

veya

def f(): return 2

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

veya

def f(): return 2

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

hepsi aynı şekilde davranacak.

Aslında, hile yaptım. printProgramın anlamını değiştirmeden çağrının dönüş değeriyle (hiç bir değeri yoktur) değiştirebilmeliyim. Bununla birlikte, açıkça, eğer iki printifadeyi kaldırırsam, programın anlamı değişecektir: önce, ekrana bir şey basmaz, sonra yapmaz. G / Ç, referans olarak saydam değildir.

Basit kural şudur: Herhangi bir ifade, alt ifade veya alt yordam çağrısını, bu ifadenin dönüş değeriyle değiştirebilirseniz, alt ifade veya alt yordam çağrısını programın herhangi bir yerinde, programın anlamını değiştirmeden değiştirebilirsiniz; şeffaflık. Ve bunun anlamı, pratik olarak konuşursanız, herhangi bir G / Ç’niz olamaz, değişken bir duruma sahip olamazsınız, herhangi bir yan etkisi olamaz. Her ifadede, ifadenin değeri yalnızca ifadenin kurucu bölümlerinin değerlerine bağlı olmalıdır. Ve her alt rutin çağrısında, dönüş değeri yalnızca argümanlara bağlı olmalıdır.

Bu cevabın bazı kısımları GitHub hesabımda barındırılan fonksiyonel programlama konusunda bitmemiş bir eğiticiden doğrudan alınmıştır :

Bir işlevin, aynı girdi parametreleri verildiğinde, her zaman aynı çıktıyı (dönüş değeri) üretmesi durumunda referans olarak şeffaf olduğu söylenir. Birisi saf fonksiyonel programlama için bir yükseliş arıyorsa, referans şeffaflığı iyi bir adaydır. Cebir, aritmetik ve mantıktaki formüllerle mantık yürütürken, bu özellik - eşittir için eşdeğerlerin ikame edilebilirliği olarak da adlandırılır - temelde çok önemlidir.

Basit bir örnek düşünün:

x = 42

Saf bir işlevsel dilde, eşittir işaretinin sol ve sağ yanları her iki yönde de ikame edilebilir. Yani, C gibi bir dilin aksine, yukarıdaki gösterim gerçekten bir eşitlik ifade eder. Bunun bir sonucu olarak, matematiksel denklemler gibi program koduyla ilgili sebep olabiliriz.

Gönderen Haskell wiki :

Saf hesaplamalar her çağrıldığında aynı değeri verir. Bu özelliğe referans şeffaflığı denir ve kod üzerinde eşit bir akıl yürütme yapmayı mümkün kılar ...

Bunun aksine, C benzeri diller tarafından gerçekleştirilen operasyon tipine bazen yıkıcı bir atama denir .

Terim saf genellikle bu tartışma ile ilgili ifadelerin bir özelliğini tanımlamak için kullanılır. Saf sayılacak bir fonksiyon için,

• herhangi bir yan etki sergilemesi yasaktır ve
• referans olarak şeffaf olmalıdır.

Çok sayıda matematik ders kitabında bulunan kara kutu metaforuna göre, bir işlevin iç dünyası tamamen dış dünyadan mühürlenir. Bir yan etki, bir işlev veya ifadenin bu prensibi ihlal etmesidir - yani, prosedürün başka birimlerle bir şekilde iletişim kurmasına izin verilir (örn. Bilgi paylaşımı ve alışverişi).

Özet olarak, referans saydamlığı, programlama dilleri anlamında da fonksiyonların gerçek , matematiksel fonksiyonlar gibi davranması için bir zorunluluktur .