Skip to content

Updating Russian pages to match English pages #2988

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Mar 4, 2024
Merged

Updating Russian pages to match English pages #2988

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
93 changes: 46 additions & 47 deletions _ru/overviews/parallel-collections/concrete-parallel-collections.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -43,10 +43,10 @@ num: 2

[ParRange](https://www.scala-lang.org/api/{{ site.scala-212-version }}/scala/collection/parallel/immutable/ParRange.html) представляет собой упорядоченную последовательность элементов, отстоящих друг от друга на одинаковые промежутки. Параллельный диапазон создается подобно последовательному [Range](https://www.scala-lang.org/api/{{ site.scala-212-version }}/scala/collection/immutable/Range.html):

scala> 1 to 3 par
scala> (1 to 3).par
res0: scala.collection.parallel.immutable.ParRange = ParRange(1, 2, 3)

scala> 15 to 5 by -2 par
scala> (15 to 5 by -2).par
res1: scala.collection.parallel.immutable.ParRange = ParRange(15, 13, 11, 9, 7, 5)

Подобно тому, как последовательные диапазоны не имеют строителей, параллельные диапазоны не имеют [компоновщиков]({{ site.baseurl }}/ru/overviews/parallel-collections/architecture.html). При создании отображения (mapping) элементов параллельного диапазона получается параллельный вектор. Последовательные и параллельные диапазоны могут эффективно преобразовываться друг в друга вызовами методов `seq` и `par`.
Expand All @@ -72,7 +72,7 @@ num: 2
scala> val phs = scala.collection.parallel.immutable.ParHashSet(1 until 1000: _*)
phs: scala.collection.parallel.immutable.ParHashSet[Int] = ParSet(645, 892, 69, 809, 629, 365, 138, 760, 101, 479,...

scala> phs map { x => x * x } sum
scala> phs.map(x => x * x).sum
res0: Int = 332833500

[Компоновщики]({{ site.baseurl }}/overviews/parallel-collections/architecture.html) параллельных хэш-деревьев действуют аналогично компоновщикам хэш-таблиц, а именно предварительно распределяют элементы по блокам, а после этого параллельно составляют результирующее хэш-дерево, назначая обработку различных блоков разным процессорам, каждый из которых независимо собирает свое поддерево.
Expand All @@ -88,19 +88,19 @@ num: 2

scala> while (numbers.nonEmpty) {
| numbers foreach { case (num, sqrt) =>
| val nsqrt = 0.5 * (sqrt + num / sqrt)
| numbers(num) = nsqrt
| if (math.abs(nsqrt - sqrt) < 0.01) {
| println(num, nsqrt)
| numbers.remove(num)
| }
| }
| }
(1.0,1.0)
| val nsqrt = 0.5 * (sqrt + num / sqrt)
| numbers(num) = nsqrt
| if (math.abs(nsqrt - sqrt) < 0.01) {
| println(num, nsqrt)
| numbers.remove(num)
| }
| }
| }
(1.0,1.0)
(2.0,1.4142156862745097)
(7.0,2.64576704419029)
(4.0,2.0000000929222947)
...
...

[Компоновщики]({{ site.baseurl }}/ru/overviews/parallel-collections/architecture.html) реализованы как `TrieMap`-- так как эта структура является многопоточной, при вызове метода трансформации создается только один компоновщик, разделяемый всеми процессорами.

Expand All @@ -110,53 +110,52 @@ num: 2

Характеристики производительности последовательных типов (sequence types):

| | head | tail | apply | update| prepend | append | insert |
| -------- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
| `ParArray` | C | L | C | C | L | L | L |
| `ParVector` | eC | eC | eC | eC | eC | eC | - |
| `ParRange` | C | C | C | - | - | - | - |
| | head | tail | apply | update | prepend | append | insert |
| ----------- | ---- | ---- | ----- | ------ | ------- | ------ | ------ |
| `ParArray` | C | L | C | C | L | L | L |
| `ParVector` | eC | eC | eC | eC | eC | eC | - |
| `ParRange` | C | C | C | - | - | - | - |

Характеристики производительности множеств (set) и ассоциативных массивов (map):

| | lookup | add | remove |
| -------- | ---- | ---- | ---- |
| **неизменяемые** | | | |
| `ParHashSet`/`ParHashMap`| eC | eC | eC |
| **изменяемые** | | | |
| `ParHashSet`/`ParHashMap`| C | C | C |
| `ParTrieMap` | eC | eC | eC |

| | lookup | add | remove |
| ------------------------- | ------ | --- | ------ |
| **неизменяемые** | | | |
| `ParHashSet`/`ParHashMap` | eC | eC | eC |
| **изменяемые** | | | |
| `ParHashSet`/`ParHashMap` | C | C | C |
| `ParTrieMap` | eC | eC | eC |

### Расшифровка

Обозначения в двух представленных выше таблицах означают следующее:

| | |
| --- | ---- |
| **C** | Операция (быстрая) выполняется за постоянное время. |
| **eC** | Операция выполняется за фактически постоянное время, но только при соблюдении некоторых предположений, например о максимальной длине вектора или распределении хэш-кодов.|
| | |
| ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **C** | Операция (быстрая) выполняется за постоянное время. |
| **eC** | Операция выполняется за фактически постоянное время, но только при соблюдении некоторых предположений, например о максимальной длине вектора или распределении хэш-кодов. |
| **aC** | Операция выполняется за амортизированное постоянное время. Некоторые вызовы операции могут выполняться медленнее, но при подсчете времени выполнения большого количества операций выходит, что в среднем на операцию требуется постоянное время. |
| **Log** | Операция занимает время, пропорциональное логарифму размера коллекции. |
| **L** | Операция линейна, то есть занимает время, пропорциональное размеру коллекции. |
| **-** | Операция не поддерживается. |
| **Log** | Операция занимает время, пропорциональное логарифму размера коллекции. |
| **L** | Операция линейна, то есть занимает время, пропорциональное размеру коллекции. |
| **-** | Операция не поддерживается. |

Первая таблица трактует последовательные типы-- изменяемые и неизменяемые-- в контексте выполнения следующих операций:

| | |
| --- | ---- |
| **head** | Получение первого элемента последовательности. |
| **tail** | Получение новой последовательности, состоящей из всех элементов исходной, кроме первого. |
| **apply** | Индексирование. |
| **update** | Функциональное обновление (с помощью `updated`) для неизменяемых последовательностей, обновление с побочными действиями (с помощью `update`) для изменяемых. |
| **prepend**| Добавление элемента в начало последовательности. Для неизменяемых последовательностей создается новая последовательность, для изменяемых-- модифицируется существующая. |
| **append** | Добавление элемента в конец последовательности. Для неизменяемых последовательностей создается новая последовательность, для изменяемых-- модифицируется существующая. |
| **insert** | Вставка элемента в выбранную позицию последовательности. Поддерживается только изменяемыми последовательностями. |
| | |
| ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **head** | Получение первого элемента последовательности. |
| **tail** | Получение новой последовательности, состоящей из всех элементов исходной, кроме первого. |
| **apply** | Индексирование. |
| **update** | Функциональное обновление (с помощью `updated`) для неизменяемых последовательностей, обновление с побочными действиями (с помощью `update`) для изменяемых. |
| **prepend** | Добавление элемента в начало последовательности. Для неизменяемых последовательностей создается новая последовательность, для изменяемых-- модифицируется существующая. |
| **append** | Добавление элемента в конец последовательности. Для неизменяемых последовательностей создается новая последовательность, для изменяемых-- модифицируется существующая. |
| **insert** | Вставка элемента в выбранную позицию последовательности. Поддерживается только изменяемыми последовательностями. |

Вторая таблица рассматривает изменяемые и неизменяемые множества и ассоциативные массивы в контексте следующих операций:

| | |
| --- | ---- |
| | |
| ---------- | ---------------------------------------------------------------------------------------------- |
| **lookup** | Проверка принадлежности элемента множеству, или получение значения, ассоциированного с ключом. |
| **add** | Добавление нового элемента во множество или новой пары ключ/значение в ассоциативный массив. |
| **remove** | Удаление элемента из множества или ключа из ассоциативного массива. |
| **min** | Минимальный элемент множества или минимальный ключ ассоциативного массива. |
| **add** | Добавление нового элемента во множество или новой пары ключ/значение в ассоциативный массив. |
| **remove** | Удаление элемента из множества или ключа из ассоциативного массива. |
| **min** | Минимальный элемент множества или минимальный ключ ассоциативного массива. |
9 changes: 4 additions & 5 deletions _ru/scala3/book/fp-intro.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,16 +12,15 @@ previous-page: collections-summary
next-page: fp-what-is-fp
---


Scala позволяет писать код в стиле объектно-ориентированного программирования (ООП),
в стиле функционального программирования (ФП), а также в гибридном стиле, используя оба подхода в комбинации.
По словам [Martin Odersky](https://twitter.com/alexelcu/status/996408359514525696),
Scala позволяет писать код в стиле объектно-ориентированного программирования (ООП),
в стиле функционального программирования (ФП), а также в гибридном стиле, используя оба подхода в комбинации.
По словам Martin Odersky,
сущность Scala — это слияние функционального и объектно-ориентированного программирования в типизированной среде:

- Функции для логики
- Объекты для модульности

В этой главе предполагается, что вы знакомы с ООП и менее знакомы с ФП,
В этой главе предполагается, что вы знакомы с ООП и менее знакомы с ФП,
поэтому в ней представлено краткое введение в несколько основных концепций функционального программирования:

- Что такое функциональное программирование?
Expand Down
Loading