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

В ситуациях как этот я обычно иду с Concat. Это обычно подразумевает мне, что создается новый объект.

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

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

единственный способ, которым Вы собираетесь препятствовать тому, чтобы Ваши пользователи приняли объект за что-то изменяемое, путем создания этого явным, или через название самого объекта или через название метода (как с подробными опциями как "GetCopyWith" или "CopyAndAdd").

Поэтому просто идут с Вашим фаворитом, "Плюс".

Я думаю ключевая вещь, которую Вы пытаетесь достигнуть, это трудно выразить, неперестановка, поэтому возможно, что-то с порождающим словом в нем, чем-то как CopyWith () или InstancePlus ().

DateTime в использовании C# Добавляют. Итак, почему бы не использовать то же имя? Поскольку долго пользователи Вашего класса понимают, что класс неизменен.

Несколько случайных мыслей:

• ImmutableAdd ()
• Добавляют ()
• ImmutableList< T> (ImmutableList< T> originalList, T newItem) Конструктор

Join кажется соответствующим.

Это - вероятно, фрагмент, но в Ruby существует наиболее часто используемая нотация для различия: add не видоизменяется; add! видоизменяется. Если это - распространяющаяся проблема в Вашем проекте, Вы могли бы сделать это также (не обязательно с небуквенными символами, но последовательно использованием нотации для указания на mutating/non-mutating методы).

Добавленный (), Добавленный ()

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

кроме того, потому что видоизменяющиеся имена методов часто являются глаголами настоящего времени, это относится к большинству immutable-method-name-needed случаев, с которыми Вы сталкиваетесь. Например, неизменному стеку "продвинули" методы и "вытолканный".

Мне нравится mmyers предложение CopyAndAdd. В соответствии с темой "мутации", возможно, Вы могли пойти с (бесполое размножение) Bud , Растут , Копируют , или Развиваются ? =)

РЕДАКТИРОВАНИЕ: Чтобы продолжить мою генетическую тему, как насчет Рожают детей , подразумевая, что новый объект сделан, который основан на предыдущем, но с чем-то новым добавил.

Я звонил бы, это Расширяется () или возможно ExtendWith () , если Вы чувствуете себя подобно действительно подробный.

Расширяет средства, добавляющие что-то к чему-то еще, не изменяя его. Я думаю, что это - очень соответствующая терминология в C#, так как это подобно понятию дополнительных методов - они "добавляют" новый метод к классу, не "касаясь" самого класса.

Иначе, если Вы действительно хотите подчеркнуть, что Вы не изменяете исходный объект вообще, с помощью некоторого префикса, любят, Добираются - похож неизбежный мне.

Чтобы быть максимально ясными, Вы могли бы хотеть пойти с более многословным CopyAndAdd, или что-то подобное.

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

, Например, интуитивно очевидно, что, когда Вы говорите

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 присвоен результат добавления "слова" к list2.

Иначе, я просто назвал бы функцию Плюс ().

Я закончил тем, что шел с, Добавляют для всех моих Неизменных Наборов в BclExtras. Так как причина, то, что это - легкое предсказуемое имя. Я не волнуюсь так о людях, путающих, Добавляют с видоизменением, добавляют, так как название типа снабжается префиксом Неизменный.

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

Другие Имена: Вы упомянули:

• Плюс: я слаб / промывка на этом. Для меня это не отличает его как являющийся операцией невидоизменения больше, чем Добавляют, делает
• С: вызовет проблемы с VB (предназначенная игра слов)
• перегрузка Оператора: Discoverability был бы выпуском

Возможности, которые я рассмотрел:

• Concat: Строка Неизменна и использует это. К сожалению, это только действительно хорошо для добавления в конец
• CopyAdd: Копия, что? Источник, список?
• AddToNewList: Возможно, хороший для Списка. Но что относительно Набора, Стека, Очередь, и т.д.

, К сожалению, там, действительно кажется, не слово, которое является

1. Определенно неизменная операция
2. Понятно большинству пользователей
3. Представимый меньше чем в 4 словах

, Это становится еще более нечетным, когда Вы рассматриваете наборы кроме Списка. Возьмите, например, Стек. Даже первые программисты года могут сказать Вам, что Стеки имеют пару Нажатия/Поп методов. Если Вы создаете ImmutableStack и даете ему совершенно другое имя, позволяет, называют это Нечто/Щеголем, Вы только что добавили больше работы для них для использования набора.

Редактирование: Ответ на Плюс Редактирование

я вижу, куда Вы идете с Плюс. Я думаю, что более сильный случай на самом деле был бы Минус для, удаляют. Если бы я видел следующий, то я, конечно, задался бы вопросом, что в мире программист думал

list.Minus(obj);

самая большая проблема, с которой я имею Плюс/Минус, или новое соединение - она, чувствует себя подобно излишеству. Сам набор уже имеет различающее имя, Неизменный префикс. Почему идут далее путем добавления словаря, намерение которого состоит в том, чтобы добавить то же различие, как Неизменный префикс уже сделал.

я вижу аргумент сайта вызова. Это делает это более ясным из точки зрения отдельного выражения. Но в контексте целой функции это кажется ненужным.

Редактирование 2

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

Однако я думаю, что ImmutableList является другим аргументом. Нет ничего о Строке или DateTime, который устанавливает ее как Неизменную программисту. Вы должны просто знать , что это неизменно через некоторый другой источник. Таким образом, беспорядок не неожидан.

ImmutableList не имеет той проблемы, потому что имя определяет, это - поведение. Вы могли утверждать, что люди не знают то, что Неизменный, и я думаю, что это также допустимо. Я, конечно, не знал это до приблизительно год 2 в колледже. Но у Вас есть та же проблема с любым именем, которое Вы выбираете вместо, Добавляют.

Редактирование 3: Что относительно типов как TestSuite, которые неизменны, но не содержат слово?

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

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

Теперь, как можно идентифицировать TestSuite как Неизменный? В сегодняшней среде я думаю, что существует несколько путей

1. Префикс с Неизменным: ImmutableTestSuite
2. Добавляет Атрибут, который описывает уровень Immutablitiy. Это очень еще - конечно, меньше поддающееся обнаружению
3. Не.

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

Лично, мне нравится.With (). Если бы я использовал объект после чтения документации или комментариев к коду, то было бы ясно, что это делает, и это читает хорошо в исходном коде.

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

Или, Вы добавляете "Вперед" с ним.. :)

object.AlongWith("this new item");

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

thesaurus.com возвраты это для "добавляет":

Определение: примыкают, увеличение; сделайте дальнейшие Синонимы комментария

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

, мне нравится звук Adjoin, или проще Join. Именно это Вы делаете, правильно? Метод мог также относиться к присоединению к другому ImmutableList<>.

На самом деле мне нравится And, особенно идиоматическим способом. Я особенно хотел бы его, если бы у Вас было статическое свойство только для чтения для Пустого списка, и, возможно, сделайте конструктора частным, таким образом, всегда необходимо создавать из пустого списка.

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

Я пошел бы с Недостатками по одной простой причине: это означает точно, к чему Вы хотите это.

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

2. то, что это было бы "бессмысленно" людям без опыта FP, является на самом деле большим преимуществом. Как Вы указали, все другие слова, которые Вы нашли уже, имеют некоторое значение, и что значение или немного отличается или неоднозначно. Новое понятие должно иметь новое слово (или в этом случае, старое). Я быть бы, кто-то должен искать определение Недостатков, чем принимать неправильно, что он знает то, что Добавляет, делает.

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

(Полное раскрытие: я - программист Lisp, таким образом, я уже знаю, какие Недостатки означает.)

Во-первых, интересная начальная точка: http://en.wikipedia.org/wiki/Naming_conventions_ (программирование) ... В частности, проверьте, "См. Также" ссылки внизу.

я выступаю за или Плюс или И, эффективно одинаково.

Плюс и И оба основаны на математике в этимологии. По сути, оба означают математическую операцию; оба приводят к выражению, которое читает естественно как выражения, которые могут решить в значение, которое соответствует методу, имеющему возвращаемое значение. And переносы дополнительная логическая коннотация, но оба слова применяется интуитивно к спискам. Add означает действие, выполненное на объекте, который конфликтует с неизменной семантикой метода.

Оба коротки, который особенно важен, учитывая примитивность операции. Простые, часто выполненные операции заслуживают более коротких имен.

Выражение неизменной семантики является чем-то, что я предпочитаю делать через контекст. Таким образом, я просто подразумевал бы, что этот весь блок кода имеет функциональное чувство; предположите, что все неизменно. Это могло бы просто быть я, как бы то ни было. Я предпочитаю, чтобы неизменность была правилом; если это сделано, это сделало много в том же месте; переменчивость является исключением.

Я предпочитаю Плюс (и Минус). Они легко понятны и отображаются непосредственно на операции, включающие известные неизменные типы (числа). 2+2 не изменяет значение 2, оно возвращает новое, одинаково неизменное, значение.

Некоторые другие возможности:

Соединение встык ()

Пересадка ткани ()

Сросшийся ()

list.CopyWith(element)

, Как делает Smalltalk:)

И также list.copyWithout(element), который удаляет все случаи элемента, который является самым полезным при использовании в качестве list.copyWithout(null) для удаления элементов сброса.

Append - потому что, обратите внимание, что названия эти System.String методы предлагают, чтобы они видоизменили экземпляр, но они не делают.

Или мне вполне нравится AfterAppending:

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

Рассмотрение http://thesaurus.reference.com/browse/add и http://thesaurus.reference.com/browse/plus я нашел усиление и аффикс , но я не уверен, насколько они подразумевают немутацию.

Возможно, существуют некоторые слова, которые помнят меня больше создания копии и добавляют материал к этому вместо того, чтобы видоизмениться, экземпляр (как "Конкатенируют"). Но я думаю, имея некоторую симметрию для тех слов для других действий, было бы хорошо, чтобы иметь также. Я не знаю о подобном слове для, "Удаляют" это, я думаю о том же виде, любят, "Конкатенируют". "Плюс" звуки, мало странные для меня. Я не ожидал бы то, чтобы это было используемым в нечисловом контексте. Но это могло также произойти из моей неанглийской среды.

, Возможно, я использовал бы эту схему

AddToCopy
RemoveFromCopy
InsertIntoCopy

, Они имеют их собственные проблемы, хотя, когда я думаю об этом. Можно было думать, что они удаляют что-то или добавляют что-то к данному аргументу. Не уверенный в этом вообще. Те слова не играют по правилам в объединении в цепочку также, я думаю. Слишком многословный для ввода.

, Возможно, я просто использовал бы плоскость, "Добавляют" и друзья также. Мне нравится, как это используется в математике

Add 1 to 2 and you get 3

ну, конечно, 2 остается 2, и Вы получаете новое число. Это - приблизительно два числа а не о списке и элементе, но я думаю, что он имеет некоторую аналогию. По-моему, add не обязательно означает, что Вы видоизменяете что-то. Я, конечно, вижу Вашу точку, что наличие одинокого оператора, содержащего просто add и не использующего возвращенный новый объект, не выглядит ошибочным. Но я теперь также думал некоторое время о той идее использовать другое имя, чем "добавляют", но я просто не могу придумать другое имя, не заставляя меня думать "хм, я должен был бы посмотреть на документацию для знания то, что это о", потому что ее имя отличается от того, чем я ожидал бы позвониться, "добавляют". Просто некоторая странная мысль об этом от litb, не уверенного, это имеет смысл вообще :)

Я думаю, "Добавляют" или "Плюс" прекрасные звуки. Названия самого списка должно быть достаточно для передачи неизменности списка.

Как насчет помощник , mateWith, или совокупление , для тех, кто пребывает. С точки зрения репродуцирования млекопитающих обычно считаются неизменными.

Попытка бросить Объединение там также. Одолженный от SQL.

Как насчет цепочки () или присоединение ()?

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

Я думаю, что Плюс () и Минус () или, альтернативно, Включая () , Исключая () разумны при , подразумевая неизменное поведение.

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

Может быть, путаница связана с тем, что вам нужно две операции в одной. Почему бы не разделить их? Стиль DSL:

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

Копия вернет промежуточный объект, который является изменяемой копией исходного списка. С помощью вернет новый неизменяемый список.

Обновление:

Но наличие промежуточной изменяемой коллекции - не лучший подход.Промежуточный объект должен содержаться в операции 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")
);

Это предполагает, что rules.Append Метод возвращает this .

Вот как это будет выглядеть в вашем последнем примере:

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

По-видимому, я первый, кто ответит на этот вопрос по Obj-C / Cocoa.

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

С этим я не выиграю ни одной кодовой игры в гольф.