ชื่อที่ดีที่สุดสำหรับวิธี“ เพิ่ม” ที่ไม่กลายพันธุ์ในคอลเลกชันที่ไม่เปลี่ยนรูปแบบคืออะไร

ขออภัยสำหรับชื่อวาฟเฟิล - ถ้าฉันสามารถสร้างชื่อที่กระชับได้ฉันไม่ต้องถามคำถาม

สมมติว่าฉันมีประเภทรายการที่ไม่เปลี่ยนรูป มันมีการดำเนินงานFoo(x)ที่ส่งกลับรายการที่ไม่เปลี่ยนรูปใหม่ที่มีข้อโต้แย้งที่ระบุว่าเป็นองค์ประกอบพิเศษในตอนท้าย ดังนั้นเพื่อสร้างรายการของสตริงที่มีค่า "Hello", "immutable", "world" คุณสามารถเขียน:

var empty = new ImmutableList<string>();
var list1 = empty.Foo("Hello");
var list2 = list1.Foo("immutable");
var list3 = list2.Foo("word");

(นี่คือรหัส C # และฉันสนใจคำแนะนำ C # มากที่สุดหากคุณรู้สึกว่าภาษามีความสำคัญไม่ใช่คำถามทางภาษา แต่พื้นฐานของภาษาอาจมีความสำคัญ)

สิ่งสำคัญคือรายการที่มีอยู่จะไม่เปลี่ยนแปลงโดยFooดังนั้นempty.Countจะยังคงกลับ 0

อีกวิธีหนึ่ง (สำนวนมากขึ้น) ของการบรรลุผลจะเป็น:

var list = new ImmutableList<string>().Foo("Hello")
                                      .Foo("immutable")
                                      .Foo("word");

คำถามของฉันคืออะไรชื่อที่ดีที่สุดสำหรับ Foo คืออะไร?

แก้ไข 3 : เมื่อฉันเปิดเผยในภายหลังชื่อของประเภทอาจไม่เป็นจริงImmutableList<T>ซึ่งทำให้ตำแหน่งชัดเจน ลองนึกภาพว่ามันเป็นแบบนั้นTestSuiteและมันไม่เปลี่ยนรูปเพราะทั้งเฟรมมันเป็นส่วนหนึ่งของมันไม่เปลี่ยนรูป ...

(สิ้นสุดการแก้ไข 3)

ตัวเลือกฉันมาด้วยจนถึงตอนนี้:

• Add: ทั่วไปใน. NET แต่หมายถึงการกลายพันธุ์ของรายการเดิม
• Cons: ฉันเชื่อว่านี่เป็นชื่อปกติในภาษาที่ใช้งานได้ แต่ไม่มีความหมายสำหรับผู้ที่ไม่มีประสบการณ์ในภาษาดังกล่าว
• Plus: ที่ชื่นชอบเพื่อให้ห่างไกลก็ไม่ได้หมายความถึงการกลายพันธุ์ให้ฉัน เห็นได้ชัดว่าสิ่งนี้ยังใช้ใน Haskellแต่ด้วยความคาดหวังที่แตกต่างกันเล็กน้อย (โปรแกรมเมอร์ Haskell อาจคาดหวังว่าจะเพิ่มสองรายการด้วยกันแทนที่จะเพิ่มค่าเดียวในรายการอื่น)
• With: สอดคล้องกับอนุสัญญาที่ไม่เปลี่ยนรูปแบบอื่น ๆ แต่ไม่มี "การเพิ่ม" ที่เหมือนกันกับ IMO
• And: ไม่สื่อความหมายมาก
• ตัวดำเนินการโอเวอร์โหลดสำหรับ +: ฉันไม่ชอบสิ่งนี้มากนัก ฉันคิดว่าผู้ประกอบการควรใช้กับประเภทระดับล่างเท่านั้น ฉันยินดีที่จะโน้มน้าวใจ!

เกณฑ์ที่ฉันใช้ในการเลือกคือ:

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

โปรดสอบถามรายละเอียดเพิ่มเติมหากฉันไม่ทำให้ตัวเองชัดเจน ...

แก้ไข 1:นี่คือเหตุผลของฉันสำหรับการเลือกที่จะPlus Addพิจารณาโค้ดสองบรรทัดนี้:

list.Add(foo);
list.Plus(foo);

ในมุมมองของฉัน (และนี่เป็นเรื่องส่วนตัว) สิ่งหลังนี้มีความชัดเจนมาก - มันเหมือนกับการเขียน "x + 5;" เป็นคำสั่งในตัวของมันเอง บรรทัดแรกดูเหมือนจะไม่เป็นไรจนกว่าคุณจะจำได้ว่ามันไม่เปลี่ยนรูป ในความเป็นจริงวิธีการที่ตัวดำเนินการบวกด้วยตัวของมันเองไม่ได้กลายเป็นตัวถูกดำเนินการของมันก็เป็นอีกสาเหตุหนึ่งที่Plusฉันชอบ หากไม่มีความยุ่งเหยิงเล็กน้อยของโอเปอเรเตอร์การบรรทุกเกินพิกัดก็ยังคงให้ความหมายที่เหมือนกันซึ่งรวมถึง (สำหรับฉัน) ที่ไม่กลายพันธุ์ตัวถูกดำเนินการ (หรือเป้าหมายของวิธีการในกรณีนี้)

แก้ไข 2:เหตุผลที่ไม่ชอบเพิ่ม

คำตอบที่หลากหลายนั้นมีประสิทธิภาพ: "ไปกับเพิ่มนั่นคือสิ่งที่DateTimeทำและStringมีReplaceวิธีการอื่น ๆ ที่ไม่ทำให้การเปลี่ยนแปลงไม่ได้ชัดเจน" ฉันเห็นด้วย - มีความสำคัญที่นี่ แต่ผมเคยเห็นคนจำนวนมากโทรDateTime.AddหรือString.Replaceและคาดหวังว่าการกลายพันธุ์ มีคำถามกลุ่มข่าวสารมากมาย (และอาจเป็นคำถามที่ถ้าฉันขุด) ซึ่งตอบโดย "คุณไม่สนใจค่าส่งคืนของString.Replace; สตริงไม่เปลี่ยนรูป, สตริงใหม่จะได้รับคืน"

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

var list = new ImmutableList<string>();
list.Add("foo");

จะไม่ประสบความสำเร็จอะไรเลย แต่มันจะกลายเป็นเรื่องไม่ดีมากเมื่อคุณเปลี่ยนเป็น:

var suite = new TestSuite<string, int>();
suite.Add(x => x.Length);

ดูเหมือนว่าควรจะไม่เป็นไร สำหรับฉันแล้วสิ่งนี้ทำให้ความผิดพลาดชัดเจนขึ้น:

var suite = new TestSuite<string, int>();
suite.Plus(x => x.Length);

นั่นเป็นเพียงการขอร้องให้เป็น:

var suite = new TestSuite<string, int>().Plus(x => x.Length);

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

ฉันขอโทษที่ทำให้คำถามดั้งเดิมง่ายเกินไปโดยพูดถึงประเภทลิสต์ที่ไม่เปลี่ยนรูปเท่านั้น คอลเล็คชั่นบางตัวนั้นไม่ได้อธิบายตัวเองได้ดีเท่าImmutableList<T>:)

Concatในสถานการณ์เช่นนั้นผมมักจะไปด้วย ซึ่งมักจะบอกเป็นนัยว่าฉันมีการสร้างวัตถุใหม่

var p = listA.Concat(listB);
var k = listA.Concat(item);

ฉันจะไปกับ Cons ด้วยเหตุผลง่ายๆข้อเดียวนั่นคือสิ่งที่คุณต้องการ

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

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

3. การดำเนินการอื่น ๆ ที่ยืมมาจากภาษาที่ใช้งานได้มักจะเก็บชื่อดั้งเดิมไว้โดยไม่มีหายนะที่ชัดเจน ฉันไม่เห็นคำพ้องความหมายสำหรับคำว่า "แผนที่" และ "ลด" ซึ่งฟังดูคุ้นเคยกับผู้ที่ไม่ใช่ FPers และฉันไม่เห็นประโยชน์ใด ๆ จากการทำเช่นนั้น

(การเปิดเผยอย่างเต็มรูปแบบ: ฉันเป็นโปรแกรมเมอร์ Lisp ดังนั้นฉันจึงรู้อยู่แล้วว่าจุดด้อยหมายถึงอะไร)

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

var list = ImmutableList<string>.Empty.And("Hello")
                                      .And("Immutable")
                                      .And("Word");

เมื่อใดก็ตามที่ฉันติดขัดกับศัพท์บัญญัติฉันตี interwebs

thesaurus.comส่งคืนสิ่งนี้สำหรับ "เพิ่ม":

คำจำกัดความ: adjoin, เพิ่ม; แสดงความคิดเห็นเพิ่มเติม

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

ผมชอบเสียงAdjoinหรืออื่น ๆ Joinอีกมากมายเพียงแค่ นั่นคือสิ่งที่คุณทำใช่ไหม? วิธีนี้ยังสามารถนำไปใช้กับการเข้าร่วมอื่น ๆImmutableList<>'s

โดยส่วนตัวแล้วฉันชอบด้วย () ถ้าฉันใช้วัตถุหลังจากอ่านเอกสารหรือข้อคิดเห็นรหัสแล้วมันจะชัดเจนว่ามันทำอะไรและมันก็อ่านได้ในซอร์สโค้ด

object.With("My new item as well");

หรือคุณเพิ่ม "พร้อม" กับมัน .. :)

object.AlongWith("this new item");

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

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

ชื่ออื่น ๆ : คุณพูดถึง:

• บวก: ฉันปรารถนา / กำลังซักผ้าอยู่ สำหรับฉันนี่ไม่ได้แยกความแตกต่างว่าเป็นการดำเนินการที่ไม่กลายพันธุ์อีกต่อไปกว่าเพิ่ม
• ด้วย: จะทำให้เกิดปัญหากับ VB (ปุนตั้งใจ)
• ผู้ประกอบการมากไป: การค้นพบจะเป็นปัญหา

ตัวเลือกที่ฉันพิจารณา:

• Concat: String ของนั้นไม่เปลี่ยนรูปและใช้สิ่งนี้ น่าเสียดายที่มันเพิ่มได้ดีจริงๆเท่านั้น
• CopyAdd: คัดลอกอะไร แหล่งที่มารายการ?
• AddToNewList: อาจดีสำหรับ List แต่สิ่งที่เกี่ยวกับ Collection, Stack, Queue, ฯลฯ ...

น่าเสียดายที่ดูเหมือนจะไม่มีคำที่เป็นจริง

1. เป็นการดำเนินการที่ไม่แน่นอนอย่างแน่นอน
2. ผู้ใช้ส่วนใหญ่เข้าใจได้ง่าย
3. สามารถแทนได้ด้วยคำน้อยกว่า 4 คำ

มันจะยิ่งแปลกเมื่อคุณพิจารณาคอลเล็กชันนอกเหนือจาก List รับอินสแตนซ์ของ Stack แม้แต่โปรแกรมเมอร์ในปีแรกก็สามารถบอกคุณได้ว่า Stacks มีวิธีการคู่แบบ Push / Pop หากคุณสร้าง ImmutableStack และตั้งชื่อให้แตกต่างกันโดยสิ้นเชิงให้เรียกว่า Foo / Fop คุณเพิ่งเพิ่มงานเพื่อให้พวกเขาใช้คอลเลกชันของคุณ

แก้ไข: การตอบสนองต่อการแก้ไขเพิ่มเติม

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

list.Minus(obj);

ปัญหาที่ใหญ่ที่สุดที่ฉันมีกับ Plus / Minus หรือการจับคู่ใหม่คือมันรู้สึกเหมือน overkill คอลเลกชันเองมีชื่อที่แตกต่างอยู่แล้วคำนำหน้าไม่เปลี่ยนรูป ทำไมต้องไปต่อด้วยการเพิ่มคำศัพท์ที่มีเจตนาที่จะเพิ่มความแตกต่างเช่นเดียวกับคำนำหน้าไม่เปลี่ยนรูปได้ทำไปแล้ว

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

แก้ไข 2

ยอมรับว่าผู้คนสับสนโดย String.Concat และ DateTime.Add ฉันเคยเห็นโปรแกรมเมอร์ที่สว่างมากหลายคนประสบปัญหานี้

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

ImmutableList ไม่มีปัญหานั้นเนื่องจากชื่อกำหนดลักษณะการทำงาน คุณอาจโต้แย้งว่าผู้คนไม่รู้ว่า Immutable คืออะไรและฉันคิดว่ามันก็ใช้ได้เช่นกัน แน่นอนฉันไม่รู้จนกระทั่งประมาณ 2 ปีในวิทยาลัย แต่คุณมีปัญหาเดียวกันกับชื่ออะไรก็ตามที่คุณเลือกแทนที่จะเพิ่ม

แก้ไข 3:สิ่งที่เกี่ยวกับประเภทเช่น TestSuite ซึ่งไม่เปลี่ยนรูป แต่ไม่ประกอบด้วยคำว่า?

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

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

ตอนนี้คุณจะระบุ TestSuite ว่าไม่เปลี่ยนรูปได้อย่างไร ในสภาพแวดล้อมปัจจุบันฉันคิดว่ามีไม่กี่วิธี

1. คำนำหน้าด้วย Immutable: ImmutableTestSuite
2. เพิ่มคุณสมบัติซึ่งอธิบายระดับของ Immutablitiy นี่เป็นสิ่งที่ค้นพบได้น้อยกว่าอย่างแน่นอน
3. ไม่มาก

เดา / ความหวังของฉันคือเครื่องมือในการพัฒนาจะเริ่มช่วยเหลือปัญหานี้โดยทำให้ง่ายต่อการระบุประเภทที่ไม่เปลี่ยนรูปแบบได้ง่ายๆโดยการเห็น (สีที่แตกต่างแบบอักษรที่แข็งแกร่งกว่า ฯลฯ ) แต่ฉันคิดว่านั่นเป็นคำตอบแม้ว่าจะเปลี่ยนชื่อวิธีทั้งหมด

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

ตัวอย่างเช่นมันชัดเจนโดยสังหรณ์ใจเมื่อคุณพูด

x = 2 + 2;

ค่าผลลัพธ์ของ x คือ 4 ไม่ใช่ 22

ในทำนองเดียวกัน

var empty = new ImmutableList<string>();
var list1 = empty + "Hello";
var list2 = list1 + "immutable";
var list3 = list2 + "word";

ควรทำให้ชัดเจนว่าแต่ละตัวแปรกำลังจะถืออะไร ควรชัดเจนว่าlist2จะไม่เปลี่ยนแปลงในบรรทัดสุดท้าย แต่list3จะกำหนดผลลัพธ์ของการต่อท้าย "word" list2แทน

มิฉะนั้นฉันจะตั้งชื่อฟังก์ชั่น Plus ()

เพื่อให้ชัดเจนที่สุดคุณอาจต้องการไปกับ wordier CopyAndAddหรือสิ่งที่คล้ายกัน

ฉันจะเรียกมันว่าExtend ()หรืออาจจะExtendWith ()ถ้าคุณรู้สึกว่า verbose จริงๆ

การขยายหมายถึงการเพิ่มบางสิ่งลงในอย่างอื่นโดยไม่ต้องเปลี่ยน ฉันคิดว่านี่เป็นคำศัพท์ที่เกี่ยวข้องมากใน C # เนื่องจากคล้ายกับแนวคิดของวิธีการขยาย - พวกเขา "เพิ่ม" วิธีการใหม่ในชั้นเรียนโดยไม่ต้อง "สัมผัส" ในชั้นเรียนของตัวเอง

มิฉะนั้นถ้าคุณต้องการเน้นว่าคุณไม่ได้ปรับเปลี่ยนวัตถุต้นฉบับเลยใช้คำนำหน้าบางอย่างเช่น Get- ดูเหมือนจะหลีกเลี่ยงไม่ได้สำหรับฉัน

เพิ่ม () ต่อท้าย ()

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

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

ฉันชอบคำแนะนำmmyersของCopyAndเพิ่ม ในการรักษาด้วยชุดรูปแบบ "การกลายพันธุ์" บางทีคุณสามารถไปกับBud (การสืบพันธุ์แบบไม่อาศัยเพศ), เติบโต , จำลอง , หรือวิวัฒนาการ ? =)

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

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

Join ดูเหมือนว่าเหมาะสม

บางทีความสับสนอาจเกิดจากความจริงที่ว่าคุณต้องการสองการดำเนินงานในที่เดียว ทำไมไม่แยกพวกเขา สไตล์ DSL:

var list = new ImmutableList<string>("Hello");
var list2 = list.Copy().With("World!");

Copyจะส่งคืนวัตถุกลางนั่นคือสำเนาที่ไม่แน่นอนของรายการเดิม Withจะส่งคืนรายการที่ไม่เปลี่ยนรูปแบบใหม่

ปรับปรุง:

แต่การมีคอลเล็กชั่นสื่อกลางที่เปลี่ยนแปลงไม่ได้อยู่รอบ ๆ นั้นไม่ใช่วิธีที่ดี วัตถุกลางควรมีอยู่ในการCopyดำเนินการ:

var list1 = new ImmutableList<string>("Hello");
var list2 = list1.Copy(list => list.Add("World!"));

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

public ImmutableList<T> Copy(Action<IList<T>> mutate) {
  if (mutate == null) return this;
  var list = new List<T>(this);
  mutate(list);
  return new ImmutableList<T>(list);
}

ตอนนี้มีความเป็นไปได้ของการเข้าใจผิดโดยผู้ใช้ไม่ว่าพวกเขาจะเป็นธรรมชาติตกอยู่ในหลุมของความสำเร็จ

ยังมีการอัพเดทอื่น:

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

var list1 = new ImmutableList<string>("Hello");
// rules is a specification object, that takes commands to run in the copied collection
var list2 = list1.Copy(rules => rules.Append("World!"));

ตอนนี้คุณสามารถมีความคิดสร้างสรรค์ที่มีชื่อกฎและคุณจะสามารถสัมผัสฟังก์ชั่นที่คุณต้องการที่จะสนับสนุนไม่ได้เป็นความสามารถทั้งหมดของCopyIList

สำหรับการใช้งานเชนคุณสามารถสร้างนวกรรมิกที่สมเหตุสมผล (ซึ่งจะไม่ใช้การโยงเชน):

public ImmutableList(params T[] elements) ...

...

var list = new ImmutableList<string>("Hello", "immutable", "World");

หรือใช้ผู้รับมอบสิทธิ์เดิมในตัวสร้างอื่น:

var list = new ImmutableList<string>(rules => 
  rules
    .Append("Hello")
    .Append("immutable")
    .Append("World")
);

นี้อนุมานว่าวิธีการส่งกลับrules.Appendthis

นี่คือสิ่งที่ดูเหมือนกับตัวอย่างล่าสุดของคุณ:

var suite = new TestSuite<string, int>(x => x.Length);
var otherSuite = suite.Copy(rules => 
  rules
    .Append(x => Int32.Parse(x))
    .Append(x => x.GetHashCode())
);

ความคิดสุ่มเล็กน้อย:

• ImmutableAdd ()
• ผนวก()
• ImmutableList <T> (ImmutableList <T> originalList, T newItem) Constructor

DateTime ใน C # ใช้ Add เหตุใดจึงไม่ใช้ชื่อเดียวกัน ตราบใดที่ผู้ใช้ในชั้นเรียนของคุณเข้าใจว่าคลาสนั้นไม่เปลี่ยนรูป

ฉันคิดว่าสิ่งสำคัญที่คุณพยายามที่จะแสดงให้เห็นก็คือการแสดงที่ไม่ใช่การแสดงออกดังนั้นอาจมีบางคำที่มีคำทั่วไปอยู่ในนั้นเช่น CopyWith () หรือ InstancePlus ()

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

วิธีเดียวที่คุณจะป้องกันผู้ใช้ของคุณจากการเข้าใจผิดวัตถุสำหรับบางสิ่งที่ไม่แน่นอนคือการทำให้ชัดเจนโดยผ่านชื่อของวัตถุเองหรือผ่านชื่อของวิธีการ (เช่นเดียวกับตัวเลือก verbose เช่น "GetCopyWith" หรือ "CopyAndAdd")

ดังนั้นไปกับรายการโปรดของคุณ "บวก"

ก่อนอื่นจุดเริ่มต้นที่น่าสนใจ: http://en.wikipedia.org/wiki/Naming_conventions_(programming) ... โดยเฉพาะให้ตรวจสอบลิงก์ "ดูเพิ่มเติม" ที่ด้านล่าง

ฉันชอบทั้งบวกหรืออย่างมีประสิทธิภาพเท่ากัน

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

ทั้งสองสั้นซึ่งเป็นสิ่งสำคัญโดยเฉพาะอย่างยิ่งให้ความสำคัญของการดำเนินงาน การดำเนินการที่ง่ายและดำเนินการบ่อยครั้งควรได้รับชื่อที่สั้นกว่า

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

วิธีการเกี่ยวกับ Chain () หรือ Attach ()

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

ความเป็นไปได้อื่น ๆ :

Splice ()

Graft ()

Accrete ()

วิธีการเกี่ยวกับเพื่อน , mateWithหรือมีเพศสัมพันธ์สำหรับผู้ที่ปฏิบัติ ในแง่ของการทำซ้ำสัตว์เลี้ยงลูกด้วยนมโดยทั่วไปถือว่าไม่เปลี่ยนรูป

จะโยนสหภาพออกไปที่นั่นด้วย ยืมมาจาก SQL

เห็นได้ชัดว่าฉันเป็นคนแรกที่ Obj-C / Cocoa ตอบคำถามนี้

NNString *empty = [[NSString alloc] init];
NSString *list1 = [empty stringByAppendingString:@"Hello"];
NSString *list2 = [list1 stringByAppendingString:@"immutable"];
NSString *list3 = [list2 stringByAppendingString:@"word"];

จะไม่ชนะเกมกอล์ฟรหัสใด ๆ กับสิ่งนี้

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

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

บางทีฉันอาจจะใช้รูปแบบนี้

AddToCopy
RemoveFromCopy
InsertIntoCopy

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

บางทีฉันก็แค่ใช้ "เพิ่ม" ธรรมดาและเพื่อนด้วย ฉันชอบวิธีที่ใช้ในวิชาคณิตศาสตร์

Add 1 to 2 and you get 3

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

ดูที่http://thesaurus.reference.com/browse/addและhttp://thesaurus.reference.com/browse/plusฉันพบว่าได้รับและติดแต่ฉันไม่แน่ใจว่าพวกเขาหมายถึงการกลายพันธุ์ที่ไม่ใช่

ผมคิดว่าPlus()และMinus()หรือผลัดกันIncluding(), Excluding()มีความเหมาะสมที่อ้างพฤติกรรมไม่เปลี่ยนรูป

อย่างไรก็ตามไม่มีตัวเลือกการตั้งชื่อที่จะทำให้ทุกคนชัดเจนอย่างสมบูรณ์ดังนั้นฉันเองเชื่อว่าความคิดเห็น xml doc ที่ดีจะไปไกลมากที่นี่ VS ขว้างสิ่งเหล่านี้ในหน้าของคุณเมื่อคุณเขียนโค้ดใน IDE - มันยากที่จะมองข้าม

Append- เพราะโปรดทราบว่าชื่อของSystem.Stringวิธีการแนะนำให้พวกเขากลายพันธุ์อินสแตนซ์ แต่พวกเขาไม่

หรือฉันชอบAfterAppending:

void test()
{
  Bar bar = new Bar();
  List list = bar.AfterAppending("foo");
}

list.CopyWith(element)

Smalltalk เช่นเดียวกับ :)

และยังlist.copyWithout(element)ลบองค์ประกอบทั้งหมดที่เกิดขึ้นซึ่งมีประโยชน์มากที่สุดเมื่อใช้list.copyWithout(null)เพื่อลบองค์ประกอบที่ไม่ได้ตั้งค่า

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