Как лучше всего назвать не мутирующий метод «add» в неизменяемой коллекции? - PullRequest
224 голосов
/ 06 февраля 2009

Извините за вафельный заголовок - если бы я мог придумать краткое название, мне не пришлось бы задавать вопрос.

Предположим, у меня есть тип неизменяемого списка. Он имеет операцию Foo(x), которая возвращает новый неизменный список с указанным аргументом в качестве дополнительного элемента в конце. Таким образом, чтобы создать список строк со значениями «Hello», «immutable», «world», вы можете написать:

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

(Это код на C #, и меня больше всего интересует предложение на C #, если вы считаете, что язык важен. Это не вопрос языка, но и идиомы языка могут быть важны.)

Важно то, что существующие списки не изменены Foo, поэтому empty.Count все равно вернет 0.

Другой (более идиоматический) способ достижения конечного результата:

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

Мой вопрос: Какое имя Foo лучше всего?

РЕДАКТИРОВАТЬ 3 : Как я выясню позже, имя типа может на самом деле не быть ImmutableList<T>, что делает позицию ясной. Вместо этого представьте, что он TestSuite и что он неизменен, потому что весь фреймворк, частью которого он является, неизменен ...

(конец редактирования 3)

Опции, которые я до сих пор придумал:

  • Add: распространено в .NET, но подразумевает мутацию исходного списка
  • Cons: Я считаю, что это нормальное имя в функциональных языках, но не имеет смысла для тех, кто не имеет опыта работы с такими языками
  • Plus: мой любимый до сих пор, это не подразумевает мутации для меня . Очевидно, это также используется в Haskell , но с немного иными ожиданиями (программист на Haskell может ожидать, что он добавит два списка вместе, а не добавит одно значение в другой список).
  • With: согласуется с некоторыми другими неизменными соглашениями, но не имеет такой же «добавляемости» к этому IMO.
  • And: не очень описательный.
  • Перегрузка оператора для +: мне действительно не очень нравится; Я вообще думаю, что операторы должны применяться только к типам более низкого уровня. Я готов быть убежденным, хотя!

Критерии, которые я использую для выбора:

  • Дает правильное представление о результате вызова метода (то есть, что это оригинальный список с дополнительным элементом)
  • делает как можно более ясным, что он не изменяет существующий список
  • Звучит разумно, когда объединены в цепочку, как во втором примере выше

Пожалуйста, попросите более подробную информацию, если я не проясняю себя достаточно ...

РЕДАКТИРОВАТЬ 1: Вот мои аргументы в пользу предпочтения от Plus до Add. Рассмотрим эти две строки кода:

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

На мой взгляд (а это является личным делом) последнее явно глючит - это все равно что писать "х + 5;" как заявление само по себе. Первая строка выглядит нормально, пока вы не помните, что она неизменна. Фактически, то, что оператор плюс сам по себе не изменяет свои операнды, является еще одной причиной, по которой Plus является моим любимым. Без незначительной перегрузки операторов, он по-прежнему дает те же коннотации, которые включают (для меня) не мутирование операндов (или цель метода в этом случае).

РЕДАКТИРОВАТЬ 2: Причины неприязни Add.

Различные ответы эффективны: «Идите с Add. Вот что делает DateTime, и у String есть Replace методы и т. Д., Которые не делают очевидной неизменность». Я согласен - здесь есть приоритет. Тем не менее, я видел много людей, которые звонят DateTime.Add или String.Replace и ожидают мутации . Есть множество вопросов группы новостей (и, вероятно, SO, если я копаюсь), на которые отвечают: «Вы игнорируете возвращаемое значение String.Replace; строки неизменны, возвращается новая строка.»

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

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

ничего не добьется, но становится лот мрачнее, когда вы меняете его на:

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

Похоже, все должно быть в порядке. Тогда как для меня это делает ошибку более ясной:

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

Вот только прошу:

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

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

Я прошу прощения за чрезмерное упрощение исходного вопроса, говоря только о неизменяемом типе списка. Не все коллекции настолько информативны, как ImmutableList<T>:)

Ответы [ 74 ]

0 голосов
/ 08 февраля 2009

Как насчет "Stick" или "StickTo", он вставляет элемент в конец.

Или «Присоединить» или «Присоединить».

0 голосов
/ 25 апреля 2010

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

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

0 голосов
/ 06 февраля 2009

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

0 голосов
/ 07 февраля 2009

Итак, я думаю, что метод с именем "ImmutableAdd ()" слишком упрощен?

0 голосов
/ 24 мая 2010

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

var empty = new ImmutableList<string>(); 
var list1 = empty.Clone("Hello"); 
var list2 = list1.Clone("immutable"); 
var list3 = list2.Clone("word");
0 голосов
/ 11 марта 2009

Я бы назвал это 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);
0 голосов
/ 06 февраля 2009

А как насчет "Аугмента"?

Это слово отличается от Add, но это близкий синоним.

0 голосов
/ 08 февраля 2009

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

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

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

0 голосов
/ 17 ноября 2011

Лично я бы пошел с Pad (..), возможно, если вы предпочитаете свободный стиль, также с методом расширения AndWith (..)

var list = new ImmutableList<string>().Pad("Hello")
                                      .AndWith("immutable")
                                      .AndWith("word");
0 голосов
/ 22 ноября 2010

Для функций такого типа я обычно использую глагол во второй форме, в данном случае Added.

Это соглашение используется Qt, например, QVector2D::normalized возвращает нормализованный вектор, а QVector2D::normalize нормализует вектор.

Точно так же Added вернет объект с новым добавленным элементом.

...