Programming

// JavaScript numeric types
const x = 42;           // number (integer-like)
const y = 3.14;          // number (float-like) — same type!
const z = 42n;           // BigInt — integers beyond 2^53
typeof x;               // 'number'
Number.isInteger(x);    // true
parseInt('3.9');         // 3   (truncates, like int())
Number('3.9');           // 3.9 (converts string to float)
// JS has ONE number type for both int and float

// JavaScript sequence types
const arr    = [1, 2, 3];                // Array — mutable (like list)
const frozen = Object.freeze([1, 2, 3]);  // immutable (like tuple)

arr[0] = 99;    // OK
// frozen[0] = 99; // silently ignored (TypeError in strict mode)

// Combine with spread (no TypeError)
[...arr, ...frozen];   // [99, 2, 3, 1, 2, 3]

// range equivalent: Array.from
Array.from({ length: 5 }, (_, i) => i * 2); // [0, 2, 4, 6, 8]

// JavaScript Map and Set
const m = new Map([['a', 1], ['b', 2]]);
m.set('c', 3);                   // add entry
m.get('z') ?? 0;               // 0  (nullish coalescing as default)

const s = new Set([1, 2, 2, 3]);  // Set {1, 2, 3} — duplicates removed
s.add(4);
// Set intersection (no native operator — use filter)
const other = new Set([2, 4, 6]);
new Set([...s].filter(x => other.has(x)));  // Set {2, 4}

-- SQL key-value lookup (dict equivalent)
SELECT value FROM config WHERE key = 'a';

-- Set intersection via INTERSECT
SELECT val FROM set_a
INTERSECT
SELECT val FROM set_b;

-- Distinct values (set deduplication)
SELECT DISTINCT category FROM products;

// Convert any type to float — JavaScript
function toFloat(x) {
  if (['number', 'string', 'boolean'].includes(typeof x)) {
    return parseFloat(x);
  } else if (Array.isArray(x)) {    // x = [1, 2, 3]
    return parseFloat(x[0]);          // 1.0
  } else if (x instanceof Set) {    // x = new Set([1,2,3])
    return parseFloat([...x][0]);     // 1.0
  } else if (x !== null && typeof x === 'object') {
    return parseFloat(Object.values(x)[0]);
  }
  return null;
}

-- SQL CASE WHEN (equivalent to if/elif/else)
SELECT
  CASE
    WHEN data_type IN ('int','float','str','bool')
         THEN CAST(raw_val AS FLOAT)
    WHEN data_type = 'list'
         THEN CAST(first_element AS FLOAT)
    WHEN data_type = 'dict'
         THEN CAST(first_value AS FLOAT)
    ELSE NULL
  END AS converted_value
FROM source_table;

// Extract the first run of digits — JavaScript
let str = 'abc123def456';
let y = 0;
while (str.length > 0) {
  if (y > 0 && !/\d/.test(str[0])) break;       // done
  if (y === 0 && !/\d/.test(str[0])) {
    str = str.slice(1); continue;            // skip non-digits
  }
  y = 10 * y + parseInt(str[0]);
  str = str.slice(1);
}
// y === 123

// for...of, entries(), zip equivalent — JavaScript
const fruits = ['apple', 'banana', 'cherry'];
const prices = [1.2, 0.5, 2.0];

for (const fruit of fruits) {
    console.log(fruit);              // apple, banana, cherry
}

// enumerate equivalent: Array.entries()
for (const [i, fruit] of fruits.entries()) {
    console.log(`${i + 1}. ${fruit}`);  // 1. apple, 2. banana...
}

// zip equivalent: map with index
fruits.forEach((fruit, i) => {
    console.log(`${fruit}: $${prices[i]}`);
});

// for...in iterates over object KEYS
const obj = { a: 1, b: 2 };
for (const key in obj) console.log(key);  // 'a', 'b'

// map / filter / reduce — JavaScript equivalents
const nums = [0,1,2,3,4,5,6,7,8,9];

// filter (like [x for x in ... if ...])
const evens = nums.filter(x => x % 2 === 0);
// [0, 2, 4, 6, 8]

// map (like [f(x) for x in ...])
const squares = nums.slice(0,5).map(x => x ** 2);
// [0, 1, 4, 9, 16]

// dict comprehension → Object.fromEntries + map
const words = ['cat', 'elephant', 'ox'];
const wordLengths = Object.fromEntries(words.map(w => [w, w.length]));
// {cat: 3, elephant: 8, ox: 2}

// reduce (like sum() or any accumulation)
const total = nums.reduce((acc, x) => acc + x ** 2, 0);
// 285

// Higher-order functions — JavaScript
function mixer(s1, s2) {
  if (!s1.length || !s2.length) return '';
  return s1[0] + s2[0] + mixer(s1.slice(1), s2.slice(1));
}

function funcBuilder(sample, ...transforms) {
  function dicBuilder(x) {
    x = x.toUpperCase();
    for (const fn of transforms) x = fn(x);
    return { lstrip: x.trimStart(), rstrip: x.trimEnd() };
  }
  return { func: dicBuilder, sampleResult: dicBuilder(sample) };
}

const { func, sampleResult } = funcBuilder(
  'hello',
  x => mixer(x, '12345')
);
// sampleResult == { lstrip: 'H1E2L3L4O5', rstrip: 'H1E2L3L4O5' }

// Decorator pattern — JavaScript (higher-order function)
function registerCalls(fn) {
  const registry = {};
  function wrapper(...args) {
    const result = fn(...args);
    registry[Object.keys(registry).length] = [
      args[0]?.name ?? '?', result
    ];
    return result;
  }
  wrapper.registry = registry;
  return wrapper;
}

function showRegistry() {}

const callWithReg = registerCalls((fn, x) => fn(x));
callWithReg(s => s.toUpperCase(), 'hello');  // 'HELLO' — logged
callWithReg.registry;  // {0: ['', 'HELLO']}

// Closure — JavaScript (factory function)
function multiplierFactory(factor) {
  return function(x) {
    return x * factor;   // 'factor' lives in the closure
  };
}

const double = multiplierFactory(2);
const triple = multiplierFactory(3);
double(5);   // 10
triple(5);   // 15

// Arrow function shorthand (idiomatic JS):
const makeMultiplier = factor => x => x * factor;
makeMultiplier(4)(5);  // 20

// Arrow functions — concise and lexical `this`
const square = x => x ** 2;
square(5);   // 25

// Sort by age
const people = [{name:'Alice',age:30},{name:'Bob',age:25}];
people.sort((a, b) => a.age - b.age);
// [{name:'Bob',age:25}, {name:'Alice',age:30}]

// map and filter
[1, 2, 3].map(x => x * 2);            // [2, 4, 6]
[0, 1, 2, 3].filter(x => x > 1);       // [2, 3]

// Block body (needs explicit return)
const classify = x => {
  if (x > 0) return 'positive';
  if (x < 0) return 'negative';
  return 'zero';
};

// Manual memoization with Map
function memoize(fn) {
  const cache = new Map();
  return (...args) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
}

const fib = memoize(function(n) {
  if (n <= 1) return n;
  return fib(n - 1) + fib(n - 2);
});

fib(50);   // 12586269025 — instant

// Recursion for nested array flattening
function flatten(arr) {
  return arr.reduce((acc, item) =>
    Array.isArray(item) ? [...acc, ...flatten(item)] : [...acc, item],
  []);
}
flatten([1, [2, [3, 4]], 5]);  // [1, 2, 3, 4, 5]
// Or natively: arr.flat(Infinity)

// JavaScript: Symbol-based operator overloading hooks
class Vector {
  constructor(x, y) { this.x = x; this.y = y; }

  // toString() ≈ __str__
  toString() { return `Vector(${this.x}, ${this.y})`; }

  // No operator overloading — write explicit methods
  add(other) { return new Vector(this.x + other.x, this.y + other.y); }
  equals(other) { return this.x === other.x && this.y === other.y; }

  // Symbol.toPrimitive ≈ __int__ / __float__
  [Symbol.toPrimitive](hint) {
    if (hint === 'number') return Math.hypot(this.x, this.y);
    return this.toString();
  }
}

const v1 = new Vector(1, 2);
const v2 = new Vector(3, 4);
v1.add(v2).toString();  // "Vector(4, 6)"
+v1;                    // 2.236... (magnitude, via toPrimitive)
`${v1}`;                // "Vector(1, 2)"

// Generator function — JavaScript (function*)
function* randomCharGenerator() {
  const alpha = 'abcdefghijklmnopqrstuvwxyz';
  let charsToRemove = '';
  while (true) {
    const chars = [...alpha].filter(c => !charsToRemove.includes(c));
    const char  = chars[Math.floor(Math.random() * chars.length)];
    charsToRemove = yield char;  // caller sends exclusion list back
  }
}

const rcg = randomCharGenerator();
rcg.next();    // prime the generator

const result = [];
for (let i = 0; i < 20; i++) {
  result.push(rcg.next('aeiou').value);  // exclude vowels
}
// result contains 20 consonants

// Custom iterable — JavaScript (Symbol.iterator protocol)
class Countdown {
  constructor(start) { this.start = start; }

  [Symbol.iterator]() {
    let current = this.start;
    return {
      next() {
        if (current <= 0) return { done: true, value: undefined };
        return { done: false, value: current-- };
      }
    };
  }
}

[...new Countdown(5)];   // [5, 4, 3, 2, 1]
for (const n of new Countdown(3)) {
  console.log(n);        // 3, 2, 1
}

-- SQL equivalent of MultiIndex .loc selection
-- Select rows where N='B', get the c_4 column
SELECT N, V, c_4
FROM dataframe
WHERE N = 'B';
--  N   V   c_4
--  B   1    18
--  B   2    21

-- Label + slice: WHERE N = 'B' AND V BETWEEN 1 AND 2
SELECT N, V, c_3, c_4, d_4
FROM dataframe
WHERE N = 'B' AND V IN (1, 2);

-- SQL UNPIVOT (wide → long, like pd.melt)
SELECT N, V, col_name, val
FROM dataframe
UNPIVOT (val FOR col_name IN (c_3, c_4, d_4)) AS upvt;

-- SQL conditional aggregation PIVOT (long → wide, like pivot_table)
SELECT N, V,
  MAX(CASE WHEN col_name = 'c_3' THEN val END) AS c_3,
  MAX(CASE WHEN col_name = 'c_4' THEN val END) AS c_4,
  MAX(CASE WHEN col_name = 'd_4' THEN val END) AS d_4
FROM unpivoted
GROUP BY N, V;

-- SQL equivalents of pd.concat / pd.merge

-- UNION ALL (like pd.concat — keeps duplicates)
SELECT a, b, NULL AS c FROM df
UNION ALL
SELECT NULL AS a, b, c FROM dg;

-- INNER JOIN (how='inner') — only matched rows
SELECT df.a, df.b, dg.c
FROM df INNER JOIN dg ON df.b = dg.b;

-- LEFT JOIN (how='left') — all df rows + matches from dg
SELECT df.a, df.b, dg.c
FROM df LEFT JOIN dg ON df.b = dg.b;

-- FULL OUTER JOIN (how='outer') — everything, NULLs for gaps
SELECT df.a, COALESCE(df.b, dg.b) AS b, dg.c
FROM df FULL OUTER JOIN dg ON df.b = dg.b;

-- GROUP BY + aggregation (like .groupby().agg())
SELECT region,
       SUM(revenue)   AS total,
       AVG(revenue)   AS mean,
       COUNT(*)       AS n
FROM sales
GROUP BY region;

-- Multi-key grouping
SELECT region, product,
       SUM(revenue) AS total,
       COUNT(*) AS n
FROM sales
GROUP BY region, product;

-- Window function = transform (keeps all rows)
SELECT *,
  SUM(revenue) OVER (PARTITION BY region) AS region_total,
  ROUND(revenue * 100.0 /
    SUM(revenue) OVER (PARTITION BY region), 1) AS pct_of_region
FROM sales;

// JavaScript: try / catch / finally
function safeDivide(a, b) {
  try {
    if (b === 0) throw new Error('Cannot divide by zero');
    if (typeof a !== 'number' || typeof b !== 'number')
      throw new TypeError('Arguments must be numbers');
    return a / b;
  } catch (e) {
    // No multi-catch — check instanceof instead
    if (e instanceof TypeError) console.error('Type error:', e.message);
    else console.error(e.message);
    return null;
  } finally {
    console.log('Cleanup — always runs');
  }
}

// No native context manager — use try/finally manually
const conn = openConnection();
try {
  conn.query('SELECT ...');
} finally {
  conn.close();   // always close
}

// Custom Error classes — JavaScript
class AppError extends Error {
  constructor(message) {
    super(message);
    this.name = this.constructor.name;
  }
}

class ValidationError extends AppError {
  constructor(field, message) {
    super(`${field}: ${message}`);
    this.field = field;
  }
}

class NotFoundError extends AppError {
  constructor(resource, id) {
    super(`${resource} ${id} not found`);
  }
}

function getUser(userId) {
  if (typeof userId !== 'number')
    throw new ValidationError('userId', 'must be a number');
  if (userId === 0) throw new NotFoundError('User', userId);
}

try {
  getUser(0);
} catch (e) {
  // JS has no multi-catch — use instanceof chain
  if (e instanceof ValidationError) console.log('Invalid:', e.field);
  else if (e instanceof NotFoundError) console.log('Missing');
  else if (e instanceof AppError) console.log('App error');
  else throw e;  // re-throw unexpected errors
}

// async/await — JavaScript
async function fetchData(url) {
  // fetch() returns a Promise — await unwraps it
  const response = await fetch(url);
  const data = await response.json();
  return data;
}

// Sequential (slow) — each waits for the previous
async function sequential() {
  const r1 = await fetchData('/a');
  const r2 = await fetchData('/b');
  return [r1, r2];
}

// Concurrent (fast) — all start at the same time
async function concurrent() {
  const [r1, r2, r3] = await Promise.all([
    fetchData('/a'),
    fetchData('/b'),
    fetchData('/c'),
  ]);
  return [r1, r2, r3];
}

// Error handling in async code
try {
  const data = await fetchData('/api');
} catch (e) {
  console.error('Fetch failed:', e.message);
}

import asyncio

# asyncio.gather = Promise.all
async def task(name, delay):
    await asyncio.sleep(delay)
    return f"{name} done"

async def main():
    # Concurrent — all start immediately
    results = await asyncio.gather(
        task('A', 1),
        task('B', 2),
        task('C', 0.5),
    )
    print(results)  # ['A done', 'B done', 'C done']

    # asyncio.wait = Promise.allSettled
    tasks = [asyncio.create_task(task('X', 1))]
    done, pending = await asyncio.wait(tasks,
                        timeout=0.5)
    # done = set of finished tasks, pending = set of timed-out ones

asyncio.run(main())