diff --git a/_overviews/scala3-book/introduction.md b/_overviews/scala3-book/introduction.md
index 737e068e75..c1dd65583c 100644
--- a/_overviews/scala3-book/introduction.md
+++ b/_overviews/scala3-book/introduction.md
@@ -2,7 +2,7 @@
title: Introduction
type: chapter
description: This page begins the overview documentation of the Scala 3 language.
-languages: [zh-cn]
+languages: [ru, zh-cn]
num: 1
previous-page:
next-page: scala-features
diff --git a/_overviews/scala3-book/scala-features.md b/_overviews/scala3-book/scala-features.md
index 50817f4980..0e5b94f0db 100644
--- a/_overviews/scala3-book/scala-features.md
+++ b/_overviews/scala3-book/scala-features.md
@@ -2,7 +2,7 @@
title: Scala Features
type: chapter
description: This page discusses the main features of the Scala programming language.
-languages: [zh-cn]
+languages: [ru, zh-cn]
num: 2
previous-page: introduction
next-page: why-scala-3
diff --git a/_overviews/scala3-book/taste-hello-world.md b/_overviews/scala3-book/taste-hello-world.md
index a4275d4a91..e60f2ee7be 100644
--- a/_overviews/scala3-book/taste-hello-world.md
+++ b/_overviews/scala3-book/taste-hello-world.md
@@ -2,7 +2,7 @@
title: Hello, World!
type: section
description: This section demonstrates a Scala 3 'Hello, World!' example.
-languages: [zh-cn]
+languages: [ru, zh-cn]
num: 5
previous-page: taste-intro
next-page: taste-repl
diff --git a/_overviews/scala3-book/taste-intro.md b/_overviews/scala3-book/taste-intro.md
index 877d6506d8..c3b0433544 100644
--- a/_overviews/scala3-book/taste-intro.md
+++ b/_overviews/scala3-book/taste-intro.md
@@ -2,7 +2,7 @@
title: A Taste of Scala
type: chapter
description: This chapter provides a high-level overview of the main features of the Scala 3 programming language.
-languages: [zh-cn]
+languages: [ru, zh-cn]
num: 4
previous-page: why-scala-3
next-page: taste-hello-world
diff --git a/_overviews/scala3-book/why-scala-3.md b/_overviews/scala3-book/why-scala-3.md
index 5b936e2790..44b14845d5 100644
--- a/_overviews/scala3-book/why-scala-3.md
+++ b/_overviews/scala3-book/why-scala-3.md
@@ -2,7 +2,7 @@
title: Why Scala 3?
type: chapter
description: This page describes the benefits of the Scala 3 programming language.
-languages: [zh-cn]
+languages: [ru, zh-cn]
num: 3
previous-page: scala-features
next-page: taste-intro
diff --git a/_ru/scala3/book/introduction.md b/_ru/scala3/book/introduction.md
new file mode 100644
index 0000000000..ae23a36516
--- /dev/null
+++ b/_ru/scala3/book/introduction.md
@@ -0,0 +1,38 @@
+---
+layout: multipage-overview
+title: Введение
+scala3: true
+partof: scala3-book
+overview-name: "Scala 3 — Book"
+type: chapter
+description: На этой странице начинается обзорная документация по языку Scala 3.
+language: ru
+num: 1
+previous-page:
+next-page: scala-features
+---
+
+Добро пожаловать в книгу по Scala 3.
+Цель этой книги — предоставить неформальное введение в язык Scala.
+Она относительно легко затрагивает все темы Scala.
+Если в какой-то момент во время чтения этой книги вы захотите получить дополнительную информацию о конкретной функции,
+можете воспользоваться ссылкой на нашу [Справочную документацию][reference],
+в которой более подробно рассматриваются многие новые функции языка Scala.
+
+
+ Если вас интересует заархивированное издание книги для Scala 2,
+доступ к нему можно получить здесь.
+В настоящее время мы находимся в процессе слияния двух книг, и вы можете нам помочь.
+
+
+В этой книге мы надеемся продемонстрировать, что Scala — это красивый, выразительный язык программирования с чистым современным синтаксисом,
+который поддерживает и функциональное программирование (ФП), и объектно-ориентированное программирование (ООП),
+а также обеспечивает безопасную статическую систему типов.
+Синтаксис, грамматика и функции Scala были переосмыслены, открыто обсуждались и были обновлены в 2020 году,
+чтобы стать яснее и проще для понимания, чем когда-либо прежде.
+
+Книга начинается с беглого обзора возможностей Scala в [разделе “Почувствуй Scala”][taste].
+После этого обзора в следующих разделах содержится более подробная информация о рассмотренных языковых функциях.
+
+[reference]: {{ site.scala3ref }}/overview.html
+[taste]: {% link _overviews/scala3-book/taste-intro.md %}
diff --git a/_ru/scala3/book/scala-features.md b/_ru/scala3/book/scala-features.md
new file mode 100644
index 0000000000..f1eab830aa
--- /dev/null
+++ b/_ru/scala3/book/scala-features.md
@@ -0,0 +1,487 @@
+---
+layout: multipage-overview
+title: Возможности Scala
+scala3: true
+partof: scala3-book
+overview-name: "Scala 3 — Book"
+type: chapter
+description: На этой странице рассматриваются основные возможности языка программирования Scala.
+language: ru
+num: 2
+previous-page: introduction
+next-page: why-scala-3
+---
+
+
+Название _Scala_ происходит от слова _scalable_, и в соответствии с этим названием язык Scala используется для
+поддержки загруженных веб-сайтов и анализа огромных наборов данных.
+В этом разделе представлены функции, которые делают Scala масштабируемым языком.
+Эти функции разделены на три раздела:
+
+- Функции высокоуровневого языка программирования
+- Функции низкоуровневого языка программирования
+- Особенности экосистемы Scala
+
+
+
+## Высокоуровневые функции
+
+Глядя на Scala с пресловутого “вида с высоты 30 000 фунтов”, вы можете сделать о нем следующие утверждения:
+
+- Это высокоуровневый язык программирования
+- Он имеет краткий, читаемый синтаксис
+- Он статически типизирован (но кажется динамичным)
+- Имеет выразительную систему типов
+- Это язык функционального программирования (ФП)
+- Это язык объектно-ориентированного программирования (ООП)
+- Он поддерживает слияние ФП и ООП
+- Контекстные абстракции обеспечивают понятный способ реализации _вывода терминов_ (_term inference_)
+- Он работает на JVM (и в браузере)
+- Беспрепятственно взаимодействует с Java кодом
+- Он используется для серверных приложений (включая микросервисы), приложений для работы с большими данными, а также может использоваться в браузере с помощью Scala.js
+
+Эти функции кратко рассматриваются в следующих разделах.
+
+
+### Высокоуровневый язык
+
+Scala считается высокоуровневым языком как минимум по двум причинам.
+Во-первых, подобно Java и многим другим современным языкам, вы не имеете дело с низкоуровневыми понятиями,
+такими как указатели и управление памятью.
+
+Во-вторых, с использованием лямбда-выражений и функций высшего порядка вы пишете свой код на очень высоком уровне.
+Как говорится в функциональном программировании, в Scala вы пишете то, _что_ хотите, а не то, _как_ этого добиться.
+То есть мы не пишем императивный код вот так:
+
+{% tabs scala-features-1 class=tabs-scala-version %}
+{% tab 'Scala 2' for=scala-features-1 %}
+```scala
+import scala.collection.mutable.ListBuffer
+
+def double(ints: List[Int]): List[Int] = {
+ val buffer = new ListBuffer[Int]()
+ for (i <- ints) {
+ buffer += i * 2
+ }
+ buffer.toList
+}
+
+val oldNumbers = List(1, 2, 3)
+val newNumbers = double(oldNumbers)
+```
+{% endtab %}
+{% tab 'Scala 3' for=scala-features-1 %}
+```scala
+import scala.collection.mutable.ListBuffer
+
+def double(ints: List[Int]): List[Int] =
+ val buffer = new ListBuffer[Int]()
+ for i <- ints do
+ buffer += i * 2
+ buffer.toList
+
+val oldNumbers = List(1, 2, 3)
+val newNumbers = double(oldNumbers)
+```
+{% endtab %}
+{% endtabs %}
+
+Этот код шаг за шагом указывает компилятору, что делать.
+Вместо этого мы пишем высокоуровневый функциональный код, используя функции высшего порядка и лямбда-выражения,
+подобные этому, для вычисления того же результата:
+
+{% tabs scala-features-2 %}
+{% tab 'Scala 2 and 3' for=scala-features-2 %}
+```scala
+val newNumbers = oldNumbers.map(_ * 2)
+```
+{% endtab %}
+{% endtabs %}
+
+
+Как видите, этот код намного лаконичнее, его легче читать и легче поддерживать.
+
+
+### Лаконичный синтаксис
+
+Scala имеет краткий, удобочитаемый синтаксис.
+Например, переменные создаются лаконично, а их типы понятны:
+
+{% tabs scala-features-3 %}
+{% tab 'Scala 2 and 3' for=scala-features-3 %}
+```scala
+val nums = List(1,2,3)
+val p = Person("Martin", "Odersky")
+```
+{% endtab %}
+{% endtabs %}
+
+
+Функции высшего порядка и лямбда-выражения делают код кратким и удобочитаемым:
+
+{% tabs scala-features-4 %}
+{% tab 'Scala 2 and 3' for=scala-features-4 %}
+```scala
+nums.map(i => i * 2) // длинная форма
+nums.map(_ * 2) // краткая форма
+
+nums.filter(i => i > 1)
+nums.filter(_ > 1)
+```
+{% endtab %}
+{% endtabs %}
+
+Трэйты, классы и методы определяются с помощью простого и легкого синтаксиса:
+
+{% tabs scala-features-5 class=tabs-scala-version %}
+{% tab 'Scala 2' for=scala-features-5 %}
+```scala mdoc
+trait Animal {
+ def speak(): Unit
+}
+
+trait HasTail {
+ def wagTail(): Unit
+}
+
+class Dog extends Animal with HasTail {
+ def speak(): Unit = println("Woof")
+ def wagTail(): Unit = println("⎞⎜⎛ ⎞⎜⎛")
+}
+```
+{% endtab %}
+{% tab 'Scala 3' for=scala-features-5 %}
+```scala
+trait Animal:
+ def speak(): Unit
+
+trait HasTail:
+ def wagTail(): Unit
+
+class Dog extends Animal, HasTail:
+ def speak(): Unit = println("Woof")
+ def wagTail(): Unit = println("⎞⎜⎛ ⎞⎜⎛")
+```
+{% endtab %}
+{% endtabs %}
+
+
+Исследования показали, что время, которое разработчик тратит на _чтение_ и _написание_ кода, составляет как минимум 10:1,
+поэтому важно писать краткий и читабельный код.
+
+
+### Ощущение динамики
+
+Scala — это язык со статической типизацией, но благодаря своим возможностям вывода типов он кажется динамичным.
+Все эти выражения выглядят как языки с динамической типизацией, такие как Python или Ruby, но это все Scala:
+
+{% tabs scala-features-6 class=tabs-scala-version %}
+{% tab 'Scala 2' for=scala-features-6 %}
+```scala
+val s = "Hello"
+val p = Person("Al", "Pacino")
+val sum = nums.reduceLeft(_ + _)
+val y = for (i <- nums) yield i * 2
+val z = nums
+ .filter(_ > 100)
+ .filter(_ < 10_000)
+ .map(_ * 2)
+```
+{% endtab %}
+{% tab 'Scala 3' for=scala-features-6 %}
+```scala
+val s = "Hello"
+val p = Person("Al", "Pacino")
+val sum = nums.reduceLeft(_ + _)
+val y = for i <- nums yield i * 2
+val z = nums
+ .filter(_ > 100)
+ .filter(_ < 10_000)
+ .map(_ * 2)
+```
+{% endtab %}
+{% endtabs %}
+
+
+Как утверждает Heather Miller, Scala считается [сильным языком со статической типизацией](https://heather.miller.am/blog/types-in-scala.html),
+и вы получаете все преимущества статических типов:
+
+- Корректность: вы обнаруживаете большинство ошибок во время компиляции
+- Отличная поддержка IDE
+ - Надежное автодополнение кода
+ - Отлов ошибок во время компиляции означает отлов ошибок по мере написания
+ - Простой и надежный рефакторинг
+- Вы можете уверенно рефакторить свой код
+- Объявления типов методов сообщают читателям, что делает метод, и помогают служить документацией
+- Масштабируемость и удобство обслуживания: типы помогают обеспечить корректность в произвольно больших приложениях и командах разработчиков
+- Строгая типизация в сочетании с превосходным выводом типов позволяет использовать такие механизмы, как [контекстная абстракция]({{ site.scala3ref }}/contextual), которая позволяет вам опускать шаблонный код. Часто этот шаблонный код может быть выведен компилятором на основе определений типов и заданного контекста.
+
+
+### Выразительная система типов
+
+Система типов в Scala во время компиляции обеспечивает безопасное и согласованное использование абстракций.
+В частности, система типов поддерживает:
+
+- [Выводимые типы]({% link _overviews/scala3-book/types-inferred.md %})
+- [Generic классы]({% link _overviews/scala3-book/types-generics.md %})
+- [Аннотации вариантности]({% link _overviews/scala3-book/types-variance.md %})
+- [Верхняя](/tour/upper-type-bounds.html) и [нижняя](/tour/lower-type-bounds.html) границы типов
+- [Полиморфные методы](/tour/polymorphic-methods.html)
+- [Типы пересечения]({% link _overviews/scala3-book/types-intersection.md %})
+- [Типы объединения]({% link _overviews/scala3-book/types-union.md %})
+- [Лямбда-типы]({{ site.scala3ref }}/new-types/type-lambdas.html)
+- [Экземпляры `given` и предложения `using`]({% link _overviews/scala3-book/ca-given-using-clauses.md %})
+- [Методы расширения]({% link _overviews/scala3-book/ca-extension-methods.md %})
+- [Типовые классы]({% link _overviews/scala3-book/ca-type-classes.md %})
+- [Многостороннее равенство]({% link _overviews/scala3-book/ca-multiversal-equality.md %})
+- [Псевдонимы непрозрачного типа]({% link _overviews/scala3-book/types-opaque-types.md %})
+- [Открытые классы]({{ site.scala3ref }}/other-new-features/open-classes.html)
+- [Типы соответствия]({{ site.scala3ref }}/new-types/match-types.html)
+- [Зависимые типы функций]({{ site.scala3ref }}/new-types/dependent-function-types.html)
+- [Полиморфные функциональные типы]({{ site.scala3ref }}/new-types/polymorphic-function-types.html)
+- [Контекстные границы]({{ site.scala3ref }}/contextual/context-bounds.html)
+- [Контекстные функции]({{ site.scala3ref }}/contextual/context-functions.html)
+- [Внутренние классы](/tour/inner-classes.html) и [элементы абстрактного типа](/tour/abstract-type-members.html) как элементы объекта
+
+В сочетании эти функции обеспечивают мощную основу для безопасного повторного использования программных абстракций
+и для безопасного расширения программного обеспечения.
+
+
+### Язык функционального программирования
+
+Scala — это язык функционального программирования (ФП), что означает:
+
+- Функции — это значения, и их можно передавать, как и любое другое значение
+- Напрямую поддерживаются функции высшего порядка
+- Встроенные лямбда
+- Все в Scala — это выражение, возвращающее значение
+- Синтаксически легко использовать неизменяемые переменные, и их использование приветствуется
+- В стандартной библиотеке языка содержится множество неизменяемых классов коллекций
+- Эти классы коллекций поставляются с десятками функциональных методов: они не изменяют коллекцию, вместо этого возвращая обновленную копию данных
+
+
+### Объектно-ориентированный язык
+
+Scala — это язык объектно-ориентированного программирования (ООП).
+Каждое значение — это экземпляр класса, а каждый “оператор” — это метод.
+
+В Scala все типы наследуются от класса верхнего уровня `Any`, чьими непосредственными дочерними элементами являются `AnyVal` (_типы значений_, такие как `Int` и `Boolean`) и `AnyRef` (_ссылочные типы_, как в Java).
+Это означает, что различие в Java между примитивными и упакованными типами (например, `int` против `Integer`) отсутствует в Scala.
+Упаковка и распаковка полностью прозрачны для пользователя.
+
+
+### Поддерживает слияние ФП/ООП
+
+
+Суть Scala заключается в слиянии функционального программирования и объектно-ориентированного программирования в типизированной среде:
+
+- Функции для логики
+- Объекты для модульности
+
+[Как заявил Мартин Одерски](https://jaxenter.com/current-state-scala-odersky-interview-129495.html), “Scala был разработан, чтобы показать, что слияние функционального и объектно-ориентированного программирования возможно и практично”.
+
+
+### Вывод терминов стал более понятным
+
+После Haskell Scala был вторым популярным языком, в котором была некоторая форма неявных (_implicits_) выражений.
+В Scala 3 эти концепции были полностью переосмыслены и реализованы более четко.
+
+Основная идея заключается в _выводе терминов_: на основе заданного, компилятор синтезирует “канонический” термин, который имеет этот тип.
+В Scala параметр контекста напрямую ведет к выводимому термину аргумента, который также может быть записан явно.
+
+Примеры использования этой концепции включают реализацию [типовых классов]({% link _overviews/scala3-book/ca-type-classes.md %}),
+установление контекста, внедрение зависимостей, выражение возможностей, вычисление новых типов и доказательство отношений между ними.
+
+Scala 3 делает этот процесс более понятным, чем когда-либо прежде.
+О контекстных абстракциях можно прочесть в [Справочной документации]({{ site.scala3ref }}/contextual).
+
+
+### Клиент & сервер
+
+Код Scala работает на виртуальной машине Java (JVM), поэтому вы получаете все ее преимущества:
+
+- Безопасность
+- Производительность
+- Управление памятью
+- Портативность и независимость от платформы
+- Возможность использовать множество существующих Java и JVM библиотек
+
+Помимо работы на JVM, Scala также работает в браузере с помощью Scala.js (и сторонних инструментов с открытым исходным кодом для интеграции популярных библиотек JavaScript), а собственные исполняемые файлы могут быть созданы с помощью Scala Native и GraalVM.
+
+
+### Беспрепятственное взаимодействие с Java
+
+Вы можете использовать Java классы и библиотеки в своих приложениях Scala, а также код Scala в приложениях Java.
+Что касается второго пункта, большие библиотеки, такие как [Akka](https://akka.io) и [Play Framework](https://www.playframework.com) написаны на Scala и могут использоваться в приложениях Java.
+
+Что касается первого пункта, классы и библиотеки Java используются в приложениях Scala каждый день.
+Например, в Scala вы можете читать файлы с помощью `BufferedReader` и `FileReader` из Java:
+
+{% tabs scala-features-7 %}
+{% tab 'Scala 2 and 3' for=scala-features-7 %}
+```scala
+import java.io.*
+val br = BufferedReader(FileReader(filename))
+// чтение файла в `br` ...
+```
+{% endtab %}
+{% endtabs %}
+
+Использование Java-кода в Scala, как правило, не вызывает затруднений.
+
+В Scala также можно использовать коллекции Java, и если вы хотите использовать с ними богатый набор методов классов коллекций Scala,
+то можете преобразовать их с помощью всего нескольких строк кода:
+
+{% tabs scala-features-8 %}
+{% tab 'Scala 2 and 3' for=scala-features-8 %}
+```scala
+import scala.jdk.CollectionConverters.*
+val scalaList: Seq[Integer] = JavaClass.getJavaList().asScala.toSeq
+```
+{% endtab %}
+{% endtabs %}
+
+
+### Богатство библиотек
+
+Как будет видно в третьем разделе этой страницы, библиотеки и фреймворки Scala, подобные нижеследующим,
+были написаны для поддержки загруженных веб-сайтов и работы с огромными наборами данных:
+
+1. [Play Framework](https://www.playframework.com) — это легкая, без сохранения состояния, удобная для web, удобная для разработчиков архитектура для создания масштабируемых приложений
+2. [Lagom](https://www.lagomframework.com) — это инфраструктура микросервисов, которая помогает разделить устаревший монолит и создавать, тестировать и развертывать целые системы реактивных микросервисов
+3. [Apache Spark](https://spark.apache.org) — это унифицированный аналитический механизм для обработки больших данных со встроенными модулями для потоковой передачи, SQL, машинного обучения и обработки графиков
+
+В [списке Awesome Scala](https://github.com/lauris/awesome-scala) представлены десятки дополнительных инструментов
+с открытым исходным кодом, созданных разработчиками для создания приложений Scala.
+
+В дополнение к программированию на стороне сервера, [Scala.js](https://www.scala-js.org) представляет собой
+строго типизированную замену для написания JavaScript со сторонними библиотеками с открытым исходным кодом,
+которые включают инструменты для интеграции с библиотекой Facebook React, jQuery и т.д.
+
+
+## Функции низкоуровневого языка
+
+Хотя в предыдущем разделе были рассмотрены высокоуровневые функции Scala, интересно отметить,
+что на высоком уровне вы можете делать одни и те же утверждения как о Scala 2, так и о Scala 3.
+Десять лет назад Scala начиналась с прочного фундамента желаемых функций, и вы увидите в этом разделе,
+что в Scala 3 эти преимущества были улучшены.
+
+С точки зрения деталей “на уровне моря” — то есть функций языка, которые программисты используют каждый день —
+Scala 3 имеет значительные преимущества по сравнению со Scala 2:
+
+- Возможность более лаконично создавать алгебраические типы данных (ADT) с перечислениями
+- Еще более лаконичный и читаемый синтаксис:
+ - Синтаксис “тихой” структуры управления легче читать
+ - Опциональные фигурные скобки
+ - Меньшее количество символов в коде создает меньше визуального шума, что упрощает его чтение
+ - Ключевое слово `new` обычно больше не требуется при создании экземпляров класса
+ - Формальность объектов пакета была заменена более простыми определениями “верхнего уровня”
+- Более понятная грамматика:
+ - Несколько различных вариантов использования ключевого слова `implicit` были удалены; это использование заменено более очевидными ключевыми словами, такими как `given`, `using`, и `extension`, фокусирующихся на намерении, а не механизме (подробности см. в разделе [Givens][givens])
+ - [Методы расширения][extension] заменяют неявные классы более понятным и простым механизмом
+ - Добавление модификатора `open` для классов заставляет разработчика намеренно объявить, что класс открыт для модификации, тем самым ограничивая специальные расширения кодовой базы
+ - [Многостороннее равенство][multiversal] исключает бессмысленные сравнения с `==` и `!=` (т.е. попытки сравнить `Person` с `Planet`)
+ - Гораздо проще реализуются макросы
+ - Объединение и пересечение предлагают гибкий способ моделирования типов
+ - Параметры трейтов заменяют и упрощают ранние инициализаторы
+ - [Псевдонимы непрозрачных типов][opaque_types] заменяют большинство случаев использования классов значений, гарантируя при этом отсутствие упаковки
+ - Export предложения обеспечивают простой и общий способ выражения агрегации, который может заменить предыдущий шаблон фасада объектов пакета, наследуемых от классов
+ - Синтаксис procedure был удален, а синтаксис varargs - изменен, чтобы сделать язык более согласованным
+ - `@infix` аннотация делает очевидным желаемое применение метода
+ - Аннотация метода [`@targetName`]({{ site.scala3ref }}/other-new-features/targetName.html) определяет альтернативное имя метода, улучшая совместимость с Java и позволяя указывать псевдонимы для символических операторов
+
+Демонстрация всех этих функций заняла бы слишком много места, но перейдите по ссылкам в пунктах выше, чтобы увидеть эти функции в действии.
+Все эти функции подробно обсуждаются на страницах *New*, *Changed* и *Dropped* функций в [обзорной документации][reference].
+
+
+## Экосистема Scala
+
+
+У Scala динамичная экосистема с библиотеками и фреймворками под любые требования.
+[Список “Awesome Scala”](https://github.com/lauris/awesome-scala) содержит список сотен проектов с открытым исходным кодом,
+доступных разработчикам Scala, а [Scaladex](https://index.scala-lang.org) предоставляет доступный для поиска индекс библиотек Scala.
+Некоторые из наиболее известных библиотек перечислены ниже.
+
+
+
+### Web разработка
+
+- [Play Framework](https://www.playframework.com) следует модели Ruby on Rails, чтобы стать легкой, не сохраняющей состояния,
+ удобной для разработчиков и web архитектурой для высокомасштабируемых приложений
+- [Scalatra](https://scalatra.org) — небольшой высокопроизводительный асинхронный web framework, вдохновленный Sinatra
+- [Finatra](https://twitter.github.io/finatra) — это сервисы Scala, построенные на TwitterServer и Finagle
+- [Scala.js](https://www.scala-js.org) — это строго типизированная замена JavaScript, обеспечивающая более безопасный способ создания надежных интерфейсных web-приложений
+- [ScalaJs-React](https://github.com/japgolly/scalajs-react) поднимает библиотеку Facebook React на Scala.js и пытается сделать ее максимально безопасной для типов и удобной для Scala
+- [Lagom](https://www.lagomframework.com) — это инфраструктура микросервисов, которая помогает разделить устаревший монолит и создавать, тестировать и развертывать целые системы реактивных микросервисов
+
+
+HTTP(S) библиотеки:
+
+- [Akka-http](https://akka.io)
+- [Finch](https://github.com/finagle/finch)
+- [Http4s](https://github.com/http4s/http4s)
+- [Sttp](https://github.com/softwaremill/sttp)
+
+JSON библиотеки:
+
+- [Argonaut](https://github.com/argonaut-io/argonaut)
+- [Circe](https://github.com/circe/circe)
+- [Json4s](https://github.com/json4s/json4s)
+- [Play-JSON](https://github.com/playframework/play-json)
+
+Сериализация:
+
+- [ScalaPB](https://github.com/scalapb/ScalaPB)
+
+### Наука и анализ данных:
+
+- [Algebird](https://github.com/twitter/algebird)
+- [Spire](https://github.com/typelevel/spire)
+- [Squants](https://github.com/typelevel/squants)
+
+
+### Большие данные
+
+- [Apache Spark](https://github.com/apache/spark)
+- [Apache Flink](https://github.com/apache/flink)
+
+
+### ИИ, машинное обучение
+
+- [BigDL](https://github.com/intel-analytics/BigDL) (Распределенная среда глубокого обучения для Apache Spark)
+- [TensorFlow Scala](https://github.com/eaplatanios/tensorflow_scala)
+
+
+### Функциональное программирование & Функциональное реактивное программирование
+
+ФП:
+
+- [Cats](https://github.com/typelevel/cats)
+- [Zio](https://github.com/zio/zio)
+
+Функциональное реактивное программирование (ФРП):
+
+- [fs2](https://github.com/typelevel/fs2)
+- [monix](https://github.com/monix/monix)
+
+
+### Инструменты сборки
+
+- [sbt](https://www.scala-sbt.org)
+- [Gradle](https://gradle.org)
+- [Mill](https://github.com/lihaoyi/mill)
+
+
+
+## Подведем итоги
+
+Как показано на этой странице, Scala обладает множеством замечательных функций высокоуровневого языка программирования,
+низкоуровневого языка программирования и богатой экосистемой разработчиков.
+
+
+[reference]: {{ site.scala3ref }}/overview.html
+[multiversal]: {% link _overviews/scala3-book/ca-multiversal-equality.md %}
+[extension]: {% link _overviews/scala3-book/ca-extension-methods.md %}
+[givens]: {% link _overviews/scala3-book/ca-given-using-clauses.md %}
+[opaque_types]: {% link _overviews/scala3-book/types-opaque-types.md %}
+
diff --git a/_ru/scala3/book/taste-hello-world.md b/_ru/scala3/book/taste-hello-world.md
new file mode 100644
index 0000000000..1a029de9ef
--- /dev/null
+++ b/_ru/scala3/book/taste-hello-world.md
@@ -0,0 +1,205 @@
+---
+layout: multipage-overview
+title: Пример 'Hello, World!'
+scala3: true
+partof: scala3-book
+overview-name: "Scala 3 — Book"
+type: chapter
+description: В этом примере демонстрируется пример 'Hello, World!' на Scala 3.
+language: ru
+num: 5
+previous-page: taste-intro
+next-page:
+---
+
+> **Подсказка**: в следующих примерах попробуйте выбрать предпочтительную для вас версию Scala.
+>
+
+## Ваша первая Scala-программа
+
+
+Пример “Hello, World!” на Scala выглядит следующим образом.
+Сначала поместите этот код в файл с именем _hello.scala_:
+
+
+{% tabs hello-world-demo class=tabs-scala-version %}
+
+{% tab 'Scala 2' for=hello-world-demo %}
+```scala
+object hello {
+ def main(args: Array[String]) = {
+ println("Hello, World!")
+ }
+}
+```
+> В этом коде мы определили метод с именем `main` внутри Scala `object`-а с именем `hello`.
+> `object` в Scala похож на `class`, но определяет экземпляр singleton, который можно передать.
+> `main` принимает входной параметр с именем `args`, который должен иметь тип `Array[String]`
+> (`args` пока можно игнорировать).
+
+{% endtab %}
+
+{% tab 'Scala 3' for=hello-world-demo %}
+```scala
+@main def hello() = println("Hello, World!")
+```
+> В этом коде `hello` - это метод.
+> Он определяется с помощью `def` и объявляется в качестве основного метода с помощью аннотации `@main`.
+> Он выводит строку "Hello, World!" на стандартный вывод (STDOUT) с помощью метода `println`.
+
+{% endtab %}
+
+{% endtabs %}
+
+
+Затем скомпилируйте код с помощью `scalac`:
+
+```bash
+$ scalac hello.scala
+```
+
+Если вы переходите на Scala с Java: `scalac` похоже на `javac`, эта команда создает несколько файлов:
+
+
+{% tabs hello-world-outputs class=tabs-scala-version %}
+
+{% tab 'Scala 2' for=hello-world-outputs %}
+```bash
+$ ls -1
+hello$.class
+hello.class
+hello.scala
+```
+{% endtab %}
+
+{% tab 'Scala 3' for=hello-world-outputs %}
+```bash
+$ ls -1
+hello$package$.class
+hello$package.class
+hello$package.tasty
+hello.scala
+hello.class
+hello.tasty
+```
+{% endtab %}
+
+{% endtabs %}
+
+
+Как и Java, файлы _.class_ представляют собой файлы байт-кода, и они готовы к запуску в JVM.
+
+Теперь вы можете запустить метод `hello` командой `scala`:
+
+```bash
+$ scala hello
+Hello, World!
+```
+
+Если запуск прошел успешно, поздравляем, вы только что скомпилировали и запустили свое первое приложение Scala.
+
+> Дополнительную информацию о sbt и других инструментах, упрощающих разработку на Scala, можно найти в главе [Инструменты Scala][scala_tools].
+
+## Запрос пользовательского ввода
+
+В нашем следующем примере давайте спросим имя пользователя, прежде чем приветствовать его!
+
+Есть несколько способов прочитать ввод из командной строки, но самый простой способ —
+использовать метод `readLine` из объекта _scala.io.StdIn_.
+Чтобы использовать этот метод, вам нужно сначала его импортировать, например:
+
+{% tabs import-readline %}
+{% tab 'Scala 2 and 3' for=import-readline %}
+```scala
+import scala.io.StdIn.readLine
+```
+{% endtab %}
+{% endtabs %}
+
+Чтобы продемонстрировать, как это работает, давайте создадим небольшой пример.
+Поместите этот исходный код в файл с именем _helloInteractive.scala_:
+
+
+{% tabs hello-world-interactive class=tabs-scala-version %}
+
+{% tab 'Scala 2' for=hello-world-interactive %}
+```scala
+import scala.io.StdIn.readLine
+
+object helloInteractive {
+
+ def main(args: Array[String]) = {
+ println("Please enter your name:")
+ val name = readLine()
+
+ println("Hello, " + name + "!")
+ }
+
+}
+```
+{% endtab %}
+
+{% tab 'Scala 3' for=hello-world-interactive %}
+```scala
+import scala.io.StdIn.readLine
+
+@main def helloInteractive() =
+ println("Please enter your name:")
+ val name = readLine()
+
+ println("Hello, " + name + "!")
+```
+{% endtab %}
+
+{% endtabs %}
+
+
+В этом коде мы сохраняем результат из `readLine` в переменную с именем `name`,
+затем используем оператор над строками `+` для соединения `"Hello, "` с `name` и `"!"`, создавая одно единственное строковое значение.
+
+> Вы можете узнать больше об использовании val, прочитав главу [Переменные и типы данных](/scala3/book/taste-vars-data-types.html).
+
+Затем скомпилируйте код с помощью `scalac`:
+
+```bash
+$ scalac helloInteractive.scala
+```
+
+Затем запустите его с помощью `scala helloInteractive`. На этот раз программа сделает паузу после запроса вашего имени
+и подождет, пока вы не наберете имя и не нажмете клавишу возврата на клавиатуре.
+Выглядит это так:
+
+```bash
+$ scala helloInteractive
+Please enter your name:
+▌
+```
+
+Когда вы вводите свое имя в "приглашении", окончательное взаимодействие должно выглядеть так:
+
+```bash
+$ scala helloInteractive
+Please enter your name:
+Alvin Alexander
+Hello, Alvin Alexander!
+```
+
+### Примечание об импорте
+
+Как вы ранее видели, иногда определенные методы или другие типы определений, которые мы увидим позже, недоступны,
+если вы не используете подобное предложение `import`:
+
+{% tabs import-readline-2 %}
+{% tab 'Scala 2 and 3' for=import-readline-2 %}
+```scala
+import scala.io.StdIn.readLine
+```
+{% endtab %}
+{% endtabs %}
+
+Импорт помогает писать и распределять код несколькими способами:
+ - вы можете поместить код в несколько файлов, чтобы избежать беспорядка и облегчить навигацию в больших проектах.
+ - вы можете использовать библиотеку кода, возможно, написанную кем-то другим, которая имеет полезную функциональность.
+ - вы видите, откуда берется определенное определение (особенно если оно не было записано в текущем файле).
+
+[scala_tools]: {% link _overviews/scala3-book/scala-tools.md %}
diff --git a/_ru/scala3/book/taste-intro.md b/_ru/scala3/book/taste-intro.md
new file mode 100644
index 0000000000..16b484daa8
--- /dev/null
+++ b/_ru/scala3/book/taste-intro.md
@@ -0,0 +1,31 @@
+---
+layout: multipage-overview
+title: Почувствуй Scala
+scala3: true
+partof: scala3-book
+overview-name: "Scala 3 — Book"
+type: chapter
+description: В этой главе представлен общий обзор основных возможностей языка программирования Scala 3.
+language: ru
+num: 4
+previous-page: why-scala-3
+next-page: taste-hello-world
+---
+
+
+В этой главе представлен краткий обзор основных возможностей языка программирования Scala 3.
+После начального ознакомления остальная часть книги содержит более подробную информацию об описанных функциях,
+а [справочная документация][reference] содержит массу подробностей.
+
+## Настройка Скала
+
+На протяжении этой главы и остальной части книги мы рекомендуем вам пробовать примеры, скопировав их или набрав вручную.
+Инструменты, необходимые для работы с примерами на вашем компьютере, можно установить,
+следуя нашему [руководству для началы работы со Scala][get-started].
+
+> В качестве альтернативы вы можете запустить примеры в веб-браузере с помощью [Scastie](https://scastie.scala-lang.org),
+> полного онлайн-редактора и исполнителя кода для Scala.
+
+
+[reference]: {{ site.scala3ref }}/overview.html
+[get-started]: {% link _getting-started/index.md %}
diff --git a/_ru/scala3/book/why-scala-3.md b/_ru/scala3/book/why-scala-3.md
new file mode 100644
index 0000000000..3a8efd51f3
--- /dev/null
+++ b/_ru/scala3/book/why-scala-3.md
@@ -0,0 +1,492 @@
+---
+layout: multipage-overview
+title: Почему Scala 3?
+scala3: true
+partof: scala3-book
+overview-name: "Scala 3 — Book"
+type: chapter
+description: На этой странице описаны преимущества языка программирования Scala 3.
+language: ru
+num: 3
+previous-page: scala-features
+next-page: taste-intro
+---
+
+Использование Scala, и Scala 3 в частности, дает много преимуществ.
+Трудно перечислить их все, но “топ десять” может выглядеть так:
+
+1. Scala сочетает в себе функциональное программирование (ФП) и объектно-ориентированное программирование (ООП)
+2. Scala статически типизирован, но часто ощущается как язык с динамической типизацией
+3. Синтаксис Scala лаконичен, но все же удобочитаем; его часто называют _выразительным_
+4. _Implicits_ в Scala 2 были определяющей функцией, а в Scala 3 они были улучшены и упрощены
+5. Scala легко интегрируется с Java, поэтому вы можете создавать проекты со смешанным кодом Scala и Java, а код Scala легко использует тысячи существующих библиотек Java
+6. Scala можно использовать на сервере, а также в браузере со [Scala.js](https://www.scala-js.org)
+7. Стандартная библиотека Scala содержит десятки готовых функциональных методов, позволяющих сэкономить ваше время и значительно сократить потребность в написании пользовательских циклов `for` и алгоритмов
+8. “Best practices”, встроенные в Scala, поддерживают неизменность, анонимные функции, функции высшего порядка, сопоставление с образцом, классы, которые не могут быть расширены по умолчанию, и многое другое
+9. Экосистема Scala предлагает самые современные ФП библиотеки в мире
+10. Сильная система типов
+
+
+## 1) Слияние ФП/ООП
+
+Больше, чем любой другой язык, Scala поддерживает слияние парадигм ФП и ООП.
+Как заявил Мартин Одерски, сущность Scala — это слияние функционального и объектно-ориентированного программирования в типизированной среде, где:
+
+- Функции для логики
+- Объекты для модульности
+
+Возможно, одними из лучших примеров модульности являются классы стандартной библиотеки.
+Например, `List` определяется как класс---технически это абстрактный класс---и новый экземпляр создается следующим образом:
+
+{% tabs list %}
+{% tab 'Scala 2 and 3' for=list %}
+```scala
+val x = List(1, 2, 3)
+```
+{% endtab %}
+{% endtabs %}
+
+Однако то, что кажется программисту простым `List`, на самом деле построено из комбинации нескольких специализированных типов,
+включая трейты с именами `Iterable`, `Seq` и `LinearSeq`.
+Эти типы также состоят из других небольших модульных единиц кода.
+
+В дополнение к построению типа наподобие `List` из серии модульных трейтов,
+`List` API также состоит из десятков других методов, многие из которых являются функциями высшего порядка:
+
+{% tabs list-methods %}
+{% tab 'Scala 2 and 3' for=list-methods %}
+```scala
+val xs = List(1, 2, 3, 4, 5)
+
+xs.map(_ + 1) // List(2, 3, 4, 5, 6)
+xs.filter(_ < 3) // List(1, 2)
+xs.find(_ > 3) // Some(4)
+xs.takeWhile(_ < 3) // List(1, 2)
+```
+{% endtab %}
+{% endtabs %}
+
+В этих примерах значения в списке не могут быть изменены.
+Класс `List` неизменяем, поэтому все эти методы возвращают новые значения, как показано в каждом комментарии.
+
+## 2) Ощущение динамики
+
+_Вывод типов_ (_type inference_) в Scala часто заставляет язык чувствовать себя динамически типизированным, даже если он статически типизирован.
+Это верно для объявления переменной:
+
+{% tabs dynamic %}
+{% tab 'Scala 2 and 3' for=dynamic %}
+```scala
+val a = 1
+val b = "Hello, world"
+val c = List(1,2,3,4,5)
+val stuff = ("fish", 42, 1_234.5)
+```
+{% endtab %}
+{% endtabs %}
+
+Это также верно при передаче анонимных функций функциям высшего порядка:
+
+{% tabs dynamic-hof %}
+{% tab 'Scala 2 and 3' for=dynamic-hof %}
+```scala
+list.filter(_ < 4)
+list.map(_ * 2)
+list.filter(_ < 4)
+ .map(_ * 2)
+```
+{% endtab %}
+{% endtabs %}
+
+и при определении методов:
+
+{% tabs dynamic-method %}
+{% tab 'Scala 2 and 3' for=dynamic-method %}
+```scala
+def add(a: Int, b: Int) = a + b
+```
+{% endtab %}
+{% endtabs %}
+
+Это как никогда верно для Scala 3, например, при использовании [типов объединения][union-types]:
+
+{% tabs union %}
+{% tab 'Scala 3 Only' for=union %}
+```scala
+// параметр типа объединения
+def help(id: Username | Password) =
+ val user = id match
+ case Username(name) => lookupName(name)
+ case Password(hash) => lookupPassword(hash)
+ // дальнейший код ...
+
+// значение типа объединения
+val b: Password | Username = if (true) name else password
+```
+{% endtab %}
+{% endtabs %}
+
+## 3) Лаконичный синтаксис
+
+Scala — это неформальный, “краткий, но все же читабельный“ язык. Например, объявление переменной лаконично:
+
+{% tabs concise %}
+{% tab 'Scala 2 and 3' for=concise %}
+```scala
+val a = 1
+val b = "Hello, world"
+val c = List(1,2,3)
+```
+{% endtab %}
+{% endtabs %}
+
+Создание типов, таких как трейты, классы и перечисления, является кратким:
+
+{% tabs enum %}
+{% tab 'Scala 3 Only' for=enum %}
+```scala
+trait Tail:
+ def wagTail(): Unit
+ def stopTail(): Unit
+
+enum Topping:
+ case Cheese, Pepperoni, Sausage, Mushrooms, Onions
+
+class Dog extends Animal, Tail, Legs, RubberyNose
+
+case class Person(
+ firstName: String,
+ lastName: String,
+ age: Int
+)
+```
+{% endtab %}
+{% endtabs %}
+
+Функции высшего порядка кратки:
+
+{% tabs list-hof %}
+{% tab 'Scala 2 and 3' for=list-hof %}
+
+```scala
+list.filter(_ < 4)
+list.map(_ * 2)
+```
+{% endtab %}
+{% endtabs %}
+
+Все эти и многие другие выражения кратки и при этом очень удобочитаемы: то, что мы называем _выразительным_ (_expressive_).
+
+## 4) Implicits, упрощение
+
+Implicits в Scala 2 были главной отличительной особенностью дизайна.
+Они представляли собой фундаментальный способ абстрагирования от контекста с единой парадигмой,
+обслуживающей множество вариантов использования, среди которых:
+
+- Реализация [типовых классов]({% link _overviews/scala3-book/ca-type-classes.md %})
+- Установление контекста
+- Внедрение зависимости
+- Выражение возможностей
+
+С тех пор другие языки внедрили аналогичные концепции, все из которых являются вариантами основной идеи _вывода терминов_:
+при заданном типе компилятор синтезирует “канонический” термин этого типа.
+
+Хотя implicits были определяющей функцией в Scala 2, их дизайн был значительно улучшен в Scala 3:
+
+- Есть единственный способ определить значения “given”
+- Есть единственный способ ввести неявные параметры и аргументы
+- Есть отдельный способ импорта givens, который не позволяет им потеряться в море обычного импорта
+- Существует единственный способ определить неявное преобразование, которое четко обозначено как таковое и не требует специального синтаксиса
+
+К преимуществам этих изменений относятся:
+
+- Новый дизайн позволяет избежать взаимодействия функциональностей и делает язык более согласованным
+- Это делает implicits более простыми для изучения и более сложными для злоупотребления
+- Это значительно улучшает ясность 95% программ Scala, использующих implicits
+- У него есть потенциал, чтобы сделать вывод терминов принципиальным способом, который также доступен и удобен
+
+Эти возможности подробно расписаны в соответствующих разделах, таких как [введение в контекстную абстракцию][contextual], а также раздел о [`given` и предложениях `using`][given] для получения более подробной информации.
+
+## 5) Полная интеграция с Java
+
+Взаимодействие между Scala и Java не вызывает затруднений во многих ситуациях.
+Например:
+
+- Вы можете использовать все тысячи библиотек Java, доступных в ваших проектах Scala
+- Scala `String` — это, по сути, Java `String` с дополнительными возможностями
+- Scala легко использует классы даты/времени из Java пакета *java.time._*
+
+Вы также можете использовать классы коллекций Java в Scala, а для придания им большей функциональности Scala включает методы,
+позволяющие преобразовывать их в коллекции Scala.
+
+Несмотря на то, что почти каждое взаимодействие является бесшовным,
+в [главе “Взаимодействие с Java”][java] показано, как лучше использовать некоторые функции вместе,
+в том числе как использовать:
+
+- Коллекции Java в Scala
+- Java `Optional` в Scala
+- Интерфейсы Java в Scala
+- Коллекции Scala в Java
+- Scala `Option` в Java
+- Scala traits в Java
+- Методы Scala, вызывающие исключения в Java коде
+- Scala varargs параметры в Java
+
+Подробнее об этих функциях см. в этой главе.
+
+## 6) Клиент & сервер
+
+Scala можно использовать на стороне сервера с потрясающими фреймворками:
+
+- [Play Framework](https://www.playframework.com) позволяет создавать масштабируемые серверные приложения и микросервисы
+- [Akka Actors](https://akka.io) позволяет использовать модель акторов для значительного упрощения распределенных и параллельных программных приложений
+
+Scala также можно использовать в браузере с [проектом Scala.js](https://www.scala-js.org), который является безопасной заменой JavaScript.
+В экосистеме Scala.js есть [десятки библиотек](https://www.scala-js.org/libraries), позволяющих использовать React, Angular, jQuery
+и многие другие библиотеки JavaScript и Scala в браузере.
+
+В дополнение к этим инструментам проект [Scala Native](https://github.com/scala-native/scala-native)
+“представляет собой оптимизирующий опережающий компилятор и облегченную управляемую среду выполнения, разработанную специально для Scala”.
+Он позволяет создавать бинарные исполняемые приложения в “системном” стиле с помощью простого кода Scala, а также позволяет использовать низкоуровневые примитивы.
+
+## 7) Стандартные библиотечные методы
+
+Вам довольно редко понадобится писать пользовательский цикл `for`,
+потому что десятки готовых функциональных методов в стандартной библиотеке Scala сэкономят ваше время
+и помогут сделать код более согласованным в разных приложениях.
+
+В следующих примерах показаны некоторые из встроенных методов коллекций, а также многие другие.
+Хотя все они используют класс `List`, одни и те же методы работают с другими классами коллекций,
+такими как `Seq`, `Vector`, `LazyList`, `Set`, `Map`, `Array` и `ArrayBuffer`.
+
+Вот некоторые примеры:
+
+{% tabs list-more %}
+{% tab 'Scala 2 and 3' for=list-more %}
+```scala
+List.range(1, 3) // List(1, 2)
+List.range(start = 1, end = 6, step = 2) // List(1, 3, 5)
+List.fill(3)("foo") // List(foo, foo, foo)
+List.tabulate(3)(n => n * n) // List(0, 1, 4)
+List.tabulate(4)(n => n * n) // List(0, 1, 4, 9)
+
+val a = List(10, 20, 30, 40, 10) // List(10, 20, 30, 40, 10)
+a.distinct // List(10, 20, 30, 40)
+a.drop(2) // List(30, 40, 10)
+a.dropRight(2) // List(10, 20, 30)
+a.dropWhile(_ < 25) // List(30, 40, 10)
+a.filter(_ < 25) // List(10, 20, 10)
+a.filter(_ > 100) // List()
+a.find(_ > 20) // Some(30)
+a.head // 10
+a.headOption // Some(10)
+a.init // List(10, 20, 30, 40)
+a.intersect(List(19,20,21)) // List(20)
+a.last // 10
+a.lastOption // Some(10)
+a.map(_ * 2) // List(20, 40, 60, 80, 20)
+a.slice(2, 4) // List(30, 40)
+a.tail // List(20, 30, 40, 10)
+a.take(3) // List(10, 20, 30)
+a.takeRight(2) // List(40, 10)
+a.takeWhile(_ < 30) // List(10, 20)
+a.filter(_ < 30).map(_ * 10) // List(100, 200, 100)
+
+val fruits = List("apple", "pear")
+fruits.map(_.toUpperCase) // List(APPLE, PEAR)
+fruits.flatMap(_.toUpperCase) // List(A, P, P, L, E, P, E, A, R)
+
+val nums = List(10, 5, 8, 1, 7)
+nums.sorted // List(1, 5, 7, 8, 10)
+nums.sortWith(_ < _) // List(1, 5, 7, 8, 10)
+nums.sortWith(_ > _) // List(10, 8, 7, 5, 1)
+```
+{% endtab %}
+{% endtabs %}
+
+## 8) Встроенные "best practices"
+
+Идиомы Scala поощряют "best practices" во многих ситуациях.
+Для неизменяемости рекомендуется создавать неизменяемые val переменные:
+
+{% tabs val %}
+{% tab 'Scala 2 and 3' for=val %}
+```scala
+val a = 1 // неизменяемая переменная
+```
+{% endtab %}
+{% endtabs %}
+
+Вам также рекомендуется использовать неизменяемые классы коллекций, такие как `List` и `Map`:
+
+{% tabs list-map %}
+{% tab 'Scala 2 and 3' for=list-map %}
+```scala
+val b = List(1,2,3) // List неизменяем
+val c = Map(1 -> "one") // Map неизменяема
+```
+{% endtab %}
+{% endtabs %}
+
+Case классы в первую очередь предназначены для использования в [моделировании предметной области]({% link _overviews/scala3-book/domain-modeling-intro.md %}), и их параметры также неизменяемы:
+
+{% tabs case-class %}
+{% tab 'Scala 2 and 3' for=case-class %}
+```scala
+case class Person(name: String)
+val p = Person("Michael Scott")
+p.name // Michael Scott
+p.name = "Joe" // compiler error (переназначение val name)
+```
+{% endtab %}
+{% endtabs %}
+
+Как показано в предыдущем разделе, классы коллекций Scala поддерживают функции высшего порядка,
+и вы можете передавать в них методы (не показаны) и анонимные функции:
+
+{% tabs higher-order %}
+{% tab 'Scala 2 and 3' for=higher-order %}
+```scala
+a.dropWhile(_ < 25)
+a.filter(_ < 25)
+a.takeWhile(_ < 30)
+a.filter(_ < 30).map(_ * 10)
+nums.sortWith(_ < _)
+nums.sortWith(_ > _)
+```
+{% endtab %}
+{% endtabs %}
+
+Выражения `match` позволяют использовать сопоставление с образцом, и они действительно являются _выражениями_, которые возвращают значения:
+
+{% tabs match class=tabs-scala-version %}
+{% tab 'Scala 2' for=match %}
+```scala
+val numAsString = i match {
+ case 1 | 3 | 5 | 7 | 9 => "odd"
+ case 2 | 4 | 6 | 8 | 10 => "even"
+ case _ => "too big"
+}
+```
+{% endtab %}
+
+{% tab 'Scala 3' for=match %}
+```scala
+val numAsString = i match
+ case 1 | 3 | 5 | 7 | 9 => "odd"
+ case 2 | 4 | 6 | 8 | 10 => "even"
+ case _ => "too big"
+```
+{% endtab %}
+{% endtabs %}
+
+Поскольку они могут возвращать значения, их часто используют в качестве тела метода:
+
+{% tabs match-body class=tabs-scala-version %}
+{% tab 'Scala 2' for=match-body %}
+```scala
+def isTruthy(a: Matchable) = a match {
+ case 0 | "" => false
+ case _ => true
+}
+```
+{% endtab %}
+
+{% tab 'Scala 3' for=match-body %}
+```scala
+def isTruthy(a: Matchable) = a match
+ case 0 | "" => false
+ case _ => true
+```
+{% endtab %}
+{% endtabs %}
+
+## 9) Библиотеки экосистемы
+
+Библиотеки Scala для функционального программирования, такие как [Cats](https://typelevel.org/cats) и [Zio](https://zio.dev),
+являются передовыми библиотеками в сообществе ФП.
+Об этих библиотеках можно сказать все модные словечки, такие как высокопроизводительная, типобезопасная, параллельная, асинхронная, ресурсобезопасная, тестируемая, функциональная, модульная, бинарно-совместимая, эффективная, эффектная и т.д.
+
+Мы могли бы перечислить здесь сотни библиотек, но, к счастью, все они перечислены в другом месте: подробности см. в списке [“Awesome Scala”](https://github.com/lauris/awesome-scala).
+
+## 10) Сильная система типов
+
+В Scala есть сильная система типов, и она была еще больше улучшена в Scala 3.
+Цели Scala 3 были определены на раннем этапе, и к ним относятся:
+
+- Упрощение
+- Устранение несоответствий
+- Безопасность
+- Эргономика
+- Производительность
+
+_Упрощение_ достигается за счет десятков измененных и удаленных функций.
+Например, изменения перегруженного ключевого слова `implicit` в Scala 2 на термины `given` и `using` в Scala 3 делает язык более понятным, особенно для начинающих разработчиков.
+
+_Устранение несоответствий_ связано с десятками [удаленных функций][dropped], [измененных функций][changed], и [добавленных функций][added] в Scala 3.
+Некоторые из наиболее важных функций в этой категории:
+
+- Типы пересечения
+- Типы объединения
+- Неявные функциональные типы
+- Зависимые функциональные типы
+- Параметры трейтов
+- Generic кортежи
+
+_Безопасность_ связана с несколькими новыми и измененными функциями:
+
+- Мультиверсальное равенство
+- Ограничение неявных преобразований
+- Null безопасность
+- Безопасная инициализация
+
+Хорошими примерами _эргономики_ являются перечисления и методы расширения,
+добавленные в Scala 3 довольно удобочитаемым образом:
+
+{% tabs extension %}
+{% tab 'Scala 3 Only' for=extension %}
+```scala
+// перечисления
+enum Color:
+ case Red, Green, Blue
+
+// методы расширения
+extension (c: Circle)
+ def circumference: Double = c.radius * math.Pi * 2
+ def diameter: Double = c.radius * 2
+ def area: Double = math.Pi * c.radius * c.radius
+```
+{% endtab %}
+{% endtabs %}
+
+_Производительность_ относится к нескольким областям.
+Одним из них являются [непрозрачные типы][opaque-types].
+В Scala 2 было несколько попыток создать решения, соответствующие практике проектирования, управляемого предметной областью (DDD),
+когда значениям присваивались более осмысленные типы.
+Эти попытки включали:
+
+- Псевдонимы типов
+- Классы значений
+- Case классы
+
+К сожалению, у всех этих подходов были недостатки, как описано в [SIP непрозрачных типов](https://docs.scala-lang.org/sips/opaque-types.html).
+И наоборот, цель непрозрачных типов, как описано в этом SIP, заключается в том, что “операции с этими типами-оболочками не должны создавать дополнительных накладных расходов во время выполнения, но при этом обеспечивать безопасное использование типов во время компиляции”.
+
+Дополнительные сведения о системе типов см. в [справочной документации][reference].
+
+## Другие замечательные функции
+
+Scala обладает множеством замечательных функций, и выбор Топ-10 может быть субъективным.
+Несколько опросов показали, что разные группы разработчиков ценят разные функции.
+Надеемся, вы откроете для себя больше замечательных возможностей Scala по мере использования языка.
+
+[java]: {% link _overviews/scala3-book/interacting-with-java.md %}
+[given]: {% link _overviews/scala3-book/ca-given-using-clauses.md %}
+[contextual]: {% link _overviews/scala3-book/ca-contextual-abstractions-intro.md %}
+[reference]: {{ site.scala3ref }}
+[dropped]: {{ site.scala3ref }}/dropped-features
+[changed]: {{ site.scala3ref }}/changed-features
+[added]:{{ site.scala3ref }}/other-new-features
+
+[union-types]: {% link _overviews/scala3-book/types-union.md %}
+[opaque-types]: {% link _overviews/scala3-book/types-opaque-types.md %}