Почему Java использует -> вместо => для лямбда-функций?

8 сентября 2011 года Брайан Гетц из Oracle объявил в списке рассылки OpenJDK, что синтаксис для лямбда-выражений в Java в основном решен, но некоторые «тонкие моменты», такие как тип стрелки, все еще находятся в стадии разработки. воздух:

Это просто: EG (в основном) приняла решение по синтаксису.

После рассмотрения ряда альтернатив, мы решили по существу использовать синтаксис C#. Мы можем еще поразмыслить над тонкостями (например, тонкая стрела против толстой стрелы, особая форма нилари и т. д.), и не имеют пока не пришли к решению о синтаксисе ссылки на метод.

27 сентября 2011 года Брайан опубликовал еще одно обновление, объявив, что будет использоваться стрелка -> вместо использования => в C# (и прототипе Java):

Обновление синтаксиса: EG решила придерживаться формы -> стрелка, которую в настоящее время использует прототип, вместо использования =>.

Далее он дает некоторое описание обоснования, рассмотренного комитетом:

Вы можете думать об этом двумя способами (я уверен, что услышу оба):

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

  x => x.age <= 0;                 // duelling arrows
  

  или

  Predicate p = x => x.size == 0;  // duelling equals
  

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

Конечно, мы не считаем себя идиотами, но у каждого может быть свое мнение :)

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

Ховард Ловатт ответил в поддержку решения отдать предпочтение ->, написав, что у него «были проблемы с чтением кода Scala». Пол Бенедикт из Apache согласился:

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

Пайган Джадот тоже вмешалась:

Я нахожу "->" намного лучше, чем "=>". Если стрелы вообще вместо более регулярный шаблон "#(){...}", чем что-то определенно отличное от Токены gte/lte явно лучше. А "потому что так делают другие" никогда не во всяком случае, это был хороший аргумент :D.

Подводя итог, можно сказать, что, рассмотрев аргументы обеих сторон, комитет счел, что согласованность с другими языками (=> используется в Scala и C#) менее убедительна, чем четкое отличие от операторов равенства, в результате чего -> победил.

Но Ливен Лемиенгр был настроен скептически:

Другие языки (такие как Scala или Groovy) не имеют этой проблемы, потому что они поддерживают некоторый синтаксис заполнителей.

На самом деле вы не пишете "x => x.age <= 0;" Но это очень распространенный «someList.partition (x => x.age <= 18)», и я согласен это выглядит плохо. Другие языки делают это более понятным, используя синтаксис заполнителя. "someList.partition(_.age <= 18)" или "someList.partition(it.age <= 18)" Я надеюсь, что вы рассматриваете что-то подобное, эти маленькие замыкания будут много использовать!
(И я не думаю, что замена '=>' на '->' сильно поможет)

Кроме Ливена, я не видел никого, кто критиковал бы выбор -> и защищал =>, отвечая в этом списке рассылки. Конечно, как и предсказывал Брайан, мнения почти наверняка были с обеих сторон, но, в конечном счете, в таких вопросах просто необходимо сделать выбор, и комитет сделал его по указанным причинам.