console.log('_________CHALLENGE 01________');
let add = (a,b)=>a+b;
let mul = (a,b)=>a*b;
let sub = (a,b)=>a-b;
console.log('sum:',add(3,4));
console.log('mul:',mul(3,4));
console.log('sub:',sub(3,4));
let identityf = a=>()=>a;// same as function(a){retunr function(){return a;};}
let three = identityf(3);
console.log('three exec:',three());
let addf = a=>{
return function(b){
return a+b;
};
};
console.log('addf:',addf(3)(4));
let liftf = function(binaryFunc){
return function(a){
return function(b){
return binaryFunc(a,b);
};
};
};
let add2 = liftf(add);
console.log('liftf:',add2(3)(4));
/////////////////////////////////////////challenge 2///////////////////////////////
console.log('_________CHALLENGE 02________');
//let curry = function(binaryFunc, a){
// return function(b){
// return binaryFunc(a,b)
// }
//}
let curry = (bFunc, a)=> liftf(bFunc)(a);
let add3 = curry(add,3);
console.log('add3:',add3(5));
//let inc = addf(1);
//let inc = liftf(add)(1);
let inc = curry(add,1);
console.log('inc:',inc(inc(5)));
////////////////////challenge 3////////////////////////////
console.log('_________CHALLENGE 03________');
let twice = bf=>(a)=>bf(a,a);
let doubl = twice(add);
let square = twice(mul);
console.log('twice:',doubl(3));
console.log('twice2:',square(3));
let reverse = bf=>(a,b)=>bf(b,a);
let bus = reverse(sub);
console.log('reverse:',bus(2,3));
let composeu = (ufa, ufb)=>a=>ufb(ufa(a));
console.log('compose U:',composeu(doubl, square)(5));
let composeb = (bfa,bfb)=>(a,b,c)=>bfb(bfa(a,b),c);
console.log('compose B:', composeb(add, mul)(2,3,7));
let limit = (func, count)=>{
return function (a,b){
if (count){
count-=1;
return func(a,b);
}else{
return undefined;
}
};
};
let limitedAdd = limit(add,1);
console.log('limitedAdd 1:',limitedAdd(2,3));
console.log('limitedAdd 2:',limitedAdd(3,4));
console.log('limitedAdd 3:',limitedAdd(3,4));
////////////////////////challenge 04///////////////////////////////
console.log('_________CHALLENGE 04________');
let from = arg=>{
return ()=>{
let buffer = arg;
arg+=1;
return buffer;
};
};
let index = from(0);
console.log('call 01 of index:',index());
console.log('call 02 of index:',index());
console.log('call 03 of index:',index());
let to = (generator, limit)=>{
return ()=>{
let x = generator();
if (x<limit){
return x;
}
return undefined;
};
};
let limitedIndex = to(from(1), 3);
console.log('call 01 of limited index:', limitedIndex());
console.log('call 02 of limited index:', limitedIndex());
console.log('call 03 of limited index:', limitedIndex());
let fromTo = (a, b)=>{
return to(from(a), b);
};
let fromToIndex = fromTo(0, 3);
console.log('call 01 of fromTo index:', fromToIndex());
console.log('call 02 of fromTo index:', fromToIndex());
console.log('call 03 of fromTo index:', fromToIndex());
console.log('call 04 of fromTo index:', fromToIndex());
let element = (arr, gen)=>{
return ()=>{
let index = gen();
if(index!==undefined){
return arr[index];
}
return undefined;
};
};
let ele = element(['a','b','c','d'],fromTo(1, 3));
console.log('call 01 of element:', ele());
console.log('call 02 of element:', ele());
console.log('call 03 of element:', ele());
let elementV2 = (arr, gen)=>{
if (gen ===undefined){
gen = fromTo(0,arr.length);
}
return element(arr, gen);
};
let eleV2 = elementV2(['a','b','c','d']);
console.log('call 01 of elementV2:', eleV2());
console.log('call 02 of elementV2:', eleV2());
console.log('call 03 of elementV2:', eleV2());
console.log('call 04 of elementV2:', eleV2());
console.log('call 05 of elementV2:', eleV2());
////////////////////////challenge 05///////////////////////////////
console.log('_________CHALLENGE 05________');
let collect = (gen,arr)=>{
return ()=>{
let buffer = gen();
if (buffer!== undefined){
arr.push(buffer);
}
return buffer;
}
};
let array =[];
let col = collect(fromTo(0,2),array);
console.log('call 01 of collector:', col());
console.log('call 02 of collector:', col());
console.log('call 03 of collector:', col());
console.log('call 04 of collector:', col());
console.log('array:', array);
//Write a filter function that takes a generator and a predicate and produces a generator that produces only the values approved by the predicate.
let filter = (gen, pred)=>{
return ()=>{
let value = gen();
while(!pred(value) && value!==undefined){
value = gen();
}
return value;
};
};
let fil = filter (fromTo(0,5), value=>{return value%3===0;});
console.log('call 01 of filter:', fil());
console.log('call 02 of filter:', fil());
console.log('call 03 of filter:', fil());
console.log('call 04 of filter:', fil());
//Write a concat function that takes two generators and produces a generator that combines the sequences
let concat = (gen1, gen2)=>{
return ()=>{
let buffer = gen1();
if (buffer !== undefined){
return buffer
}
return gen2();
}
};
let con = concat (fromTo(0,3), fromTo(0,2));
console.log('call 01 of concat:', con());
console.log('call 02 of concat:', con());
console.log('call 03 of concat:', con());
console.log('call 04 of concat:', con());
console.log('call 05 of concat:', con());
console.log('call 06 of concat:', con());
////////////////////////challenge 06///////////////////////////////
console.log('_____________CHALLENGE 06_____________');
//Make a function gensymf that makes a function that generates unique symbols
let gensymf = symbol=>{
let count = 0;
return ()=>{
count += 1;
return symbol.toString()+count
};
};
let geng = gensymf('G');
let genh = gensymf('H');
console.log('call 01 of geng:', geng());
console.log('call 01 of genh:', genh());
console.log('call 02 of geng:', geng());
console.log('call 02 of genh:', genh());
//Make a function fibonaccif that returns a generator that will return the next fibonacci number
let fibonaccif = (a, b)=>{
return ()=>{
let next = a;
a = b;
b+= next;
return next;
}
}
let fib = fibonaccif(0,1);
console.log('call 01 of fib:', fib());
console.log('call 02 of fib:', fib());
console.log('call 03 of fib:', fib());
console.log('call 04 of fib:', fib());
console.log('call 05 of fib:', fib());
console.log('call 06 of fib:', fib());
