JavaScript Functions and Functional Programming

// Function Declaration - hoisted, can call before definition
console.log(add(2, 3));  // Works: 5
function add(a, b) {
    return a + b;
}

// Function Expression - not hoisted
// console.log(subtract(5, 2));  // Error: Cannot access before initialization
const subtract = function(a, b) {
    return a - b;
};

// Named Function Expression - name visible only inside
const factorial = function fact(n) {
    return n <= 1 ? 1 : n * fact(n - 1);  // 'fact' accessible here
};
console.log(factorial(5));  // 120
// console.log(fact(5));  // Error: fact is not defined

// Arrow function - concise syntax
const multiply = (a, b) => a * b;
const square = x => x * x;  // Single param, no parens needed
const greet = () => 'Hello';  // No params

// Problem with regular functions - this binding changes
function Timer() {
    this.seconds = 0;
    
    // Regular function - 'this' is window/undefined in strict mode
    setInterval(function() {
        this.seconds++;  // ✗ Wrong 'this'
        console.log(this.seconds);  // NaN
    }, 1000);
}

// Solution 1: Arrow function - lexical 'this'
function Timer() {
    this.seconds = 0;
    
    setInterval(() => {
        this.seconds++;  // ✓ Correct 'this' from Timer
        console.log(this.seconds);  // 1, 2, 3...
    }, 1000);
}

// Solution 2: Old approach with .bind() (before ES6)
function Timer() {
    this.seconds = 0;
    setInterval(function() {
        this.seconds++;
    }.bind(this), 1000);  // Explicitly bind 'this'
}

// Class methods with arrow functions
class Counter {
    count = 0;
    
    // Arrow function as class field - 'this' always bound to instance
    increment = () => {
        this.count++;
    }
    
    // Regular method - 'this' depends on how it's called
    decrement() {
        this.count--;
    }
}

const counter = new Counter();
const inc = counter.increment;
const dec = counter.decrement;

inc();  // ✓ Works - arrow function has lexical 'this'
dec();  // ✗ Error - 'this' is undefined (not bound)

// Expression body - implicit return
const double = x => x * 2;
const sum = (a, b) => a + b;

// Block body - explicit return needed
const greet = name => {
    const message = `Hello, ${name}!`;
    return message.toUpperCase();
};

// Returning object literal - wrap in parentheses
const makePerson = (name, age) => ({ name, age });
const point = (x, y) => ({ x: x, y: y });

// Array methods with arrows
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(n => n * 2);
const evens = numbers.filter(n => n % 2 === 0);
const total = numbers.reduce((sum, n) => sum + n, 0);

// Chaining with concise arrows
const result = [1, 2, 3, 4, 5]
    .filter(x => x % 2 === 0)
    .map(x => x * x)
    .reduce((sum, x) => sum + x, 0);  // 20

// Basic default parameters
function greet(name = 'Guest', greeting = 'Hello') {
    return `${greeting}, ${name}!`;
}
console.log(greet());  // "Hello, Guest!"
console.log(greet('Alice'));  // "Hello, Alice!"
console.log(greet('Bob', 'Hi'));  // "Hi, Bob!"

// Default only applies to undefined, not null
console.log(greet(null));  // "Hello, null!" (null !== undefined)
console.log(greet(undefined, 'Hey'));  // "Hey, Guest!" (undefined triggers default)

// Default expressions evaluated at call time
let counter = 0;
function f(x = counter++) {
    return x;
}
console.log(f());  // 0 (counter becomes 1)
console.log(f());  // 1 (counter becomes 2)
console.log(f(10));  // 10 (default not used, counter stays 2)

// Using previous parameters in defaults
function createRect(width, height = width) {
    return { width, height };  // height defaults to width (square)
}
console.log(createRect(5));  // { width: 5, height: 5 }
console.log(createRect(5, 10));  // { width: 5, height: 10 }

// Rest parameters collect remaining arguments into array
function sum(...numbers) {
    return numbers.reduce((total, n) => total + n, 0);
}
console.log(sum(1, 2, 3, 4));  // 10
console.log(sum());  // 0 (empty array)

// Combine regular params with rest
function multiply(multiplier, ...numbers) {
    return numbers.map(n => n * multiplier);
}
console.log(multiply(2, 1, 2, 3));  // [2, 4, 6]

// Rest must be last parameter
// function invalid(...args, last) {}  // ✗ SyntaxError

// Rest vs arguments object
function oldWay() {
    // arguments is array-like, not real array
    const args = Array.from(arguments);
    return args.reduce((sum, n) => sum + n, 0);
}

function newWay(...args) {
    // args is real array with all array methods
    return args.reduce((sum, n) => sum + n, 0);
}

// Arrow functions don't have arguments, use rest
const arrowSum = (...nums) => nums.reduce((s, n) => s + n, 0);

// Object destructuring in parameters
function createUser({ name, age, email = 'none@example.com' }) {
    return { name, age, email };
}
createUser({ name: 'Alice', age: 30 });
// { name: 'Alice', age: 30, email: 'none@example.com' }

// Array destructuring in parameters
function sumFirstTwo([a, b]) {
    return a + b;
}
console.log(sumFirstTwo([10, 20, 30]));  // 30

// Nested destructuring
function displayPoint({ coords: { x, y }, label = 'Point' }) {
    return `${label}: (${x}, ${y})`;
}
displayPoint({ coords: { x: 10, y: 20 } });  // "Point: (10, 20)"

// Destructuring with rest
function getFirstAndRest([first, ...rest]) {
    return { first, rest };
}
console.log(getFirstAndRest([1, 2, 3, 4]));
// { first: 1, rest: [2, 3, 4] }

// Rename while destructuring
function printDimensions({ width: w, height: h }) {
    console.log(`Width: ${w}, Height: ${h}`);
}
printDimensions({ width: 100, height: 200 });

// Default for entire destructured object
function config({ host = 'localhost', port = 8080 } = {}) {
    return `${host}:${port}`;
}
console.log(config());  // "localhost:8080"
console.log(config({ host: 'example.com' }));  // "example.com:8080"

// Function that takes function as argument
function repeat(n, action) {
    for (let i = 0; i < n; i++) {
        action(i);
    }
}
repeat(3, console.log);  // Logs: 0, 1, 2

// Function that returns function (function factory)
function multiplier(factor) {
    return function(number) {
        return number * factor;
    };
}
const double = multiplier(2);
const triple = multiplier(3);
console.log(double(5));  // 10
console.log(triple(5));  // 15

// Function composition
function compose(f, g) {
    return function(x) {
        return f(g(x));
    };
}
const addOne = x => x + 1;
const square = x => x * x;
const addOneThenSquare = compose(square, addOne);
console.log(addOneThenSquare(4));  // 25 (5²)

// Practical HOF: logger wrapper
function withLogging(fn) {
    return function(...args) {
        console.log(`Calling ${fn.name} with`, args);
        const result = fn(...args);
        console.log(`Result:`, result);
        return result;
    };
}
const add = (a, b) => a + b;
const loggedAdd = withLogging(add);
loggedAdd(2, 3);  // Logs call info, returns 5

const users = [
    { id: 1, name: 'Alice', age: 25, active: true },
    { id: 2, name: 'Bob', age: 30, active: false },
    { id: 3, name: 'Charlie', age: 35, active: true }
];

// map - transform data
const names = users.map(user => user.name);
// ['Alice', 'Bob', 'Charlie']

// filter - select subset
const activeUsers = users.filter(user => user.active);
// [Alice, Charlie]

// reduce - aggregate
const totalAge = users.reduce((sum, user) => sum + user.age, 0);
// 90

// Chaining HOFs
const result = users
    .filter(user => user.active)
    .map(user => user.name)
    .map(name => name.toUpperCase());
// ['ALICE', 'CHARLIE']

// find - first match
const user = users.find(u => u.age > 25);
// { id: 2, name: 'Bob', age: 30, active: false }

// some - any match
const hasInactive = users.some(u => !u.active);  // true

// every - all match
const allActive = users.every(u => u.active);  // false

// Complex reduce example
const grouped = users.reduce((groups, user) => {
    const key = user.active ? 'active' : 'inactive';
    groups[key] = groups[key] || [];
    groups[key].push(user);
    return groups;
}, {});
// { active: [Alice, Charlie], inactive: [Bob] }

// Simple closure - inner function accesses outer variable
function outer() {
    let count = 0;  // Variable in outer scope
    
    function inner() {
        count++;  // Accesses count from outer scope
        return count;
    }
    
    return inner;
}

const counter = outer();
console.log(counter());  // 1
console.log(counter());  // 2
console.log(counter());  // 3
// 'count' persists between calls through closure

// Multiple closures over same variable
function makeCounter() {
    let count = 0;
    return {
        increment: () => ++count,
        decrement: () => --count,
        value: () => count
    };
}

const c1 = makeCounter();
const c2 = makeCounter();  // Separate closure, separate count
c1.increment();
c1.increment();
console.log(c1.value());  // 2
console.log(c2.value());  // 0 (independent)

// Function factory with closure
function multiplier(factor) {
    return function(number) {
        return number * factor;  // 'factor' remembered via closure
    };
}
const double = multiplier(2);
const triple = multiplier(3);
console.log(double(5));  // 10
console.log(triple(5));  // 15

// Private variables pattern
function createBankAccount(initialBalance) {
    let balance = initialBalance;  // Private variable
    
    return {
        deposit(amount) {
            if (amount > 0) balance += amount;
            return balance;
        },
        withdraw(amount) {
            if (amount > 0 && amount <= balance) balance -= amount;
            return balance;
        },
        getBalance() {
            return balance;
        }
    };
    // No direct access to 'balance' from outside
}

const account = createBankAccount(100);
account.deposit(50);  // 150
account.withdraw(30);  // 120
console.log(account.balance);  // undefined (private)
console.log(account.getBalance());  // 120

// Memoization with closure
function memoize(fn) {
    const cache = {};  // Closure over cache
    return function(...args) {
        const key = JSON.stringify(args);
        if (key in cache) {
            console.log('Cached');
            return cache[key];
        }
        const result = fn(...args);
        cache[key] = result;
        return result;
    };
}

const slowFunction = (n) => {
    console.log('Computing...');
    return n * 2;
};
const fast = memoize(slowFunction);
fast(5);  // Computing... 10
fast(5);  // Cached 10

// Basic IIFE - executes immediately
(function() {
    const message = 'Hello from IIFE';
    console.log(message);
})();  // Logs: Hello from IIFE
// 'message' not accessible here (private scope)

// IIFE with parameters
(function(name) {
    console.log(`Hello, ${name}!`);
})('Alice');  // Hello, Alice!

// IIFE returning value
const config = (function() {
    const privateKey = 'secret123';
    return {
        apiUrl: 'https://api.example.com',
        timeout: 5000,
        getKey: () => privateKey  // Controlled access
    };
})();
console.log(config.apiUrl);  // 'https://api.example.com'
console.log(config.privateKey);  // undefined (private)

// Arrow function IIFE (ES6+)
(() => {
    const temp = 'temporary variable';
    console.log(temp);
})();

// Named IIFE for recursion
(function factorial(n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
})(5);  // 120

// IIFE for variable capture in loops (pre-let solution)
for (var i = 0; i < 3; i++) {
    (function(index) {
        setTimeout(() => console.log(index), 100);
    })(i);  // Capture current value of i
}

// Classic Module Pattern
const Calculator = (function() {
    // Private variables and functions
    let history = [];
    
    function log(operation, result) {
        history.push({ operation, result, timestamp: Date.now() });
    }
    
    // Public API
    return {
        add(a, b) {
            const result = a + b;
            log('add', result);
            return result;
        },
        subtract(a, b) {
            const result = a - b;
            log('subtract', result);
            return result;
        },
        getHistory() {
            return [...history];  // Return copy, not reference
        },
        clearHistory() {
            history = [];
        }
    };
})();

Calculator.add(5, 3);  // 8
Calculator.subtract(10, 4);  // 6
console.log(Calculator.getHistory());  // Array of operations
console.log(Calculator.history);  // undefined (private)

// Revealing Module Pattern
const Counter = (function() {
    let count = 0;
    
    function increment() { return ++count; }
    function decrement() { return --count; }
    function getValue() { return count; }
    function reset() { count = 0; }
    
    // Reveal selected functions
    return {
        increment,
        decrement,
        getValue,
        reset
    };
})();

Counter.increment();  // 1
Counter.increment();  // 2
console.log(Counter.getValue());  // 2

// Module with dependencies
const UserManager = (function($, _) {
    // Use jQuery ($) and lodash (_) passed as parameters
    function getUsers() {
        return _.map(users, user => user.name);
    }
    
    return { getUsers };
})(jQuery, lodash);  // Inject dependencies

const person = {
    name: 'Alice',
    greet(greeting, punctuation) {
        return `${greeting}, I'm ${this.name}${punctuation}`;
    }
};

console.log(person.greet('Hello', '!'));  // "Hello, I'm Alice!"

// call() - set 'this' and pass individual arguments
const otherPerson = { name: 'Bob' };
console.log(person.greet.call(otherPerson, 'Hi', '.'));
// "Hi, I'm Bob."

// apply() - set 'this' and pass arguments as array
console.log(person.greet.apply(otherPerson, ['Hey', '...']));
// "Hey, I'm Bob..."

// Practical: borrowing array methods for array-like objects
function sumAll() {
    // 'arguments' is array-like, not real array
    // Borrow reduce() from Array
    return Array.prototype.reduce.call(arguments, (sum, n) => sum + n, 0);
}
console.log(sumAll(1, 2, 3, 4));  // 10

// Math.max with apply (pre-spread operator)
const numbers = [5, 2, 9, 1, 7];
const max = Math.max.apply(null, numbers);  // 9
// Modern: Math.max(...numbers)

// Invoking function with specific context
function introduce() {
    return `My name is ${this.name} and I'm ${this.age}`;
}
const user = { name: 'Charlie', age: 30 };
console.log(introduce.call(user));
// "My name is Charlie and I'm 30"

const obj = {
    value: 42,
    getValue() {
        return this.value;
    }
};

// Problem: 'this' lost when method assigned to variable
const getValue = obj.getValue;
console.log(getValue());  // undefined ('this' is window/undefined)

// Solution: bind() creates new function with fixed 'this'
const boundGetValue = obj.getValue.bind(obj);
console.log(boundGetValue());  // 42

// Practical: event handlers
class Button {
    constructor(label) {
        this.label = label;
        this.clickCount = 0;
    }
    
    handleClick() {
        this.clickCount++;
        console.log(`${this.label} clicked ${this.clickCount} times`);
    }
}

const btn = new Button('Submit');
// Without bind, 'this' would be the button element, not our object
document.querySelector('button').addEventListener('click', 
    btn.handleClick.bind(btn)
);

// Partial application with bind()
function multiply(a, b) {
    return a * b;
}
const double = multiply.bind(null, 2);  // Pre-fill first argument
const triple = multiply.bind(null, 3);
console.log(double(5));  // 10
console.log(triple(5));  // 15

// Binding with setTimeout
const timer = {
    seconds: 0,
    start() {
        // bind() ensures 'this' refers to timer object
        setInterval(function() {
            this.seconds++;
            console.log(this.seconds);
        }.bind(this), 1000);
        
        // Modern alternative: arrow function (lexical 'this')
        // setInterval(() => { this.seconds++; }, 1000);
    }
};

// Multiple bind() calls - first one wins
function log() { console.log(this.value); }
const obj1 = { value: 1 };
const obj2 = { value: 2 };
const bound1 = log.bind(obj1);
const bound2 = bound1.bind(obj2);  // Has no effect
bound2();  // 1 (not 2 - can't rebind)

// Standard recursion - NOT tail recursive
function factorial(n) {
    // Base case
    if (n <= 1) return 1;
    
    // Recursive case - operation AFTER recursive call
    return n * factorial(n - 1);  // ✗ Not tail call (multiplication pending)
}
console.log(factorial(5));  // 120
// Stack: factorial(5) waits for factorial(4)
//        factorial(4) waits for factorial(3), etc.

// Tail recursive version - uses accumulator
function factorialTail(n, acc = 1) {
    // Base case
    if (n <= 1) return acc;
    
    // Recursive case - nothing after recursive call
    return factorialTail(n - 1, n * acc);  // ✓ Tail call (direct return)
}
console.log(factorialTail(5));  // 120
// With TCO: reuses same stack frame

// Fibonacci - standard recursion (exponential time!)
function fib(n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);  // Two recursive calls
}
// Very slow for large n: fib(40) takes seconds

// Fibonacci - tail recursive with two accumulators
function fibTail(n, a = 0, b = 1) {
    if (n === 0) return a;
    return fibTail(n - 1, b, a + b);  // Tail call
}
console.log(fibTail(40));  // Fast even for large n

// Array sum - standard recursion
function sumArray(arr) {
    if (arr.length === 0) return 0;
    return arr[0] + sumArray(arr.slice(1));  // ✗ Not tail call
}

// Array sum - tail recursive
function sumArrayTail(arr, acc = 0) {
    if (arr.length === 0) return acc;
    return sumArrayTail(arr.slice(1), acc + arr[0]);  // ✓ Tail call
}

// Problem: countdown - NOT tail recursive
function countdown(n) {
    if (n < 0) return;
    console.log(n);
    countdown(n - 1);
    console.log('Done', n);  // ✗ Operation after recursive call
}

// Solution: tail recursive countdown
function countdownTail(n) {
    if (n < 0) return;
    console.log(n);
    return countdownTail(n - 1);  // ✓ Tail call
}

// Problem: power - NOT tail recursive
function power(base, exp) {
    if (exp === 0) return 1;
    return base * power(base, exp - 1);  // ✗ Multiplication pending
}

// Solution: tail recursive with accumulator
function powerTail(base, exp, acc = 1) {
    if (exp === 0) return acc;
    return powerTail(base, exp - 1, acc * base);  // ✓ Tail call
}

// Tree traversal - naturally recursive
function sumTree(node) {
    if (!node) return 0;
    return node.value 
        + sumTree(node.left) 
        + sumTree(node.right);
    // Not tail recursive but appropriate for trees
}

// Tail recursive tree traversal (using continuation)
function sumTreeTail(node, cont = x => x) {
    if (!node) return cont(0);
    return sumTreeTail(node.left, leftSum =>
        sumTreeTail(node.right, rightSum =>
            cont(node.value + leftSum + rightSum)
        )
    );
}

// ✓ Good use of recursion - tree/graph structures
function findNode(tree, value) {
    if (!tree) return null;
    if (tree.value === value) return tree;
    return findNode(tree.left, value) || findNode(tree.right, value);
}

// ✓ Good use of recursion - divide and conquer
function binarySearch(arr, target, left = 0, right = arr.length - 1) {
    if (left > right) return -1;
    const mid = Math.floor((left + right) / 2);
    if (arr[mid] === target) return mid;
    if (arr[mid] > target) return binarySearch(arr, target, left, mid - 1);
    return binarySearch(arr, target, mid + 1, right);
}

// ✗ Bad use of recursion - simple iteration better
function sumToN(n) {
    if (n === 0) return 0;
    return n + sumToN(n - 1);  // Just use n * (n + 1) / 2
}

// ✓ Better: iterative solution
function sumToNIterative(n) {
    let sum = 0;
    for (let i = 1; i <= n; i++) {
        sum += i;
    }
    return sum;
    // Or: return n * (n + 1) / 2;
}

// Trampoline pattern (TCO workaround)
function trampoline(fn) {
    while (typeof fn === 'function') {
        fn = fn();  // Keep calling until not a function
    }
    return fn;
}

function factorialTrampoline(n, acc = 1) {
    if (n <= 1) return acc;
    return () => factorialTrampoline(n - 1, n * acc);  // Return thunk
}

console.log(trampoline(factorialTrampoline(100000)));  // No stack overflow