From 80e20598b90351f7840d53396cd0fa303f9c9fec Mon Sep 17 00:00:00 2001 From: Dmytro Kazanzhy Date: Thu, 26 May 2022 19:07:08 +0300 Subject: [PATCH 1/2] Add Ukrainian cheatsheet --- _cheatsheets/index.md | 3 +- _uk/cheatsheets/index.md | 624 +++++++++++++++++++++++++++++++++++++++ _uk/index.md | 2 +- 3 files changed, 626 insertions(+), 3 deletions(-) create mode 100644 _uk/cheatsheets/index.md diff --git a/_cheatsheets/index.md b/_cheatsheets/index.md index 2b4cc489ec..41e35e3eb2 100644 --- a/_cheatsheets/index.md +++ b/_cheatsheets/index.md @@ -7,7 +7,7 @@ partof: cheatsheet by: Brendan O'Connor about: Thanks to Brendan O'Connor, this cheatsheet aims to be a quick reference of Scala syntactic constructions. Licensed by Brendan O'Connor under a CC-BY-SA 3.0 license. -languages: [ba, fr, ja, pl, pt-br, zh-cn, th, ru] +languages: [ba, fr, ja, pl, pt-br, zh-cn, th, ru, uk] --- @@ -220,7 +220,6 @@ languages: [ba, fr, ja, pl, pt-br, zh-cn, th, ru] 
import scala.util.control.Breaks._
-
 breakable {
   for (x <- xs) {
     if (Math.random < 0.1)
diff --git a/_uk/cheatsheets/index.md b/_uk/cheatsheets/index.md
new file mode 100644
index 0000000000..80caabc188
--- /dev/null
+++ b/_uk/cheatsheets/index.md
@@ -0,0 +1,624 @@
+---
+layout: cheatsheet
+title: Scala Cheatsheet
+
+partof: cheatsheet
+
+by: Dmytro Kazanzhy
+about: Ця шпаргалка створена завдяки Brendan O'Connor, та призначена для швидкого ознайомлення з синтаксичними конструкціями Scala. Ліцензовано Brendan O'Connor за ліцензією CC-BY-SA 3.0.
+
+language: uk
+---
+
+###### Contributed by {{ page.by }}
+
+{{ page.about }}
+
+
+  
+    
+    
+  
+  
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+     
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+  
+
змінні 
var x = 5

 Вірно
x = 6
Змінна.
val x = 5

 Невірно
x = 6
Константа (значення).
var x: Double = 5
Явне вказання типу.
функції 
Вірно
 
def f(x: Int) = { x * x }

 Невірно
 
def f(x: Int)   { x * x }
Визначення функції.
Прихована помилка: без = це процедура, що повертає Unit та може ввести в оману. Не підтримується зі Scala 2.13.
Вірно
 
def f(x: Any) = println(x)

 Невірно
 
def f(x) = println(x)
Визначення функції.
Синтаксична помилка: для кожного аргументу має бути вказано тип.
type R = Double
Псевдонім (синонім) типу.
def f(x: R)
 vs.
 
def f(x: => R)
Виклик-за-значенням.

Виклик-за-іменем (розрахунок параметру відкладено).
(x: R) => x * x
Анонімна функція.
(1 to 5).map(_ * 2)
 vs.
 
(1 to 5).reduceLeft(_ + _)
Анонімна функція: підкреслення це позиційний аргумент, тобто місце, куди буде підставлено аргумент функції.
(1 to 5).map(x => x * x)
Анонімна функція: зліва від => задається ім'я змінної, якій буде присвоєно аргумент та яку можна використати справа.
(1 to 5).map { x =>
+  val y = x * 2
+  println(y)
+  y
+}
Анонімна функція: блоковий стиль (фігурні дужки означають блок) повертає останній вираз.
(1 to 5) filter {
+  _ % 2 == 0
+} map {
+  _ * 2
+}
Анонімна функція: конвеєрний стиль.
def compose(g: R => R, h: R => R) =
+  (x: R) => g(h(x))
 
 
val f = compose(_ * 2, _ - 1)
Анонімна функція: для передачі кількох блоків потрібні зовнішні дужки.
val zscore =
+  (mean: R, sd: R) =>
+    (x: R) =>
+      (x - mean) / sd
Каррування, явний синтакси.
def zscore(mean: R, sd: R) =
+  (x: R) =>
+    (x - mean) / sd
Каррування, явний синтаксис.
def zscore(mean: R, sd: R)(x: R) =
+  (x - mean) / sd
Каррування, синтаксичний цукор. Але:
val normer =
+  zscore(7, 0.4) _
Потрібне кінцеве підкреслення, щоб отримати частково застосовану функцію (лише для версії з синтаксичним цукром).
def mapmake[T](g: T => T)(seq: List[T]) =
+  seq.map(g)
Узагальнений тип (параметричний поліморфізм).
5.+(3); 5 + 3
 
 
(1 to 5) map (_ * 2)
Інфіксний цукор (метод з одним аргументом може бути викликано як оператор).
def sum(args: Int*) =
+  args.reduceLeft(_+_)
Varargs (аргументи змінної довжини).
пакети 
import scala.collection._
Імпорт всього вмісту пакету.
import scala.collection.Vector
 
 
import scala.collection.{Vector, Sequence}
Вибірковий імпорт.
import scala.collection.{Vector => Vec28}
Імпорт з перейменуванням.
import java.util.{Date => _, _}
Імпорт всього з java.util окрім Date.
На початку файлу: 
package pkg

 Пакет в певних межах:  
package pkg {
+  ...
+}

Пакет одиночка (singleton):  
package object pkg {
+  ...
+}
Оголошення пакету.
структури даних 
(1, 2, 3)
Кортеж (Tuple). Трансформується у виклик Tuple3.
var (x, y, z) = (1, 2, 3)
Деструктивна прив'язка: кортеж розпаковується через зіставлення зі зразком (pattern matching).
Невірно
var x, y, z = (1, 2, 3)
Прихована помилка: кожна змінна прив'язана до всього кортежу.
var xs = List(1, 2, 3)
Список (немутабельний).
xs(2)
Індексація через дужки (slides).
1 :: List(2, 3)
Додавання елементу до голови списку.
1 to 5
 так само, як і 
1 until 6
 
 
1 to 10 by 2
Синтаксичний цукор для діапазонів.
()
Пусті дужки це єдине значення для типу Unit.
Еквівалентно до void у C та Java.
управляючі конструкти 
if (check) happy else sad
Умовний конструкт.
if (check) happy

+      
так само, як і

+      
if (check) happy else ()
Умовний конструкт (синтаксичний цукор).
while (x < 5) {
+  println(x)
+  x += 1
+}
Цикл while.
do {
+  println(x)
+  x += 1
+} while (x < 5)
Цикл do-while.
import scala.util.control.Breaks._
+breakable {
+  for (x <- xs) {
+    if (Math.random < 0.1)
+      break
+  }
+}
Break (slides).
for (x <- xs if x % 2 == 0)
+  yield x * 10

+      
так само, як і

+      
xs.filter(_ % 2 == 0).map(_ * 10)
Цикл for: filter/map.
for ((x, y) <- xs zip ys)
+  yield x * y

+      
так само, як і

+      
(xs zip ys) map {
+  case (x, y) => x * y
+}
Цикл for: деструктивна прив'язка.
for (x <- xs; y <- ys)
+  yield x * y

+      
так само, як і

+      
xs flatMap { x =>
+  ys map { y =>
+    x * y
+  }
+}
Цикл for: декартів добуток.
for (x <- xs; y <- ys) {
+  val div = x / y.toFloat
+  println("%d/%d = %.1f".format(x, y, div))
+}
Цикл for: імперативність.
стильsprintf.
for (i <- 1 to 5) {
+  println(i)
+}
Цикл for: ітерація з включенням верхньої межі.
for (i <- 1 until 5) {
+  println(i)
+}
Цикл for: ітерація без включення верхньої межі.
зіставлення із зразком (pattern matching) 
Вірно
 
(xs zip ys) map {
+  case (x, y) => x * y
+}

 Невірно
 
(xs zip ys) map {
+  (x, y) => x * y
+}
Для зіставлення зі зразком необхідно використати case перед аргументами анонімної функції.
Невірно

+      
val v42 = 42
+24 match {
+  case v42 => println("42")
+  case _   => println("Not 42")
+}
v42 буде інтерпретовано так само як ім'я змінної, яка буде вірно зіставлена з будь-яким Int значенням, і буде виведено “42”.
Вірно

+      
val v42 = 42
+24 match {
+  case `v42` => println("42")
+  case _     => println("Not 42")
+}
`v42` у зворотних галочках буде інтерпретовано як значення змінної v42, і буде виведено “Not 42”.
Вірно

+      
val UppercaseVal = 42
+24 match {
+  case UppercaseVal => println("42")
+  case _            => println("Not 42")
+}
UppercaseVal буде інтерпретовано так само як наявна змінна, а не патерн, тому що починається з великої літери. Тому значення, що міститься в UppercaseVal буде порівняно з 24, і буде виведено “Not 42”.
об'єктна орієнтація 
class C(x: R)
Параметри конструктора - тільки x доступний в тілі класу.
class C(val x: R)

var c = new C(4)

c.x
Параметри конструктора - автоматичне створення публічного об'єкта.
class C(var x: R) {
+  assert(x > 0, "positive please")
+  var y = x
+  val readonly = 5
+  private var secret = 1
+  def this = this(42)
+}
Тіло класу є конструктором.
Оголосити відкритий (public) атрибут.
Оголосити атрибут, доступний тільки на читання.
Оголосити закритий (private) атрибут.
Альтернативний конструктор.
new {
+  ...
+}
Анонімний клас.
abstract class D { ... }
Визначити абстрактний клас (без можливості створення об'єкту).
class C extends D { ... }
Визначити клас, що наслідує інший.
class D(var x: R)

class C(x: R) extends D(x)
Наслідування та параметри конструктора (за замовчуванням відбувається передача аргументів).
object O extends D { ... }
Визначити єдиний екземпляр (singleton).
trait T { ... }

class C extends T { ... }

class C extends D with T { ... }
Риси - трейти (traits).
Інтерфейси-з-імплементацією. У трейту немає параметрів конструктора. композиція з домішками (mixin).
trait T1; trait T2

class C extends T1 with T2

class C extends D with T1 with T2
Множинні трейти.
class C extends D { override def f = ...}
При реалізації вже наявного методу необхідно вказати overrides.
new java.io.File("f")
Створення об'єкту.
Невірно
 
new List[Int]

 Вірно
 
List(1, 2, 3)
Помилка типу: абстрактний тип.
Натомість, необхідно використати виклик конструктора, що приховує тип.
classOf[String]
Визначити клас (Class[String] = class java.lang.String).
x.isInstanceOf[String]
Перевірка типу під час виконання (runtime).
x.asInstanceOf[String]
Приведення типу під час виконання (runtime).
x: String
Приписування типу під час компіляції (compile time). 
опції (options) 
Some(42)
Конструктор для непустого опціонального значення (тип Some[T]).
None
Конструктор для пустого опціонального значення (тип None).
Option(null) == None
+Option(24) == Some(24)

+      
obj.unsafeMethod // number or null
+Option(obj.unsafeMethod) // Some or None

+      проте
+      
Some(null) != None
Null-safe конструктор опціональних значень.
val optStr: Option[String] = None

+      так само, як і
+      
val optStr = Option.empty[String]
Явна типізація опціонального значення.
 Конструктор пустих опціональних значень.
val name: Option[String] =
+  request.getParameter("name")
+val upper = name.map {
+  _.trim
+} filter {
+  _.length != 0
+} map {
+  _.toUpperCase
+}
+println(upper.getOrElse(""))
Конвеєрний стиль.
val upper = for {
+  name <- request.getParameter("name")
+  trimmed <- Some(name.trim)
+    if trimmed.length != 0
+  upper <- Some(trimmed.toUpperCase)
+} yield upper
+println(upper.getOrElse(""))
Синтаксис у циклі for.
option.map(f(_))

+      так само, як і
+      
option match {
+  case Some(x) => Some(f(x))
+  case None    => None
+}
Застосування функції до опціонального значення.
option.flatMap(f(_))

+      так само, як і
+      
option match {
+  case Some(x) => f(x)
+  case None    => None
+}
Так само, як і mapб але функція має повернути опціональне значення.
optionOfOption.flatten

+      так само, як і
+      
optionOfOption match {
+  case Some(Some(x)) => Some(x)
+  case _             => None
+}
Екстракція вкладених опціональних значень.
option.foreach(f(_))

+      так само, як і
+      
option match {
+  case Some(x) => f(x)
+  case None    => ()
+}
Застосувати процедуру на опціональному значенні.
option.fold(y)(f(_))

+      так само, як і
+      
option match {
+  case Some(x) => f(x)
+  case None    => y
+}
Застосувати функцію на опціональному значенні та повернути значення, якщо воно порожнє.
option.collect {
+  case x => ...
+}

+      так само, як і
+      
option match {
+  case Some(x) if f.isDefinedAt(x) => ...
+  case Some(_)                     => None
+  case None                        => None
+}
Виконати часткове зіставлення зі зразком опціонального значення.
option.isDefined

+      так само, як і
+      
option match {
+  case Some(_) => true
+  case None    => false
+}
true якщо не порожнє.
option.isEmpty

+      так само, як і
+      
option match {
+  case Some(_) => false
+  case None    => true
+}
true якщо порожнє.
option.nonEmpty

+      так само, як і
+      
option match {
+  case Some(_) => true
+  case None    => false
+}
true якщо не порожнє.
option.size

+      так само, як і
+      
option match {
+  case Some(_) => 1
+  case None    => 0
+}
0 якщо порожнє, інакше 1.
option.orElse(Some(y))

+      так само, як і
+      
option match {
+  case Some(x) => Some(x)
+  case None    => Some(y)
+}
Оцінити та повернути альтернативне опціональне значення, якщо порожнє.
option.getOrElse(y)

+      так само, як і
+      
option match {
+  case Some(x) => x
+  case None    => y
+}
Оцінити та повернути значення за замовчуванням, якщо порожнє.
option.get

+      так само, як і
+      
option match {
+  case Some(x) => x
+  case None    => throw new Exception
+}
Повернути значення, або помилку, якщо порожнє.
option.orNull

+      так само, як і
+      
option match {
+  case Some(x) => x
+  case None    => null
+}
Повернути значення, null якщо порожнє.
option.filter(f)

+      так само, як і
+      
option match {
+  case Some(x) if f(x) => Some(x)
+  case _               => None
+}
Фільтрація опціонального значення. Повернути значення, якщо предикат істинний.
option.filterNot(f(_))

+      так само, як і
+      
option match {
+  case Some(x) if !f(x) => Some(x)
+  case _                => None
+}
Фільтрація опціонального значення. Повернути значення, якщо предикат хибний.
option.exists(f(_))

+      так само, як і
+      
option match {
+  case Some(x) if f(x) => true
+  case Some(_)         => false
+  case None            => false
+}
Повернути значення предикату на опціональному значенні або false якщо порожнє.
option.forall(f(_))

+      так само, як і
+      
option match {
+  case Some(x) if f(x) => true
+  case Some(_)         => false
+  case None            => true
+}
Повернути значення предикату на опціональному значенні або true якщо порожнє..
option.contains(y)

+      так само, як і
+      
option match {
+  case Some(x) => x == y
+  case None    => false
+}
Перевіряє чи дорівнює опціональне значення параметру, false якщо порожнє.

diff --git a/_uk/index.md b/_uk/index.md
index 211050d3f1..298a5b8a18 100644
--- a/_uk/index.md
+++ b/_uk/index.md
@@ -105,7 +105,7 @@ scala2-sections:
       - title: "Шпаргалка"
         description: "Зручна шпаргалка з основ синтаксису Scala."
         icon: "fa fa-list"
-        link: /cheatsheets/index.html
+        link: /uk/cheatsheets/index.html
       - title: "Питання-Відповіді"
         description: "Відповіді на часті запитання про Scala."
         icon: "fa fa-question-circle"

From 337d5c66e7bd8298b42176d7bf23b16ec5192267 Mon Sep 17 00:00:00 2001
From: Dmytro Kazanzhy 
Date: Wed, 1 Jun 2022 20:09:35 +0300
Subject: [PATCH 2/2] Fix of some mistakes

---
 _uk/cheatsheets/index.md | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/_uk/cheatsheets/index.md b/_uk/cheatsheets/index.md
index 80caabc188..24412df349 100644
--- a/_uk/cheatsheets/index.md
+++ b/_uk/cheatsheets/index.md
@@ -54,7 +54,7 @@ language: uk
     
     
       
def f(x: R)
 vs.
 
def f(x: => R)

-      Виклик-за-значенням.

Виклик-за-іменем (розрахунок параметру відкладено).
+      Виклик-за-значенням.

Виклик-за-іменем (аргумент обчислюється кожен раз як до нього звертаються).
     
     
       
(x: R) => x * x

@@ -66,7 +66,7 @@ language: uk
     
     
       
(1 to 5).map(x => x * x)

-      Анонімна функція: зліва від => задається ім'я змінної, якій буде присвоєно аргумент та яку можна використати справа.
+      Анонімна функція: щоб використати аргумент двічі, треба його назвати. Зліва від => задається ім'я змінної, якій буде присвоєно аргумент та яку можна використати справа.
     
     
       
(1 to 5).map { x =>
@@ -172,7 +172,7 @@ language: uk
     
     
       
var xs = List(1, 2, 3)

-      Список (немутабельний).
+      Список (імутабельний, тобто такий, що не змінюється).
     
     
       
xs(2)

@@ -260,7 +260,7 @@ breakable {
   val div = x / y.toFloat
   println("%d/%d = %.1f".format(x, y, div))
 }

-      Цикл for: імперативність.
стильsprintf.
+      Цикл for: імперативізм.
стильsprintf.
     
     
       
for (i <- 1 to 5) {
@@ -293,7 +293,7 @@ breakable {
   case v42 => println("42")
   case _   => println("Not 42")
 }

-      v42 буде інтерпретовано так само як ім'я змінної, яка буде вірно зіставлена з будь-яким Int значенням, і буде виведено “42”.
+      v42 буде інтерпретовано як ім'я змінної у зразку, яка буде вірно зіставлена з будь-яким Int значенням, і буде виведено “42”.
     
     
       Вірно

@@ -302,7 +302,7 @@ breakable {
   case `v42` => println("42")
   case _     => println("Not 42")
 }
- `v42` у зворотних галочках буде інтерпретовано як значення змінної v42, і буде виведено “Not 42”. + `v42` у зворотних галочках буде інтерпретовано як значення наявної змінної v42, і буде виведено “Not 42”. Вірно
@@ -311,7 +311,7 @@ breakable { case UppercaseVal => println("42") case _ => println("Not 42") } - UppercaseVal буде інтерпретовано так само як наявна змінна, а не патерн, тому що починається з великої літери. Тому значення, що міститься в UppercaseVal буде порівняно з 24, і буде виведено “Not 42”. + UppercaseVal буде інтерпретовано так само як наявна змінна, а не нова змінна в патерні. Тому значення, що міститься в UppercaseVal буде порівняно з 24, і буде виведено “Not 42”. об'єктна орієнтація @@ -375,11 +375,11 @@ breakable { Невірно
new List[Int]

Вірно
List(1, 2, 3)
- Помилка типу: абстрактний тип.
Натомість, необхідно використати виклик конструктора, що приховує тип. + Помилка типу: абстрактний тип.
Натомість, існує конвенція у таких випадках використовувати фабричний метод обʼєкту компаньйону, що приховує конкретний тип. 
classOf[String]
- Визначити клас (Class[String] = class java.lang.String). + Літерал класу (Class[String] = class java.lang.String). 
x.isInstanceOf[String]
@@ -404,7 +404,7 @@ breakable { 
None
- Конструктор для пустого опціонального значення (тип None). + Одинак (Singleton) пустого опціонального значення (тип None). 
Option(null) == None
@@ -413,13 +413,13 @@ Option(24) == Some(24)
Option(obj.unsafeMethod) // Some or None проте 
Some(null) != None
- Null-safe конструктор опціональних значень. + Null-safe фабрика опціональних значень. 
val optStr: Option[String] = None
так само, як і 
val optStr = Option.empty[String]
- Явна типізація опціонального значення.
Конструктор пустих опціональних значень. + Явна типізація опціонального значення.
Фабричний метод для створення пустих опціональних значень. 
val name: Option[String] =
@@ -442,7 +442,7 @@ println(upper.getOrElse(""))
upper <- Some(trimmed.toUpperCase) } yield upper println(upper.getOrElse("")) - Синтаксис у циклі for. + Синтаксис for-виразу. 
option.map(f(_))
@@ -469,7 +469,7 @@ println(upper.getOrElse("")) case Some(Some(x)) => Some(x) case _ => None } - Екстракція вкладених опціональних значень. + Вилучення вкладених опціональних значень. 
option.foreach(f(_))
@@ -544,7 +544,7 @@ println(upper.getOrElse("")) case Some(x) => Some(x) case None => Some(y) } - Оцінити та повернути альтернативне опціональне значення, якщо порожнє. + Обчислити та повернути альтернативне опціональне значення, якщо порожнє. 
option.getOrElse(y)
@@ -553,7 +553,7 @@ println(upper.getOrElse("")) case Some(x) => x case None => y } - Оцінити та повернути значення за замовчуванням, якщо порожнє. + Обчислити та повернути значення за замовчуванням, якщо порожнє. 
option.get
@@ -562,7 +562,7 @@ println(upper.getOrElse("")) case Some(x) => x case None => throw new Exception } - Повернути значення, або помилку, якщо порожнє. + Повернути значення, або згенерувати виключення, якщо порожнє. 
option.orNull