คำถามติดแท็ก side-effect

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

69 functional-programming  side-effect 

ตกลงดังนั้นชื่อเรื่องนั้นเป็นเรื่อง clickbaity เล็ก ๆ น้อย ๆ แต่อย่างจริงจังฉันได้รับการบอกไม่ต้องถามสักครู่ ฉันชอบที่มันส่งเสริมวิธีการที่จะใช้เป็นข้อความในแบบเชิงวัตถุจริง แต่นี่เป็นปัญหาที่จู้จี้ที่คร่ำครวญในหัวของฉัน ฉันสงสัยว่ารหัสที่เขียนได้ดีสามารถปฏิบัติตามหลักการ OO และหลักการทำงานได้ในเวลาเดียวกัน returnฉันพยายามที่จะกระทบความคิดเหล่านี้และจุดเกาะใหญ่ที่ผมเคยมีที่ดินบน ฟังก์ชั่นบริสุทธิ์มีสองคุณสมบัติ: การเรียกซ้ำ ๆ ด้วยอินพุตเดียวกันจะให้ผลลัพธ์เดียวกันเสมอ นี่ก็หมายความว่ามันไม่เปลี่ยนรูป สถานะของมันถูกตั้งค่าเพียงครั้งเดียว มันไม่มีผลข้างเคียง การเปลี่ยนแปลงเพียงอย่างเดียวที่เกิดจากการเรียกมันคือการสร้างผลลัพธ์ ดังนั้นวิธีการอย่างใดอย่างหนึ่งเกี่ยวกับการทำงานอย่างหมดจดถ้าคุณได้สาบานว่าจะใช้returnเป็นวิธีการสื่อสารผลลัพธ์ของคุณ? บอกไม่ได้ถามผลงานความคิดโดยใช้สิ่งที่บางคนจะพิจารณาผลข้างเคียง เมื่อฉันจัดการกับวัตถุฉันไม่ถามเกี่ยวกับสถานะภายในของวัตถุนั้น ฉันบอกสิ่งที่ฉันต้องทำและใช้สถานะภายในเพื่อหาว่าจะทำอย่างไรกับสิ่งที่ฉันบอกให้ทำ เมื่อฉันบอกมันฉันไม่ได้ถามว่ามันทำอะไร ฉันแค่หวังว่ามันจะทำอะไรบางอย่างเกี่ยวกับสิ่งที่มันถูกบอกให้ทำ ฉันคิดว่า Tell, Don't Ask เป็นมากกว่าชื่อที่แตกต่างกันสำหรับการห่อหุ้ม เมื่อฉันใช้returnฉันไม่มีความคิดในสิ่งที่เรียกว่าฉัน ฉันไม่สามารถพูดได้ว่าเป็นโปรโตคอลฉันต้องบังคับให้จัดการกับโปรโตคอลของฉัน ซึ่งในหลายกรณีได้รับการแสดงออกเป็นสถานะภายใน แม้ว่าสิ่งที่ได้รับการเปิดเผยไม่ได้ระบุอย่างชัดเจน แต่โดยทั่วไปแล้วการคำนวณบางอย่างที่ทำกับสถานะและอินพุต args มีอินเทอร์เฟซสำหรับการตอบสนองผ่านกำบังโอกาสที่จะนวดผลลัพธ์เป็นสิ่งที่มีความหมายมากกว่าสถานะภายในหรือการคำนวณ นั่นคือข้อความผ่าน ดูตัวอย่างนี้ ย้อนกลับไปในวันที่เมื่อดิสก์ไดรฟ์มีดิสก์อยู่ในนั้นและไดรฟ์หัวแม่มือคือสิ่งที่คุณทำในรถเมื่อล้อเย็นเกินไปที่จะสัมผัสด้วยนิ้วมือของคุณฉันได้รับการสอนว่าคนที่น่ารำคาญพิจารณาฟังก์ชั่น void swap(int *first, int *second)ดูเหมือนมีประโยชน์มาก แต่เราได้รับการสนับสนุนให้เขียนฟังก์ชันที่ส่งคืนผลลัพธ์ ดังนั้นฉันจึงใส่ใจเรื่องความเชื่อและเริ่มติดตามมัน แต่ตอนนี้ฉันเห็นผู้คนกำลังสร้างสถาปัตยกรรมที่วัตถุให้วิธีที่พวกเขาสร้างการควบคุมที่พวกเขาส่งผลลัพธ์ของพวกเขา …

45 object-oriented  architecture  functional-programming  side-effect 

สมมติว่าเรามีฟังก์ชั่นบริสุทธิ์ปกติเช่น function add(a, b) { return a + b } จากนั้นเราก็ดัดแปลงมันโดยที่มันมีผลข้างเคียง function add(a, b) { writeToDatabase(Math.random()) return a + b; } มันไม่ถือว่าเป็นฟังก์ชั่นที่บริสุทธิ์เท่าที่ฉันรู้เพราะฉันมักจะได้ยินคนเรียกฟังก์ชั่นที่บริสุทธิ์ว่า "ฟังก์ชั่นที่ไม่มีผลข้างเคียง" อย่างไรก็ตามมันจะทำตัวเหมือนฟังก์ชั่นแท้ๆเท่าที่ความจริงที่ว่ามันจะคืนค่าเอาต์พุตเดียวกันสำหรับอินพุตเดียวกัน มีชื่อที่แตกต่างกันสำหรับฟังก์ชั่นประเภทนี้มันไม่มีชื่อหรือมันยังบริสุทธิ์อยู่และฉันเข้าใจผิดเกี่ยวกับคำนิยามของความบริสุทธิ์หรือไม่?

43 functional-programming  side-effect  pure-function 

ฉันส่วนใหญ่เป็นโปรแกรมเมอร์ C / C ++ ซึ่งหมายความว่าประสบการณ์ส่วนใหญ่ของฉันอยู่กับกระบวนทัศน์เชิงกระบวนทัศน์และเชิงวัตถุ อย่างไรก็ตามในขณะที่โปรแกรมเมอร์ C ++ หลายคนตระหนักดี C ++ ได้เปลี่ยนการเน้นในช่วงหลายปีที่ผ่านมาเป็นรูปแบบการใช้งานแบบเอสคิว ไม่ว่าในขณะที่ฉันมีประสบการณ์การเขียนโค้ดในรูปแบบการทำงานโดยใช้ C ++ ฉันมีประสบการณ์น้อยมากกับภาษาที่ใช้งานได้จริงเช่น Lisp, Haskell เป็นต้น ฉันเพิ่งเริ่มศึกษาภาษาเหล่านี้เนื่องจากความคิดที่ว่า "ไม่มีผลข้างเคียง" ในภาษาที่ใช้งานได้ล้วนทำให้ฉันทึ่งเสมอโดยเฉพาะอย่างยิ่งเกี่ยวกับแอพพลิเคชั่นของมันในการทำงานพร้อมกันและการคำนวณแบบกระจาย อย่างไรก็ตามมาจากพื้นหลัง C ++ ฉันสับสนว่า philsophy "ไม่มีผลข้างเคียง" นี้ทำงานร่วมกับการเขียนโปรแกรมแบบอะซิงโครนัสได้อย่างไร โดยการเขียนโปรแกรมแบบอะซิงโครนัสฉันหมายถึงเฟรมเวิร์ก / API / รูปแบบการเข้ารหัสที่ให้ผู้ใช้จัดการเหตุการณ์เพื่อจัดการเหตุการณ์ที่เกิดขึ้นแบบอะซิงโครนัส (นอกกระแสของโปรแกรม) ซึ่งรวมถึงไลบรารีแบบอะซิงโคร ตัวจัดการสัญญาณหรือตัวจัดการเหตุการณ์ Java GUI สิ่งหนึ่งที่สิ่งเหล่านี้มีเหมือนกันคือธรรมชาติของการเขียนโปรแกรมแบบอะซิงโครนัสดูเหมือนจะต้องการการสร้างผลข้างเคียง (สถานะ) เพื่อให้กระแสหลักของโปรแกรมตระหนักว่ามีการเรียกใช้ตัวจัดการเหตุการณ์แบบอะซิงโครนัส โดยทั่วไปในเฟรมเวิร์กเช่น Boost.ASIO ตัวจัดการเหตุการณ์จะเปลี่ยนสถานะของวัตถุเพื่อให้เอฟเฟกต์ของเหตุการณ์นั้นแพร่กระจายเกินเวลาชีวิตของฟังก์ชันตัวจัดการเหตุการณ์ จริงๆแล้วตัวจัดการเหตุการณ์สามารถทำอะไรได้อีก? ไม่สามารถ "ส่งคืน" ค่าไปยังจุดโทรได้เนื่องจากไม่มีจุดโทร …

31 async  functional-programming  side-effect 

ในขณะที่เรียนรู้ Haskell ฉันได้พบกับบทเรียนมากมายที่พยายามอธิบายสิ่งที่ monads และทำไม monads มีความสำคัญใน Haskell แต่ละคนใช้การเปรียบเทียบดังนั้นการจับความหมายได้ง่ายขึ้น ในตอนท้ายของวันฉันได้จบลงด้วยมุมมองที่แตกต่างกัน 3 แบบว่า monad คืออะไร: ดู 1: Monad เป็นป้ายกำกับ บางครั้งฉันคิดว่า monad เป็นป้ายชื่อประเภทเฉพาะ ตัวอย่างเช่นฟังก์ชั่นของประเภท: myfunction :: IO Int myfunction เป็นฟังก์ชันที่เมื่อใดก็ตามที่มีการดำเนินการมันจะให้ค่า Int ชนิดของผลลัพธ์ไม่ใช่ Int แต่เป็น IO Int ดังนั้น IO จึงเป็นเลเบลของค่า Int เตือนผู้ใช้ให้รู้ว่าค่า Int เป็นผลลัพธ์ของกระบวนการที่ได้ทำการกระทำของ IO ดังนั้นค่า Int นี้จึงถูกทำเครื่องหมายเป็นค่าที่มาจากกระบวนการที่มี IO ดังนั้นค่านี้จึงเป็น "สกปรก" กระบวนการของคุณไม่บริสุทธิ์อีกต่อไป ดู …

29 functional-programming  haskell  monad  side-effect 

ขออภัยสำหรับคำถามข้างเคียงอีกคำถามของ FP + แต่ฉันไม่พบคำถามที่มีอยู่ซึ่งตอบคำถามนี้ให้ฉันได้ ความเข้าใจของฉัน (จำกัด ) ของการเขียนโปรแกรมเชิงฟังก์ชันคือผลกระทบของรัฐ / ผลข้างเคียงควรถูกย่อให้เล็กสุดและแยกจากตรรกะไร้สัญชาติ ฉันยังรวบรวมวิธีการของ Haskell เพื่อทำสิ่งนี้ IO monad ประสบความสำเร็จในการทำสิ่งนี้ด้วยการห่อตัวการกระทำแบบ stateful ไว้ในคอนเทนเนอร์เพื่อการดำเนินการในภายหลังโดยพิจารณานอกขอบเขตของโปรแกรม ฉันพยายามที่จะเข้าใจรูปแบบนี้ แต่จริงๆแล้วเพื่อตรวจสอบว่าจะใช้ในโครงการ Python หรือไม่ดังนั้นต้องการหลีกเลี่ยง Haskell ถ้ามี ตัวอย่างที่เข้ามาหยาบ หากโปรแกรมของฉันแปลงไฟล์ XML เป็นไฟล์ JSON: def main(): xml_data = read_file('input.xml') # impure json_data = convert(xml_data) # pure write_file('output.json', json_data) # impure ไม่ใช่วิธีการของ IO monad ในการทำสิ่งนี้อย่างมีประสิทธิภาพ: steps …

17 python  functional-programming  state  side-effect  monad 

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

16 functional-programming  side-effect 

ในการให้สัมภาษณ์กับ John Hughesที่ซึ่งเขาพูดเกี่ยวกับ Erlang และ Haskell เขามีดังต่อไปนี้ที่จะพูดเกี่ยวกับการใช้ห้องสมุด stateful ใน Erlang: ถ้าฉันต้องการใช้ไลบรารี stateful ฉันมักจะสร้างอินเทอร์เฟซที่ไม่มีผลข้างเคียงเพื่อให้ฉันสามารถใช้อย่างปลอดภัยในส่วนที่เหลือของรหัสของฉัน สิ่งนี้หมายความว่าอย่างไร ฉันพยายามคิดถึงตัวอย่างว่าสิ่งนี้จะมีลักษณะอย่างไร แต่จินตนาการและ / หรือความรู้ของฉันทำให้ฉันล้มเหลว

16 haskell  erlang  state  side-effect 

ในโครงการปัจจุบันของฉันฉันมีเวลาที่ยากลำบากในการหาวิธีแก้ปัญหาที่ดีในการสร้างการทดสอบการรวมที่ปรับขนาดได้ซึ่งไม่มีผลข้างเคียง การชี้แจงเล็ก ๆ น้อย ๆ เกี่ยวกับคุณสมบัติฟรีผลข้างเคียง: ส่วนใหญ่เกี่ยวกับฐานข้อมูล; ไม่ควรมีการเปลี่ยนแปลงใด ๆ ในฐานข้อมูลหลังจากการทดสอบเสร็จสมบูรณ์ (ควรมีการเก็บรักษาสถานะ) บางทีความสามารถในการปรับขยายและการสงวนรักษาของรัฐไม่ได้มาด้วยกัน แต่ฉันต้องการผลักดันให้เกิดทางออกที่ดีกว่า นี่คือการทดสอบการรวมทั่วไป (การทดสอบเหล่านี้แตะเลเยอร์ฐานข้อมูล): public class OrderTests { List<Order> ordersToDelete = new ArrayList<Order>(); public testOrderCreation() { Order order = new Order(); assertTrue(order.save()); orderToDelete.add(order); } public testOrderComparison() { Order order = new Order(); Order order2 = new Order(); assertFalse(order.isEqual(order2); orderToDelete.add(order); …

14 integration-tests  side-effect 

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

12 language-agnostic  history  side-effect  pure-function 

ฟังก์ชั่นการเขียนโปรแกรมใน Scalaอธิบายผลกระทบของผลกระทบต่อการทำลายความโปร่งใสในการอ้างอิง: ผลข้างเคียงซึ่งแสดงถึงการละเมิดความโปร่งใสในการอ้างอิงบางส่วน ฉันอ่านส่วนหนึ่งของSICPซึ่งกล่าวถึงการใช้ "รูปแบบการแทนที่" เพื่อประเมินโปรแกรม เมื่อฉันเข้าใจแบบจำลองการแทนที่ด้วย referential transparent (RT) คร่าวๆคุณสามารถยกเลิกการเขียนฟังก์ชันลงในส่วนที่ง่ายที่สุดได้ หากการแสดงออกเป็น RT แล้วคุณสามารถยกเลิกการเขียนการแสดงออกและมักจะได้รับผลเดียวกัน อย่างไรก็ตามตามที่ระบุไว้ข้างต้นการใช้ผลข้างเคียงสามารถ / จะทำลายรูปแบบการทดแทน ตัวอย่าง: val x = foo(50) + bar(10) ถ้าfooและbar ไม่ได้มีผลข้างเคียงแล้วดำเนินการอย่างใดอย่างหนึ่งฟังก์ชั่นจะเสมอxกลับผลเดียวกัน แต่หากพวกเขามีผลข้างเคียงพวกเขาจะเปลี่ยนตัวแปรที่ขัดขวาง / โยนประแจเข้ากับโมเดลการแทนที่ ฉันรู้สึกสบายใจกับคำอธิบายนี้ แต่ฉันก็ไม่รู้สึกแย่ โปรดแก้ไขฉันและกรอกข้อมูลในหลุมใด ๆ ที่เกี่ยวกับผลข้างเคียงที่ทำให้ RT แตกหักพูดคุยถึงผลกระทบต่อรูปแบบการทดแทนเช่นกัน

11 functional-programming  side-effect 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันกำลังเรียนหลักสูตรโครงสร้างข้อมูลระดับกลางเป็นสิ่งที่จำเป็นสำหรับการเข้าสู่โปรแกรม CS MS ที่มหาวิทยาลัยทุกคนในอเมริกาเคยได้ยิน โค้ดหนึ่งบรรทัดที่เขียนในชั้นเรียนจับตาฉัน: if (a > 33 | b++ < 54) {...} สิ่งนี้จะไม่ผ่านการตรวจสอบรหัสที่ทำงานของฉัน หากคุณเขียนโค้ดเช่นนี้ในการสัมภาษณ์นี่จะเป็นการประท้วงครั้งสำคัญกับคุณ (นอกเหนือจากการเป็นเงื่อนไขกับผลข้างเคียงมันก็ฉลาดที่ค่าใช้จ่ายของความชัดเจน) ในความเป็นจริงฉันไม่เคยเห็นเงื่อนไขที่มีผลข้างเคียงและ Googling ก็ไม่ได้ผลมากนักเช่นกัน นักเรียนอีกคนอยู่ข้างหลังเลิกเรียนเพื่อถามเกี่ยวกับเรื่องนี้ด้วยดังนั้นฉันไม่ใช่คนเดียวที่คิดว่านี่แปลก แต่อาจารย์ค่อนข้างแน่วแน่ว่านี่เป็นรหัสที่ยอมรับได้และเขาจะเขียนอะไรทำนองนั้นในที่ทำงาน (งาน FT ของเขาคือ SWE หลักที่ บริษัท คุณเคยได้ยินมา) ฉันไม่สามารถจินตนาการถึงโลกที่บรรทัดของรหัสนี้จะเป็นที่ยอมรับได้ ฉันผิดหรือเปล่า? ตกลงไหม กรณีทั่วไปมากขึ้น: เงื่อนไขกับผลข้างเคียง? เหล่านั้นเคยตกลง?

10 language-agnostic  side-effect 

ฉันเริ่มเขียนรหัส C ++ เพื่อเรียกใช้หุ่นยนต์และฉันไม่ทราบวิธีรวมการทดสอบหน่วยหากฉันสามารถทำได้ ฉันได้รับห้องสมุดที่อนุญาตให้สร้าง "คำสั่ง" สำหรับหุ่นยนต์ซึ่งมีกำหนดและดำเนินการโดยอัตโนมัติ กลไกในการสร้างคำสั่งเหล่านี้เป็นประเภทรองชั้นฐานคำสั่งพวกเขาให้และดำเนินการเสมือนvoid Initialize(), void Execute()และvoid End()วิธีการ ฟังก์ชั่นเหล่านี้ทำงานอย่างหมดจดสำหรับผลข้างเคียงซึ่งทำสิ่งต่าง ๆ กับหุ่นยนต์ (วิ่งมอเตอร์ยืดลูกสูบ ฯลฯ ) ด้วยเหตุนี้ฉันไม่เห็นที่ใดก็ได้ในการแนบการทดสอบหน่วยกับโค้ดขาดการเยาะเย้ยห้องสมุดทั้งหมดเพื่อให้ฉันสามารถตรวจสอบเสมือนก่อนและหลังสถานะของหุ่นยนต์ มีวิธีทดสอบหน่วยที่ไม่เป็นภาระมากเกินไปหรือไม่ แก้ไข ฉันคิดว่าฉันเข้าใจผิดเกี่ยวกับการทำงานของห้องสมุด ห้องสมุดมีส่วนต่อประสานกับหุ่นยนต์เป็นส่วนใหญ่รวมถึงระบบคำสั่ง / การตั้งเวลาดังนั้นมันจึงไม่ง่ายเท่ากับการเยาะเย้ยคลาสฐานคำสั่ง ฉันโชคไม่ดีที่ไม่มีเวลาทำเช่นนั้น

10 c++  unit-testing  side-effect 

ตามหลักการแบ่งแยกคำสั่งรวมถึงการคิดในข้อมูลและDDD ด้วยการนำเสนอClojureหนึ่งควรแยกผลข้างเคียง (แก้ไขโลก) จากการคำนวณและการตัดสินใจเพื่อให้ง่ายต่อการเข้าใจและทดสอบทั้งสองส่วน นี่เป็นคำถามที่ยังไม่ได้ตอบ: เราควรใส่ "ถามโลก" ที่ไหน ในอีกด้านหนึ่งการร้องขอข้อมูลจากระบบภายนอก (เช่นฐานข้อมูล, บริการนอกระบบ 'APIs และอื่น ๆ ) นั้นไม่ได้อ้างอิงอย่างโปร่งใสดังนั้นจึงไม่ควรใช้ร่วมกับการคำนวณและการตัดสินใจที่บริสุทธิ์ ในทางกลับกันมันเป็นปัญหาหรืออาจเป็นไปไม่ได้ที่จะหยอกล้อพวกเขานอกเหนือจากส่วนการคำนวณและส่งผ่านเป็นอาร์กิวเมนต์เนื่องจากเราอาจไม่ทราบล่วงหน้าว่าต้องการข้อมูลใด

10 functional-programming  domain-driven-design  clojure  design  side-effect 

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

10 functional-programming  paradigms  side-effect  imperative-programming  declarative-programming