Functions
Unpacked

// parameters: the names written in the definition
function greet(name: string, greeting: string = "Hello"): string {
  return `${greeting}, ${name}!`;
}

// arguments: the values you hand over at the call site
console.log(greet("Shree"));             // one argument, the default fills the rest
console.log(greet("Advik", "Namaste"));   // two arguments
console.log(greet.length);               // counts parameters before the first default

function pair(a, b) {
  return [a, b];
}
console.log(pair(1));        // missing argument becomes undefined
console.log(pair(1, 2, 3));  // the extra argument is silently ignored

function rename(user, label) {
  user.name = label;   // mutates the object the caller also holds
  label = "changed";   // reassigning a parameter never reaches the caller
}
const account = { name: "old" };
let tag = "new";
rename(account, tag);
console.log(account.name, tag);

// 1. declaration: hoisted, has its own this and arguments
function add(a: number, b: number) { return a + b; }

// 2. expression: a function stored in a variable
const sub = function (a: number, b: number) { return a - b; };

// 3. arrow: short, no own this, no arguments object
const mul = (a: number, b: number) => a * b;

// 4. method shorthand inside an object
const math = { div(a: number, b: number) { return a / b; } };

// 5. async and 6. generator
const later = async (x: number) => x * 10;
function* range(n: number) { for (let i = 0; i < n; i++) yield i; }

console.log(add(2, 3), sub(9, 4), mul(3, 3), math.div(8, 2));
later(4).then((v) => console.log(v, [...range(4)]));

console.log(area(3));   // works: declarations are hoisted
// console.log(cube(3)); // ReferenceError: Cannot access 'cube' before initialization

function area(r) { return Math.round(Math.PI * r * r); }
const cube = (n) => n ** 3;

// arrow bodies: implicit return, and parentheses around an object literal
const toUser = (id, name) => ({ id, name });
console.log(toUser(7, "Ravi"));

const timer = {
  ticks: 0,
  withArrow() {
    setTimeout(() => {
      this.ticks++;                 // arrow borrows this from withArrow
      console.log("arrow sees", this.ticks);
    }, 0);
  },
  withClassic() {
    setTimeout(function () {
      console.log("classic sees", this?.ticks); // this is no longer timer
    }, 0);
  },
};
timer.withArrow();
timer.withClassic();

// classic IIFE, with an argument passed straight in
(function (env) {
  console.log(`booting in ${env}`);
})("production");

// arrow IIFE
(() => console.log("arrow IIFE ran"))();

// module pattern: private state, public API
const ids = (() => {
  let next = 0;
  return { take: () => ++next, peek: () => next };
})();
console.log(ids.take(), ids.take(), ids.peek());
console.log(typeof next); // next never leaked

const sleep = (ms: number) => new Promise<void>((done) => setTimeout(done, ms));

// async IIFE: await without top-level await support
(async () => {
  console.log("connecting...");
  await sleep(50);
  console.log("connected after 50ms");
})();

// a leading semicolon guards against the previous line
;(function () { console.log("safe even after a line with no semicolon"); })();

"use strict";
function whoAmI(greeting = "hi") {
  return `${greeting} from ${this?.name ?? "nobody"}`;
}
const svc = { name: "orders", whoAmI };

console.log(whoAmI());                                // function call
console.log(svc.whoAmI());                            // method call
console.log(whoAmI.call({ name: "billing" }, "hey")); // call: args one by one
console.log(whoAmI.apply({ name: "auth" }, ["yo"]));  // apply: args as an array
const bound = whoAmI.bind({ name: "search" }, "bound");
console.log(bound());                                 // bind: a new function, this fixed

class Queue {
  constructor(public name: string, public size = 0) {}
}
const q = new Queue("emails");               // constructor invocation
console.log(q);

const double = (n: number) => n * 2;
console.log([1, 2, 3].map(double));          // pass the function, do not call it
// [1, 2, 3].map(double());                  // Error: expected 1 argument, got 0

const hooks: { onDone?: (ms: number) => void } = {};
hooks.onDone?.(120);                          // optional call: skipped, no crash
hooks.onDone = (ms) => console.log(`done in ${ms}ms`);
hooks.onDone?.(120);

type Level = "debug" | "info" | "error";

function log(message: string, level: Level = "info", meta?: Record<string, unknown>): void {
  const extra = meta ? ` ${JSON.stringify(meta)}` : "";
  console.log(`[${level.toUpperCase()}] ${message}${extra}`);
}

log("server started");                          // default level
log("cache miss", "debug", { key: "user:42" }); // optional meta supplied
// log("oops", "fatal");  // Error: '"fatal"' is not assignable to type 'Level'

// a function type alias with a generic payload
type Handler<T> = (payload: T) => void;
const onUser: Handler<{ id: number; name: string }> = (u) => console.log(`hello ${u.name}`);
onUser({ id: 1, name: "Shree" });

// generic parameter: the return type follows the argument
function first<T>(items: readonly T[]): T | undefined {
  return items[0];
}
const n = first([10, 20]);    // n: number | undefined
const s = first(["a", "b"]);  // s: string | undefined
console.log(n, s);

// overloads: two call shapes, one implementation
function parse(input: string): number;
function parse(input: string[]): number[];
function parse(input: string | string[]): number | number[] {
  return Array.isArray(input) ? input.map(Number) : Number(input);
}

const one = parse("42");          // one: number
const many = parse(["1", "2"]);   // many: number[]
console.log(one + 1, many);

// old way: arguments is array-like, not a real array
function oldSum() {
  return Array.prototype.reduce.call(arguments, (a, b) => a + b, 0);
}

// modern way: a rest parameter is a real array
const sum = (...nums) => nums.reduce((a, b) => a + b, 0);

console.log(oldSum(1, 2, 3), sum(1, 2, 3, 4));
console.log(sum());               // zero arguments is fine, nums is []

// fixed parameters first, the rest collects everything after
function tagAll(prefix: string, ...tags: string[]): string[] {
  return tags.map((t) => `${prefix}:${t}`);
}
console.log(tagAll("env", "dev", "qa", "prod"));

// tuple typed rest: a fixed shape with an optional last slot
function move(...[x, y, label]: [number, number, string?]): string {
  return `${label ?? "point"} -> (${x}, ${y})`;
}
console.log(move(3, 4), "|", move(0, 0, "origin"));

// spread at the call site: an array becomes separate arguments
const scores = [71, 94, 88];
console.log(Math.max(...scores));

const coords: [number, number] = [3, 4];
console.log(Math.hypot(...coords));

// many settings? take one options object and destructure it
interface RequestOpts { url: string; retries?: number; timeoutMs?: number }
function request({ url, retries = 2, timeoutMs = 1000 }: RequestOpts): string {
  return `${url} retries=${retries} timeout=${timeoutMs}ms`;
}
console.log(request({ url: "/api/users", timeoutMs: 500 }));

type Step<T> = (input: T) => T | Promise<T>;

// rest parameter: any number of typed steps
function pipeline<T>(...steps: Step<T>[]) {
  return async (input: T): Promise<T> => {
    let value = input;
    for (const step of steps) value = await step(value);
    return value;
  };
}

// arrow functions as small, typed steps
const trim: Step<string> = (s) => s.trim();
const lower: Step<string> = (s) => s.toLowerCase();
const slug: Step<string> = (s) => s.replace(/[^a-z0-9]+/g, "-");

// higher order: returns a step, with a default parameter
const withSuffix = (suffix = "-v1"): Step<string> => (s) => `${s}${suffix}`;

// async IIFE wires everything together
(async () => {
  const toSlug = pipeline(trim, lower, slug, withSuffix());
  const titles = ["  Function Args vs Params ", "Arrow Functions 101"];
  const slugs = await Promise.all(titles.map((t) => toSlug(t)));
  console.log(slugs);
  console.log(`steps used: ${[trim, lower, slug].length + 1}`);
})();