Update lower-type-bounds.md and upper-type-bounds.md in russian

Author: artemkorsakov

_ru/tour/lower-type-bounds.md

@@ -9,57 +9,107 @@ previous-page: upper-type-bounds
 prerequisite-knowledge: upper-type-bounds, generics, variance
 ---
 
-В то время как [верхнее ограничение типа](upper-type-bounds.html) ограничивает тип до подтипа стороннего типа, *нижнее ограничение типа* объявляют тип супертипом стороннего типа. Термин  `B >: A` выражает, то что параметр типа `B` или абстрактный тип `B` относится к супертипу типа `A`. В большинстве случаев `A` будет задавать тип класса, а `B` задавать тип метода.
+В то время как [верхнее ограничение типа](upper-type-bounds.html) ограничивает тип до подтипа стороннего типа, _нижнее ограничение типа_ объявляют тип супертипом стороннего типа. Термин `B >: A` выражает, то что параметр типа `B` или абстрактный тип `B` относится к супертипу типа `A`. В большинстве случаев `A` будет задавать тип класса, а `B` задавать тип метода.
 
 Вот пример, где это полезно:
 
+{% tabs upper-type-bounds_1 class=tabs-scala-version %}
+{% tab 'Scala 2' for=upper-type-bounds_1 %}
+
 ```scala mdoc:fail
-trait Node[+B] {
-  def prepend(elem: B): Node[B]
+trait List[+A] {
+  def prepend(elem: A): NonEmptyList[A] = NonEmptyList(elem, this)
 }
 
-case class ListNode[+B](h: B, t: Node[B]) extends Node[B] {
-  def prepend(elem: B): ListNode[B] = ListNode(elem, this)
-  def head: B = h
-  def tail: Node[B] = t
-}
+case class NonEmptyList[+A](head: A, tail: List[A]) extends List[A]
 
-case class Nil[+B]() extends Node[B] {
-  def prepend(elem: B): ListNode[B] = ListNode(elem, this)
-}
+object Nil extends List[Nothing]
+```
+
+{% endtab %}
+{% tab 'Scala 3' for=upper-type-bounds_1 %}
+
+```scala
+trait List[+A]:
+  def prepend(elem: A): NonEmptyList[A] = NonEmptyList(elem, this)
+
+case class NonEmptyList[+A](head: A, tail: List[A]) extends List[A]
+
+object Nil extends List[Nothing]
 ```
 
-В данной программе реализован связанный список. `Nil` представляет пустой список. Класс `ListNode` - это узел, который содержит элемент типа `B` (`head`) и ссылку на остальную часть списка (`tail`). Класс `Node` и его подтипы ковариантны, потому что у нас указанно `+B`.
+{% endtab %}
+{% endtabs %}
+
+В данной программе реализован связанный список. `Nil` представляет пустой список. Класс `NonEmptyList` - это узел, который содержит элемент типа `A` (`head`) и ссылку на остальную часть списка (`tail`). `trait List` и его подтипы ковариантны, потому что у нас указанно `+A`.
 
-Однако эта программа _не компилируется_, потому что параметр `elem` в `prepend` имеет тип `B`, который мы объявили *ко*вариантным. Так это не работает, потому что функции *контр*вариантны в типах своих параметров и *ко*вариантны в типах своих результатов.
+Однако эта программа _не компилируется_, потому что параметр `elem` в `prepend` имеет тип `A`, который мы объявили *ко*вариантным. Так это не работает, потому что функции *контр*вариантны в типах своих параметров и *ко*вариантны в типах своих результатов.
 
-Чтобы исправить это, необходимо перевернуть вариантность типа параметра `elem` в `prepend`. Для этого мы вводим новый тип для параметра `U`, у которого тип `B` указан в качестве нижней границы типа.
+Чтобы исправить это, необходимо перевернуть вариантность типа параметра `elem` в `prepend`. Для этого мы вводим новый тип для параметра `B`, у которого тип `A` указан в качестве нижней границы типа.
+
+{% tabs upper-type-bounds_2 class=tabs-scala-version %}
+{% tab 'Scala 2' for=upper-type-bounds_2 %}
 
 ```scala mdoc
-trait Node[+B] {
-  def prepend[U >: B](elem: U): Node[U]
+trait List[+A] {
+  def prepend[B >: A](elem: B): NonEmptyList[B] = NonEmptyList(elem, this)
 }
 
-case class ListNode[+B](h: B, t: Node[B]) extends Node[B] {
-  def prepend[U >: B](elem: U): ListNode[U] = ListNode(elem, this)
-  def head: B = h
-  def tail: Node[B] = t
-}
+case class NonEmptyList[+A](head: A, tail: List[A]) extends List[A]
 
-case class Nil[+B]() extends Node[B] {
-  def prepend[U >: B](elem: U): ListNode[U] = ListNode(elem, this)
-}
+object Nil extends List[Nothing]
+```
+
+{% endtab %}
+{% tab 'Scala 3' for=upper-type-bounds_2 %}
+
+```scala
+trait List[+A]:
+  def prepend[B >: A](elem: B): NonEmptyList[B] = NonEmptyList(elem, this)
+
+case class NonEmptyList[+A](head: A, tail: List[A]) extends List[A]
+
+object Nil extends List[Nothing]
 ```
 
+{% endtab %}
+{% endtabs %}
+
 Теперь мы можем сделать следующее:
+
+{% tabs upper-type-bounds_3 %}
+{% tab 'Scala 2 и 3' for=upper-type-bounds_3 %}
+
 ```scala mdoc
 trait Bird
 case class AfricanSwallow() extends Bird
 case class EuropeanSwallow() extends Bird
 
+val africanSwallows: List[AfricanSwallow] = Nil.prepend(AfricanSwallow())
+val swallowsFromAntarctica: List[Bird] = Nil
+val someBird: Bird = EuropeanSwallow()
+
+// присвоить птицам (birds) африканских ласточек (swallows)
+val birds: List[Bird] = africanSwallows
 
-val africanSwallowList= ListNode[AfricanSwallow](AfricanSwallow(), Nil())
-val birdList: Node[Bird] = africanSwallowList
-birdList.prepend(EuropeanSwallow())
+// добавляем новую птицу к африканским ласточкам, `B` - это `Bird`
+val someBirds = africanSwallows.prepend(someBird)
+
+// добавляем европейскую ласточку к птицам
+val moreBirds = birds.prepend(EuropeanSwallow())
+
+// соединяем вместе различных ласточек, `B` - это `Bird`, потому что это общий супертип для обоих типов ласточек
+val allBirds = africanSwallows.prepend(EuropeanSwallow())
+
+// но тут ошибка! добавление списка птиц слишком расширяет тип аргументов. -Xlint предупредит!
+val error = moreBirds.prepend(swallowsFromAntarctica)    // List[Object]
 ```
-`Node[Bird]` может быть присвоен `africanSwallowList` , но затем может добавлять и `EuropeanSwallow`.
+
+{% endtab %}
+{% endtabs %}
+
+Параметр ковариантного типа позволяет `birds` получать значение `africanSwallows`.
+
+Тип, связанный с параметром типа `prepend`, позволяет добавлять различные разновидности ласточек и получать более абстрактный тип: вместо `List[AfricanSwallow]`, мы получаем `List[Bird]`.
+
+Используйте `-Xlint`, чтобы предупредить, если аргумент предполагаемого типа слишком абстрактен.

_ru/tour/upper-type-bounds.md

@@ -12,6 +12,9 @@ previous-page: variances
 В Scala [параметры типа](generic-classes.html) и [члены абстрактного типа](abstract-type-members.html) могут быть ограничены определенными диапазонами. Такие диапазоны ограничивают конкретные значение типа и, возможно, предоставляют больше информации о членах таких типов. _Верхнее ограничение типа_ `T <: A` указывает на то что тип `T` относится к подтипу типа `A`.
 Приведем пример, демонстрирующий верхнее ограничение для типа класса `PetContainer`:
 
+{% tabs upper-type-bounds class=tabs-scala-version %}
+{% tab 'Scala 2' for=upper-type-bounds %}
+
 ```scala mdoc
 abstract class Animal {
  def name: String
@@ -39,10 +42,53 @@ val dogContainer = new PetContainer[Dog](new Dog)
 val catContainer = new PetContainer[Cat](new Cat)
 ```
 
+{% endtab %}
+{% tab 'Scala 3' for=upper-type-bounds %}
+
+```scala
+abstract class Animal:
+  def name: String
+
+abstract class Pet extends Animal
+
+class Cat extends Pet:
+  override def name: String = "Cat"
+
+class Dog extends Pet:
+  override def name: String = "Dog"
+
+class Lion extends Animal:
+  override def name: String = "Lion"
+
+class PetContainer[P <: Pet](p: P):
+  def pet: P = p
+
+val dogContainer = PetContainer[Dog](Dog())
+val catContainer = PetContainer[Cat](Cat())
+```
+
+{% endtab %}
+{% endtabs %}
+
+{% tabs upper-type-bounds_error class=tabs-scala-version %}
+{% tab 'Scala 2' for=upper-type-bounds_error %}
+
 ```scala mdoc:fail
 // это не скомпилируется
 val lionContainer = new PetContainer[Lion](new Lion)
 ```
+
+{% endtab %}
+{% tab 'Scala 3' for=upper-type-bounds_error %}
+
+```scala
+// это не скомпилируется
+val lionContainer = PetContainer[Lion](Lion())
+```
+
+{% endtab %}
+{% endtabs %}
+
 Класс `PetContainer` принимает тип `P`, который должен быть подтипом `Pet`. `Dog` и `Cat` - это подтипы `Pet`, поэтому мы можем создать новые `PetContainer[Dog]` и `PetContainer[Cat]`. Однако, если мы попытаемся создать `PetContainer[Lion]`, то получим следующую ошибку:
 
 `type arguments [Lion] do not conform to class PetContainer's type parameter bounds [P <: Pet]`