// Basic function composition
function compose(f, g) {
    return function(x) {
        return f(g(x));
    };
}

// Example functions
const addOne = x => x + 1;
const double = x => x * 2;
const square = x => x * x;

// Create composed functions
const doubleAndAddOne = compose(addOne, double);
const squareAndDouble = compose(double, square);

console.log(doubleAndAddOne(3));  // 7 (double 3 = 6, add 1 = 7)
console.log(squareAndDouble(3));  // 18 (square 3 = 9, double = 18)

// Multiple function composition
function composeMultiple(...fns) {
    return function(x) {
        return fns.reduceRight((acc, fn) => fn(acc), x);
    };
}

const addOneDoubleThenSquare = composeMultiple(square, double, addOne);
console.log(addOneDoubleThenSquare(3));  // 64 (3+1=4, 4*2=8, 8^2=64)

// Partial application
function partial(fn, ...presetArgs) {
    return function(...laterArgs) {
        return fn(...presetArgs, ...laterArgs);
    };
}

function greet(greeting, name) {
    return `${greeting}, ${name}!`;
}

const sayHello = partial(greet, "Hello");
console.log(sayHello("John"));  // "Hello, John!"
console.log(sayHello("Sarah")); // "Hello, Sarah!"

// Advanced currying
function curry(fn) {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn(...args);
        }
        
        return function(...moreArgs) {
            return curried(...args, ...moreArgs);
        };
    };
}

function add(a, b, c) {
    return a + b + c;
}

const curriedAdd = curry(add);

console.log(curriedAdd(1)(2)(3));   // 6
console.log(curriedAdd(1, 2)(3));   // 6
console.log(curriedAdd(1)(2, 3));   // 6
console.log(curriedAdd(1, 2, 3));   // 6

// Generic memoization function
function memoize(fn) {
    const cache = new Map();
    
    return function(...args) {
        // Create a key from the arguments
        const key = JSON.stringify(args);
        
        if (cache.has(key)) {
            console.log("Returning from cache");
            return cache.get(key);
        }
        
        console.log("Calculating result");
        const result = fn(...args);
        cache.set(key, result);
        return result;
    };
}

// Example of an expensive function
function fibonacci(n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// Regular fibonacci is very slow for larger numbers
console.time("Regular fibonacci");
console.log(fibonacci(30));
console.timeEnd("Regular fibonacci");

// Memoized version is much faster
const memoizedFibonacci = memoize(function(n) {
    if (n <= 1) return n;
    return memoizedFibonacci(n - 1) + memoizedFibonacci(n - 2);
});

console.time("Memoized fibonacci");
console.log(memoizedFibonacci(30));
console.timeEnd("Memoized fibonacci");

// Basic generator function
function* countUp(max) {
    let count = 0;
    while (count < max) {
        yield count++;
    }
}

// Using the generator
const counter = countUp(5);
console.log(counter.next().value);  // 0
console.log(counter.next().value);  // 1
console.log(counter.next().value);  // 2
console.log(counter.next().value);  // 3
console.log(counter.next().value);  // 4
console.log(counter.next().value);  // undefined (generator is done)

// Infinite sequence generator
function* fibonacci() {
    let a = 0, b = 1;
    
    while (true) {
        yield a;
        [a, b] = [b, a + b];
    }
}

// Using the infinite generator (with a limit)
const fibGen = fibonacci();
for (let i = 0; i < 10; i++) {
    console.log(fibGen.next().value);  // 0, 1, 1, 2, 3, 5, 8, 13, 21, 34
}

// Generators for async operations
function* fetchSequentially(urls) {
    for (const url of urls) {
        try {
            const response = yield fetch(url);
            const data = yield response.json();
            yield data;
        } catch (error) {
            yield { error: error.message, url };
        }
    }
}

// Using generators with async/await (would be in an async function)
async function fetchAllData(urls) {
    const gen = fetchSequentially(urls);
    let result = gen.next();
    
    while (!result.done) {
        try {
            // Handle the yielded promises
            const value = await result.value;
            result = gen.next(value);
        } catch (error) {
            result = gen.throw(error);
        }
    }
}

// Using Proxy for validating object properties
function createValidatedObject(initialValues, validators) {
    return new Proxy(initialValues || {}, {
        set(target, property, value) {
            // Check if we have a validator for this property
            if (validators.hasOwnProperty(property)) {
                const validator = validators[property];
                const validationResult = validator(value);
                
                if (validationResult !== true) {
                    throw new Error(`Invalid value for ${property}: ${validationResult}`);
                }
            }
            
            // If valid or no validator, set the value
            target[property] = value;
            return true;
        }
    });
}

// Example usage
const user = createValidatedObject({
    name: "John",
    age: 30
}, {
    name: value => {
        if (typeof value !== 'string') return "Name must be a string";
        if (value.length < 2) return "Name must be at least 2 characters";
        return true;
    },
    age: value => {
        if (typeof value !== 'number') return "Age must be a number";
        if (value < 0) return "Age cannot be negative";
        if (value > 120) return "Age cannot be greater than 120";
        return true;
    }
});

// Valid operations
user.name = "Jane"; // Works fine
user.age = 25;      // Works fine

// These would throw errors
// user.name = "";       // Error: Name must be at least 2 characters
// user.age = -5;        // Error: Age cannot be negative
// user.age = "thirty";  // Error: Age must be a number