diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js
@@ -1,5 +1,5 @@
function spy(func) {
-  // your code
}


diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md
@@ -1 +1 @@
-Here we can use `calls.push(args)` to store all arguments in the log and `f.apply(this, args)` to forward the call.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
@@ -2,17 +2,17 @@ importance: 5

---

-# Spy decorator

-Create a decorator `spy(func)` that should return a wrapper that saves all calls to function in its `calls` property.

-Every call is saved as an array of arguments.

-For instance:

```js
function work(a, b) {
-  alert( a + b ); // work is an arbitrary function or method
}

*!*
@@ -27,4 +27,4 @@ for (let args of work.calls) {
}
```

-P.S. That decorator is sometimes useful for unit-testing. Its advanced form is `sinon.spy` in [Sinon.JS](http://sinonjs.org/) library.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md
@@ -1,4 +1,4 @@
-The solution:

```js run demo
function delay(f, ms) {
@@ -11,22 +11,22 @@ function delay(f, ms) {

let f1000 = delay(alert, 1000);

-f1000("test"); // shows "test" after 1000ms
```

-Please note how an arrow function is used here. As we know, arrow functions do not have own `this` and `arguments`, so `f.apply(this, arguments)` takes `this` and `arguments` from the wrapper.

-If we pass a regular function, `setTimeout` would call it without arguments and `this=window` (assuming we're in the browser).

-We still can pass the right `this` by using an intermediate variable, but that's a little bit more cumbersome:

```js
function delay(f, ms) {

  return function(...args) {
-    let savedThis = this; // store this into an intermediate variable
    setTimeout(function() {
-      f.apply(savedThis, args); // use it here
    }, ms);
  };


diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/task.md
@@ -2,25 +2,25 @@ importance: 5

---

-# Delaying decorator

-Create a decorator `delay(f, ms)` that delays each call of `f` by `ms` milliseconds.

-For instance:

```js
function f(x) {
  alert(x);
}

-// create wrappers
let f1000 = delay(f, 1000);
let f1500 = delay(f, 1500);

-f1000("test"); // shows "test" after 1000ms
-f1500("test"); // shows "test" after 1500ms
```

-In other words, `delay(f, ms)` returns a "delayed by `ms`" variant of `f`.

-In the code above, `f` is a function of a single argument, but your solution should pass all arguments and the context `this`.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/task.md
@@ -2,23 +2,23 @@ importance: 5

---

-# Debounce decorator

-The result of `debounce(f, ms)` decorator should be a wrapper that passes the call to `f` at maximum once per `ms` milliseconds.

-In other words, when we call a "debounced" function, it guarantees that all other future in the closest `ms` milliseconds will be ignored.

-For instance:

```js no-beautify
let f = debounce(alert, 1000);

-f(1); // runs immediately
-f(2); // ignored

-setTimeout( () => f(3), 100); // ignored ( only 100 ms passed )
-setTimeout( () => f(4), 1100); // runs
-setTimeout( () => f(5), 1500); // ignored (less than 1000 ms from the last run)
```

-In practice `debounce` is useful for functions that retrieve/update something when we know that nothing new can be done in such a short period of time, so it's better not to waste resources.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md
@@ -30,10 +30,10 @@ function throttle(func, ms) {
}
```

-A call to `throttle(func, ms)` returns `wrapper`.

-1. During the first call, the `wrapper` just runs `func` and sets the cooldown state (`isThrottled = true`).
-2. In this state all calls memorized in `savedArgs/savedThis`. Please note that both the context and the arguments are equally important and should be memorized. We need them simultaneously to reproduce the call.
-3. ...Then after `ms` milliseconds pass, `setTimeout` triggers. The cooldown state is removed (`isThrottled = false`). And if we had ignored calls, then `wrapper` is executed with last memorized arguments and context.

-The 3rd step runs not `func`, but `wrapper`, because we not only need to execute `func`, but once again enter the cooldown state and setup the timeout to reset it.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
@@ -2,47 +2,47 @@ importance: 5

---

-# Throttle decorator

-Create a "throttling" decorator `throttle(f, ms)` -- that returns a wrapper, passing the call to `f` at maximum once per `ms` milliseconds. Those calls that fall into the "cooldown" period, are ignored.

-**The difference with `debounce` -- if an ignored call is the last during the cooldown, then it executes at the end of the delay.**

-Let's check the real-life application to better understand that requirement and to see where it comes from.

-**For instance, we want to track mouse movements.**

-In browser we can setup a function to run at every mouse movement and get the pointer location as it moves. During an active mouse usage, this function usually runs very frequently, can be something like 100 times per second (every 10 ms).

-**The tracking function should update some information on the web-page.**

-Updating function `update()` is too heavy to do it on every micro-movement. There is also no sense in making it more often than once per 100ms.

-So we'll wrap it into the decorator: use `throttle(update, 100)` as the function to run on each mouse move instead of the original `update()`. The decorator will be called often, but `update()` will be called at maximum once per 100ms.

-Visually, it will look like this:

-1. For the first mouse movement the decorated variant passes the call to `update`. That's important, the user sees our reaction to their move immediately.
-2. Then as the mouse moves on, until `100ms` nothing happens. The decorated variant ignores calls.
-3. At the end of `100ms` -- one more `update` happens with the last coordinates. 
-4. Then, finally, the mouse stops somewhere. The decorated variant waits until `100ms` expire and then runs `update` with last coordinates. So, perhaps the most important, the final mouse coordinates are processed.

-A code example:

```js
function f(a) {
  console.log(a)
};

-// f1000 passes calls to f at maximum once per 1000 ms
let f1000 = throttle(f, 1000);

-f1000(1); // shows 1
-f1000(2); // (throttling, 1000ms not out yet)
-f1000(3); // (throttling, 1000ms not out yet)

-// when 1000 ms time out...
-// ...outputs 3, intermediate value 2 was ignored
```

-P.S. Arguments and the context `this` passed to `f1000` should be passed to the original `f`.
Original file line number	Diff line number	Diff line change
		@@ -1 +1 @@
		Here we can use `calls.push(args)` to store all arguments in the log and `f.apply(this, args)` to forward the call.