tova 0.1.1 → 0.2.2

package/src/stdlib/collections.js

@@ -88,3 +88,248 @@ export function values(obj) {
 export function merge(...objects) {
   return Object.assign({}, ...objects);
 }
+
+export function partition(arr, fn) {
+  const y = [], n = [];
+  for (const v of arr) { (fn(v) ? y : n).push(v); }
+  return [y, n];
+}
+
+export function zip_with(a, b, fn) {
+  const m = Math.min(a.length, b.length);
+  const r = [];
+  for (let i = 0; i < m; i++) r.push(fn(a[i], b[i]));
+  return r;
+}
+
+export function frequencies(arr) {
+  const r = {};
+  for (const v of arr) {
+    const k = String(v);
+    r[k] = (r[k] || 0) + 1;
+  }
+  return r;
+}
+
+export function scan(arr, fn, init) {
+  const r = [];
+  let acc = init;
+  for (const v of arr) { acc = fn(acc, v); r.push(acc); }
+  return r;
+}
+
+export function min_by(arr, fn) {
+  if (arr.length === 0) return null;
+  let best = arr[0], bestK = fn(arr[0]);
+  for (let i = 1; i < arr.length; i++) {
+    const k = fn(arr[i]);
+    if (k < bestK) { best = arr[i]; bestK = k; }
+  }
+  return best;
+}
+
+export function max_by(arr, fn) {
+  if (arr.length === 0) return null;
+  let best = arr[0], bestK = fn(arr[0]);
+  for (let i = 1; i < arr.length; i++) {
+    const k = fn(arr[i]);
+    if (k > bestK) { best = arr[i]; bestK = k; }
+  }
+  return best;
+}
+
+export function sum_by(arr, fn) {
+  let s = 0;
+  for (const v of arr) s += fn(v);
+  return s;
+}
+
+export function product(arr) {
+  return arr.reduce((a, b) => a * b, 1);
+}
+
+export function from_entries(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+export function has_key(obj, key) {
+  return obj != null && Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+export function get(obj, path, def) {
+  const keys = Array.isArray(path) ? path : String(path).split('.');
+  let cur = obj;
+  for (const k of keys) {
+    if (cur == null || typeof cur !== 'object') return def !== undefined ? def : null;
+    cur = cur[k];
+  }
+  return cur !== undefined ? cur : (def !== undefined ? def : null);
+}
+
+export function pick(obj, ks) {
+  const r = {};
+  for (const k of ks) { if (k in obj) r[k] = obj[k]; }
+  return r;
+}
+
+export function omit(obj, ks) {
+  const s = new Set(ks);
+  const r = {};
+  for (const k of Object.keys(obj)) { if (!s.has(k)) r[k] = obj[k]; }
+  return r;
+}
+
+export function map_values(obj, fn) {
+  const r = {};
+  for (const [k, v] of Object.entries(obj)) r[k] = fn(v, k);
+  return r;
+}
+
+export function sliding_window(arr, n) {
+  if (n <= 0 || n > arr.length) return [];
+  const r = [];
+  for (let i = 0; i <= arr.length - n; i++) r.push(arr.slice(i, i + n));
+  return r;
+}
+
+// ── Set Operations ────────────────────────────────────────
+
+export function intersection(a, b) {
+  const s = new Set(b);
+  return a.filter(x => s.has(x));
+}
+
+export function difference(a, b) {
+  const s = new Set(b);
+  return a.filter(x => !s.has(x));
+}
+
+export function symmetric_difference(a, b) {
+  const sa = new Set(a);
+  const sb = new Set(b);
+  return [...a.filter(x => !sb.has(x)), ...b.filter(x => !sa.has(x))];
+}
+
+export function is_subset(a, b) {
+  const s = new Set(b);
+  return a.every(x => s.has(x));
+}
+
+export function is_superset(a, b) {
+  const s = new Set(a);
+  return b.every(x => s.has(x));
+}
+
+// ── Itertools ─────────────────────────────────────────────
+
+export function pairwise(arr) {
+  const r = [];
+  for (let i = 0; i < arr.length - 1; i++) r.push([arr[i], arr[i + 1]]);
+  return r;
+}
+
+export function combinations(arr, r) {
+  const result = [];
+  const combo = [];
+  function gen(start, depth) {
+    if (depth === r) { result.push([...combo]); return; }
+    for (let i = start; i < arr.length; i++) {
+      combo.push(arr[i]);
+      gen(i + 1, depth + 1);
+      combo.pop();
+    }
+  }
+  gen(0, 0);
+  return result;
+}
+
+export function permutations(arr, r) {
+  const n = r === undefined ? arr.length : r;
+  const result = [];
+  const perm = [];
+  const used = new Array(arr.length).fill(false);
+  function gen() {
+    if (perm.length === n) { result.push([...perm]); return; }
+    for (let i = 0; i < arr.length; i++) {
+      if (!used[i]) {
+        used[i] = true;
+        perm.push(arr[i]);
+        gen();
+        perm.pop();
+        used[i] = false;
+      }
+    }
+  }
+  gen();
+  return result;
+}
+
+export function intersperse(arr, sep) {
+  if (arr.length <= 1) return [...arr];
+  const r = [arr[0]];
+  for (let i = 1; i < arr.length; i++) { r.push(sep, arr[i]); }
+  return r;
+}
+
+export function interleave(...arrs) {
+  const m = Math.max(...arrs.map(a => a.length));
+  const r = [];
+  for (let i = 0; i < m; i++) {
+    for (const a of arrs) { if (i < a.length) r.push(a[i]); }
+  }
+  return r;
+}
+
+export function repeat_value(val, n) {
+  return Array(n).fill(val);
+}
+
+// ── Array Utilities ───────────────────────────────────────
+
+export function binary_search(arr, target, keyFn) {
+  let lo = 0, hi = arr.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    const val = keyFn ? keyFn(arr[mid]) : arr[mid];
+    if (val === target) return mid;
+    if (val < target) lo = mid + 1; else hi = mid - 1;
+  }
+  return -1;
+}
+
+export function is_sorted(arr, keyFn) {
+  for (let i = 1; i < arr.length; i++) {
+    const a = keyFn ? keyFn(arr[i - 1]) : arr[i - 1];
+    const b = keyFn ? keyFn(arr[i]) : arr[i];
+    if (a > b) return false;
+  }
+  return true;
+}
+
+export function compact(arr) {
+  return arr.filter(v => v != null);
+}
+
+export function rotate(arr, n) {
+  if (arr.length === 0) return [];
+  const k = ((n % arr.length) + arr.length) % arr.length;
+  return [...arr.slice(k), ...arr.slice(0, k)];
+}
+
+export function insert_at(arr, idx, val) {
+  const r = [...arr];
+  r.splice(idx, 0, val);
+  return r;
+}
+
+export function remove_at(arr, idx) {
+  const r = [...arr];
+  r.splice(idx, 1);
+  return r;
+}
+
+export function update_at(arr, idx, val) {
+  const r = [...arr];
+  r[idx] = val;
+  return r;
+}

package/src/stdlib/core.js

@@ -96,3 +96,90 @@ export function any(arr, fn) {
 export function all(arr, fn) {
   return arr.every(fn || Boolean);
 }
+
+// ── Randomness ──────────────────────────────────────────
+
+export function random_int(lo, hi) {
+  return Math.floor(Math.random() * (hi - lo + 1)) + lo;
+}
+
+export function random_float(lo, hi) {
+  return Math.random() * (hi - lo) + lo;
+}
+
+export function choice(arr) {
+  return arr.length === 0 ? null : arr[Math.floor(Math.random() * arr.length)];
+}
+
+export function sample(arr, n) {
+  const c = [...arr];
+  for (let i = c.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [c[i], c[j]] = [c[j], c[i]];
+  }
+  return c.slice(0, n);
+}
+
+export function shuffle(arr) {
+  const c = [...arr];
+  for (let i = c.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [c[i], c[j]] = [c[j], c[i]];
+  }
+  return c;
+}
+
+// ── Type Conversion ─────────────────────────────────────
+
+export function to_int(v) {
+  if (typeof v === 'boolean') return v ? 1 : 0;
+  const n = typeof v === 'string' ? parseInt(v, 10) : Math.trunc(Number(v));
+  return isNaN(n) ? null : n;
+}
+
+export function to_float(v) {
+  if (typeof v === 'boolean') return v ? 1.0 : 0.0;
+  const n = Number(v);
+  return isNaN(n) ? null : n;
+}
+
+export function to_string(v) {
+  if (v == null) return 'nil';
+  if (v && v.__tag) return v.__tag + (v.value !== undefined ? '(' + String(v.value) + ')' : '');
+  return String(v);
+}
+
+export function to_bool(v) {
+  if (typeof v === 'string') return v !== '' && v !== '0' && v !== 'false';
+  return Boolean(v);
+}
+
+// ── General Utilities ────────────────────────────────────
+
+export function is_empty(v) {
+  if (v == null) return true;
+  if (typeof v === 'string' || Array.isArray(v)) return v.length === 0;
+  if (typeof v === 'object') return Object.keys(v).length === 0;
+  return false;
+}
+
+// ── Date/Time ────────────────────────────────────────────
+
+export function now() {
+  return Date.now();
+}
+
+export function now_iso() {
+  return new Date().toISOString();
+}
+
+// ── UUID ──────────────────────────────────────────────────
+
+export function uuid() {
+  return typeof crypto !== 'undefined' && crypto.randomUUID
+    ? crypto.randomUUID()
+    : 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        var r = Math.random() * 16 | 0;
+        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+      });
+}

package/src/stdlib/datetime.js

@@ -0,0 +1,88 @@
+// Tova standard library — date/time utilities
+
+export function date_parse(s) {
+  const d = new Date(s);
+  if (isNaN(d.getTime())) {
+    return { __tag: 'Err', error: 'Invalid date: ' + s, map(_) { return this; }, unwrap() { throw new Error(this.error); }, isOk() { return false; }, isErr() { return true; } };
+  }
+  return { __tag: 'Ok', value: d, map(fn) { return { __tag: 'Ok', value: fn(d), unwrap() { return fn(d); }, isOk() { return true; }, isErr() { return false; } }; }, unwrap() { return d; }, isOk() { return true; }, isErr() { return false; } };
+}
+
+export function date_format(d, fmt) {
+  if (typeof d === 'number') d = new Date(d);
+  if (fmt === 'iso') return d.toISOString();
+  if (fmt === 'date') return d.toISOString().slice(0, 10);
+  if (fmt === 'time') return d.toTimeString().slice(0, 8);
+  if (fmt === 'datetime') return d.toISOString().slice(0, 10) + ' ' + d.toTimeString().slice(0, 8);
+  return fmt
+    .replace('YYYY', String(d.getFullYear()))
+    .replace('MM', String(d.getMonth() + 1).padStart(2, '0'))
+    .replace('DD', String(d.getDate()).padStart(2, '0'))
+    .replace('HH', String(d.getHours()).padStart(2, '0'))
+    .replace('mm', String(d.getMinutes()).padStart(2, '0'))
+    .replace('ss', String(d.getSeconds()).padStart(2, '0'));
+}
+
+export function date_add(d, amount, unit) {
+  if (typeof d === 'number') d = new Date(d);
+  const r = new Date(d.getTime());
+  if (unit === 'years') r.setFullYear(r.getFullYear() + amount);
+  else if (unit === 'months') r.setMonth(r.getMonth() + amount);
+  else if (unit === 'days') r.setDate(r.getDate() + amount);
+  else if (unit === 'hours') r.setHours(r.getHours() + amount);
+  else if (unit === 'minutes') r.setMinutes(r.getMinutes() + amount);
+  else if (unit === 'seconds') r.setSeconds(r.getSeconds() + amount);
+  return r;
+}
+
+export function date_diff(d1, d2, unit) {
+  if (typeof d1 === 'number') d1 = new Date(d1);
+  if (typeof d2 === 'number') d2 = new Date(d2);
+  const ms = d2.getTime() - d1.getTime();
+  if (unit === 'seconds') return Math.floor(ms / 1000);
+  if (unit === 'minutes') return Math.floor(ms / 60000);
+  if (unit === 'hours') return Math.floor(ms / 3600000);
+  if (unit === 'days') return Math.floor(ms / 86400000);
+  if (unit === 'months') return (d2.getFullYear() - d1.getFullYear()) * 12 + (d2.getMonth() - d1.getMonth());
+  if (unit === 'years') return d2.getFullYear() - d1.getFullYear();
+  return ms;
+}
+
+export function date_from(parts) {
+  return new Date(
+    parts.year || 0,
+    (parts.month || 1) - 1,
+    parts.day || 1,
+    parts.hour || 0,
+    parts.minute || 0,
+    parts.second || 0
+  );
+}
+
+export function date_part(d, part) {
+  if (typeof d === 'number') d = new Date(d);
+  if (part === 'year') return d.getFullYear();
+  if (part === 'month') return d.getMonth() + 1;
+  if (part === 'day') return d.getDate();
+  if (part === 'hour') return d.getHours();
+  if (part === 'minute') return d.getMinutes();
+  if (part === 'second') return d.getSeconds();
+  if (part === 'weekday') return d.getDay();
+  return null;
+}
+
+export function time_ago(d) {
+  if (typeof d === 'number') d = new Date(d);
+  const s = Math.floor((Date.now() - d.getTime()) / 1000);
+  if (s < 60) return s + ' seconds ago';
+  const m = Math.floor(s / 60);
+  if (m < 60) return m + (m === 1 ? ' minute ago' : ' minutes ago');
+  const h = Math.floor(m / 60);
+  if (h < 24) return h + (h === 1 ? ' hour ago' : ' hours ago');
+  const dy = Math.floor(h / 24);
+  if (dy < 30) return dy + (dy === 1 ? ' day ago' : ' days ago');
+  const mo = Math.floor(dy / 30);
+  if (mo < 12) return mo + (mo === 1 ? ' month ago' : ' months ago');
+  const yr = Math.floor(mo / 12);
+  return yr + (yr === 1 ? ' year ago' : ' years ago');
+}

package/src/stdlib/encoding.js

@@ -0,0 +1,35 @@
+// Tova standard library — encoding utilities
+
+export function base64_encode(s) {
+  return typeof btoa === 'function'
+    ? btoa(unescape(encodeURIComponent(s)))
+    : Buffer.from(s, 'utf-8').toString('base64');
+}
+
+export function base64_decode(s) {
+  return typeof atob === 'function'
+    ? decodeURIComponent(escape(atob(s)))
+    : Buffer.from(s, 'base64').toString('utf-8');
+}
+
+export function url_encode(s) {
+  return encodeURIComponent(s);
+}
+
+export function url_decode(s) {
+  return decodeURIComponent(s);
+}
+
+// ── Hex Encoding ──────────────────────────────────────────
+
+export function hex_encode(s) {
+  let r = '';
+  for (let i = 0; i < s.length; i++) r += s.charCodeAt(i).toString(16).padStart(2, '0');
+  return r;
+}
+
+export function hex_decode(s) {
+  let r = '';
+  for (let i = 0; i < s.length; i += 2) r += String.fromCharCode(parseInt(s.substr(i, 2), 16));
+  return r;
+}

package/src/stdlib/functional.js

@@ -0,0 +1,82 @@
+// Tova standard library — functional utilities
+
+export function compose(...fns) {
+  return (x) => fns.reduceRight((v, fn) => fn(v), x);
+}
+
+export function pipe_fn(...fns) {
+  return (x) => fns.reduce((v, fn) => fn(v), x);
+}
+
+export function identity(x) {
+  return x;
+}
+
+export function memoize(fn) {
+  const cache = new Map();
+  return function(...args) {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) return cache.get(key);
+    const result = fn.apply(this, args);
+    cache.set(key, result);
+    return result;
+  };
+}
+
+export function debounce(fn, ms) {
+  let timer;
+  return function(...args) {
+    clearTimeout(timer);
+    timer = setTimeout(() => fn.apply(this, args), ms);
+  };
+}
+
+export function throttle(fn, ms) {
+  let last = 0;
+  return function(...args) {
+    const now = Date.now();
+    if (now - last >= ms) {
+      last = now;
+      return fn.apply(this, args);
+    }
+  };
+}
+
+export function once(fn) {
+  let called = false, result;
+  return function(...args) {
+    if (!called) {
+      called = true;
+      result = fn.apply(this, args);
+    }
+    return result;
+  };
+}
+
+export function negate(fn) {
+  return function(...args) {
+    return !fn.apply(this, args);
+  };
+}
+
+// ── Extended Functional ───────────────────────────────────
+
+export function partial(fn, ...bound) {
+  return function(...args) {
+    return fn(...bound, ...args);
+  };
+}
+
+export function curry(fn, arity) {
+  const n = arity || fn.length;
+  return function curried(...args) {
+    if (args.length >= n) return fn(...args);
+    return function(...more) { return curried(...args, ...more); };
+  };
+}
+
+export function flip(fn) {
+  return function(a, b, ...rest) {
+    return fn(b, a, ...rest);
+  };
+}