Почему Scala выбирает типы после имен переменных?

Возможный дубликат:
Любая причина наличия "val capacity: Int" вместо "val Int Capacity" в Scala

В Scala переменные объявляются как:

var stockPrice: Double = 100.

Если тип (Double) следует за идентификатором (stockPrice). Традиционно на императивных языках, таких как C, Java, С#, имя типа предшествует идентификатору.

double stock_price = 100.0;

Это просто вопрос вкуса, или же имя типа в конце помогает компилятору каким-либо образом? Go также имеет тот же стиль.

Ответы

Ответ 1

Помимо поддержки вывода типа, это также имеет эргономическую выгоду.

Для любого заданного типа name + type вероятность состоит в том, что имя является более важной частью информации. Перемещение его влево делает его более заметным, а код более читабельным, как только вы привыкли к стилю.

Другие эргономические преимущества:

  • С val, var или def перед именами участников вместо их типа все они аккуратно выстраиваются в столбец.
  • Если вы меняете только тип члена или полностью отбрасываете его в пользу вывода, то мелкозернистый инструмент diff ясно покажет, что имя не изменяется
  • Аналогично, изменение между val/var/def очень ясно в diffs Вывод
  • должен рассматриваться как поведение по умолчанию в Scala, вам нужны только спецификации типов в определенных конкретных сценариях, даже тогда это в основном делается для компилятора. Поэтому, ставя их в самое начало декларации, подчеркивается неправильная вещь.
  • "name: Type" вместо "Type name" более точно соответствует тому, как большинство программистов действительно будут думать об объявлении, это более естественно.
  • Различные соглашения C/С++ и Java для указателей и массивов (т.е. * является префиксом следующего имени, а не суффиксом предшествующего типа в C/С++ или [], являющимся допустимым суффиксом на обоих имена и типы в Java) все еще запутывают новичков или переводчиков языка и вызывают некоторые очень реальные ошибки при объявлении нескольких переменных в одной строке. Scala не оставляет места для сомнений и путаницы здесь.

Ответ 2

Кевин понял это правильно. Основное замечание состоит в том, что синтаксис "имя типа" отлично работает, поскольку типы - это короткие ключевые слова, такие как int или float: 
int x = 1
float d = 0.0

По цене одного вы получаете две части информации: "Здесь начинается новое определение" и "здесь (результат) тип определения". Но мы сейчас проходим мимо простых простых примитивов. Если вы пишете

HashMap<Shape, Pair<String, String>> shapeInfo = makeInfo()

самая важная часть того, что вы определяете (имя), скрывается за выражением типа. Сравните с

val shapeInfo: HashMap[Shape, (String, String)] = makeInfo()

Он четко говорит

  • Мы определяем здесь значение, а не переменную или метод (val)
  • Название вещи, которую мы определяем, это shapeInfo
  • Если вам это нравится, вот этот тип (HashMap [...])

Ответ 3

После этого он может быть удален для вывода типа:

var stockPrice: Double = 100.0
var stockPrice = 100.0

Однако, это не так, что императивные языки традиционно имеют типы в первую очередь. Например, Паскаль не делает.

Теперь C делает это, а С++, Java и С# основаны на синтаксисе C, поэтому, естественно, они делают это тоже, но это абсолютно не имеет отношения к императивным языкам.

Ответ 4

Следует отметить, что даже C не "традиционно" определяет тип перед именем переменной, но позволяет разрешить чередование объявлений.

int foo[];

где тип для foo объявляется как до, так и после него, лексически.

Помимо этого, я предполагаю, что это различие без разницы. Разработчики компилятора, конечно же, не могли бы так или иначе заботиться.