มีเหตุผลว่าทำไมฟังก์ชั่นในภาษาการเขียนโปรแกรมส่วนใหญ่ (?) ได้รับการออกแบบมาเพื่อรองรับพารามิเตอร์อินพุตจำนวนเท่าใดก็ได้ แต่มีค่าส่งคืนเดียวเท่านั้น

ในภาษาส่วนใหญ่มีความเป็นไปได้ที่จะ "หลีกเลี่ยง" ข้อ จำกัด นั้นเช่นโดยการใช้พารามิเตอร์, พอยน์เตอร์ที่ส่งคืนหรือโดยการกำหนด / ส่งกลับ structs / คลาส แต่ดูเหมือนว่าแปลกที่ภาษาการเขียนโปรแกรมไม่ได้ถูกออกแบบมาเพื่อรองรับค่าตอบแทนที่หลากหลายในทาง "เป็นธรรมชาติ"

มีคำอธิบายสำหรับเรื่องนี้?

บางภาษาเช่น Pythonสนับสนุนค่าที่ส่งคืนหลายค่าในขณะที่บางภาษาเช่น C #สนับสนุนพวกเขาผ่านไลบรารีฐานของพวกเขา

แต่โดยทั่วไปแม้ในภาษาที่สนับสนุนพวกเขาค่าการส่งคืนจำนวนมากไม่ได้ถูกใช้บ่อยเพราะมันเลอะเทอะ:

• ฟังก์ชั่นที่ส่งกลับค่าหลายยากที่จะตั้งชื่ออย่างชัดเจน

• ง่ายต่อการเข้าใจผิดลำดับของค่าส่งคืน

  (password, username) = GetUsernameAndPassword()  
  

  (ด้วยเหตุผลเดียวกันนี้หลายคนหลีกเลี่ยงการมีพารามิเตอร์มากเกินไปในฟังก์ชั่นบางคนถึงกับบอกว่าฟังก์ชั่นไม่ควรมีสองพารามิเตอร์ในประเภทเดียวกัน!)

• ภาษาของ OOP มีทางเลือกที่ดีกว่าสำหรับหลาย ๆ ค่าที่ส่งคืน: คลาส
  พวกมันพิมพ์อย่างรุนแรงมากขึ้นพวกเขาเก็บค่าส่งคืนจัดกลุ่มเป็นหนึ่งหน่วยตรรกะและพวกเขาเก็บชื่อ (คุณสมบัติของ) ค่าตอบแทนที่สอดคล้องกันในการใช้งานทั้งหมด

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

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

สิ่งนี้ไม่ได้เปลี่ยนแปลงเนื่องจากโปรแกรมเมอร์พบoutพารามิเตอร์ที่จะสร้างอย่างไม่น่าเชื่อที่มีประโยชน์ในชุดสถานการณ์จำลองที่ จำกัด เท่านั้น เช่นเดียวกับสิ่งอื่น ๆ การสนับสนุนไม่ได้อยู่ที่นั่นเพราะความต้องการ / ความต้องการไม่อยู่ที่นั่น

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

สำหรับฟังก์ชั่นที่มีหลายค่า (ตัวอย่างเช่นรากที่สองของจำนวนเต็มบวกเป็นต้น) ก็เพียงพอแล้วที่จะส่งคืนคอลเลกชันหรือลำดับของค่า

สำหรับประเภทของฟังก์ชั่นที่คุณกำลังพูดถึง (เช่นฟังก์ชั่นที่คืนค่าหลายค่าของประเภทที่แตกต่างกัน ) ฉันเห็นว่ามันแตกต่างจากที่คุณดูเหมือนเล็กน้อย: ฉันเห็นความต้องการ / การใช้งาน params เป็นวิธีแก้ปัญหาสำหรับการออกแบบที่ดีขึ้นหรือ โครงสร้างข้อมูลที่มีประโยชน์มากขึ้น ตัวอย่างเช่นฉันต้องการถ้า*.TryParse(...)วิธีคืนMaybe<T>monad แทนที่จะใช้ param out คิดว่ารหัสนี้ใน F #:

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

การสนับสนุนคอมไพเลอร์ / IDE / การวิเคราะห์ดีมากสำหรับโครงสร้างเหล่านี้ สิ่งนี้จะช่วยแก้ปัญหา "ความต้องการ" ส่วนมากสำหรับการทำ params เพื่อความซื่อสัตย์อย่างสมบูรณ์ฉันไม่สามารถคิดวิธีอื่นใดนอกมือที่นี่จะไม่แก้ปัญหา

สำหรับสถานการณ์อื่น ๆ - สถานการณ์ที่ฉันจำไม่ได้ - ความเรียบง่ายของ Tuple

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

กรณีการใช้งานจำนวนมากที่คุณจะต้องใช้ค่าส่งคืนหลายครั้งในอดีตไม่จำเป็นต้องใช้อีกต่อไปด้วยคุณสมบัติภาษาที่ทันสมัย ต้องการส่งคืนรหัสข้อผิดพลาดหรือไม่? Either<T, Throwable>โยนยกเว้นหรือกลับ ต้องการส่งคืนผลลัพธ์เสริมหรือไม่? Option<T>กลับ ต้องการส่งคืนหนึ่งในหลายประเภทหรือไม่ ส่งคืนEither<T1, T2>หรือเป็นสหภาพที่ติดแท็ก

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

นี่คือตัวอย่างบางส่วนของภาษาที่ไม่สนับสนุนการคืนค่าหลายค่า ฉันไม่เห็นจริง ๆ ว่าการเพิ่มการสนับสนุนสำหรับค่าส่งคืนหลายค่าจะทำให้พวกเขาแสดงออกได้ชัดเจนขึ้นเพื่อชดเชยค่าใช้จ่ายของคุณลักษณะภาษาใหม่

ทับทิม

def foo; return 1, 2, 3 end

one, two, three = foo

one
# => 1

three
# => 3

หลาม

def foo(): return 1, 2, 3

one, two, three = foo()

one
# >>> 1

three
# >>> 3

สกาล่า

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

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

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

Perlเป็นภาษาอื่นที่บางครั้งอาจทำหน้าที่เหมือนฟังก์ชันส่งคืนค่าหลายค่าแม้ว่าโดยปกติแล้วจะถือว่าเป็นการส่งคืนรายการ วิธีแสดงรายการ"interpolate"ใน Perl ให้รายการเหมือนกับ(1, foo(), 3)ที่อาจมีองค์ประกอบ 3 อย่างที่คนส่วนใหญ่ที่ไม่รู้จัก Perl คาดหวัง แต่อาจมีองค์ประกอบเพียง 2 องค์ประกอบ 4 องค์ประกอบหรือองค์ประกอบอื่น ๆ อีกมากมายขึ้นอยู่กับfoo(). รายการใน Perl ถูกทำให้แบนเพื่อให้รายการไวยากรณ์ไม่ได้มีความหมายของรายการเสมอไป มันอาจเป็นเพียงส่วนหนึ่งของรายการขนาดใหญ่

อีกวิธีที่จะให้ฟังก์ชั่นคืนค่าหลายค่าจะต้องมีความหมายของการแสดงออกทางเลือกที่การแสดงออกใด ๆ สามารถมีหลายค่าและแต่ละค่าแสดงถึงความเป็นไป เอาx + 1อีกครั้ง แต่คราวนี้ลองนึกภาพว่าxมีสองค่า {3, 4} ดังนั้นค่าของx + 1จะเป็น {4, 5} และค่าของx + xจะเป็น {6, 8} หรืออาจจะ {6, 7, 8} xขึ้นอยู่กับว่าการประเมินผลอย่างใดอย่างหนึ่งได้รับอนุญาตให้ใช้ค่าหลาย ภาษาเช่นนั้นอาจถูกนำมาใช้โดยใช้การย้อนรอยเหมือนPrologใช้ในการตอบคำถามหลายข้อ

ในระยะสั้นการเรียกใช้ฟังก์ชั่นเป็นหน่วยไวยากรณ์เดียวและหน่วยไวยากรณ์เดียวมีค่าเดียวในความหมายการแสดงออกที่เราทุกคนรู้และชื่นชอบ ความหมายอื่น ๆ จะบังคับให้คุณทำสิ่งแปลก ๆ เช่น Perl, Prolog หรือ Forth

ตามคำแนะนำในคำตอบนี้มันเป็นเรื่องของการสนับสนุนฮาร์ดแวร์แม้ว่าประเพณีในการออกแบบภาษาก็มีบทบาท

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

ในสามภาษาแรกคือ Fortran, Lisp และ COBOL ซึ่งเป็นภาษาแรกที่ใช้ค่าส่งคืนเดียวเนื่องจากเป็นแบบจำลองทางคณิตศาสตร์ ที่สองส่งกลับจำนวนพารามิเตอร์โดยพลการในลักษณะเดียวกับที่ได้รับ: เป็นรายการ (อาจเป็นที่ถกเถียงกันอยู่ว่ามันผ่านและส่งกลับพารามิเตอร์เดียวเท่านั้น: ที่อยู่ของรายการ) ผลตอบแทนที่สามเป็นศูนย์หรือหนึ่งค่า

ภาษาแรกเหล่านี้มีอิทธิพลอย่างมากต่อการออกแบบของภาษาที่ตามมาแม้ว่าจะมีเพียงค่าเดียวที่คืนค่า Lisp แต่ก็ไม่เคยรวบรวมความนิยมมากนัก

เมื่อ C มาถึงแม้จะได้รับอิทธิพลจากภาษาก่อนหน้านั้นมันให้ความสำคัญอย่างมากกับการใช้ทรัพยากรฮาร์ดแวร์อย่างมีประสิทธิภาพรักษาความสัมพันธ์ที่ใกล้ชิดระหว่างสิ่งที่ภาษา C ทำกับรหัสเครื่องที่ใช้งาน คุณสมบัติที่เก่าแก่ที่สุดของมันเช่นตัวแปร "auto" vs "register" เป็นผลมาจากปรัชญาการออกแบบ

จะต้องมีการชี้ให้เห็นว่าภาษาแอสเซมบลีเป็นที่นิยมอย่างกว้างขวางจนถึงยุค 80 เมื่อในที่สุดก็เริ่มที่จะค่อย ๆ ออกจากการพัฒนาที่สำคัญ คนที่เขียนคอมไพเลอร์และภาษาที่สร้างจะคุ้นเคยกับการชุมนุมและส่วนใหญ่เก็บไว้ในสิ่งที่ทำงานได้ดีที่สุดที่นั่น

ภาษาส่วนใหญ่ที่แยกออกจากบรรทัดฐานนี้ไม่เคยได้รับความนิยมมากนักและดังนั้นจึงไม่เคยมีบทบาทที่แข็งแกร่งที่มีอิทธิพลต่อการตัดสินใจของนักออกแบบภาษา (แน่นอนว่าเป็นแรงบันดาลใจจากสิ่งที่พวกเขารู้)

ลองดูภาษาแอสเซมบลีกัน ก่อนอื่นมาดูที่6502ซึ่งเป็นไมโครโพรเซสเซอร์ 1975 ซึ่งถูกใช้อย่างมีชื่อเสียงโดยไมโครคอมพิวเตอร์ Apple II และ VIC-20 มันอ่อนแอมากเมื่อเทียบกับสิ่งที่ใช้ในเมนเฟรมและ minicomputers ของเวลาแม้ว่าทรงพลังเมื่อเทียบกับคอมพิวเตอร์เครื่องแรกของ 20, 30 ปีก่อนในตอนเช้าของภาษาโปรแกรม

ถ้าคุณดูที่คำอธิบายทางเทคนิคมันมี 5 รีจิสเตอร์พร้อมกับแฟล็กหนึ่งบิต การลงทะเบียน "เต็ม" เพียงอย่างเดียวคือ Program Counter (PC) - ที่ลงทะเบียนคะแนนไปยังคำสั่งถัดไปที่จะดำเนินการ รีจิสเตอร์อื่นโดยที่ตัวสะสม (A), สอง "ดัชนี" รีจิสเตอร์ (X และ Y) และตัวชี้สแต็ก (SP)

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

หากคุณดูโปรเซสเซอร์ที่เป็นแรงบันดาลใจ 6502, 6800จะมีการลงทะเบียนเพิ่มเติม, ดัชนีการลงทะเบียน (IX), กว้างเท่ากับ SP ซึ่งสามารถรับค่าจาก SP

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

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

สามารถเรียกได้หลายครั้งเพราะพื้นที่ชั่วคราวทั้งหมดอยู่บนสแต็ก

8080 , ใช้ใน TRS-80 และโฮสต์ของ CP / M-ไมโครคอมพิวเตอร์ที่ใช้สามารถทำบางสิ่งบางอย่างที่คล้ายกับ 6800 โดยการผลักดัน SP ในกองแล้ว popping มันเกี่ยวกับการลงทะเบียนโดยทางอ้อม, HL

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

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

ดังนั้นสิ่งที่มักจะทำคือจองหนึ่งทะเบียนสำหรับค่าส่งคืน รหัสการโทรรู้ว่าค่าส่งคืนจะอยู่ในการลงทะเบียนเฉพาะซึ่งจะต้องเก็บรักษาไว้จนกว่าจะสามารถบันทึกหรือใช้งานได้

ลองดูภาษาที่อนุญาตการคืนค่าหลาย ๆ ค่า: Forth สิ่งที่ Forth ทำคือการรักษา stack stack (RP) และ data stack (SP) ที่แยกต่างหากเพื่อให้ฟังก์ชั่นทั้งหมดที่ต้องทำคือ pop พารามิเตอร์ทั้งหมดและเก็บค่าส่งคืนบนสแต็ก เนื่องจากสแต็กส่งคืนแยกจากกันจึงไม่สามารถเข้าถึงได้

ในฐานะคนที่เรียนรู้ภาษาแอสเซมบลีและ Forth ในช่วงหกเดือนแรกของประสบการณ์กับคอมพิวเตอร์ ตัวดำเนินการเช่น Forth's /modซึ่งคืนค่าการแบ่งจำนวนเต็มและส่วนที่เหลือดูเหมือนจะชัดเจน ในทางกลับกันฉันสามารถเห็นได้อย่างง่ายดายว่าคนที่มีประสบการณ์ในช่วงต้นคือ C ใจพบแนวคิดที่แปลก: มันขัดกับความคาดหวังที่ฝังแน่นของพวกเขาในสิ่งที่ "ฟังก์ชั่น" คืออะไร

ส่วนคณิตศาสตร์ ... ก็ฉันเขียนโปรแกรมทางคอมพิวเตอร์ก่อนที่ฉันจะเข้าฟังก์ชั่นในวิชาคณิตศาสตร์ มีเป็นทั้งส่วนของการบริการลูกค้าและการเขียนโปรแกรมภาษาซึ่งได้รับอิทธิพลจากคณิตศาสตร์ แต่แล้วอีกครั้งมีทั้งส่วนที่ไม่ได้

ดังนั้นเราจึงมีการรวมตัวกันของปัจจัยที่คณิตศาสตร์มีอิทธิพลต่อการออกแบบภาษายุคแรก ๆ ที่ข้อ จำกัด ของฮาร์ดแวร์กำหนดสิ่งที่นำไปปฏิบัติได้ง่ายและที่ภาษายอดนิยมมีอิทธิพลต่อการพัฒนาฮาร์ดแวร์ (เครื่อง Lisp และโปรเซสเซอร์จากเครื่อง

ภาษาที่ใช้งานได้ที่ฉันรู้จักสามารถคืนค่าหลาย ๆ ค่าได้อย่างง่ายดายผ่านการใช้สิ่งอันดับ (ในภาษาที่พิมพ์แบบไดนามิกคุณยังสามารถใช้รายการได้) Tuples รองรับภาษาอื่นด้วย:

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);
}

ในตัวอย่างข้างต้นfเป็นฟังก์ชันที่คืนค่า 2 int

ในทำนองเดียวกัน ML, Haskell, F # และอื่น ๆ สามารถกลับโครงสร้างข้อมูลได้ (พอยน์เตอร์อยู่ในระดับต่ำเกินไปสำหรับภาษาส่วนใหญ่) ฉันไม่เคยได้ยินภาษา GP สมัยใหม่ที่มีข้อ จำกัด ดังกล่าว:

data MyValue = MyValue Int Int

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

ในที่สุดoutพารามิเตอร์สามารถจำลองได้แม้ในภาษาที่ใช้งานIORefได้ มีสาเหตุหลายประการที่ไม่มีการสนับสนุนพื้นเมืองสำหรับตัวแปรออกในภาษาส่วนใหญ่:

• ความหมายไม่ชัดเจน : ฟังก์ชันต่อไปนี้พิมพ์ 0 หรือ 1 หรือไม่? ฉันรู้ภาษาที่จะพิมพ์ 0 และคนที่จะพิมพ์ 1 มีประโยชน์ทั้งสองอย่าง (ทั้งในแง่ของประสิทธิภาพและการจับคู่รูปแบบจิตของโปรแกรมเมอร์):

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

• เอฟเฟ็กต์ที่ไม่แปล : ดังตัวอย่างข้างต้นคุณจะพบว่าคุณมีสายโซ่ยาวและฟังก์ชั่นด้านในมีผลต่อสถานะโลก โดยทั่วไปแล้วมันทำให้ยากที่จะให้เหตุผลเกี่ยวกับข้อกำหนดของฟังก์ชั่นและถ้าการเปลี่ยนแปลงนั้นถูกกฎหมาย เนื่องจากกระบวนทัศน์สมัยใหม่ส่วนใหญ่พยายาม จำกัด ผลกระทบ (encapsulation ใน OOP) หรือกำจัดผลข้างเคียง (การโปรแกรมเชิงปฏิบัติ) มันขัดแย้งกับกระบวนทัศน์เหล่านั้น

• การซ้ำซ้อน : หากคุณมีสิ่งอันดับคุณมี 99% ของการทำงานของoutพารามิเตอร์และการใช้สำนวน 100% หากคุณเพิ่มพอยน์เตอร์เข้ากับมิกซ์นั้นคุณจะครอบคลุม 1%

ฉันมีปัญหาในการตั้งชื่อภาษาหนึ่งซึ่งไม่สามารถคืนค่าหลายค่าโดยใช้ tuple คลาสหรือoutพารามิเตอร์ (และในกรณีส่วนใหญ่อนุญาตให้ใช้วิธีเหล่านี้อย่างน้อย 2 วิธี)

ฉันคิดว่ามันเป็นเพราะการแสดงออก(a + b[i]) * cเช่น

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

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

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

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

x = n + sqrt(y);

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

ฉันแค่ต้องการสร้างคำตอบของฮาร์วีย์ เดิมทีฉันพบคำถามนี้ในเว็บไซต์ข่าวเทคโนโลยี (arstechnica) และพบคำอธิบายที่น่าอัศจรรย์ที่ฉันรู้สึกว่าตอบคำถามหลักของคำถามนี้และขาดคำตอบอื่น ๆ ทั้งหมด (ยกเว้นฮาร์วีย์):

ต้นกำเนิดของการส่งคืนจากฟังก์ชั่นเดียวอยู่ในรหัสเครื่อง ที่ระดับรหัสเครื่องฟังก์ชั่นสามารถคืนค่าในการลงทะเบียน A (ตัวสะสม) ค่าส่งคืนอื่น ๆ จะอยู่ในสแต็ก

ภาษาที่รองรับค่าส่งคืนสองค่าจะคอมไพล์เป็นรหัสเครื่องที่ส่งกลับค่าหนึ่งและวางที่สองในสแต็ก กล่าวอีกนัยหนึ่งมูลค่าส่งคืนที่สองจะสิ้นสุดเป็นพารามิเตอร์ออก

มันเหมือนกับถามว่าทำไมการมอบหมายให้เป็นหนึ่งตัวแปรในแต่ละครั้ง คุณสามารถมีภาษาที่อนุญาตให้ a, b = 1, 2 ได้ แต่มันจะจบลงที่ระดับรหัสเครื่องเป็น a = 1 ตามด้วย b = 2

มีเหตุผลในการสร้างภาษาการเขียนโปรแกรมมีรูปร่างหน้าตาบางอย่างกับสิ่งที่จะเกิดขึ้นจริงเมื่อรหัสรวบรวมและทำงาน

มันเริ่มต้นด้วยคณิตศาสตร์ FORTRAN ชื่อสำหรับ "การแปลสูตร" เป็นคอมไพเลอร์ตัวแรก FORTRAN เป็นและมุ่งเน้นไปที่ฟิสิกส์ / คณิตศาสตร์ / วิศวกรรม

COBOL เกือบแก่แล้วไม่มีค่าตอบแทนชัดเจน มันแทบจะไม่มีรูทีนย่อย ตั้งแต่นั้นมาความเฉื่อยส่วนใหญ่

ไปยกตัวอย่างเช่นมีค่าที่ส่งคืนหลายและผลที่ได้คือการทำความสะอาดและคลุมเครือน้อยกว่าการใช้ "ออก" พารามิเตอร์ หลังการใช้งานเล็กน้อยมันเป็นธรรมชาติและมีประสิทธิภาพ ฉันแนะนำให้คืนค่าหลาย ๆ ค่าสำหรับภาษาใหม่ทั้งหมด บางทีสำหรับภาษาเก่าด้วย

อาจเป็นเรื่องเกี่ยวกับมรดกของวิธีการเรียกใช้ฟังก์ชันในคำสั่งเครื่องโปรเซสเซอร์และความจริงที่ว่าภาษาการเขียนโปรแกรมทั้งหมดได้มาจากรหัสเครื่อง: ตัวอย่างเช่น C -> Assembly -> Machine

โปรเซสเซอร์ดำเนินการเรียกใช้ฟังก์ชันอย่างไร

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

ทีนี้เหตุใดโปรเซสเซอร์จึงถูกออกแบบด้วยวิธีนี้ ... มันอาจเป็นคำถามของข้อ จำกัด ด้านทรัพยากร