我个人倾向于使用AddVoid或者其他方式的VoidAdd

This seems to come down to finding a word that expresses that the object is not modified. Also, that it is cloned and the element passed as a parameter is added to the end of the cloned list. Standard names like add and clone are never going to cover it. Perhaps clone_and_append which is also rather ambiguous, since the append part might imply that the parameter is appended to the original list. So it should probably be something like clone_and_append_to_clone or better yet append_to_clone, although this one does not really imply that the clone is going to be returned by this method, but rather that the clone already exists as part of the origina list.

因此，更多地考虑寻找一个不意味着对原始列表进行修改的名称，并建议创建一个新列表，考虑以下内容:

Offshoot -- var list1 = list.Offshoot("tail") - in the strictest sense, offshoot refers here to the new element and not the entire new list. Another apparent disadvantage is that it is not an action, the more correct name being list.CreateOffshoot. However, I find it gives a clear indication of the fact that the new list will contain the original list and that the new element will come at the end of the list. Spawn -- var list1 = list.Spawn("tail") - similar to the previous. The advantage is that it is an action, but there is a weaker implication that the new list will contain the original list. BranchOff -- var list1 = list.BranchOff("tail") - an action that suggests the original list will be cloned. One potential ambiguity is that it is not very clear how the parameter element will be used.

我把它叫做ToInclude

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

惯用地(?)

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

对你提到的案子也适用。

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

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

如果你是一个函数式程序员，它有几个名字:

(++)

明显的“附加”。也可以是concat，这取决于你的类型:

-- join two things into one thing:
append :: a -> a -> a    

-- join many things into one thing
concat :: [a] -> a

或者你可能会说(:)，又名cons:

(:) :: a -> [a] -> [a]    

如果你在列表的前面加入东西，那么在列表的末尾加入snoc。

至少在过去的20年里，在haskell的世界里，我们一直这样称呼添加到列表上的东西。

注意，这不是算术(+)，因为它是单面的，不是一个环。

就我个人而言，如果你追求流畅的风格，我会选择Pad(..)，也可以使用AndWith(..)的扩展方法。

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

1)问题分析 问题的摘要可以是: 从一个不可改变的…获得一个新的不可变的，但与原来的不同。 在当前问题的语境中: 从一个不可变列表中获得一个新的不可变列表，该列表最后包含一个新元素。 你能否给出一个有效的“动词”(编程语言中的“方法”)，以简洁的方式表达动作，而不使用简单的“添加”动词?

2) Proposal analysis First concept : Immutable give a similar immutable , >>"copy" verb express conservation in "content" but less for it defined constraints (immutable) >>"clone" verb express conservative in "content" but also for its defined constraints. >>"twin" verb is similar to clone but not common in software , but it's short and sound good. Second concept : the result give something different from the original >>"add" express an action to make the difference between original and the new object but by definition we do not act (mutate) an immutable. >>"plus" express the fact that verb result will be augmented without disturbing the original object ... "adverb" approach is more "immutable" friendly >>"with" as before it express the fact that "verb" will do something more but may be ambigous of what it will doing more. Can also express the fact the "verb parameter" is the "more" of the "verb" 3) Answers With verb "clone" >> augmentClone >> growClone >> extendClone with "with" >> cloneWith >> augmentCloneWith >> growCloneWith >> extendCloneWith With verb "twin" >> augmentTwin >> growTwin >> extendTwin with "with" >> twinWith >> augmentTwinWith >> growTwinWith >> extendTwinWith