Değişmez bir koleksiyonda mutasyona uğramayan bir "ekleme" yöntemi için en iyi isim nedir?

Waffly unvanı için özür dilerim - kısa bir başlık bulabilirsem soruyu sormak zorunda kalmazdım.

Değişmez bir liste türüm olduğunu varsayalım. Sonunda Foo(x)belirtilen bağımsız değişken ile yeni bir değişmez liste döndüren bir işlem var. Yani "Merhaba", "değişmez", "dünya" değerlerine sahip dizelerin bir listesini oluşturmak için şunu yazabilirsiniz:

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

(Bu C # kodudur ve dilin önemli olduğunu düşünüyorsanız en çok C # önerisiyle ilgileniyorum. Temelde bir dil sorusu değil, ancak dilin deyimleri önemli olabilir.)

Önemli olan mevcut listeleri olmasıdır değil tarafından değiştirilmiş Fooöylesine - empty.Counthala 0 döndürecektir.

Son sonuca ulaşmanın bir başka (daha deyimsel) yolu:

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

Sorum şu: Foo'nun en iyi adı nedir?

DÜZENLEME 3 : Daha sonra açıkladığım gibi ImmutableList<T>, türün adı aslında olmayabilir , bu da konumu netleştirir. Bunun yerine TestSuiteve bunun değişmez olduğunu hayal edin çünkü bir parçası olduğu çerçevenin tamamı değişmez ...

(Düzenleme sonu 3)

Şimdiye kadar bulduğum seçenekler:

• Add: .NET'te yaygındır, ancak orijinal listenin mutasyonunu ima eder
• Cons: Bunun işlevsel dillerde normal ad olduğuna inanıyorum, ancak bu dillerde deneyimi olmayanlar için anlamsız
• Plus: şimdiye kadarki favorim, bana mutasyon demek değil . Görünüşe göre bu Haskell'de de kullanılıyor, ancak biraz farklı beklentilerle (bir Haskell programcısı, diğer listeye tek bir değer eklemek yerine birlikte iki liste eklemesini bekleyebilir).
• With: diğer bazı değişmez sözleşmelerle tutarlı olmakla birlikte, IMO'ya tamamen aynı "katılıma" sahip değildir.
• And: çok açıklayıcı değil.
• + İçin operatör aşırı yükü: Gerçekten bu kadar sevmiyorum; Genel olarak operatörlerin yalnızca daha düşük seviye türlerine uygulanması gerektiğini düşünüyorum. Yine de ikna olmaya hazırım!

Seçim için kullandığım kriterler:

• Yöntem çağrısının sonucuna ilişkin doğru izlenimi verir (yani, fazladan bir öğeye sahip orijinal liste olduğu anlamına gelir)
• Mevcut listeyi değiştirmediğini olabildiğince netleştirir
• Yukarıdaki ikinci örnekte olduğu gibi birlikte zincirlendiğinde makul geliyor

Kendimi yeterince açıklamıyorsam lütfen daha fazla ayrıntı isteyin ...

DÜZENLEME 1: İşte tercih Plusetme nedenim Add. Şu iki kod satırını düşünün:

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

(Ve bu benim görünümünde olan kişisel bir şey) ikincisi açıkça adamcağız - yazılı gibi "x + 5;" kendi başına bir ifade olarak. İlk satır, değişmez olduğunu hatırlayana kadar, tamam gibi görünüyor. Aslında, artı operatörün kendi başına işlenenlerini değiştirmemesi Plus, benim favorimin başka bir nedenidir . Operatörün aşırı yüklenmesi gibi hafif bir rahatsızlık olmadan, yine de (benim için) işlenenleri mutasyona uğratmamayı (veya bu durumda yöntem hedefini) içeren aynı çağrışımları verir.

DÜZENLEME 2: Add'i beğenmeme nedenleri.

Çeşitli cevaplar etkili bir şekilde: "Add ile git. Bu , değişmezliği açık hale getirmeyen yöntemlere sahiptir DateTimeve böyle." Katılıyorum - burada öncelik var. İnsanlar diyoruz Ancak, ben bol gördüm ya ve mutasyon bekliyoruz . Çok sayıda haber grubu sorusu var (ve eğer etrafta kazarsam muhtemelen SO olanlar).StringReplaceDateTime.AddString.ReplaceString.Replace ; dizeler değiştirilemez, yeni bir dize döndürülür."

Şimdi, soruya incelik açığa çıkarmalıdır - tipi olabilir değil aslında bir değişmez liste, ancak farklı bir değişmez tipte. Özellikle, bir pakete testler eklediğiniz ve bu yeni bir paket oluşturan bir karşılaştırma çerçevesi üzerinde çalışıyorum. Açıktır ki:

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

hiçbir şey başaramayacak, ancak şu şekilde değiştirdiğinizde çok daha karanlık oluyor:

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

Tamam olmalı. Oysa bu benim için hatayı daha net hale getiriyor:

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

Bu sadece yalvarıyor:

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

İdeal olarak, kullanıcılarımın test paketinin değişmez olduğu söylenmemesini istiyorum. Onların başarı çukuruna düşmelerini istiyorum. Bu mümkün olmayabilir , ama denemek istiyorum.

Sadece değişmez bir liste türü hakkında konuşarak orijinal soruyu aşırı basitleştirdiğim için özür dilerim. Tüm koleksiyonlar kendileri kadar açıklayıcı değildir ImmutableList<T>:)

Bu gibi durumlarda, genellikle giderim Concat. Bu genellikle bana yeni bir nesne yaratıldığını ima eder.

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

Eksileriyle basit bir nedenden dolayı giderdim: tam olarak ne istediğinizi ifade eder.

1. Tam olarak ne demek istediğimi söylemenin büyük bir hayranıyım, özellikle kaynak kodunda. Bir acemi, Eksilerin tanımını sadece bir kez aramak zorunda kalacak, ancak daha sonra bunu binlerce kez okuyup kullanacak. Uzun vadede, ön maliyet biraz daha yüksek olsa bile, ortak durumu kolaylaştıran sistemlerle çalışmak daha hoş.

2. FP deneyimi olmayan insanlar için "anlamsız" olması aslında büyük bir avantajdır. Belirttiğiniz gibi, bulduğunuz diğer tüm kelimelerin zaten bir anlamı vardır ve bu anlam biraz farklı veya belirsizdir. Yeni bir kavramın yeni bir sözcüğü olmalıdır (ya da bu durumda eski bir sözcük). Birisinin, eklentinin ne yaptığını yanlış bildiğini varsaymak yerine, Cons'un tanımına bakmasını tercih ederim.

3. İşlevsel dillerden ödünç alınan diğer işlemler genellikle belirgin isimleri olmadan orijinal adlarını korur. FPer olmayanlara daha tanıdık gelen "harita" ve "azaltmak" için eşanlamlılar bulmak için herhangi bir baskı görmedim, ne de bundan fayda görmüyorum.

(Tam açıklama: Lisp programcısıyım, bu yüzden Eksilerin ne anlama geldiğini zaten biliyorum.)

Aslında And, özellikle deyimsel olarak hoşuma gidiyor. Özellikle Boş liste için statik bir salt okunur özelliğiniz varsa ve belki de her zaman boş listeden inşa etmek zorunda olduğunuzda yapıcıyı özel yapmayı sevdim.

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

Ne zaman isimlendirme ile bir reçeldeysem, iç ağlara çarptım.

thesaurus.com bunu "ekle" için döndürür:

Tanım: adjoin, artış; daha fazla yorum yap

Eşanlamlılar: ek, ek, ante, ekle, artırma, sığır eti yukarı, artırma, biriktirme, şarj etme, devam et, işaretleme, şekil verme, et dışarı, ısınma, yürüyüş, yürüyüş, takılma, bağlanma, bağlanma dahil, jack up, jazz up, birlikte katılmak, yastık, parlay, sırtlama, tak, dökmek, cevap, koşmak, daha fazla söylemek, tokat, kartopu, çorba, hızlandırmak, başak, hızlandırmak, ek, tatlandırmak, tack, etiket

Sesini seviyorum Adjoinya da daha basit olarak Join. Yaptığın şey bu, değil mi? Yöntem, diğerlerinin katılımına da uygulanabilir ImmutableList<>.

Şahsen ben .With () ile seviyorum. Nesneyi kullanıyordum, belgeleri veya kod yorumlarını okuduktan sonra, ne yaptığı açıktır ve kaynak kodunda ok okur.

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

Veya onunla birlikte "Along" ekleyin .. :)

object.AlongWith("this new item");

BclExtras'taki tüm Immektif Koleksiyonlarım için Add ile devam ettim . Nedeni kolay tahmin edilebilir bir isim olmasıdır. Ben kafa karıştırıcı insanlar hakkında çok endişelenmiyorum mutasyona bir ekleme ile Add türü adı Immutable ile ön ekidir çünkü.

Bir süredir Eksileri ve diğer işlevsel stil isimlerini düşündüm. Sonunda onları indirim yaptım çünkü neredeyse çok iyi bilinmiyorlar. Elbette fonksiyonel programcılar anlayacaktır, ancak kullanıcıların çoğunluğu değildir.

Diğer İsimler: bahsettiğiniz:

• Artı: Bunu istiyorum / yıkıyorum. Benim için bu, artık Add'den daha mutasyona uğramayan bir işlem olarak ayırt edilmiyor
• İle: VB ile ilgili sorunlara neden olur (pun amaçlı)
• Operatör aşırı yüklenmesi: Keşfedilebilirlik bir sorun olurdu

Düşündüğüm seçenekler:

• Concat: String'ler Değişmezdir ve bunu kullanırlar. Ne yazık ki sonuna kadar eklemek gerçekten çok iyi
• CopyAdd: Ne kopyalansın? Kaynak, liste?
• AddToNewList: Liste için iyi olabilir. Ama bir Koleksiyon, Yığın, Sıra vb.

Ne yazık ki bir kelime var gibi gözükmüyor

1. Kesinlikle değişmez bir operasyon
2. Kullanıcıların çoğunluğu tarafından anlaşılabilir
3. 4 kelimeden az temsil edilebilir

Liste dışındaki koleksiyonları düşündüğünüzde daha da garipleşir. Örneğin Stack'i ele alalım. İlk yıl programcıları bile Stacks'ın bir Push / Pop çifti yöntemine sahip olduğunu söyleyebilir. Bir ImmutableStack oluşturursanız ve ona tamamen farklı bir ad verirseniz, buna Foo / Fop diyelim, koleksiyonunuzu kullanmaları için daha fazla iş eklediniz.

Düzenleme: Artı Düzenleme'ye Yanıt

Plus ile nereye gittiğini görüyorum. Bence daha güçlü bir dava aslında kaldırılması için Eksi olurdu. Eğer aşağıdakileri görürsem kesinlikle programcının ne düşündüğünü merak ederdim

list.Minus(obj);

Artı / Eksi veya yeni bir eşleştirme ile ilgili en büyük sorun, aşırıya kaçma gibi hissetmek. Koleksiyonun zaten ayırt edici bir adı var, Immutable öneki. Niçin Değiştirilebilir önek ile aynı ayrımı eklemek olan kelime dağarcığını ekleyerek neden daha ileri gidelim.

Çağrı sitesi argümanını görebiliyorum. Tek bir ifade açısından onu daha net hale getirir. Ancak tüm fonksiyon bağlamında gereksiz görünüyor.

Düzenle 2

İnsanların String.Concat ve DateTime.Add tarafından kesinlikle karıştırıldığını kabul edin. Birkaç parlak programcının bu soruna çarptığını gördüm.

Ancak ImmutableList'in farklı bir argüman olduğunu düşünüyorum. String veya DateTime ile ilgili olarak onu programcıya bağdaşmaz olarak belirleyen hiçbir şey yoktur. Sadece bilmelisin bazı diğer kaynak yoluyla değişmez olduğunu. Yani karışıklık beklenmedik değil.

ImmutableList'in adı bu davranışı tanımladığı için bu sorunu yaşamaz. İnsanların Dokunulmaz'ın ne olduğunu bilmediğini ve bence bu da geçerli. Kesinlikle üniversitede yaklaşık 2 yıla kadar bilmiyordum. Ancak, Ekle yerine seçtiğiniz adla aynı sorunu yaşarsınız.

Düzenleme 3: TestSuite gibi değişmeyen ancak kelimeyi içermeyen türler ne olacak?

Sanırım bu, yeni yöntem isimleri icat etmemeniz gerektiği fikrini eve getiriyor. Diğer bir deyişle, paralel işlemleri kolaylaştırmak için türleri değişmez kılmak için açıkça bir dürtü vardır. Koleksiyonlar için yöntemlerin adını değiştirmeye odaklanırsanız, bir sonraki adım, kullandığınız her türde değiştirilemeyen mutasyon yöntem adları olacaktır.

Bunun yerine türleri Değişmez olarak tanımlanabilir hale getirmeye odaklanmanın daha değerli bir çaba olacağını düşünüyorum. Bu şekilde, orada her mutasyon yöntemini yeniden düşünmeden sorunu çözebilirsiniz.

Şimdi TestSuite'i Bağlanabilir olarak nasıl tanımlayabilirsiniz? Bugünün ortamında bence birkaç yol var

1. Immutable ile Önek: ImmutableTestSuite
2. Immutablitiy seviyesini tanımlayan bir Nitelik ekleyin. Bu kesinlikle daha az keşfedilebilir
3. Çok fazla değil.

Tahminim / umudum, geliştirme araçlarının değişmez türleri kolayca görerek (farklı renk, daha güçlü yazı tipi, vb ...) tanımlamayı kolaylaştırarak bu soruna yardımcı olmaya başlayacağıdır. Ama bence bu, tüm yöntem adlarını değiştirmenin cevabı.

Bence bu, +operatöre aşırı yüklenmenin kabul edilebilir olduğu nadir durumlardan biri olabilir . Matematik terminolojisinde bunun +başka bir şeyin sonuna bir şey eklemediğini biliyoruz . Her zaman iki değeri bir araya getirir ve yeni bir sonuç değeri döndürür.

Örneğin, sezgisel olarak açıktır ki,

x = 2 + 2;

elde edilen x değeri 22 değil 4'tür.

Benzer şekilde,

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

her değişkenin ne tutacağını netleştirmelidir. O açık olmalıdır list2değildir değişti son satırında, ancak bunun yerine o list3kadar "sözcüğü" ekleyerek sonucu atanır list2.

Aksi takdirde, sadece Plus () işlevini adlandırırdım.

Mümkün olduğunca açık olmak için, wordier CopyAndAddveya benzeri bir şeyle gitmek isteyebilirsiniz .

Ben bunu Extend () veya belki ExtendWith ()Eğer gerçekten ayrıntılı gibi hissediyorum .

Genişletme, değiştirmeden başka bir şeye bir şey eklemek anlamına gelir. Bu uzatma yöntemleri kavramına benzer çünkü bu C # 'da çok ilgili bir terminoloji olduğunu düşünüyorum - onlar sınıf "kendisi" dokunmadan "bir sınıfa yeni bir yöntem" eklemek ".

Aksi takdirde, orijinal nesneyi hiç değiştirmediğinizi gerçekten vurgulamak istiyorsanız, Get- gibi bir önek kullanmak benim için kaçınılmaz gibi görünüyor.

Eklendi (), Eklendi ()

Geçmiş zamanı, değişmeyen nesneler üzerindeki işlemler için kullanmayı seviyorum. Orijinal nesneyi değiştirmediğiniz fikrini aktarır ve gördüğünüzde kolayca fark edebilirsiniz.

Ayrıca, mutasyon yöntemi adları genellikle gergin fiiller olduğundan, karşılaştığınız değişmez yöntem-adı gerekli durumların çoğuna uygulanır. Örneğin, değişmez bir yığın "itilmiş" ve "atmış" yöntemlere sahiptir.

Mmyers CopyAndAdd önerisini seviyorum . Bir "mutasyon" temasına uygun olarak, belki Bud (aseksüel üreme), Büyümek , Çoğaltmak veya Evrimleşmekle gidebilirsin ? =)

DÜZENLEME: Genetik temamla devam etmek için, bir öncekine dayanan, ancak yeni bir şey eklenmiş yeni bir nesnenin yapıldığını ima eden Procreate'ye ne dersiniz .

Bu muhtemelen bir esnektir, ancak Ruby'de ayrım için yaygın olarak kullanılan bir gösterim vardır: addmutasyon yapmaz; add!mutasyona uğradığında. Bu projenizde yaygın bir sorunsa, bunu da yapabilirsiniz (alfabetik olmayan karakterlerle değil, sürekli olarak mutasyona uğrayan / mutasyona uğramayan yöntemleri belirtmek için bir gösterim kullanarak).

Join uygun görünüyor.

Belki de kafa karışıklığı bir arada iki işlem yapmaktan kaynaklanıyor. Neden onları ayırmıyorsunuz? DSL tarzı:

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

Copybir ara nesne döndürür, bu orijinal listenin değiştirilebilir bir kopyasıdır. Withyeni bir değişmez liste döndürür.

Güncelleme:

Ancak, orta ve değişken bir koleksiyona sahip olmak iyi bir yaklaşım değildir. Ara nesne Copyoperasyonda bulunmalıdır :

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

Şimdi, Copyişlem, değiştirilebilir bir liste alan bir temsilci alır, böylece kopya sonucunu kontrol edebilir. Öğeleri kaldırmak veya listeyi sıralamak gibi bir öğeyi eklemekten çok daha fazlasını yapabilir. Ayrıca, ImmutableListyapıcıda, ara değişmez listeler olmadan ilk listeyi birleştirmek için de kullanılabilir .

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

Artık kullanıcılar tarafından yanlış yorumlanma imkanı yok, doğal olarak başarı çukuruna düşecekler .

Yine başka bir güncelleme:

Değişken listeden bahsetmeyi hala sevmiyorsanız, şimdi içerdiğine rağmen , kopyalama işleminin listeyi nasıl dönüştüreceğini belirleyecek bir özellik nesnesi veya komut dosyası tasarlayabilirsiniz . Kullanım aynı olacaktır:

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!"));

Artık kural adlarıyla yaratıcı olabilirsiniz ve yalnızca Copydesteklemek istediğiniz işlevselliği açığa çıkarabilirsiniz IList.

Zincirleme kullanımı için makul bir kurucu (elbette zincirleme kullanmayacak) oluşturabilirsiniz:

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

...

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

Veya başka bir kurucuda aynı temsilciyi kullanın:

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

Bu rules.Appendyöntemin döndürdüğünü varsayarthis .

En son örneğinizle böyle görünecektir:

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

Birkaç rastgele düşünce:

• ImmutableAdd ()
• Ekleme ()
• ImmutableList <T> (ImmutableList <T> originalList, T newItem) Yapıcı

C # 'da DateTime Ekle kullanır. Öyleyse neden aynı adı kullanmıyorsunuz? Sınıfınızın kullanıcıları sınıfın değişmez olduğunu anladığı sürece.

Sanırım elde etmeye çalıştığınız anahtar şeyin ifade edilmemesi zor, bu yüzden belki de içinde üretken bir kelime olan bir şey, CopyWith () veya InstancePlus () gibi bir şey.

İngilizce dilinin, "Ekle" ile aynı anlama gelen bir fiil kullanırken, değişmez bir şekilde imkansızlığı ima etmesine izin vereceğini sanmıyorum. "Artı" neredeyse bunu yapar, ancak insanlar yine de hata yapabilir.

Kullanıcılarınızın nesneyi değiştirilebilir bir şey için yanlış kullanmasını engellemenin tek yolu, nesnenin kendisi veya yöntemin adı aracılığıyla ("GetCopyWith" gibi ayrıntılı seçeneklerle veya ) "CopyAndAdd".

En sevdiğiniz "Artı" ile gidin.

İlk olarak, ilginç bir başlangıç ​​noktası: http://en.wikipedia.org/wiki/Naming_conventions_(programming) ... Özellikle, alttaki "Ayrıca Bkz" bağlantılarını kontrol edin.

Artı ya da And'ı etkin bir şekilde eşit şekilde destekliyorum.

Artı ve Ve ikisi de etimolojide matematik tabanlıdır. Bu nedenle, her ikisi de matematiksel işlemi ifade eder; her ikisi de doğal olarak bir değere dönüşebilen ve bir dönüş değerine sahip yönteme uyan ifadeler olarak okuyan bir ifade verir. Andek mantık çağrışımı taşır, ancak her iki kelime de sezgisel olarak listelere uygulanır. Addbir nesnede gerçekleştirilen ve yöntemin değişmez semantiği ile çelişen eylemi ifade eder.

Her ikisi de kısa, bu da operasyonun ilkelliği göz önüne alındığında özellikle önemlidir. Basit, sık gerçekleştirilen işlemler daha kısa isimleri hak eder.

Değişmez anlambilimi ifade etmek, bağlam yoluyla yapmayı tercih ettiğim bir şeydir. Yani, sadece bu kod bloğunun işlevsel bir hissi olduğunu ima ederim; her şeyin değişmez olduğunu varsayalım. Ancak bu sadece ben olabilirim. Değişmezliğin kural olmasını tercih ederim; eğer yapılırsa, aynı yerde çok şey yapılır; değişebilirlik istisnadır.

Chain () veya Attach () ne dersiniz?

Artı (ve Eksi) tercih ederim. Kolayca anlaşılabilirler ve doğrudan iyi bilinen değişmez türleri (sayılar) içeren operasyonlarla eşleşirler. 2 + 2, 2 değerini değiştirmez, yeni, eşit olarak değiştirilemez bir değer döndürür.

Diğer bazı olasılıklar:

Ekleme ()

Greft ()

Çoğalmasına ()

Peki arkadaşı , mateWith veya cinsel birleşme ? Üreme açısından memeliler genellikle değişmez olarak kabul edilir.

Atacak Birliği de orada. SQL'den ödünç alındı.

Görünüşe göre bu soruya cevap veren ilk Obj-C / Cocoa kişisiyim.

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

Bununla herhangi bir kod golf oyunu kazanamayacaksınız.

Bence "Ekle" ya da "Artı" kulağa hoş geliyor. Listenin kendisi, listenin değişmezliğini iletmek için yeterli olmalıdır.

Belki de kopyayı yaptığımı daha çok hatırlayan ve örneği mutasyona uğratmak yerine buna bir şeyler ekleyen bazı kelimeler vardır ("Concatenate" gibi). Ama bence bu kelimeler için başka eylemler için biraz simetriye sahip olmak da iyi olur. Ben "Concatenate" gibi aynı tür düşünüyorum "Kaldır" için benzer bir kelime bilmiyorum. "Artı" bana biraz garip geliyor. Sayısal olmayan bir bağlamda kullanılmasını beklemezdim. Ama bu benim ingilizce olmayan geçmişimden de gelebilir.

Belki bu şemayı kullanırdım

AddToCopy
RemoveFromCopy
InsertIntoCopy

Bunları düşündüğümde, kendi sorunları var. Kişi bir şeyi kaldırdıklarını ya da verilen bir argümana bir şeyler eklediklerini düşünebilir. Hiç emin değilim. Bu kelimeler de zincirleme konusunda iyi oynamıyor sanırım. Yazmak için çok garip.

Belki de sadece düz "Ekle" ve arkadaşlar kullanmak istiyorum. Matematikte nasıl kullanıldığını seviyorum

Add 1 to 2 and you get 3

Elbette, 2 2 kalır ve yeni bir sayı alırsınız. Bu iki sayı hakkında ve bir liste ve bir öğe hakkında değil, ama bazı benzetme olduğunu düşünüyorum. Bana göre, bir addşeyi değiştirdiğiniz anlamına gelmez. Kesinlikle sadece bir içeren yalnız bir ifade olması addve döndürülen yeni nesneyi kullanmıyorum buggy görünmüyor olduğunu düşünüyorum. Ama şimdi de "eklemek" dışında başka bir ad kullanma fikri hakkında biraz zaman düşündüm ama sadece "hmm bana düşündürmeden başka bir isim ile gelemiyorum, ne bilmek için belgelere bakmak gerekir "hakkında" adı "beklemek" ne beklenir farklıdır çünkü. Bu konuda biraz garip düşündüm, hiç mantıklı olmadığından emin değilim :)

Http://thesaurus.reference.com/browse/add ve http://thesaurus.reference.com/browse/plus bakarak Kazanç ve ek buldum ama ne kadar mutasyon olmadığını ima etmedim.

Ben düşünüyorum Plus()ve Minus()ya alternatif olarak Including(), Excluding()en makul ima değişmez davranış.

Ancak, hiçbir adlandırma seçeneği hiç herkes için mükemmel açık hale getirecek, bu yüzden ben şahsen iyi bir xml doc yorum burada çok uzun bir yol gidecek inanıyoruz. IDE'de kod yazarken VS bunları yüzünüze doğru atar - görmezden gelmek zordur.

Append - çünkü, System.String yöntemlerin örneği değiştirdiklerini önerdiklerini, ancak değiştirmediklerini unutmayın.

Yoksa oldukça beğendim AfterAppending:

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

list.CopyWith(element)

Smalltalk gibi :)

Ve ayrıca list.copyWithout(element), bir öğenin tüm oluşumlarını kaldırır; bu, list.copyWithout(null)ayarlanmamış öğeleri kaldırmak için kullanıldığında en kullanışlıdır .

Daha iyi bir adın faydasını görebildiğim için Add'i seçerdim, ancak sorun, bu mantıklıysa sınıfı oldukça tanıdık kılabilecek diğer her değişmez işlem için farklı adlar bulmak olacaktır.