/*

type Fun<a,b> = {
    (input:a) : b
    then<c>(input2: Fun<b,c>) : Fun<a,c>;
}

const Functie = function<a,b>(lambda: ((_:a) => b)) : Fun<a,b> {
    const fun = lambda as Fun<a,b>
    
    fun.then = function<c>(this: Fun<a,b>, otherFunc: Fun<b,c>) : Fun<a,c> {
        return Functie<a,c>(x => otherFunc(this(x)))
    }

    return fun 
}


// fun as monad 

// fun functor 
type Fun_n<a> = Fun<number, a>
let map_Fun_n = <a,b>(f: Fun<a,b>, p: Fun_n<a>) : Fun_n<b> => p.then(f)

// fun monoid
let unit_Fun_n = <a>() => Fun<a, Fun_n<a>>(x => Functie(i => x))
let join_Fun_n = <a>() => Fun<Fun_n<Fun_n<a>>, Fun_n<a>> (nestedFun_N => Functie(numberInput => nestedFun_N(numberInput)(numberInput)))

let join_Fun_beter: Fun<Fun_n<Fun_n<number>>, Fun_n<number>> = Functie((nestedFun_N: Fun_n<Fun_n<number>>) => {
    return Functie((numberInput: number) => {
        let tmp1 = nestedFun_N(numberInput);
        console.log(tmp1);
        
        let tmp2 = tmp1(numberInput);
        console.log(tmp2);

        return tmp2;
    });
});

let incrDounbleFun: Fun_n<Fun_n<number>> = Functie((numberInput: number) => {
    return Functie((numberInput2: number) => {
        return numberInput + numberInput2;
    });
});