function unary (fn) {
    return function onlyOneArg(arg) {
        return fn(arg)
    }
}

const unary = fn => arg => fn(arg)

[1, 2, 3].map(parseInt); // [1, na, na]
// 解释一下为什么， parseInt 接收两个参数
// parseInt(a, b)
// a 要转换成整形的值
// b 要转换成数值的形式（二进制， 八进制， 十进制）

// function
function identity (v) {
    return v;
}
// arrow function
const identity = v => v;


// explames
// 1\. 空值检测
var words = "   Now is the time for all...  ".split( /\s|\b/ );

words.filter( identity );

// 2\. 参数为函数时， 作为该参数的默认值， 去掉原逻辑中，判断该参数是否函数的默认值
function output(msg,formatFn = identity) {
    msg = formatFn( msg );
    console.log( msg );
}

function upper(txt) {
    return txt.toUpperCase();
}

output( "Hello World", upper );     // HELLO WORLD
output( "Hello World" );            // Hello World

// don't work:
p1.then(foo).then(p2).then(bar)

// instead:
p1.then(foo).then(function () {return p2}).then(bar)

// or use arrow function
p1.then(foo).then(() =>  p2).then(bar)

// function 
function constant (v) {
    return function value () {
        return v;
    }
}

// arrow funtion
const constant = v => () => v;

// so you can use constant function
p1.then(foo).then(constant(p2)).then(bar)

function foo(x, y) {
    return x + y
}

fucntion bar (fn) {
    fn([3, 9])
}

function spreadArgs(fn) {
    return function speadFn(argsArr) {
        return fn(...argsArr)
    }
}

const spreadArgs = fn => argsArr => fn(...argsArr)

fucntion gatherArgs(fn) {
    return function gatheredFn(...argsArr) {
        return fn(argsArr)
    }
}

cosnt gatherArgs = fn => (...argsArr) => fn(argsArr)

function getPerson(data, cb) {
    Ajax('http://api/person', data, cb)
}
function getPerson(data, cb) {
    Ajax('http://api/person', data, cb)
}

// 这个时候， 我又需要一个定制的接口， 用于获取特定用户的信息
function getCurrentUser (cb) {
    getPerson({user: CURRENT_USER_ID}, cb)
}

function partial (fn, ...presetArgs) {
    return function partiallyApplied(...lastArgs) {
        return fn(...presetArgs, ...lastArgs)
    }
}

const partial = (fn, ...presetArgs) => (...lastArgs) => fn(...presetArgs, ...lastArgs)

function reverseArgs (fn) {
    return function argsReversed(...args) {
        fn(args.reverse())
    }
}

const reverseArgs = (fn) => (...args) =>  fn(args.reverse())

// 另一种partialRight的技巧
function partialRight (fn, presetArgs) {
    return function partiallyApplied (...laterArgs) {
        return fn(...laterArgs, ...presetArgs)
    }
}

const partialRight = (fn, ...presetArgs) => (...laterArgs) => fn(...later, ...presetArgs)

curriedAjax('http://some.api/person')({user: CURRENT_USER_ID})(function() { console.log('成功后的回调')})
// 或许以上的代码有点难以理解， 让我们把它拆分成
const personFetcher = curriedAjax('http://some.api/person');
var getCurrentUser = personFetcher({user: CURRENT_USER_ID});
getCurrentUser(function foundUser(user){//  成功后的回调})
// 这两种代码其实都是一个意思， 但是对于FP来说， 第一种风格就是我们提倡使用的

function curry(fn, arity = fn.length) {
    return (function nextCurried(prevArgs) {
        return function curried(nextArg) {
            var args = [...prevArgs, nextArg];

            if(args.length >= arity) {
                return fn(...args);
            }else {
                return nextCurried(args);
            }
        }
    })([])
}
const curry = (fn, arity = fn.length, nextCurried) => (nextCurried = prevArgs => nextArg => {
    var args = [...prevArgs, nextArg]

    if(args.length >= arity) {
        return fn(...args)
    }else {
        return nextCurried(args)
    }
})([])

const curriedAjax = curry(ajax)
const personFetcher = curriedAjax('http:some/api/person')

const getCurrentUser = personFetcher({user: CURRENT_USER_ID})

getCurrentUser(function callback () {
    // do something
})

// 再看一下之前的例子
const add = (a, b) => a + b

[1, 2, 3].map(curry(add)(3)) // 此时add函数中的a为3

funtion curriedSum (v1) {
    return function(v2) {
        return function (v3) {
            return function (v4) {
                return function (v5) {
                    return sum (v1, v2, v3, v4, v5)
                }
            }
        }
    }
}
// 用箭头函数
const curriedSum = v1 => v2 => v3 => v4 => v5 => sum(v1, v2, v3, v4, v5)

ajax(
    'http://some.api/person',
    {user: CURRENT_USER_ID},
    function foundUser(data) {

    }
)
// 让我们使用偏函数去优化它
const getCurrentUser = partial(
    ajax, 
    'http://some.api/person',
    {user: CURRENT_USER_ID}
);
getCurrentUser(function foundUser() {
    // do something
})

function looseCurry(fn, arity = fn.length) {
    return (function nextCurried(pervArgs){
        return function curried(...nextArgs) {
            var args = [...pervArgs, ...nextArgs]

            if(args.length >= arity) {
                return fn(...args)
            }else {
                return nextCurried(args)
            }
        }
    })([])
}

const looseCurry = (fn, arity = fn.length, nextCurried = pervArgs => (...nextArgs) => {
    var args = [...pervArgs, ...nextArgs]

    if(args.length > arity) {
        return fn(...args)
    }else {
        return nextCurried(args)
    }
})([])

function uncurry(fn) {
    return function uncurried (...args) {
        var ret = fn

        for(let arg in args) {
            ret = ret(arg)
        }

        return ret
    }
}

// =>
const uncurry = fn => (...args) => {
    var ret = fn

    for(let arg in args) {
        ret = ret(arg)
    }

    return ret
}

function partialProps(fn, presetArgsObj) {
    return function partiallyApplied(laterArgsObj) {
        return fn(Object.assign({}, presetArgsObj, laterArgsObj))
    }
}

function curryProps(fn,arity = 1) {
    return (function nextCurried(prevArgsObj){
        return function curried(nextArgObj = {}){
            var [key] = Object.keys( nextArgObj );
            var allArgsObj = Object.assign(
                {}, prevArgsObj, { [key]: nextArgObj[key] }
            );

            if (Object.keys( allArgsObj ).length >= arity) {
                return fn( allArgsObj );
            }
            else {
                return nextCurried( allArgsObj );
            }
        };
    })( {} );
}

function foo({ x, y, z } = {}) {
    console.log( `x:${x} y:${y} z:${z}` );
}

var f1 = curryProps( foo, 3 );
var f2 = partialProps( foo, { y: 2 } );

f1( {y: 2} )( {x: 1} )( {z: 3} );
// x:1 y:2 z:3

f2( { z: 3, x: 1 } );
// x:1 y:2 z:3

const sum = ({a=1, b=2, c=3}) => {
    return a + b + c;
}

sum({b: 5, a: 1}); // 9

const mockServer = () => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve({
                'status': 200,
                'content-type': 'application/json',
                'data': {
                    dataInfo: 42
                }
            })
        }, 1000);
    })
}

mockServer().then(({data: {dataInfo = 100 }}) => {
    console.log(dataInfo);
})

var nightMode = userSettings.nightMode || false;

const userSettings = { fontSize: 'large', nightMode: true };
const {
    nightMode = false,
    language = 'en',
    fontSize = 'normal'
} = userSettings;

console.log(nightMode, language, fontSize);

firstFunction(args, function() {
  secondFunction(args, function() {
    thirdFunction(args, function() {
      // And so on…
    });
  });
});

const makeBurger = () => {
  const beef = getBeef();
  const patty = cookBeef(beef);
  const buns = getBuns();
  const burger = putBeefBetweenBuns(buns, beef);
  return burger;
};
const burger = makeBurger();
serve(burger);

const makeBurger = () => {
  getBeef(function(beef) {
    // We can only cook beef after we get it.
  });
};

const makeBurger = () => {
  getBeef(function(beef) {
    cookBeef(beef, function(cookedBeef) {
      getBuns(function(buns) {
        // Put patty in bun
      });
    });
  });
};

const makeBurger = () => {
  getBeef(function(beef) {
    cookBeef(beef, function(cookedBeef) {
      getBuns(function(buns) {
        putBeefBetweenBuns(buns, beef, function(burger) {
            // Serve the burger
        });
      });
    });
  });
};

const makeBurger = nextStep => {
  getBeef(function (beef) {
    cookBeef(beef, function (cookedBeef) {
      getBuns(function (buns) {
        putBeefBetweenBuns(buns, beef, function(burger) {
          nextStep(burger)
        })
      })
    })
  })
}
// Make and serve the burger
makeBurger(function (burger) => {
  serve(burger)
})

// Makes a burger
// makeBurger contains four steps:
//   1. Get beef
//   2. Cook the beef
//   3. Get buns for the burger
//   4. Put the cooked beef between the buns
//   5. Serve the burger (from the callback)
// We use callbacks here because each step is asynchronous.
//   We have to wait for the helper to complete the one step
//   before we can start the next step
const makeBurger = nextStep => {
  getBeef(function(beef) {
    cookBeef(beef, function(cookedBeef) {
      getBuns(function(buns) {
        putBeefBetweenBuns(buns, beef, function(burger) {
          nextStep(burger);
        });
      });
    });
  });
};

const getBeef = nextStep => {
  const fridge = leftFright;
  const beef = getBeefFromFridge(fridge);
  nextStep(beef);
};

const cookBeef = (beef, nextStep) => {
  const workInProgress = putBeefinOven(beef);
  setTimeout(function() {
    nextStep(workInProgress);
  }, 1000 * 60 * 20);
};

const makeBurger = () => {
  return getBeef()
    .then(beef => cookBeef(beef))
    .then(cookedBeef => getBuns(beef))
    .then(bunsAndBeef => putBeefBetweenBuns(bunsAndBeef));
};
// Make and serve burger
makeBurger().then(burger => serve(burger));

const makeBurger = () => {
  return getBeef()
    .then(cookBeef)
    .then(getBuns)
    .then(putBeefBetweenBuns);
};
// Make and serve burger
makeBurger().then(serve);

const getBeefPromise = _ => {
  const fridge = leftFright;
  const beef = getBeefFromFridge(fridge);
  return new Promise((resolve, reject) => {
    if (beef) {
      resolve(beef);
    } else {
      reject(new Error(“No more beef!”));
    }
  });
};
const cookBeefPromise = beef => {
  const workInProgress = putBeefinOven(beef);
  return new Promise((resolve, reject) => {
    setTimeout(function() {
      resolve(workInProgress);
    }, 1000 * 60 * 20);
  });
};

// The function that’s defined for you
const functionName = (arg1, arg2, callback) => {
  // Do stuff here
  callback(err, stuff);
};
// How you use the function
functionName(arg1, arg2, (err, stuff) => {
  if (err) {
  console.error(err);
  }
  // Do stuff
});

const makeBurger = async () => {
  const beef = await getBeef();
  const cookedBeef = await cookBeef(beef);
  const buns = await getBuns();
  const burger = await putBeefBetweenBuns(cookedBeef, buns);
  return burger;
};
// Make and serve burger
makeBurger().then(serve);

const makeBurger = async () => {
  const [beef, buns] = await Promise.all(getBeef, getBuns);
  const cookedBeef = await cookBeef(beef);
  const burger = await putBeefBetweenBuns(cookedBeef, buns);
  return burger;
};
// Make and serve burger
makeBurger().then(serve);

let stack = Stack();
stack.push(1);
stack.push(2);
stack.push(3);
stack.pop(); //3
stack.pop(); //2

function Stack(){  
    let list = [];
    
    function push(value){ 
        list.push(value);
        
    }  
    function pop(){ 
        return list.pop(); 
    }    
    
    return Object.freeze({    
        push,    
        pop  
    });
}

stack.list; // undefined

stack.list = 0; //Cannot add property list, object is not extensible

let stack = new Stack();
stack.push(1);
stack.push(2);
stack.list = 0; //corrupt the private state
console.log(stack.pop()); //this.list.pop is not a function

class Stack {  
    constructor(){
        this.list = [];  
    }    

    push(value) { 
        this.list.push(value); 
    }  

    pop() { 
        return this.list.pop(); 
    }
}

let queue = Queue();
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);
queue.dequeue(); //1
queue.dequeue(); //2

function Queue(){  
    let list = [];    
    function enqueue(value){ 
        list.push(value);
    }  
    function dequeue(){ 
        return list.shift(); 
    }    
    return Object.freeze({    
        enqueue,    
        dequeue  
    });
}

queue.list; //undefined

// 初始化事件对象
let eventEmitter = EventEmitter();
// 订阅事件
eventEmitter.subscribe("update", doSomething);
eventEmitter.subscribe("update", doSomethingElse);
eventEmitter.subscribe("add", doSomethingOnAdd);

// 发布（触发之前的订阅）
eventEmitter.publish("update", {});

function doSomething(value) { };
function doSomethingElse(value) { };
function doSomethingOnAdd(value) { };

function EventEmitter(){  
    let subscribers = [];    
    function subscribe(type, callback){    
        subscribers[type] = subscribers[type] || [];    
        subscribers[type].push(callback);   
    }    
    function notify(value, fn){    
        try {      
            fn(value);
        } catch(e) { 
            console.error(e); 
        }  
    }    
    function publish(type, value){    
        if(subscribers[type]){      
            let notifySubscriber = notify.bind(null, value);      
            subscribers[type].forEach(notifySubscriber);    
        }  
    }    

    return Object.freeze({    
        subscribe,    
        publish  
    });
}

let timer = Timer(doSomething, 6000);
timer.start();
function doSomething(){}

function Timer(fn, interval){
    let timerId;
    function startRecursiveTimer(){  
        fn().then(function makeNewCall(){    
            timerId = setTimeout(startRecursiveTimer, interval);  
        });
    }

    function stop(){  
        if(timerId){    
            clearTimeout(timerId);    
            timerId = 0;  
        }
    }

    function start(){  
        if(!timerId){    
            startRecursiveTimer();  
        }
    }

    return Object.freeze({  start,  stop});  
}

let timer = Timer(getTodos, 2000);timer.start();

document.addEventListener("visibilitychange", toggleTimer);

function toggleTimer(){   
    if(document.visibilityState === "hidden"){     
        timer.stop();   
    }   
    
    if(document.visibilityState === "visible"){     
        timer.start();   
    }
}

var a = 1;
var a = 2;

//  a在内存中中是同一个地址， 因为在第一次定义的时候在内存中已经有a这个变量了， 第二次定义做了一次查询而已.

(sum) => {
    { // 大胡子推荐这种写法，显示的去告诉大家我需要let的块级作用域， 明确变量的范围
        let a = 1, 
            b = 2,
            c = 3;
        sum = a + b + c;
    }
    return sum;
}

const arr = [1, 2, 3]
arr = [2, 3, 4] // Throw Error
arr[0] = 2;
arr[1] = 3;
arr[2] = 4;

const obj = {
    a: 1
}

obj = {} // Throw Error
obj.a = 2; 

// 解决方案： freeze 但是注意， 分浅冻结和深冻结
Object.freeze();

a; // undefined
b; // undefined
var a = 1;
var b = 2;

var a;
var b;


a; // undefined
b; // undefined
a = 1;
b = 2;

a(); // a
function a () {
    console.log("a");
}

b(); // b is not a function 
var b = () => {console.log("b");};
b(); // b

var a = 'a';
function b () {
    console.log(a); // undefined
    var a = 'b';
}

// 实际上，js引擎做了以下处理
var a = 'a';
function b () {
    var a; // 初始化未赋值， 那么所有的初始值都是 undefined
    console.log(a); // undefined
    a = 'b';
}

{
    a = 'a'; // TDZ error
    let a; 
}

function x () {};
x.prototype = {
    sayHello: 'Hello'
};

function Car() {

}

Car.prototype = {
    washCar: 'wash',
    doors: true
}

function Honda () {

}

let HondaProto = new Car;

HondaProto.limit = function() {
    console.log('limit');
}

Honda.prototype = HondaProto;

function Electric () {

}

let ElectricProto = new Honda;

ElectricProto.electric = function () {
    console.log('electric');
}

Electric.prototype = ElectricProto;

let LX4Honda = new Electric();
console.log(LX4Honda.washCar);

const timer = (text) => {
    setTimeout(() => {
        console.log(test)
    }, 1000)
}
timer('Hello World.')

const printer = x => () => console.log(x);

var teacher = 'Kyle';

var myTeacher = () => {
    console.log(teacher);
    // 这里的变量引用是软链接，不是自己创建一个封闭的作用域
    // 它并没有把这个变量抓住， 生成一个副本
}

teacher = 'Suzy';
myTeacher(); // Suzy

for(var i = 0; i < 4; i++) {
    setTimout(() => {
        console.log(i)
    }, i * 1000);
}

// 解决方案1： let
for(var i = 0; i < 4; i++) {
    let j = i;
    setTimout(() => {
        console.log(j);
    }, j * 1000);
}
// 解决方案2： 匿名函数
var main = () => {
    for(var i = 0; i < 4; i++) {
        ((i)=> { // 在setTimeout外面写一个匿名函数，新建作用域， 形成闭包变量
            setTimeout(() => {
                console.log(i)
            }, i * 1000);
        })(i);
       
    }
}
main();
// 解决方案3： 匿名函数
var main = () => {
    for(var i = 0; i < 4; i++) {
        setTimeout(((i) => {
            return () => {
                console.log(i)
            }
        })(i), i * 1000);
    }
}
main();

var workspace = {
    name: 'Kyle',
    ask (quetion) {
        console.log(quetion);
    }
}
// 这是命名空间，并不是模块化

var workspace = (function Module(teacher) {
    var publicAPI = { ask };
    return publicAPI;

    function ask (quetion) {
        console.log(teacher, quetion); 
    }

})('Kyle');

workspace.ask('what?');

 
function Module(teacher) {
    var publicAPI = { ask };
    return publicAPI;

    function ask (quetion) {
        console.log(teacher, quetion); 
    }

};

var workspace = Module('Kyle');
workspace.ask('what?');

// file is workspace.mjs
var teacher = 'Kyle';

// 暴露单个ask
export default function ask (quetion) {
    console.log(teacher, quetion);
}

// 或者使用多个
export default {
    ask,
}

// main.js
import ask from 'workspace.mjs';

ask('what?');

// 或者你可以给你模块赋予别名

import * as workspace from 'workspace.mjs';

workspace.ask('what?');