Каково лучшее название невидоизменения, “добавляет” метод на неизменном наборе?

Я использовал бы конструктора.

Foo f1 = new Foo("one");
Foo f2 = new Foo(f1, "two");
Foo f3 = new Foo(f2, "three");

f1 содержит "тот". f2 содержит "один", "два". f3 содержит "один", "два", "три".

Таким образом, я предполагаю, что метод, названный "ImmutableAdd ()", полностью слишком упрощен?

Как насчет "Палки" или "StickTo", это прикрепляет элемент на конец.

Или "Присоединение" или "AttachTo".

мне Нравится И () . Я думаю, что это имеет наименее потенциальное для неоднозначности. Единственное столкновение, о котором я могу думать, с логическим И, я не вижу, что, будучи проблемой с разработчиком C# и даже для VB думаю, что контекст делает его вряд ли для порождения проблемы, и любая проблема была бы взята быстро во время компиляции. Это также работает хорошо в на английском языке, "Делают что-то к Ним И Что" или "Помещенный Они И Это в поле".

я думаю .With () является OK. Мое беспокойство - это, может немного походить на linq Where<> метод особенно, если существует лямбда как аргумент. Английский в моей голове также менее ясен особенно, "Делают что-то к Ним С Этим".

мне не нравится.Plus () . Я не могу закончить его, как Добавляет синоним для: плюс = знак "плюс" = + = добавляют.

"добавьте ()"

факт, который это возвращает, новый список является несущественным, это - деталь реализации, показанная подписью. Основное действие, которое выполняет метод, "добавляет" новый элемент к списку. Как или что это deos или возвраты не должны быть частью имени метода. Если бы метод синхронизировался, который влиял бы на имя метода - "synchronizedAdd ()"??? - конечно, нет.

Классы как Строка, которые следуют за would-be-mutator шаблоном все еще, имеют имена действительно простого метода - ни один не составленные слова.

. След подразумевает, что очень глубокое понимание списка не изменилось, этот объект запаздывает позади списка, это не было добавлено к нему.

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

Так как именем типа является ImmutableList, таким образом указывающий, что это, заражают неизменный, я думаю, что.Add () прекрасен. Однако, Если Ваше действительно настойчивое на чем-то еще, я мог бы пойти с чем-то как.AddEx (), где Исключая расширенными средствами и подразумевает, что пользователь должен определить то, что это Исключая (путем чтения документов) перед использованием. Мне также нравится предложение Плюс () и GetCopyWith ()

Как насчет "Приращения"?

Это - другое слово от, Добавляют, но это - близкий синоним.

Я пошел бы для простого, Добавляют (). Альтернатива была бы, Добавляют (), если Вы хотите передать это, это - действительно операция набора.

В дополнение к явному методу, я все еще предложил бы реализовать obverloaded + operatr. Это - известная операция. Все знают, что Строка неизменна, все же все используют '+' для создания новых экземпляров из нее.

"Замена"? Это не добавляет к списку, это заменяет список новым.

Я прибываю немного поздно сюда, как насчет NewWith?

Я назвал бы это 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);

2 предложения:

А "бесплатная" функция:

Foo f = new Foo(whatever);
Foo fPlusSomething = Foo.Concat(f, something);

перегрузка конструктора А (который является, в некотором смысле, вариация на "свободную функциональную" тему):

Foo f = new Foo(whatever);
Foo fPlusSomething = new Foo(f, something);

Любое имя, которое подразумевает, что объект того же типа будет возвращен, должно быть прекрасным для использования. Плюс хорошее название этого, как будто Вы плюс два объекта Вы ожидаете, что результат будет возвращен.

Плюс просто не походит на корректное имя для использования в этом экземпляре, хотя, так как Вы - 'Plus'ing тест в набор тестов.

GetWith () походит на опцию мне. Или когда-либо GetTypeWith (), где тип является, очевидно, типом Ваше использование. Так, например:

var list = new ImmutableList<String>();
var list2 = list.GetWith("First");
var list3 = list2.GetWith("Second");

// OR

var list2 = list.GetListWith("First");

Получение подразумевает, что Вы получаете список, это уже содержится, и С подразумевает, что Вы хотите другой объект наряду с ним. CopyWith () также встретил бы это критерии.

Непосредственная проблема, которую я вижу с GetWith, состоит в том, что это не является легко отгадываемым. Разработчик хочет добавить комплект, не получить текущий комплект. Я сразу ввел бы.Add, и надежда intellisence показал что-то очень близко к тому, что я буду ожидать.

Очень поздно к игре, но как насчет Freeze . В WPF есть приоритет для использования Freeze и IsFrozen для проверки, является ли объект изменчивым. Конечно, это немного искажает значение в том смысле, что обычно Freeze () предназначен для того, чтобы сделать текущий объект неизменным, но если у него есть параметр, вы можете увидеть, что получаете что-то, что является неизменным.

var list = new ImmutableList<string>().Freeze("Hello")
                                      .Freeze("Fridgid")
                                      .Freeze("World");

В основном:

1. Это одно слово.
2. Коннотация вращается вокруг неизменности.
3. Приоритет в WPF для «похожего» синтаксиса.

Как насчет метода расширения? Вы можете назвать это Присоединиться к в этом случае. Будучи методом расширения, пользователи должны знать, что это статический метод, и поэтому могут дать им небольшую паузу и побудить их взглянуть на возвращаемое значение. В то же время у вас есть удобство использования «экземпляра» метода.

public static ImmutableList<T> Join(this ImmutableList<T> body, T tail)
{
    // add robust error checking in case either is null...
    return new ImmutableList<T>(body, tail);
}

, а затем позже ...

var list = new ImmutableList<string>().Join("Hello")
                                      .Join("Extensible")
                                      .Join("World");

Я не совсем знаю, как вести себя при публикации нескольких ответов, но это интересный вопрос, поскольку Я думаю, что номенклатура является критическим шагом в дизайне, и мой мозг продолжает размышлять над этим.

Псевдокод C # выглядит следующим образом:

interface Foo
{
    // Constructors
    Foo();
    Foo(params Foo[] foos);

    // Instance method
    Foo Join(params Foo[] foos);

    // Class method
    static Foo Join(params Foo[] foos);
}    

Таким образом, вы можете называть вещи так:

var f0 = new Foo();
var f1 = new Foo(new Foo(), new Foo(), new Foo());
var f2 = Foo.Join(new Foo(), new Foo(), new Foo());
var f3 = f0.Join(new Foo(), new Foo(), new Foo());
var f4 = new Foo(new Foo(new Foo()), new Foo(), new Foo(new Foo()));

Etc ....

Как программист на C ++ и поклонник STL, я предложил add_copy . (это также предполагает remove_copy , replace_copy и так далее)

Возможно, лучше всего подойдет статический метод или оператор (который является статическим). Это снимет ответственность с экземпляров, и пользователи сразу поймут, что операция не принадлежит ни одному из экземпляров. Особенно важно НЕ использовать методы расширения, поскольку их сходство с методами экземпляра при использовании сводит на нет всю цель.

Статический метод можно назвать Join:

public static class ListOperations {
  public static ImmutableList<T> Join<T>(ImmutableList<T> list, T tail) {
    // ...
  }
  public static ImmutableList<T> Join<T>(T head, ImmutableList<T> list) {
    // ...
  }
  public static ImmutableList<T> Join<T>(ImmutableList<T> list1, ImmutableList<T> list2) {
    // ...
  }
  // substitutes chaining:
  public static ImmutableList<T> Join<T>(ImmutableList<T> list, params T[] tail) {
    // ...
  }
}

// ....

var list = new ImmutableList<string>("Hello");
var list2 = ListOperations.Join(list, "immutable"); // inferred type parameter
var list3 = ListOperations.Join(list2, "world!");

Но я бы предпочел, чтобы в C# были бесклассовые функции. Или, по крайней мере, что-то вроде статического импорта в Java.

Оператор может быть +:

var list = new ImmutableList<string>("Hello");
var list2 = list + "immutable";
var list3 = list2 + "world!";

Но я бы предпочел иметь возможность использовать что-то другое, например <<, :: или . , которые невозможны в C#.

Кроме того, статические члены выглядят более функционально и, как мне кажется, лучше подходят для такого неизменяемого представления.

Как насчет создания класса-оболочки с Augment (или AugmentWith ) метод?

Поскольку этот вопрос является теперь в основном тезаурус: Как насчет .Bring () . Например, дать мне этот список и принести с собой этот элемент?

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

Это не скатывается с языка, но означает для меня.

На самом деле, AndBring ( ) может быть даже лучше.

Я бы пошел с перегрузкой оператора + . Причина в том, что в Python это работает именно так - .append () в списке изменяет список, а выполнение + с другим списком создает новый список. + также определенно не подразумевает мутации. Думаю, именно поэтому вам так нравится .Plus () , поэтому, если вы не хотите перегружать оператор, вы можете использовать .Plus () .

list.copyAndAppend (elt)

Как это звучит?)

Как упоминалось ранее, вы пытаетесь выполнять 2 действия одновременно и выполняете микрооптимизацию только для этой цели. Если копирование происходит не в соответствии с определением исходной коллекции, такие имена, как «Добавить», «Добавить», только сбивают с толку.

« CloneAppend » - вот что я мог бы использовать в этой ситуации.Что-то подсказывает мне, что меня бы не было в этой ситуации. Я считаю, что скоро вам понадобятся другие подобные операции, такие как « CloneFirstN » или « CloneRemoveLast ». И вскоре вы поймете, что гораздо лучше связать метод клонирования / копирования, добавить / удалить все, что вам нужно, а затем преобразовать коллекцию обратно в неизменяемую, даже если для этого потребуется дополнительная строка кода.

Лично я бы назвал метод Clone и вызвал бы параметр AdditionalValue , так как это, по сути, то, что он , по-видимому, делает, и это будет легко понять, например,

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