Update variances.md due to the language rules (#2730)

Co-authored-by: n.kogut <[email protected]>

Author: DespiteDeath

_ru/overviews/collections-2.13/overview.md

@@ -41,7 +41,7 @@ language: ru
 
     scala.collection.immutable.List   // Полное объявление
     scala.List                        // объявление через псевдоним
-    List                              // тк scala._ всегда автоматически импортируется
+    List                              // т.к. scala._ всегда автоматически импортируется
                                       // можно просто указать имя коллекции
 
 Другие псевдонимы для типов 

_ru/tour/implicit-conversions.md

@@ -48,7 +48,7 @@ implicit def int2Integer(x: Int) =
   java.lang.Integer.valueOf(x)
 ```
 
-Компилятор предупреждает при компиляции об обнаружении неявных преобразований, тк неявные преобразования могут иметь разные подводные камни (особенно если использовать их без разбора).
+Компилятор предупреждает при компиляции об обнаружении неявных преобразований, т.к. неявные преобразования могут иметь разные подводные камни (особенно если использовать их без разбора).
 
 Чтоб отключить предупреждения выполните одно из следующих действий:
 

_ru/tour/variances.md

@@ -8,12 +8,12 @@ next-page: upper-type-bounds
 previous-page: generic-classes
 ---
 
-Вариантность (Variances) - это указание определенной специфики взаимосвязи между связанными типам. Scala поддерживает вариантную аннотацию типов у [обобщенных классов](generic-classes.html), что позволяет им быть ковариантными, контрвариантными или инвариантными (если нет никакого указание на вариантность). Использование вариантности в системе типов позволяет устанавливать понятные взаимосвязи между сложными типами, в то время как отсутствие вариантности может ограничить повторное использование абстракции класса.
+Вариантность (Variances) - это указание определенной специфики взаимосвязи между связанными типам. Scala поддерживает вариантную аннотацию типов у [обобщенных классов](generic-classes.html), что позволяет им быть ковариантными, контрвариантными или инвариантными (если нет никакого указания на вариантность). Использование вариантности в системе типов позволяет устанавливать понятные взаимосвязи между сложными типами, в то время как отсутствие вариантности может ограничить повторное использование абстракции класса.
 
 ```scala mdoc
 class Foo[+A] // ковариантный класс
-class Bar[-A] // контрвариантный класс
-class Baz[A]  // инвариантными класс
+class Bar[-A] // контравариантный класс
+class Baz[A]  // инвариантный класс
 ```
 
 ### Ковариантность
@@ -135,15 +135,15 @@ val cat: Cat = catContainer.getValue // Ой, мы бы закончили пр
 
 Другим примером, который может помочь понять вариантность, является трейт `Function1[-T, +R]` из стандартной библиотеки Scala. `Function1` представляет собой функцию с одним параметром, где первый тип `T` представляет собой тип параметра, а второй тип `R` представляет собой тип результата. Функция `Function1` является контрвариантной в рамках типа принимаемого аргумента, а ковариантной - в рамках возвращаемого типа. Для этого примера мы будем использовать явное обозначение типа `A =>B` чтоб продемонстрировать `Function1[A, B]`.
 
-Рассмотрим схожий пример `Cat`, `Dog`, `Animal` в той же взаимосвязи что и раньше, плюс следующее:
+Рассмотрим схожий пример `Cat`, `Dog`, `Animal` в той же взаимосвязи, что и раньше, плюс следующее:
 
 ```scala mdoc
 abstract class SmallAnimal extends Animal
 case class Mouse(name: String) extends SmallAnimal
 ```
 
-Предположим, мы работаем с функциями, которые принимают типы животных и возвращают типы еды, которую они едят. Если мы хотим `Cat => SmallAnimal` (потому что кошки едят маленьких животных), но вместо этого мы получим функцию `Animal => Mouse`, то наша программа все равно будет работать. Интуитивно функция `Animal => Mouse` все равно будет принимать `Cat` в качестве аргумента, тк `Cat` является `Animal`, и возвращать `Mouse` - который также является и `SmallAnimal`. Поскольку мы можем безопасно заменить первое вторым, можно сказать, что `Animal => Mouse` аналогично `Cat => SmallAnimal`.
+Предположим, что мы работаем с функциями, которые принимают типы животных и возвращают типы еды. Если мы хотим `Cat => SmallAnimal` (потому что кошки едят маленьких животных), но вместо этого мы получим функцию `Animal => Mouse`, то наша программа все равно будет работать. Интуитивно функция `Animal => Mouse` все равно будет принимать `Cat` в качестве аргумента, т.к. `Cat` является `Animal`, и возвращать `Mouse` - который также является и `SmallAnimal`. Поскольку мы можем безопасно заменить первое вторым, можно сказать, что `Animal => Mouse` аналогично `Cat => SmallAnimal`.
 
 ### Сравнение с другими языками
 
-В языках, похожих на Scala, разные способы поддержи вариантности. Например, указания вариантности в Scala очень похожи на то, как это делается в C#, где такие указания добавляются при объявлении абстракции класса (вариантность при объявлении). Однако в Java, указание вариантности задается непосредственно при использовании абстракции класса (вариантность при использовании).
+В языках, похожих на Scala, разные способы поддержки вариантности. Например, указания вариантности в Scala очень похожи на то, как это делается в C#, где такие указания добавляются при объявлении абстракции класса (вариантность при объявлении). Однако в Java, указание вариантности задается непосредственно при использовании абстракции класса (вариантность при использовании).