Add types pages in russian

Author: artemkorsakov

_overviews/scala3-book/types-dependent-function.md

@@ -2,7 +2,7 @@
 title: Dependent Function Types
 type: section
 description: This section introduces and demonstrates dependent function types in Scala 3.
-languages: [zh-cn]
+languages: [ru, zh-cn]
 num: 57
 previous-page: types-structural
 next-page: types-others

_overviews/scala3-book/types-opaque-types.md

@@ -2,7 +2,7 @@
 title: Opaque Types
 type: section
 description: This section introduces and demonstrates opaque types in Scala 3.
-languages: [zh-cn]
+languages: [ru, zh-cn]
 num: 55
 previous-page: types-variance
 next-page: types-structural

_overviews/scala3-book/types-others.md

@@ -2,7 +2,7 @@
 title: Other Types
 type: section
 description: This section mentions other advanced types in Scala 3.
-languages: [zh-cn]
+languages: [ru, zh-cn]
 num: 58
 previous-page: types-dependent-function
 next-page: ca-contextual-abstractions-intro

_overviews/scala3-book/types-structural.md

@@ -2,7 +2,7 @@
 title: Structural Types
 type: section
 description: This section introduces and demonstrates structural types in Scala 3.
-languages: [zh-cn]
+languages: [ru, zh-cn]
 num: 56
 previous-page: types-opaque-types
 next-page: types-dependent-function

_ru/scala3/book/types-dependent-function.md

@@ -0,0 +1,178 @@
+---
+layout: multipage-overview
+title: Зависимые типы функций
+scala3: true
+partof: scala3-book
+overview-name: "Scala 3 — Book"
+type: section
+description: В этом разделе представлены и демонстрируются зависимые типы функций в Scala 3.
+language: ru
+num: 57
+previous-page: types-structural
+next-page: types-others
+---
+
+_Зависимый тип функции_ (_dependent function type_) описывает типы функций,
+где тип результата может зависеть от значений параметров функции.
+Концепция зависимых типов и типов зависимых функций является более продвинутой,
+и обычно с ней сталкиваются только при разработке собственных библиотек или использовании расширенных библиотек.
+
+## Зависимые типы методов
+
+Рассмотрим следующий пример гетерогенной базы данных, в которой могут храниться значения разных типов.
+Ключ содержит информацию о типе соответствующего значения:
+
+```scala
+trait Key { type Value }
+
+trait DB {
+  def get(k: Key): Option[k.Value] // зависимый метод
+}
+```
+
+Получив ключ, метод `get` предоставляет доступ к карте и потенциально возвращает сохраненное значение типа `k.Value`.
+Мы можем прочитать этот _path-dependent type_ как:
+"в зависимости от конкретного типа аргумента `k` возвращается соответствующее значение".
+
+Например, у нас могут быть следующие ключи:
+
+```scala
+object Name extends Key { type Value = String }
+object Age extends Key { type Value = Int }
+```
+
+Вызовы метода `get` теперь будут возвращать такие типы:
+
+```scala
+val db: DB = ...
+val res1: Option[String] = db.get(Name)
+val res2: Option[Int] = db.get(Age)
+```
+
+Вызов метода `db.get(Name)` возвращает значение типа `Option[String]`,
+а вызов `db.get(Age)` возвращает значение типа `Option[Int]`.
+Тип возвращаемого значения _зависит_ от конкретного типа аргумента, переданного для `get` — отсюда и название _dependent type_.
+
+## Зависимые типы функций
+
+Как видно выше, в Scala 2 уже была поддержка зависимых типов методов.
+Однако создание значений типа `DB` довольно громоздко:
+
+```scala
+// создание пользователя DB
+def user(db: DB): Unit =
+  db.get(Name) ... db.get(Age)
+
+// создание экземпляра DB и передача его `user`
+user(new DB {
+  def get(k: Key): Option[k.Value] = ... // реализация DB
+})
+```
+
+Необходимо вручную создать анонимный внутренний класс `DB`, реализующий метод `get`.
+Для кода, основанного на создании множества различных экземпляров `DB`, это очень утомительно.
+
+Трейт `DB` имеет только один абстрактный метод `get`.
+Было бы неплохо использовать в этом месте лямбда-синтаксис?
+
+```scala
+user { k =>
+  ... // реализация DB
+}
+```
+
+На самом деле, в Scala 3 теперь это возможно! Можно определить `DB` как _зависимый тип функции_:
+
+```scala
+type DB = (k: Key) => Option[k.Value]
+//        ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//        зависимый тип функции
+```
+
+Учитывая это определение `DB`, можно использовать приведенный выше вызов `user`.
+
+Подробнее о внутреннем устройстве зависимых типов функций можно прочитать в [справочной документации][ref].
+
+## Практический пример: числовые выражения
+
+Предположим, что необходимо определить модуль, который абстрагируется от внутреннего представления чисел.
+Это может быть полезно, например, для реализации библиотек для автоматического дифференцирования.
+
+Начнем с определения модуля для чисел:
+
+```scala
+trait Nums:
+  // тип Num оставлен абстрактным
+  type Num
+
+  // некоторые операции над числами
+  def lit(d: Double): Num
+  def add(l: Num, r: Num): Num
+  def mul(l: Num, r: Num): Num
+```
+
+> Здесь опускается конкретная реализация `Nums`, но в качестве упражнения можно реализовать `Nums`,
+> назначив тип `Num = Double` и реализуя соответствующие методы.
+
+Программа, использующая числовую абстракцию, теперь имеет следующий тип:
+
+```scala
+type Prog = (n: Nums) => n.Num => n.Num
+
+val ex: Prog = nums => x => nums.add(nums.lit(0.8), x)
+```
+
+Тип функции, которая вычисляет производную, наподобие `ex`:
+
+```scala
+def derivative(input: Prog): Double
+```
+
+Учитывая удобство зависимых типов функций, вызов этой функции в разных программах прост:
+
+```scala
+derivative { nums => x => x }
+derivative { nums => x => nums.add(nums.lit(0.8), x) }
+// ...
+```
+
+Напомним, что та же программа в приведенной выше кодировке будет выглядеть так:
+
+```scala
+derivative(new Prog {
+  def apply(nums: Nums)(x: nums.Num): nums.Num = x
+})
+derivative(new Prog {
+  def apply(nums: Nums)(x: nums.Num): nums.Num = nums.add(nums.lit(0.8), x)
+})
+// ...
+```
+
+#### Комбинация с контекстными функциями
+
+Комбинация методов расширения, [контекстных функций][ctx-fun] и зависимых функций обеспечивает мощный инструмент для разработчиков библиотек.
+Например, мы можем уточнить нашу библиотеку, как указано выше, следующим образом:
+
+```scala
+trait NumsDSL extends Nums:
+  extension (x: Num)
+    def +(y: Num) = add(x, y)
+    def *(y: Num) = mul(x, y)
+
+def const(d: Double)(using n: Nums): n.Num = n.lit(d)
+
+type Prog = (n: NumsDSL) ?=> n.Num => n.Num
+//                       ^^^
+//     prog теперь - контекстная функция,
+//     которая неявно предполагает NumsDSL в контексте вызова
+
+def derivative(input: Prog): Double = ...
+
+// теперь нам не нужно упоминать Nums в приведенных ниже примерах
+derivative { x => const(1.0) + x }
+derivative { x => x * x + const(2.0) }
+// ...
+```
+
+[ref]: {{ site.scala3ref }}/new-types/dependent-function-types.html
+[ctx-fun]: {{ site.scala3ref }}/contextual/context-functions.html

_ru/scala3/book/types-opaque-types.md

@@ -0,0 +1,174 @@
+---
+layout: multipage-overview
+title: Непрозрачные типы
+scala3: true
+partof: scala3-book
+overview-name: "Scala 3 — Book"
+type: section
+description: В этом разделе представлены и демонстрируются непрозрачные типы в Scala 3.
+language: ru
+num: 55
+previous-page: types-variance
+next-page: types-structural
+---
+
+В Scala 3 _непрозрачные псевдонимы типов_ (_opaque type aliases_) обеспечивают абстракции типов без каких-либо **накладных расходов**.
+
+## Накладные расходы на абстракцию
+
+Предположим, что необходимо определить модуль,
+предлагающий арифметические операции над числами, которые представлены их логарифмами.
+Это может быть полезно для повышения точности, когда числовые значения очень большие или близкие к нулю.
+
+Поскольку важно отличать "обычные" `Double` от чисел, хранящихся в виде их логарифмов, введем класс `Logarithm`:
+
+```scala
+class Logarithm(protected val underlying: Double):
+  def toDouble: Double = math.exp(underlying)
+  def + (that: Logarithm): Logarithm =
+    // здесь используется метод apply сопутствующего объекта
+    Logarithm(this.toDouble + that.toDouble)
+  def * (that: Logarithm): Logarithm =
+    new Logarithm(this.underlying + that.underlying)
+
+object Logarithm:
+  def apply(d: Double): Logarithm = new Logarithm(math.log(d))
+```
+
+Метод `apply` сопутствующего объекта позволяет создавать значения типа `Logarithm`,
+которые можно использовать следующим образом:
+
+```scala
+val l2 = Logarithm(2.0)
+val l3 = Logarithm(3.0)
+println((l2 * l3).toDouble) // выводит 6.0
+println((l2 + l3).toDouble) // выводит 4.999...
+```
+
+В то время как класс `Logarithm` предлагает хорошую абстракцию для значений `Double`,
+которые хранятся в этой конкретной логарифмической форме,
+это накладывает серьезные накладные расходы на производительность:
+для каждой отдельной математической операции нужно извлекать значение `underlying`,
+а затем снова обернуть его в новый экземпляр `Logarithm`.
+
+## Модульные абстракции
+
+Рассмотрим другой подход к реализации той же библиотеки.
+На этот раз вместо того, чтобы определять `Logarithm` как класс, определяем его с помощью _псевдонима типа_.
+Во-первых, зададим абстрактный интерфейс модуля:
+
+```scala
+trait Logarithms:
+
+  type Logarithm
+
+  // операции на Logarithm
+  def add(x: Logarithm, y: Logarithm): Logarithm
+  def mul(x: Logarithm, y: Logarithm): Logarithm
+
+  // функции конвертации между Double и Logarithm
+  def make(d: Double): Logarithm
+  def extract(x: Logarithm): Double
+
+  // методы расширения, для вызова `add` и `mul` в качестве "методов" на Logarithm
+  extension (x: Logarithm)
+    def toDouble: Double = extract(x)
+    def + (y: Logarithm): Logarithm = add(x, y)
+    def * (y: Logarithm): Logarithm = mul(x, y)
+```
+
+Теперь давайте реализуем этот абстрактный интерфейс, задав тип `Logarithm` равным `Double`:
+
+```scala
+object LogarithmsImpl extends Logarithms:
+
+  type Logarithm = Double
+
+  // операции на Logarithm
+  def add(x: Logarithm, y: Logarithm): Logarithm = make(x.toDouble + y.toDouble)
+  def mul(x: Logarithm, y: Logarithm): Logarithm = x + y
+
+  // функции конвертации между Double и Logarithm
+  def make(d: Double): Logarithm = math.log(d)
+  def extract(x: Logarithm): Double = math.exp(x)
+```
+
+В рамках реализации `LogarithmsImpl` уравнение `Logarithm = Double` позволяет реализовать различные методы.
+
+#### Дырявые абстракции
+
+Однако эта абстракция немного "дырява".
+Мы должны убедиться, что всегда программируем _только_ с абстрактным интерфейсом `Logarithms`
+и никогда не используем `LogarithmsImpl` напрямую.
+Прямое использование `LogarithmsImpl` сделало бы равенство `Logarithm = Double` видимым для пользователя,
+который может случайно использовать `Double` там, где ожидается логарифмическое удвоение.
+Например:
+
+```scala
+import LogarithmsImpl.*
+val l: Logarithm = make(1.0)
+val d: Double = l // проверка типов ДОЗВОЛЯЕТ равенство!
+```
+
+Необходимость разделения модуля на абстрактный интерфейс и реализацию может быть полезной,
+но также требует больших усилий, чтобы просто скрыть детали реализации `Logarithm`.
+Программирование с использованием абстрактного модуля `Logarithms` может быть очень утомительным
+и часто требует использования дополнительных функций, таких как типы, зависящие от пути, как в следующем примере:
+
+```scala
+def someComputation(L: Logarithms)(init: L.Logarithm): L.Logarithm = ...
+```
+
+#### Накладные расходы упаковки/распаковки
+
+Абстракции типов, такие как `type Logarithm`, [стираются](https://www.scala-lang.org/files/archive/spec/2.13/03-types.html#type-erasure)
+в соответствии с их привязкой (`Any` - в нашем случае).
+То есть, хотя нам не нужно вручную переносить и разворачивать значение `Double`,
+все равно будут некоторые накладные расходы, связанные с упаковкой примитивного типа `Double`.
+
+## Непрозрачные типы
+
+Вместо того чтобы вручную разбивать компонент `Logarithms` на абстрактную часть и на конкретную реализацию,
+можно просто использовать opaque типы для достижения аналогичного эффекта:
+
+```scala
+object Logarithms:
+//vvvvvv это важное различие!
+  opaque type Logarithm = Double
+
+  object Logarithm:
+    def apply(d: Double): Logarithm = math.log(d)
+
+  extension (x: Logarithm)
+    def toDouble: Double = math.exp(x)
+    def + (y: Logarithm): Logarithm = Logarithm(math.exp(x) + math.exp(y))
+    def * (y: Logarithm): Logarithm = x + y
+```
+
+Тот факт, что `Logarithm` совпадает с `Double`, известен только в области, где он определен,
+которая в приведенном выше примере соответствует объекту `Logarithms`.
+Равенство `Logarithm = Double` может использоваться для реализации методов (например, `*` и `toDouble`).
+
+Однако вне модуля тип `Logarithm` полностью инкапсулирован или «непрозрачен».
+Для пользователей `Logarithm`-а невозможно обнаружить, что `Logarithm` на самом деле реализован как `Double`:
+
+```scala
+import Logarithms.*
+val log2 = Logarithm(2.0)
+val log3 = Logarithm(3.0)
+println((log2 * log3).toDouble) // выводит 6.0
+println((log2 + log3).toDouble) // выводит 4.999...
+
+val d: Double = log2 // ERROR: Found Logarithm required Double
+```
+
+Несмотря на то, что мы абстрагировались от `Logarithm`, абстракция предоставляется бесплатно:
+поскольку существует только одна реализация, во время выполнения не будет накладных расходов
+на упаковку для примитивных типов, таких как `Double`.
+
+### Обзор непрозрачных типов
+
+Непрозрачные типы предлагают надежную абстракцию над деталями реализации, не накладывая расходов на производительность.
+Как показано выше, непрозрачные типы удобны в использовании и очень хорошо интегрируются с [функцией методов расширения][extension].
+
+[extension]: {% link _overviews/scala3-book/ca-extension-methods.md %}