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

(++)

明显的“附加”。也可以是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的世界里，我们一直这样称呼添加到列表上的东西。

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

也许混淆源于您想要两个操作合一的事实。为什么不把它们分开呢?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!"));

现在你可以对规则名称进行创新，你可以只公开你想要Copy支持的功能，而不是IList的全部功能。

对于链接的使用，你可以创建一个合理的构造函数(当然，它不会使用链接):

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

这里假设规则。Append方法返回这个。

这是你最新的例子的样子:

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

我把它叫做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);

因为这个问题现在基本上是一个同义词库:. bring()怎么样?也就是说，给我这个列表，然后把这个元素带来?

Foo = List.Bring('short');
          .Bring('longer');
          .Bring('woah');

虽然不容易脱口而出，但对我来说很重要。

实际上，AndBring()可能更好。

虽然正确命名方法可以减少误用的机会，但如果有一些语言构造告诉编译器:“这个方法什么都不做，只是返回一个新对象，它应该被使用，否则方法调用是没有意义的”，那么每当有人在错误的设置中使用该方法时，编译器就会报错/警告。

我已经为此填写了一个功能请求，如果你同意，可以自由投票。

除了名称之外，不可变容器集合是操作符重载的经典情况(int/string/etc已经是这种情况)。这里有两个优势:

简洁:l1 = l + o1 + o2而不是l1 = l。add (o1).Add(o2) 使用赋值运算符:l += o而不是l = l。

使用操作符也使代码更不容易出错，当从可变类型切换到不可变类型时，通常会忘记赋值，只写ie l.Add(o);(会带来灾难性的后果)但只要写l+o;不使用的结果真的很突出。

您可以在作为F包一部分的集合中看到这一点。