Scala 3: новый, но необязательный синтаксис

Это первая статья в моей серии статей с обзором изменений в Scala 3.

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

Опциональные фигурные скобки делают Scala-код больше похожим на Python или Haskell, где для группировки выражений используются отступы. Рассмотрим примеры, взятые из 3-го издания моей книги Programming Scala, которое сейчас готовится к публикации.

Опциональные фигурные скобки

Для начала рассмотрим объявление типа с использованием старого и нового синтаксиса. Это также работает для пакетов, если мы объявляем несколько пакетов в одном файле.

// Со скобками
trait Monoid2[A] {
  def add(a1: A, a2: A): A
  def zero: A
}

// Без скобок
trait Monoid3[A]:
  def add(a1: A, a2: A): A
  def zero: A

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

Вы можете смешивать старый и новый стиль, компилятор Dotty (скоро будет переименован в Scala 3) скомпилирует такой код без ошибок.

Посмотрим на объявления методов. Обратите внимание, что для маркировки начала тела метода используется =, а не :.

def m2(s: String): String = {
  val result = s.toUpperCase
  println(s"output: $result")
  result
}

def m3(s: String): String =
  val result = s.toUpperCase
  println(s"output: $result")
  result

Питонисты будут по привычке писать : пока не привыкнут к особенностям Scala. Отличие от старого синтаксиса в том, что после = теперь можно писать не одно, а сколько угодно выражений. Однако придется следить за правильностью отступов, будь то табы или пробелы.

В этом же стиле могут быть переписаны partial functions, match expressions и блоки try-catch-finally (для для последнего примера не будет):

val o2:Option[Int] => Int = {
  case Some(i) => i
  case None => 0
}

val o3:Option[Int] => Int =
  case Some(i) => i
  case None => 0

0 match {
  case 0 => "zero"
  case _ => "other value"
}

0 match
  case 0 => "zero"
  case _ => "other value"

Исторически в плане синтаксиса Scala старалась держаться как можно ближе к Java. Зачем же делать столь радикальные изменения сейчас? Сегодня нередки случаи, когда люди, знающие Python, начинают изучать Scala. Возможно, они учили Python в университете, а компания, в которую они потом пошли работать, использует Scala. Многие проекты сочетают задачи data science, которые решаются на Python, и data engineering, которые решаются на Scala. В этом смысле стремление Scala быть похожей на Python выглядит интересно.

Вместе с тем, это изменение достаточно спорно. Всегда можно возразить, что и со старым синтаксисом не было особых проблем, а добавления второго варианта может просто укрепить ощущение, что Scala слишком сложна. Есть еще один небольшой недостаток:

import scala.annotation.tailrec

@tailrec def loop(whileTrue: => Boolean)(f: => Unit): Unit =
  f
  if (whileTrue) loop(whileTrue)(f)

var i=5
loop(i > 0) {
  println(i)
  i -= 1
}

var j=5
loop(j > 0):       // ERROR
  println(j)
  j -= 1

У фигурных скобок была крутая способность: с их помощью можно было определять собственные "управляющие" конструкции. В примере выше loop выглядит как встроенный цикл while. Но попытка сделать тоже самое без скобочек не работает. (Возможно, это добавят в следующих релизах.)

Когда я только начал работать над новым изданием книги Programming Scala, я был против нового синтаксиса и планировал просто рассказать про него, оставив остальной код в старом стиле. Потом, поскольку книга все-таки должна была фокусироваться на Scala 3, я решил использовать новый синтаксис практически повсеместно. Сейчас я уже привык к нему, он даже начал мне нравится. Он делает Scala-код более выразительным. Кроме того, не стоит забывать о трендах в индустрии: если этот синтаксис делает Scala более привлекательной для разработчиков на Python (и Haskell) — это хорошо.

Опциональный синтаксис для управляющих конструкций

Также появился новый синтаксис для управляющих конструкций, таких как if, for и while. Его тоже можно использовать вместе со старым:

for (i <- 0 until 5) println(i)   // Старый синтаксис
for i <- 0 until 5 do println(i)  // Новый синтаксис
for i <- 0 until 5 yield 2*i
for i <- 0 until 10
  if i%2 == 0
  ii = 2*i
yield ii

val i = 10
if (i < 10) println("yes")        // Старый синтаксис
else println("no")
if i < 10 then println("yes")     // Новый синтаксис
else println("no")

Для циклов for и while можно убирать круглые и фигурные скобки, отмечая начало тела цикла ключевым словом do. В for также можно использовать ключевое слово yield. Для if можно убирать круглые скобки и писать then после условия.

По умолчанию старый и новый стили можно смешивать. Флаг компилятора -new-syntax обязывает использовать только новый стиль, флаг -old-syntax — только старый.
Добавлен также флаг -rewrite, в зависимости от того, в комбинации с каким из двух предыдущих флагов он указан, компилятор будет конвертировать исходный код в новый синтаксис или в старый.

Заключение

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

Если у вас уже есть код на Scala 2, его не обязательно будет переписывать в соответствии с новым синтаксисом. И, конечно, я не рекомендую смешивать оба стиля. Выберите для своего проекта один из них. Вряд ли старый Java-подобный синтаксис когда-либо признают устаревшим и удалят из языка, но время покажет.

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