สิ่งใดที่คุณเรียกใช้ฟังก์ชันที่อินพุตเดียวกันจะส่งคืนเอาต์พุตเดียวกันเสมอ แต่ก็มีผลข้างเคียงเช่นกัน

สมมติว่าเรามีฟังก์ชั่นบริสุทธิ์ปกติเช่น

function add(a, b) {
  return a + b
}

จากนั้นเราก็ดัดแปลงมันโดยที่มันมีผลข้างเคียง

function add(a, b) {
  writeToDatabase(Math.random())
  return a + b;
}

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

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

ฉันไม่แน่ใจเกี่ยวกับคำจำกัดความสากลของความบริสุทธิ์ แต่จากมุมมองของ Haskell (ภาษาที่โปรแกรมเมอร์มักสนใจเกี่ยวกับสิ่งต่าง ๆ เช่นความบริสุทธิ์และความโปร่งใสในการอ้างอิง) เฉพาะหน้าที่แรกของคุณคือ "บริสุทธิ์" รุ่นที่สองของaddไม่บริสุทธิ์ ดังนั้นเพื่อตอบคำถามของคุณฉันจะเรียกมันว่า "ไม่บริสุทธิ์";)

ตามคำนิยามนี้ฟังก์ชั่นแท้เป็นฟังก์ชั่นที่:

1. ขึ้นอยู่กับอินพุตเท่านั้น นั่นคือเมื่อได้รับอินพุตเดียวกันมันจะส่งคืนเอาต์พุตเดิมเสมอ
2. มีความโปร่งใสในการอ้างอิง: ฟังก์ชันสามารถแทนที่ได้อย่างอิสระด้วยค่าของมันและ "พฤติกรรม" ของโปรแกรมจะไม่เปลี่ยนแปลง

ด้วยคำจำกัดความนี้มันชัดเจนว่าฟังก์ชั่นที่สองของคุณไม่สามารถถูกพิจารณาว่าบริสุทธิ์ได้เนื่องจากมันแบ่งกฎ 2 นั่นคือสองโปรแกรมต่อไปนี้ไม่เทียบเท่า:

function f(a, b) { 
    return add(a, b) + add(a, b);
}

และ

function g(a, b) {
    c = add(a, b);
    return c + c;
}

นี่เป็นเพราะแม้ว่าทั้งสองฟังก์ชั่นจะคืนค่าเดิม แต่ฟังก์ชั่นfจะเขียนไปยังฐานข้อมูลสองครั้ง แต่gจะเขียนครั้งเดียว มีโอกาสมากที่การเขียนลงในฐานข้อมูลเป็นส่วนหนึ่งของพฤติกรรมที่สังเกตได้ของโปรแกรมของคุณซึ่งในกรณีนี้ฉันได้แสดงเวอร์ชันที่สองของคุณaddไม่ใช่ "บริสุทธิ์"

หากการเขียนไปยังฐานข้อมูลนั้นไม่ใช่ส่วนที่สังเกตได้จากพฤติกรรมของโปรแกรมของคุณดังนั้นทั้งสองเวอร์ชันaddจะถือว่าเทียบเท่าและบริสุทธิ์ แต่ฉันไม่สามารถนึกถึงสถานการณ์ที่การเขียนไปยังฐานข้อมูลไม่สำคัญ แม้กระทั่งเรื่องการเข้าสู่ระบบ!

สิ่งใดที่คุณเรียกใช้ฟังก์ชัน [ซึ่ง] อินพุตเดียวกันจะส่งคืนเอาต์พุตเดียวกันเสมอ แต่ก็มีผลข้างเคียงเช่นกัน

ฟังก์ชั่นดังกล่าวเรียกว่า

กำหนด

อัลกอริทึมที่มีพฤติกรรมที่สามารถทำนายได้อย่างสมบูรณ์จากอินพุต

termwiki.com

เกี่ยวกับรัฐ:

ฟังก์ชั่นไม่มีสถานะขึ้นอยู่กับคำจำกัดความของฟังก์ชั่นที่คุณใช้ หากคุณมาจากโลกแห่งวัตถุที่มุ่งเน้นจำไว้ว่าx.f(y)เป็นวิธีการ f(x,y)ในฐานะที่เป็นฟังก์ชั่นมันจะมีลักษณะ และถ้าคุณเข้าสู่การปิดด้วยขอบเขตคำศัพท์ที่ล้อมรอบโปรดจำไว้ว่าสถานะที่ไม่เปลี่ยนรูปอาจจะเป็นส่วนหนึ่งของการแสดงออกของฟังก์ชั่น เป็นเพียงสถานะที่ไม่แน่นอนที่จะส่งผลกระทบต่อฟังก์ชันที่กำหนดขึ้น ดังนั้น f (x) = x + 1 เป็นตัวกำหนดตราบใดที่ 1 ไม่เปลี่ยนแปลง ไม่สำคัญว่าจะเก็บ 1 ไว้ที่ไหน

ฟังก์ชั่นของคุณมีทั้งที่กำหนดขึ้นเอง ครั้งแรกของคุณยังเป็นฟังก์ชั่นที่บริสุทธิ์ ที่สองของคุณไม่บริสุทธิ์

ฟังก์ชั่นบริสุทธิ์

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

2. การประเมินผลลัพธ์ไม่ทำให้เกิดผลข้างเคียงหรือเอาท์พุทที่สามารถสังเกตเห็นได้ทางความหมายเช่นการกลายพันธุ์ของวัตถุที่ไม่แน่นอนหรือเอาท์พุทไปยังอุปกรณ์ I / O

wikipedia.org

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

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

ผมไม่ทราบว่าของคำทั่วไปสำหรับแม่นยำคุณสมบัติที่คุณอธิบาย แต่เซตที่สำคัญคือผู้ที่มีความidempotent ในวิทยาการคอมพิวเตอร์แตกต่างกันเล็กน้อยในวิชาคณิตศาสตร์ * ฟังก์ชัน idempotentเป็นฟังก์ชันที่สามารถทำซ้ำได้ด้วยเอฟเฟกต์เดียวกัน กล่าวคือผลของผลข้างเคียงของการทำหลายครั้งเหมือนกันกับการทำครั้งเดียว

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

การรวมกันของฟังก์ชั่น idempotent อาจหรืออาจจะไม่รวม idempotent

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

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

มันขึ้นอยู่กับว่าคุณใส่ใจเรื่องความไม่บริสุทธิ์หรือไม่ หากความหมายของตารางนี้เป็นสิ่งที่คุณไม่สนใจว่ามีอยู่กี่รายการก็ถือว่าบริสุทธิ์ อื่นมันไม่บริสุทธิ์

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

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

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

• ผลข้างเคียงขึ้นอยู่กับอาร์กิวเมนต์ของฟังก์ชันหรือผลลัพธ์ที่เกิดจากผลข้างเคียงหรือไม่?
  • ไม่: "ฟังก์ชั่น effectful" สามารถ refactored เป็นฟังก์ชั่นบริสุทธิ์การกระทำที่มีประสิทธิภาพและกลไกสำหรับการรวมพวกเขา
  • ใช่: "ฟังก์ชั่น effectful" เป็นฟังก์ชั่นที่สร้างผลลัพธ์แบบ monadic

ตรงไปตรงมาเพื่อแสดงใน Haskell (และประโยคนี้เป็นเรื่องตลกเพียงครึ่งเดียว) ตัวอย่างของกรณี "ไม่" จะเป็นดังนี้:

double :: Num a => a -> IO a
double x = do
  putStrLn "I'm doubling some number"
  return (x*2)

ในตัวอย่างนี้การกระทำที่เราดำเนินการ (พิมพ์บรรทัด"I'm doubling some number") ไม่มีผลกระทบต่อความสัมพันธ์ระหว่างxและผลลัพธ์ นี่หมายความว่าเราสามารถ refactor ด้วยวิธีนี้ (โดยใช้Applicativeคลาสและ*>โอเปอเรเตอร์) ซึ่งแสดงให้เห็นว่าฟังก์ชันและเอฟเฟกต์เป็นจริง orthogonal:

double :: Num a => a -> IO a
double x = action *> pure (function x)
  where
    -- The pure function 
    function x = x*2  
    -- The side effect
    action = putStrLn "I'm doubling some number"

ดังนั้นในกรณีนี้ฉันโดยส่วนตัวจะบอกว่ามันเป็นกรณีที่คุณสามารถแยกการทำงานที่บริสุทธิ์ การเขียนโปรแกรม Haskell มากมายเกี่ยวกับสิ่งนี้ - การเรียนรู้วิธีแยกส่วนที่บริสุทธิ์ออกจากโค้ดที่มีประสิทธิภาพ

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

double :: Num a => a -> IO a
double x = do
  putStrLn ("I'm doubling the number " ++ show x)
  return (x*2)

xตอนนี้สตริงที่คุณพิมพ์ขึ้นอยู่กับมูลค่าของ อย่างไรก็ตามส่วนของฟังก์ชั่น (คูณxสอง) ไม่ได้ขึ้นอยู่กับเอฟเฟกต์ทั้งหมดดังนั้นเราจึงยังสามารถแยกมันออกมาได้:

logged :: (a -> b) -> (a -> IO x) -> IO b
logged function logger a = do
  logger a
  return (function a)

double x = logged function logger
  where function = (*2) 
        logger x putStrLn ("I'm doubling the number " ++ show x)

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

นี่คือหนึ่งในเหตุผลที่ Haskell ใช้Monadคลาสนี้อย่างกว้างขวาง Monads เป็นเครื่องมือในการวิเคราะห์และจัดโครงสร้างใหม่

ฟังก์ชั่นที่มีวัตถุประสงค์เพื่อก่อให้เกิดผลข้างเคียงที่มักจะเรียกว่าeffectful ตัวอย่างhttps://slpopejoy.github.io/posts/Effectful01.html