infinityf makes javascript able to use infinity call stack if you have enought memory.
It works exactly the same as vanilla function. There are ways to use infinity function:
###callback Best performance. It receive return data in callback function. Not support async.
Code is a little bit dirty, i don't recommend for the projects using dynamic function call.
###async Bad performance(in non blocking code). It receive return data by await expression. Support async.
I think if use this async infinity function as "async function", it will almost don't depress performance.
###generator Good performance. It receive return data by yield expression. Not support async.
I recommend this way for general projects.
$ npm install infinityf
var fibo = (n) => {
if(n <= 2)
return 1;
return fibo(n-1) + fibo(n-2);
};
console.log(fibo(10));
this code is the same as :
1.callback
const infinityf = require("infinityf");
var infFibo = (get,arg) => {
if(arg <= 2)
return 1;
get(infFibo, arg-1, (v1)=>{
get(infFibo, arg-2, (v2)=> {
return v1 + v2;
});
});
};
console.log(infinityf.callback(infFibo,10));
2.async
const infinityf = require("infinityf");
var infFibo = async (get,arg) => {
if(arg <= 2)
return 1;
return await get(infFibo, arg-1) + await get(infFibo, arg-2);
};
infinityf.async(infFibo,10).then(returnValue => {
console.log(returnValue);
});
3.generator
const infinityf = require("infinityf");
var infFibo = function* (get,arg) {
if(arg <= 2)
return 1;
return (yield get(infFibo, arg-1)) + (yield get(infFibo, arg-2));
};
console.log(infinityf.generator(infFibo,10));
infinityf runs InfinityFunction f with arg and return result.
1.callback
console.log(infinityf.callback(f,arg));
2.async
infinityf.async(f,arg).then(returnedValue => {
console.log(returnValue);
});
3.generator
console.log(infinityf.generator(f,arg));
String, "callback" or "async" or "generator"
Function, it have to be same type as InfinityFunctionType.
1.callback
let f = (get,arg) => {
get(func, otherArg, returnedValue => {
...
});
};
In callback infinity function / callback function, only call "get" once.
2.async
let f = async (get,arg) => {
let returnedValue = await get(func, otherArg);
...
};
3.generator
let f = function* (get,arg) => {
let returnedValue = yield get(func, otherArg); //use yield to ONLY call get function
...
}
get function is used to get other InfinityFunction's result with args. After get other InfinityFunction's result, it will call callback with result.
Simple.
let returnedValue = await get(func, arg); //IN ASYNC INFINITY FUNCTION
let returnedValue = yield get(func, arg); //IN GENERATOR INFINITY FUNCTION
Simple..
return returnValue; //IN ASYNC / GENERATOR INFINITY FUNCTION
just return.
After call the get function, do not use return because return don't do anything. and I recommend to don't run anything after use get function.
let myFunction = (get,arg) => {
get(otherIF,7,data=>{
console.log(`otherIF's result: ${data}`);
});
otherF(); //NOT GOOD.
};
CallbackFunction is not a real type(class). CallbackFunction is made by user code, like this:
let myFunction = (get,arg) => {
get(otherIF,7,data=>{ //<= this is CallbackFunction
console.log(`otherIF's result: ${data}`);
});
};
You can return the value in everywhere in InfinityFunction (callback). InfinityFunction (callback) or CallbackFunction.
this is a fibonacci number function:
const infinityf = require("infinityf");
var infFibo = (get,arg) => {
if(arg <= 2)
return 1; //can return
get(infFibo, arg-1, (v1)=>{
get(infFibo, arg-2, (v2)=> {
return v1 + v2; //can return in CallbackFunction
});
});
};
console.log(infinityf(infFibo,10));