updated nots curried functions and also call and aplly

Author: rohan-paul

CSS/z-index.md

@@ -0,0 +1,20 @@
+```
+div {
+  z-index: 1; /* integer */
+}
+```
+
+**The z-index property in CSS controls the vertical stacking order of elements that overlap. As in, which one appears as if it is physically closer to you. z-index only affects elements that have a position value other than static (the default).**
+
+### Why z-index may not give expected results sometimes
+
+The element doesn’t have its position set
+One of the other guidelines that determine stacking order is if an element has its position set or not.
+
+To set position for an element, add the CSS position property to anything other than static, like relative or absolute. (You can read more about it in this article that I wrote.)
+
+According to this rule, positioned elements will display on top of unpositioned elements.
+
+### Further Reading
+
+[https://coder-coder.com/z-index-isnt-working/](https://coder-coder.com/z-index-isnt-working/)

Javascript/when-not-to-use-arrow-function.md renamed to Javascript/arrow-function/when-not-to-use-arrow-function.md

@@ -9,22 +9,21 @@ There is not big difference in performance. But we can say call is bit faster as
 ### Both call() and apply() are methods we can use to assign the this pointer for the duration of a method invocation.
 
 ```js
-global.x = 10;
-// To run this file in my vs-code or in terminal (i.e. where I am in node env)
-// I have to use global . where as < var x = 10 > will work in browser dev-tool
+global.x = 10
+/* To run this file in my vs-code or in terminal (i.e. where I am in node env),
+I have to use global . where as < var x = 10 > will work in browser dev-tool
 
-// var x = 10
+var x = 10 */
 
-var o = { x: 15 };
+var o = { x: 15 }
 
-function f () {
-    console.log(this.x);
+function f() {
+  console.log(this.x)
 }
 
-f();  // => 10
-
-f.call(o);  // => 15
+f() // => 10
 
+f.call(o) // => 15
 ```
 
 The first invocation of f() will display the value of 10, because this references the global object. The second invocation (via the call method) however, will display the value 15. 15 is the value of the x property inside object o.
@@ -41,19 +40,18 @@ A> https://stackoverflow.com/questions/1986896/what-is-the-difference-between-ca
 
 ### The value of this can never be null or undefined when a function is called. When null or undefined is supplied as the receiver to call() or apply(), the global object is used as the value for receiver instead.
 
-
 B> The apply function is used to call another function, with a given context and arguments, provided as an array. The min and max functions can take an arbitrary number of input arguments: Math.max(val1, val2, ..., valN)
 
 So if we call:
 
-``Math.min.apply(Math, [1,2,3,4]);``
+`Math.min.apply(Math, [1,2,3,4]);`
 
 The apply function will execute:
 
-``Math.min(1,2,3,4);``
+`Math.min(1,2,3,4);`
 
 Note that the first parameter, the context, is not important for these functions since they are static, they will work regardless of what is passed as the context.
 
-### Special note - With ES6, the equivalent code for the above is ``Math.max(...Arr)``
+### Special note - With ES6, the equivalent code for the above is `Math.max(...Arr)`
 
-Replacing “Math” with “null” would output same output
+Replacing “Math” with “null” would output same output

Javascript/call-function.md renamed to Javascript/call-apply-bind/call-function.md

@@ -0,0 +1,60 @@
+Example
+
+```js
+const add = (x, y) => x + y
+add(2, 3) // => 5
+```
+
+And now, below is the same function in curried form.
+
+```js
+const add = x => y => x + y
+```
+
+Same code without arrow syntax
+
+```js
+const add = function(x) {
+  return function(y) {
+    return x + y
+  }
+}
+```
+
+Calling curried functions
+
+So in order to use our curried function, we have to call it a bit differently …
+
+add(2)(3) // returns 5
+
+Focus on return
+
+It might help to visualize it another way. We know that arrow functions work like this – let's pay particular attention to the return value.
+
+```js
+const f = someParam => returnValue
+```
+
+So our add function returns a function – we can use parentheses for added clarity.
+
+```js
+const add = x => y => x + y
+```
+
+More than two arrow functions can be sequenced, if necessary -
+
+```js
+const three = a => b => c => a + b + c
+
+const four = a => b => c => d => a + b + c + d
+
+three(1)(2)(3) // 6
+
+four(1)(2)(3)(4) // 10
+```
+
+In other words add of some number returns a function
+
+#### Further Reading
+
+[stackoverflow.com/questions/32782922/what-do-multiple-arrow-functions-mean-in-javascript/32784025](https://stackoverflow.com/questions/32782922/what-do-multiple-arrow-functions-mean-in-javascript/32784025)