Извините за вафельный заголовок - если бы я мог придумать краткое название, мне не пришлось бы задавать вопрос.
Предположим, у меня есть тип неизменяемого списка. Он имеет операцию 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>:)