Çoğu (?) Programlama dilindeki fonksiyonların herhangi bir sayıda giriş parametresini değil, sadece bir dönüş değerini destekleyecek şekilde tasarlanmasının bir nedeni var mı?

Çoğu dilde, bu sınırlamayı "dış parametreler kullanarak, işaretçileri döndürerek veya yapı / sınıfları tanımlayarak / geri getirerek" çözmek mümkündür. Ancak programlama dillerinin çoklu dönüş değerlerini daha "doğal" bir şekilde desteklemek için tasarlanmamış olmaları garip görünüyor.

Bunun bir açıklaması var mı?

Bazı diller, Python gibi bazı diller ise, doğal olarak birden dönüş değerleri destekleyen C # gibi onların temel kütüphaneleri aracılığıyla onlara destek.

Ancak genel olarak, onları destekleyen dillerde bile, özensiz oldukları için çok sayıda dönüş değeri sık kullanılmaz:

• Birden çok değer döndüren işlevlerin açıkça adlandırılması zordur .

• Dönüş değerlerinin sırasını yanlış yapmak kolaydır

  (password, username) = GetUsernameAndPassword()  
  

  (Bu aynı sebepten dolayı, birçok kişi bir fonksiyon için çok fazla parametre kullanmaktan kaçınır; bazıları bile bir fonksiyonun asla aynı tipte iki parametreye sahip olmaması gerektiğini söyler)

• OOP dilleri zaten birden fazla dönüş değerleri için daha iyi bir alternatif var: sınıflarını.
  Daha güçlü şekilde yazılırlar, dönüş değerlerini tek bir mantıksal birim olarak gruplandırırlar ve dönüş değerlerinin adlarını tüm kullanımlarda tutarlı tutarlar.

Onlar tek bir yerde olan oldukça kullanışlı bir fonksiyonu birden fazla dönüş değerleri birbirine birden fazla giriş parametreleri olarak kullanılabilir (Python gibi) dilde. Ancak bunun sınıf kullanmaktan daha iyi bir tasarım olduğu kullanım durumları oldukça zayıf.

Çünkü fonksiyonlar bir hesaplama yapan ve bir sonuç veren matematiksel yapılardır. Nitekim, birkaç programlama dilinin "başlığı altında" olanların çoğu, sadece bir girişe ve bir çıkışa odaklanır, çoklu girişler girişin etrafında sadece ince bir sargı yapar ve tek bir değer çıkışı çalışmadığında, tek bir Yapışkan yapı (veya demet veya Maybe) çıktı ("tek" dönüş değerinin birçok değerden oluşmasına rağmen).

Bu değişmedi, çünkü programcılar outparametreleri yalnızca sınırlı bir senaryo dizisinde faydalı olan garip yapılar olarak buldular . Diğer birçok şey gibi, destek de yok çünkü ihtiyaç / talep orada değil.

Matematik olarak, bir "iyi tanımlanmış" fonksiyonu , belirli bir girdi için sadece 1 çıkışı (bir yan not olarak, sadece tek bir giriş fonksiyonları vardır ve yine semantik kullanarak birden fazla giriş almak olduğu yerde biridir -işlemden ).

Çok değerli fonksiyonlar için (örneğin, pozitif bir tamsayıya ait kare kökü), bir koleksiyon veya değer dizisini döndürmek yeterlidir.

Bahsettiğiniz işlev türleri için (yani, birden fazla değer döndüren işlevler , farklı türlerde ) Gördüğünüzden biraz farklı görüyorum: Daha iyi bir tasarım ya da daha kullanışlı veri yapısı. Örneğin, *.TryParse(...)yöntemlerin Maybe<T>bir dış param kullanmak yerine bir monad döndürmesini tercih ederim . F # 'daki bu kodu düşünün:

let s = "1"
match tryParse s with
| Some(i) -> // do whatever with i
| None -> // failed to parse

Derleyici / IDE / analiz desteği bu yapılar için çok iyidir. Bu, params için "ihtiyaç" nin çoğunu çözer. Tamamen dürüst olmak gerekirse, bunun çözüm olmayacağı herhangi bir başka metodu düşünemiyorum.

Diğer senaryolar için - hatırlayamadığım şeyler - basit bir demet yeterlidir.

Bir işlev döndüğünde montajda kullanılan paradigmalara baktığınızda söylenenlere ek olarak, belirli bir kayıt defterinde dönen nesneye bir işaretçi bırakır. Değişken / çoklu kayıt kullanmışlarsa çağıran fonksiyon, eğer bu fonksiyon bir kütüphanede olsaydı, döndürülen değerlerin nereden alınacağını bilemezdi. Bu da kütüphanelerle bağlantı kurmayı zorlaştıracak ve keyfi bir sayıda iade edilebilir işaretçi koymak yerine bir taneyle birlikte gideceklerdi. Daha yüksek seviyeli diller aynı bahaneye sahip değil.

Geçmişte çoklu getiri değerleri kullanmış olacağınız birçok kullanım durumu, artık modern dil özellikleri için gerekli değildir. Bir hata kodu döndürmek ister misiniz? Bir istisna at veya geri dön Either<T, Throwable>. İsteğe bağlı bir sonuç döndürmek ister misiniz? Bir dönüş Option<T>. Birkaç türden birini iade etmek ister misiniz? Bir İade Either<T1, T2>veya etiketli birliği.

Ve gerçekten birden fazla değer döndürmeniz gereken durumlarda bile , modern diller genellikle çemberleri veya bir tür veri yapısını (liste, dizi, sözlük) ya da nesneleri, ayrıca ambalajlamayı oluşturan bir çeşit bağlama ya da kalıp eşleştirme biçimini destekler. çoklu değerlerinizi tek bir değere dönüştürün ve ardından tekrar önemsiz olarak çoklu değerlere imha edin.

İşte dillerin birkaç örnek yok birden çok değeri dönen destekler. Birden fazla getiri değeri için destek eklemenin onları yeni bir dil özelliğinin maliyetini dengelemek için nasıl daha anlamlı hale getireceğini gerçekten anlamıyorum.

Yakut

def foo; return 1, 2, 3 end

one, two, three = foo

one
# => 1

three
# => 3

piton

def foo(): return 1, 2, 3

one, two, three = foo()

one
# >>> 1

three
# >>> 3

Scala

def foo = (1, 2, 3)

val (one, two, three) = foo
// => one:   Int = 1
// => two:   Int = 2
// => three: Int = 3

Haskell

let foo = (1, 2, 3)

let (one, two, three) = foo

one
-- > 1

three
-- > 3

Perl6

sub foo { 1, 2, 3 }

my ($one, $two, $three) = foo

$one
# > 1

$three
# > 3

Tek bir getiri değerinin bu kadar popüler olmasının asıl nedeni, birçok dilde kullanılan ifadelerdir. Sizin gibi bir ifadeye sahip olabileceğiniz herhangi bir dilde x + 1, zaten tek dönüş değerleri olarak düşünürsünüz, çünkü kafanızdaki bir ifadeyi parçalara ayırarak ve her bir parçanın değerini belirleyerek değerlendirirsiniz. Sen bakmak xve onu değer (örneğin) 3 mi olduğuna karar ve 1 bakmak ve sonra bakmakx + 1ve bütünün değerinin 4 olduğuna karar vermek için hepsini bir araya getirin. İfadenin her sözdizimsel kısmı bir başka değere değil bir değere sahiptir; Bu, herkesin beklediği ifadelerin doğal anlambilimidir. Bir işlev bir çift değer döndürse bile, gerçekten iki değerin işini yapan bir değeri döndürür, çünkü bir şekilde tek bir koleksiyona sarılı olmayan iki değeri döndüren bir işlev fikri çok gariptir.

İnsanlar, fonksiyonların birden fazla değere sahip olması için gerekli olan alternatif anlambilim ile uğraşmak istemiyorlar. Örneğin, Forth gibi bir yığın temelli dilde , herhangi bir sayıda dönüş değerine sahip olabilirsiniz, çünkü her bir fonksiyon basitçe yığının tepesini değiştirir, girişleri fırlatır ve çıkışları istediği zaman iter. Bu nedenle Forth'un normal dillerin ifade ettiği türden ifadeleri yok.

Perl , bazen işlevler gibi davranabilen başka bir dildir, genellikle sadece bir listeyi döndürdüğü düşünüldüğü halde, birden fazla değer döndürür. Perl'deki "enterpolate" listelerinin yolu bize (1, foo(), 3)Perl'i beklemeyen çoğu insanın 3 öğeye sahip olabileceği, ancak buna bağlı olarak sadece 2 öğeye, 4 öğeye veya daha fazla öğeye sahip olabileceği gibi listeler . foo(). Perl'deki listeler düzleştirilir, böylece sözdizimsel bir liste her zaman bir listenin semantiğine sahip olmaz; sadece daha büyük bir listenin parçası olabilir.

İşlevlerin birden çok değer döndürmesini sağlamanın başka bir yolu, herhangi bir ifadenin birden çok değere sahip olabileceği ve her değerin bir olasılığı temsil ettiği alternatif bir ifade semantiğine sahip olmak olacaktır. x + 1Tekrar ele alın , ancak bu kez xiki değerin {3, 4} olduğunu, sonra değerlerinin x + 1{4, 5} x + xolacağını ve değerlerinin {6, 8} veya belki {6, 7, 8} olacağını hayal edin. , bir değerlendirmenin birden fazla değer kullanmasına izin verilip verilmediğine bağlı olarak x. Bunun gibi bir dil, Prolog'un bir sorguya birden çok cevap vermek için kullandığı gibi geri izleme kullanılarak uygulanabilir .

Kısacası, bir işlev çağrısı tek bir sözdizimsel birimdir ve tek bir sözdizimsel birim, bildiğimiz ve sevdiğimiz ifade anlamında tek bir değere sahiptir. Başka herhangi bir anlambilim sizi Perl, Prolog veya Forth gibi şeyler yapmanın garip yollarına zorlar.

Bu cevapta önerildiği gibi, bu donanım desteği konusudur, ancak dil tasarımındaki gelenek de rol oynar.

bir işlev döndüğünde, belirli bir kayıt defterinde dönen nesneye bir işaretçi bırakır

İlk üç dilden Fortran, Lisp ve COBOL, birincisi matematiğe göre modellenirken tek bir geri dönüş değeri kullandı. İkincisi, rastgele sayıda parametreyi, aldığı şekilde değiştirdi: liste halinde (yalnızca geçtiği ve tek bir parametre döndürdüğü de iddia edilebilir: listenin adresi). Üçüncüsü sıfır veya bir değer döndürür.

Bu ilk diller, onları takip eden dillerin tasarımını çok etkiledi, ancak birden fazla değer veren tek, Lisp hiçbir zaman popüler olmadı.

C geldiğinde, ondan önceki dillerden etkilenirken, donanım kaynağının verimli kullanılmasına ve C dilinin ne yaptığı ile onu uygulayan makine kodu arasında yakın bir ilişki kurmaya odaklandı. "Auto" vs "register" değişkenleri gibi en eski özelliklerinden bazıları, bu tasarım felsefesinin bir sonucudur.

Ayrıca derleme dilinin, ana akım gelişimin dışına çıkmaya başladığı 80'li yıllara kadar yaygın bir şekilde popüler olduğu belirtilmelidir. Derleyiciler yazan ve dilleri oluşturan insanlar , derleme hakkında bilgi sahibi oldular ve çoğunlukla orada en iyi olanı yapmaya devam ettiler.

Bu normdan ayrılan dillerin çoğu hiçbir zaman fazla popülerlik bulamadı ve bu nedenle, dil tasarımcılarının (elbette bildiklerinden ilham alan) kararlarını etkileyen güçlü bir rol oynamadılar.

Öyleyse gidip derleme dilini inceleyelim. Önce Apple II ve VIC-20 mikrobilgisayarları tarafından kullanılan bir 1975 mikroişlemci olan 6502'ye bakalım . Programlama dillerinin şafağında, 20, 30 yıl önceki ilk bilgisayarlara kıyasla daha güçlü olmasına rağmen, zamanın anabilgisayarında ve minibilgisayarlarında kullanılanlarla karşılaştırıldığında çok zayıftı.

Teknik açıklamaya bakarsanız, 5 yazmaç artı birkaç tane bitlik bayrak bulunur. Tek "tam" kayıt programı Program Sayacı (PC) idi - kayıt işlemi yapılacak bir sonraki talimatı işaret ediyor. Diğer, akümülatörün (A), iki "endeks" in (X ve Y) ve bir yığın göstergesinin (SP) kaydedildiği yerde saklanır.

Alt yordamın çağrılması, bilgisayarı SP'nin belirttiği belleğe koyar ve ardından SP'yi azaltır. Bir alt rutinden geri dönüş ters çalışır. Biri yığındaki diğer değerleri itip çekebilir, ancak SP'ye göre belleğe başvurmak zordur, bu nedenle yeniden giren alt programları yazmak zordu. Aldığımız, istediğimiz zaman bir alt rutin olarak adlandırdığımız bu mimari bu kadar yaygın değildi. Genellikle, ayrı bir "yığın" yaratılır, böylece parametreler ve alt rutin geri dönüş adresi ayrı tutulur.

Eğer 6502, ilham işlemci bakacak olursak 6800 , bu SP değeri alabileceği ilave bir kayıt, Index Kayıt (IX), kadar geniş SP vardı.

Makinede, yeniden giriş yapan bir alt yordamı çağırmak, parametreleri istifte zorlamak, PC'yi itmek, PC'yi yeni adrese değiştirmek ve ardından alt yordamı yerel değişkenleri yığında zorlamaktan ibaretti . Yerel değişkenlerin ve parametrelerin sayısı bilindiğinden, bunları adresleme yığına göre yapılabilir. Örneğin, iki parametre alan ve iki yerel değişkene sahip bir işlev şöyle görünür:

SP + 8: param 2
SP + 6: param 1
SP + 4: return address
SP + 2: local 2
SP + 0: local 1

Tüm geçici boşluk yığında olduğundan, herhangi bir sayıda çağrılabilir.

8080 dolaylı sicil, HL üzerine haşhaş sonra yığın SP bastırıyor ve tarafından, 6800 benzer bir şey yapabileceğini TRS-80 ve CP / M tabanlı mikro bilgisayarların bir ana bilgisayarda kullanılan.

Bu, işleri uygulamak için çok yaygın bir yöntemdir ve daha kolay dönmeden önce tüm yerel değişkenleri terk etmeyi sağlayan Base Pointer ile daha modern işlemciler konusunda daha da fazla destek aldı.

Sorun, bir şeyi nasıl iade edersiniz ? İşlemci kayıtları çok erken sayılmadı ve çoğu zaman hangi bellek parçasını ele alacağını bulmak için bile bazılarını kullanmak gerekiyordu. Yığındaki şeylerin geri dönüşü karmaşık olacaktır: her şeyi açmanız, bilgisayarı kaydetmeniz, geri dönüş parametrelerini itmeniz (bu arada nerede saklanır?), Sonra bilgisayarı tekrar itip geri dönmeniz gerekir.

Genelde yapılan şey , geri dönüş değeri için bir kayıt ayırmaktı . Çağıran kod, dönüş değerinin belirli bir sicilde olacağını, kaydedilmesi veya kullanılması için korunmasının gerekli olacağını biliyordu.

Birden fazla dönüş değerine izin veren bir dile bakalım: İleri. Forth'un yaptığı, ayrı bir geri dönüş yığını (RP) ve veri yığını (SP) tutmak, böylece bir işlevin yapması gereken, tüm parametrelerini açıp geri dönüş değerlerini yığında bırakmaktı. Dönüş yığını ayrı olduğundan, yoluna girmedi.

Bilgisayarlarda edinilen ilk altı aylık dönemde, montaj dilini ve İleri'yi öğrenen biri olarak, çoklu iade değerleri benim için tamamen normal görünüyor. /modTam sayıyı ve geri kalanını döndüren Forth's gibi operatörler açık görünüyor. Öte yandan, ilk deneyimleri C zihin olan birinin bu kavramı nasıl tuhaf bulduğunu kolayca görebiliyorum: bir "fonksiyonun" ne olduğu konusundaki yerleşik beklentilerine aykırı.

Matematik gelince ... pekala, matematik derslerinde fonksiyonlara başlamadan önce bilgisayarları programlıyordum. Orada olduğu değil bütün bir bölüm bulunmaktadır, sonra tekrar, CS ve matematik etkilenir programlama dillerinin bir bölüm ama.

Bu nedenle matematiğin erken dil tasarımını etkilediği, donanım kısıtlamalarının kolaylıkla uygulanabilen şeyleri dikte ettiği ve popüler dillerin donanımın nasıl geliştiğini etkilediği (Lisp makinesi ve Forth makine işlemcileri bu süreçte yol tutkunlarıydı) faktörlerin birleştiğine sahibiz.

Tanıdığım işlevsel diller, tuple kullanımıyla kolayca birden fazla değer döndürebilir (dinamik olarak yazılmış dillerde bile listeleri kullanabilirsiniz). Tote'ler diğer dillerde de desteklenmektedir:

f :: Int -> (Int, Int)
f x = (x - 1, x + 1)

// Even C++ have tuples - see Boost.Graph for use
std::pair<int, int> f(int x) {
  return std::make_pair(x - 1, x + 1);
}

Yukarıdaki örnekte, f2 inç döndüren bir işlevdir.

Benzer şekilde, ML, Haskell, F #, vb., Veri yapılarını da döndürebilir (işaretçiler çoğu dil için çok düşük düzeydedir). Böyle bir kısıtlama ile modern bir GP dili duymadım:

data MyValue = MyValue Int Int

g :: Int -> MyValue
g x = MyValue (x - 1, x + 1)

Son olarak, outfonksiyonel dillerde bile parametreler taklit edilebilir IORef. Çoğu dilde dışarı değişkenler için yerel destek olmamanın birkaç nedeni vardır:

• Net olmayan anlambilim : Aşağıdaki işlev 0 mı yoksa 1 mi yazdırıyor? 0 basacak dilleri ve 1 basacak dilleri biliyorum. Her ikisinin de yararları vardır (hem performans açısından hem de programcının zihinsel modelini eşleştirmenin yanı sıra):

  int x;
  
  int f(out int y) {
    x = 0;
    y = 1;
    printf("%d\n", x);
  }
  f(out x);
  

• Lokalize olmayan etkiler : Yukarıdaki örnekte olduğu gibi, uzun bir zincire sahip olabileceğinizi ve en içteki fonksiyonun küresel durumu etkilediğini görebilirsiniz. Genel olarak, işlevin gereksinimlerinin ne olduğu ve değişimin yasal olup olmadığına dair gerekçeyi zorlaştırır. Modern paradigmaların çoğunun ya etkileri yerelleştirmeye (OOP'de kapsülleme) ya da yan etkileri ortadan kaldırmaya çalıştığı göz önüne alındığında, bu paradigmalar ile çelişir.

• Yedekli Olmak : Eğer perdelere sahipseniz, outparametrelerin işlevselliğinin% 99'una ve deyimsel kullanımın% 100'üne sahipsiniz . Karışıma işaretçiler eklerseniz, kalan% 1'i karşılarsınız.

Bir dize, sınıf veya outparametre kullanarak birden fazla değer döndüremeyen bir dilin adlandırılmasında sorun yaşıyorum (ve çoğu durumda bu yöntemlerden 2 veya daha fazlasına izin verilir).

Bunun gibi ifadeler yüzünden olduğunu düşünüyorum (a + b[i]) * c.

İfadeler "tekil" değerlerden oluşur. Böylece tekil bir değer döndüren bir fonksiyon, yukarıda gösterilen dört değişkenden herhangi birinin yerine, bir ifadede doğrudan kullanılabilir. Çok çıkışlı bir işlev bir ifadede en azından biraz sakardır.

Şahsen bunun tekil bir dönüş değeri için özel olan şey olduğunu hissediyorum . Bir ifadede kullanmak istediğiniz birden çok dönüş değerinden hangisini belirtmek için sözdizimi ekleyerek bunun üstesinden gelinebilirsiniz, ancak eski ve eski matematiksel gösterime göre daha hantal ve herkes için aşinadır.

Sözdizimini biraz zorlaştırıyor, ancak uygulama düzeyinde izin vermemek için iyi bir neden yok. Diğer yanıtların bazılarına aykırı olarak, varsa, birden fazla değerin döndürülmesi, daha net ve daha verimli kodlara yol açar. Ne kadar sıklıkla bir X ve Y ya da "başarılı" bir boole ve faydalı bir değer döndürmek istediğimi hesaplayamıyorum .

İşlevlerin desteklendiği çoğu dilde, bu türden bir değişkenin kullanılabileceği her yerde işlev çağrısı kullanabilirsiniz: -

x = n + sqrt(y);

İşlev birden fazla değer döndürürse, bu çalışmaz. Dinamik olarak yazılan python gibi diller bunu yapmanıza izin verir, ancak çoğu durumda denklemin ortasındaki bir tuple ile ilgili bir şeyler yapamadıkça çalışma zamanı hatası verir.

Sadece Harvey'in cevabı üzerine inşa etmek istiyorum. Başlangıçta bu soruyu bir haber teknolojisi sitesinde (arstechnica) buldum ve bu sorunun özüne gerçekten cevap verdiğini ve diğer tüm cevaplardan (Harvey's hariç) yoksun olduğuna inandığım şaşırtıcı bir açıklama buldum:

İşlevlerden tek dönüşün kökeni, makine kodundadır. Makine kodu seviyesinde, bir fonksiyon A (akümülatör) kaydında bir değer döndürebilir. Diğer tüm iade değerleri yığında olacaktır.

İki dönüş değerini destekleyen dil, onu döndüren makine kodu olarak derlenecek ve ikinciyi yığına koyacaktır. Başka bir deyişle, ikinci dönüş değeri yine de bir çıkış parametresi olarak bitecektir.

Atamanın neden her seferinde bir değişken olduğunu sormak gibi. Mesela a, b = 1, 2 izin verilen bir dile sahip olabilirsiniz. Ancak makine kodu seviyesinde a = 1 ve ardından b = 2 olur.

Programlama dili yapılarının, kod derlenirken ve çalıştırılırken gerçekte ne olacağına dair bir miktar belirsizliğe sahip olmasının gerekçesi vardır.

Matematik ile başladı. FORTRAN, "Formula Çeviri" olarak adlandırılan ilk derleyiciydi. FORTRAN fizik / matematik / mühendisliğe yöneldi ve ona yöneldi.

COBOL, neredeyse eski, açık bir geri dönüş değerine sahip değildi; Ancak alt yordamlar vardı. O zamandan beri çoğunlukla atalet oldu.

Örneğin Go , çoklu dönüş değerlerine sahiptir ve sonuç "out" parametrelerini kullanmaktan daha temiz ve daha az belirsizdir. Biraz kullandıktan sonra çok doğal ve verimlidir. Tüm yeni diller için birden fazla dönüş değeri düşünülmesini öneririm. Belki eski diller için de.

Muhtemelen, işlev çağrılarının işlemcinin makine talimatlarında nasıl yapıldığının mirası ve tüm programlama dillerinin makine kodundan geldiği gerçeğiyle daha fazla ilgisi vardır: örneğin, C -> Assembly -> Makine.

İşlemciler İşlev Çağrısını Nasıl Gerçekleştirir?

İlk programlar makine kodu ve daha sonra montaj ile yazılmıştır. İşlemciler tarafından desteklenen işlev, mevcut tüm kayıt defterlerinin bir kopyasını yığına iterek çağırır. İşlevden geri dönmek kaydedilmiş kayıt kümesini yığından açar. Dönen fonksiyonun bir değer getirmesini sağlamak için genellikle bir sicile dokunulmazdı.

Şimdi, neden işlemcilerin bu şekilde tasarlandığına gelince ... bu büyük olasılıkla kaynak kısıtlamaları sorunuydu.