Когда использовать знак равенства в объявлении метода Scala?

Question

со знаком равенства:

object HelloWorld {
  def main(args: Array[String]) = {
    println("Hello!")
  }
}

Без знака равенства:

object HelloWorld {
  def main(args: Array[String]) {
    println("Hello!")
  }
}

Обе вышеперечисленные программы выполняются одинаково. В блоге Вещи, которые мне не нравятся в Scala Я читал, что при отсутствии знака равенства метод вернет Unit (так же, как в Java void), поэтому методы, которые возвращают значение, должны использовать знак равенства. Но методы, которые не возвращают значение, могут быть написаны в любом случае.

Как лучше всего использовать знак равенства в методах Scala, которые не возвращают значение?

Answer 1

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

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello!")
    123
  }
}

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

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

Answer 2

ОБНОВЛЕНИЕ: начиная с Scala-2.10 использование знака равенства является предпочтительным. Старый ответ:

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

object HelloWorld {
  def main(args: Array[String]) = {
    println("Hello!")
    123
  }
}

Тривиальный пример, конечно, но вы можете видеть, как это может быть проблемой. Поскольку последнее выражение не возвращает Unit, сам метод будет иметь тип возвращаемого значения, отличный от Unit. Это раскрыто в общедоступном API и может вызвать другие проблемы в будущем. С синтаксисом non-equals не имеет значения, что является последним выражением, Scala фиксирует тип возвращаемого значения как Unit.

Это также уборщик двух символов. :-) Я также склонен думать, что синтаксис неравных делает код немного легче для чтения. Более очевидно, что данный метод возвращает Unit, а не какое-либо полезное значение.

В соответствующей заметке есть аналогичный синтаксис для абстрактных методов:

trait Foo {
  def bar(s: String)
}

Метод bar имеет подпись String=>Unit. Scala делает это, когда вы опускаете аннотацию типа для абстрактного члена. Еще раз, это чище, и (я думаю) легче читать.

Answer 3

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

В этом последнем случае вы можете отказаться от знака равенства. Этот синтаксис может быть признан устаревшим, поэтому его лучше избегать. Использование знака равенства и объявления типа возврата всегда будет работать.

Answer 4

Для методов Руководство по стилю Scala рекомендует использовать синтаксис равенства в отличие от синтаксиса процедуры

Синтаксис процедуры

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

// don't do this
def printBar(bar: Baz) {
  println(bar)
}
// write this instead
def printBar(bar: Bar): Unit = {
  println(bar)
}

Answer 5

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

Answer 6

Со временем стиль по умолчанию изменился, и это упоминалось во многих комментариях к ответам. В официальном руководстве по стилю рекомендуется использовать синтаксис = для объявлений функций. .

Answer 7

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