Apply suggestions from code review

Co-Authored-By: ca11ado <projects.tlt@yandex.ru>

Author: lex111

1-js/06-advanced-functions/11-currying-partials/1-ask-currying/solution.md

@@ -8,7 +8,7 @@
 
     Теперь `user` берётся из внешних переменных, и всё выполняется правильно.
 
-2. Либо сделайте из `user.login` функцию частичного применения, которая использует `user`, как контекст, и у которой установлен правильный первый аргумент:
+2. Либо сделайте из `user.login` функцию частичного применения, которая использует `user` как контекст, и которой передан корректный первый аргумент:
 
 
     ```js 

1-js/06-advanced-functions/11-currying-partials/1-ask-currying/task.md

@@ -8,7 +8,7 @@ importance: 5
 
 Объект `user` был изменён. Теперь, вместо двух функций `loginOk/loginFail`,  у него одна функция: `user.login(true/false)`.
 
-Что нужно передать функции `askPassword` в коде ниже, чтобы она вызывала `user.login(true)`, как `ok`, и `user.login(false)`, как `fail`?
+Что нужно передать функции `askPassword` в коде ниже, чтобы она вызывала `user.login(true)` как `ok` и `user.login(false)` как `fail`?
 
 ```js
 function askPassword(ok, fail) {

1-js/06-advanced-functions/11-currying-partials/article.md

@@ -1,11 +1,11 @@
-библиотеки:
+libs:
   - lodash
 
 ---
 
 # Каррирование (currying) и частичное применение (partial application)
 
-До сих пор мы говорили только о привязывании "this". Давайте шагнём дальше.
+До сих пор мы говорили только о привязывании `this`. Давайте шагнём дальше.
 
 Мы можем привязать не только `this`, но и аргументы. Это делается редко, но иногда может быть полезно.
 
@@ -40,7 +40,7 @@ alert( double(4) ); // = mul(2, 4) = 8
 alert( double(5) ); // = mul(2, 5) = 10
 ```
 
-Вызов `mul.bind(null, 2)` создаёт новую функцию `double`, которая передаёт вызов `mul`, фиксируя `null`, как контекст и `2` -- как первый аргумент. Следующие аргументы передаются "как есть".
+Вызов `mul.bind(null, 2)` создаёт новую функцию `double`, которая передаёт вызов `mul`, фиксируя `null` как контекст и `2` -- как первый аргумент. Следующие аргументы передаются "как есть".
 
 Это называется [частичное применение](https://ru.wikipedia.org/wiki/Частичное_применение) -- мы создаём новую функцию, фиксируя некоторые из существующих параметров.
 
@@ -64,11 +64,11 @@ alert( triple(5) ); // = mul(3, 5) = 15
 
 Для чего мы обычно создаём функцию с частичным применением?
 
-Польза от этого в том, что мы можем создать независимую функцию с понятным названием (`double`, `triple`). Мы можем использовать её и не передавать каждый раз первый аргумент, т.к. он зафиксирован с помощью `bind`.
+Польза от этого в том, что возможно создать независимую функцию с понятным названием (`double`, `triple`). Мы можем использовать её и не передавать каждый раз первый аргумент, т.к. он зафиксирован с помощью `bind`.
 
-В других случаях, частичное применение полезно, когда у нас есть очень общая функция и, для удобства, мы хотим создать её частный случай.
+В других случаях частичное применение полезно, когда у нас есть очень общая функция и для удобства мы хотим создать её частный случай.
 
-Например, у нас есть функция `send(from, to, text)`. Потом, внутри объекта `user`, мы можем захотеть использовать её частный случай: `sendTo(to, text)`, который отправляет текст от имени текущего пользователя.
+Например, у нас есть функция `send(from, to, text)`. Потом внутри объекта `user` мы можем захотеть использовать её частный случай: `sendTo(to, text)`, который отправляет текст от имени текущего пользователя.
 
 ## Частичное применение без контекста
 
@@ -110,7 +110,7 @@ user.sayNow("Hello");
 - Затем передаёт ей `...argsBound` -- аргументы из "частичного" вызова (`"10:00"`)
 - Затем передаёт ей `...args` -- аргументы полученные обёрткой (`"Hello"`)
 
-Итак, это не сложно сделать с помощью оператора `spread`?
+Итак, это легко сделать с помощью оператора расширения?
 
 Так же есть готовый вариант [_.partial](https://lodash.com/docs#partial) из библиотеки lodash.
 
@@ -122,7 +122,7 @@ user.sayNow("Hello");
 
 Каррирование не вызывает функцию. Оно просто трансформирует её.
 
-Давайте создадим функцию-помощник `curry(f)`, которая выполняет каррирование функции `f` с двумя аргументами. Другими словами, `curry(f)` для функции с двумя аргументами `f(a, b)` трансформирует её в `f(a)(b)`.
+Давайте создадим вспомогательную функцию `curry(f)`, которая выполняет каррирование функции `f` с двумя аргументами. Другими словами, `curry(f)` для функции с двумя аргументами `f(a, b)` трансформирует её в `f(a)(b)`.
 
 ```js run
 *!*
@@ -145,21 +145,21 @@ let carriedSum = curry(sum);
 alert( carriedSum(1)(2) ); // 3
 ```
 
-Как вы видите, имплементация -- это серия обёрток.
+Как вы видите, реализация состоит из множества обёрток.
 
 - Результат `curry(func)` -- обёртка `function(a)`.
 - Когда она вызывается как `sum(1)`, аргумент сохраняется в лексическом окружении и возвращается новая обёртка `function(b)`.
 - When it is called like `sum(1)`, the argument is saved in the Lexical Environment, and a new wrapper is returned `function(b)`.
 - После чего `sum(1)(2)`, наконец, вызывает `function(b)`, предоставляя `2` и передаёт вызов к оригинальной функции `sum`, принимающей несколько аргументов.
 
-Более продвинутая имплементация каррирования, как [_.curry](https://lodash.com/docs#curry) из библиотеки lodash, делает нечто более сложное. Она возвращает обёртку, которая позволяет выполнить функцию, если переданы все аргументы, в противном же случае -- возвращает функцию частичного применения.
+Более продвинутая реализация каррирования, как [_.curry](https://lodash.com/docs#curry) из библиотеки lodash, делает нечто более сложное. Она возвращает обёртку, которая позволяет выполнить функцию, если переданы все аргументы, в противном же случае -- возвращает функцию частичного применения.
 
 ```js
 function curry(f) {
   return function(...args) {
     // if args.length == f.length (количество аргументов, принимаемое f).
     //   тогда передаёт вызов f
-    //  в противном случае, возвращает функцию частичного применения, которая фиксирует первые аргументы
+    // в противном случае возвращает функцию частичного применения, которая фиксирует первые аргументы
   };
 }
 ```
@@ -168,7 +168,7 @@ function curry(f) {
 
 Чтобы понять выгоду, нам определенно нужен пример из реальной жизни.
 
-Продвинутое каррирование позволяет вызывать функцию, и нормально, и частично.
+Продвинутое каррирование позволяет вызывать функцию, как обычно, так и частично.
 
 Например, у нас есть функция логирования `log(date, importance, message)`, которая подготавливает и выводит информацию. В реальных проектах у таких функций есть много других полезных возможностей, например, посылать логи по сети:
 
@@ -216,11 +216,11 @@ todayDebug("message"); // [HH:mm] DEBUG message
 
 Итак:
 1. Мы ничего не потеряли после каррирования: `log` всё так же можно вызывать нормально.
-2. Мы смоглиол создать функции с частичным применением, как сделали для логов с текущим временем.
+2. Мы смогли создать функции с частичным применением, как сделали для логов с текущим временем.
 
-## Продвинутая имплементация каррирования
+## Продвинутая реализация каррирования
 
-В случае, если вам интересны детали (не обязательно!), вот "продвинутая" имплементация каррирования, которую мы могли бы испольовать выше.
+В случае, если вам интересны детали (не обязательно!), вот "продвинутая" реализация каррирования, которую мы могли бы использовать выше.
 
 Она очень короткая:
 
@@ -274,7 +274,7 @@ function curried(...args) {
 Когда мы запускаем её, есть два пути:
 
 1. Вызвать сейчас: если количество переданных аргументов `args` совпадает с количеством аргументов при объявлении функции (`func.length`) или больше, тогда вызов просто переходит к ней.
-2. Частичное применение: в противном случае, `func` не вызывается сразу. Вместо этого, возвращается другая обёртка `pass`, которая снова применит `curried`, передав предыдущие аргументы вместе с новыми. Затем, при новом вызове, мы опять получим, либо новое частичное применение (если аргументов не достаточно), либо, наконец, результат.
+2. Частичное применение: в противном случае `func` не вызывается сразу. Вместо этого, возвращается другая обёртка `pass`, которая снова применит `curried`, передав предыдущие аргументы вместе с новыми. Затем при новом вызове, мы опять получим, либо новое частичное применение (если аргументов не достаточно), либо, наконец, результат.
 
 Например, давайте посмотрим, что произойдёт в случае `sum(a, b, c)`. У неё три аргумента, так что `sum.length = 3`.
 
@@ -295,7 +295,7 @@ function curried(...args) {
 ```smart header="Немного больше, чем каррирование"
 По определению, каррирование должно превращать `sum(a, b, c)` в `sum(a)(b)(c)`.
 
-Но, как было описано, большинство имплементаций каррирования в JavaScript более продвинуты: они так же оставляют вариант вызова функции с несколькими аргументами.
+Но, как было описано, большинство реализаций каррирования в JavaScript более продвинуты: они также оставляют вариант вызова функции с несколькими аргументами.
 ```
 
 ## Итого
@@ -304,7 +304,7 @@ function curried(...args) {
 
     Частичное применение удобно, когда мы не хотим повторять один и тот же аргумент много раз. Например, когда у нас есть функция `send(from, to)`, и `from` всё время будет одинаков для нашей задачи, мы можем выполнить частичное применение и дальше работать с ним.
 
-- *Каррирование* -- это трансформация, которая превращает вызов `f(a, b, c)` в `f(a)(b)(c)`. В JavaScript имплементации обычно позволяют вызывать функцию обоими вариантами: либо 
+- *Каррирование* -- это трансформация, которая превращает вызов `f(a, b, c)` в `f(a)(b)(c)`. В JavaScript реализация обычно позволяют вызывать функцию обоими вариантами: либо 
 нормально, либо возвращают частичное применение, если количество аргументов недостаточно.
 
     Каррирование подходит тогда, когда мы хотим легко использовать частичное применение. Как мы видели в примерах с логами: универсальная функция `log(date, importance, message)` после каррирования возвращает нам частичное применение, когда вызывается с одним аргументом, как `log(date)` или двумя аргументами, как `log(date, importance)`.