conjure-js 0.0.12 → 0.0.13

package/src/clojure/generated/clojure-set-source.ts

@@ -0,0 +1,136 @@
+// Auto-generated from src/clojure/set.clj — do not edit directly.
+// Re-generate with: npm run gen:core-source
+export const clojure_setSource = `\
+(ns clojure.set)
+
+(defn union
+  "Return a set that is the union of the input sets."
+  ([] #{})
+  ([s] s)
+  ([s1 s2]
+   (reduce conj s1 s2))
+  ([s1 s2 & sets]
+   (reduce union (union s1 s2) sets)))
+
+(defn intersection
+  "Return a set that is the intersection of the input sets."
+  ([s] s)
+  ([s1 s2]
+   (reduce (fn [acc x]
+             (if (contains? s2 x)
+               (conj acc x)
+               acc))
+           #{}
+           s1))
+  ([s1 s2 & sets]
+   (reduce intersection (intersection s1 s2) sets)))
+
+(defn difference
+  "Return a set that is the first set without elements of the remaining sets."
+  ([s] s)
+  ([s1 s2]
+   (reduce (fn [acc x]
+             (if (contains? s2 x)
+               acc
+               (conj acc x)))
+           #{}
+           s1))
+  ([s1 s2 & sets]
+   (reduce difference (difference s1 s2) sets)))
+
+(defn select
+  "Returns a set of the elements for which pred is true."
+  [pred s]
+  (reduce (fn [acc x]
+            (if (pred x)
+              (conj acc x)
+              acc))
+          #{}
+          s))
+
+(defn project
+  "Returns a rel of the elements of xrel with only the keys in ks."
+  [xrel ks]
+  (reduce (fn [acc m]
+            (conj acc (select-keys m ks)))
+          #{}
+          xrel))
+
+(defn rename-keys
+  "Returns the map with the keys in kmap renamed to the vals in kmap."
+  [m kmap]
+  (reduce (fn [acc [old-k new-k]]
+            (if (contains? acc old-k)
+              (-> acc
+                  (assoc new-k (get acc old-k))
+                  (dissoc old-k))
+              acc))
+          m
+          kmap))
+
+(defn rename
+  "Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap."
+  [xrel kmap]
+  (reduce (fn [acc m]
+            (conj acc (rename-keys m kmap)))
+          #{}
+          xrel))
+
+(defn index
+  "Returns a map of the distinct values of ks in the xrel mapped to a
+  set of the maps in xrel with the corresponding values of ks."
+  [xrel ks]
+  (reduce (fn [acc m]
+            (let [k (select-keys m ks)]
+              (assoc acc k (conj (get acc k #{}) m))))
+          {}
+          xrel))
+
+(defn map-invert
+  "Returns the map with the vals mapped to the keys."
+  [m]
+  (reduce (fn [acc [k v]]
+            (assoc acc v k))
+          {}
+          m))
+
+(defn join
+  "When passed 2 rels, returns the relation corresponding to the natural
+  join. When passed an additional keymap, joins on the corresponding keys."
+  ([xrel yrel]
+   (if (and (seq xrel) (seq yrel))
+     (let [ks (intersection (set (keys (first xrel)))
+                            (set (keys (first yrel))))]
+       (if (empty? ks)
+         (reduce (fn [acc mx]
+                   (reduce (fn [acc2 my]
+                             (conj acc2 (merge mx my)))
+                           acc
+                           yrel))
+                 #{}
+                 xrel)
+         (join xrel yrel (zipmap ks ks))))
+     #{}))
+  ([xrel yrel km]
+   (let [idx (index yrel (vals km))]
+     (reduce (fn [acc mx]
+               (let [found (get idx (rename-keys (select-keys mx (keys km)) km))]
+                 (if found
+                   (reduce (fn [acc2 my]
+                             (conj acc2 (merge my mx)))
+                           acc
+                           found)
+                   acc)))
+             #{}
+             xrel))))
+
+(defn subset?
+  "Is set1 a subset of set2?"
+  [s1 s2]
+  (every? #(contains? s2 %) s1))
+
+(defn superset?
+  "Is set1 a superset of set2?"
+  [s1 s2]
+  (every? #(contains? s1 %) s2))
+`

package/src/clojure/generated/clojure-walk-source.ts

@@ -0,0 +1,72 @@
+// Auto-generated from src/clojure/walk.clj — do not edit directly.
+// Re-generate with: npm run gen:core-source
+export const clojure_walkSource = `\
+(ns clojure.walk)
+
+(defn walk
+  "Traverses form, an arbitrary data structure. inner and outer are
+  functions. Applies inner to each element of form, building up a
+  data structure of the same type, then applies outer to the result."
+  [inner outer form]
+  (cond
+    (list? form) (outer (apply list (map inner form)))
+    (vector? form) (outer (into [] (map inner) form))
+    (map? form) (outer (into {} (map (fn [e] [(inner (first e)) (inner (second e))]) form)))
+    (set? form) (outer (into #{} (map inner) form))
+    :else (outer form)))
+
+(defn postwalk
+  "Performs a depth-first, post-order traversal of form. Calls f on
+  each sub-form, uses f's return value in place of the original."
+  [f form]
+  (walk (fn [x] (postwalk f x)) f form))
+
+(defn prewalk
+  "Like postwalk, but does pre-order traversal."
+  [f form]
+  (walk (fn [x] (prewalk f x)) identity (f form)))
+
+(defn postwalk-replace
+  "Recursively transforms form by replacing keys in smap with their
+  values. Like clojure/replace but works on any data structure."
+  [smap form]
+  (postwalk (fn [x] (if (contains? smap x) (get smap x) x)) form))
+
+(defn prewalk-replace
+  "Recursively transforms form by replacing keys in smap with their
+  values. Like clojure/replace but works on any data structure."
+  [smap form]
+  (prewalk (fn [x] (if (contains? smap x) (get smap x) x)) form))
+
+(defn keywordize-keys
+  "Recursively transforms all map keys from strings to keywords."
+  [m]
+  (postwalk
+   (fn [x]
+     (if (map? x)
+       (into {} (map (fn [e]
+                       (let [k (first e)]
+                         (if (string? k)
+                           [(keyword k) (second e)]
+                           e)))
+                     x))
+       x))
+   m))
+
+(defn stringify-keys
+  "Recursively transforms all map keys from keywords to strings."
+  [m]
+  (postwalk
+   (fn [x]
+     (if (map? x)
+       (into {}
+             (map
+              (fn [e]
+                (let [k (first e)]
+                  (if (keyword? k)
+                    [(name k) (second e)]
+                    e)))
+              x))
+       x))
+   m))
+`

package/src/clojure/set.clj

@@ -0,0 +1,132 @@
+(ns clojure.set)
+
+(defn union
+  "Return a set that is the union of the input sets."
+  ([] #{})
+  ([s] s)
+  ([s1 s2]
+   (reduce conj s1 s2))
+  ([s1 s2 & sets]
+   (reduce union (union s1 s2) sets)))
+
+(defn intersection
+  "Return a set that is the intersection of the input sets."
+  ([s] s)
+  ([s1 s2]
+   (reduce (fn [acc x]
+             (if (contains? s2 x)
+               (conj acc x)
+               acc))
+           #{}
+           s1))
+  ([s1 s2 & sets]
+   (reduce intersection (intersection s1 s2) sets)))
+
+(defn difference
+  "Return a set that is the first set without elements of the remaining sets."
+  ([s] s)
+  ([s1 s2]
+   (reduce (fn [acc x]
+             (if (contains? s2 x)
+               acc
+               (conj acc x)))
+           #{}
+           s1))
+  ([s1 s2 & sets]
+   (reduce difference (difference s1 s2) sets)))
+
+(defn select
+  "Returns a set of the elements for which pred is true."
+  [pred s]
+  (reduce (fn [acc x]
+            (if (pred x)
+              (conj acc x)
+              acc))
+          #{}
+          s))
+
+(defn project
+  "Returns a rel of the elements of xrel with only the keys in ks."
+  [xrel ks]
+  (reduce (fn [acc m]
+            (conj acc (select-keys m ks)))
+          #{}
+          xrel))
+
+(defn rename-keys
+  "Returns the map with the keys in kmap renamed to the vals in kmap."
+  [m kmap]
+  (reduce (fn [acc [old-k new-k]]
+            (if (contains? acc old-k)
+              (-> acc
+                  (assoc new-k (get acc old-k))
+                  (dissoc old-k))
+              acc))
+          m
+          kmap))
+
+(defn rename
+  "Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap."
+  [xrel kmap]
+  (reduce (fn [acc m]
+            (conj acc (rename-keys m kmap)))
+          #{}
+          xrel))
+
+(defn index
+  "Returns a map of the distinct values of ks in the xrel mapped to a
+  set of the maps in xrel with the corresponding values of ks."
+  [xrel ks]
+  (reduce (fn [acc m]
+            (let [k (select-keys m ks)]
+              (assoc acc k (conj (get acc k #{}) m))))
+          {}
+          xrel))
+
+(defn map-invert
+  "Returns the map with the vals mapped to the keys."
+  [m]
+  (reduce (fn [acc [k v]]
+            (assoc acc v k))
+          {}
+          m))
+
+(defn join
+  "When passed 2 rels, returns the relation corresponding to the natural
+  join. When passed an additional keymap, joins on the corresponding keys."
+  ([xrel yrel]
+   (if (and (seq xrel) (seq yrel))
+     (let [ks (intersection (set (keys (first xrel)))
+                            (set (keys (first yrel))))]
+       (if (empty? ks)
+         (reduce (fn [acc mx]
+                   (reduce (fn [acc2 my]
+                             (conj acc2 (merge mx my)))
+                           acc
+                           yrel))
+                 #{}
+                 xrel)
+         (join xrel yrel (zipmap ks ks))))
+     #{}))
+  ([xrel yrel km]
+   (let [idx (index yrel (vals km))]
+     (reduce (fn [acc mx]
+               (let [found (get idx (rename-keys (select-keys mx (keys km)) km))]
+                 (if found
+                   (reduce (fn [acc2 my]
+                             (conj acc2 (merge my mx)))
+                           acc
+                           found)
+                   acc)))
+             #{}
+             xrel))))
+
+(defn subset?
+  "Is set1 a subset of set2?"
+  [s1 s2]
+  (every? #(contains? s2 %) s1))
+
+(defn superset?
+  "Is set1 a superset of set2?"
+  [s1 s2]
+  (every? #(contains? s1 %) s2))

package/src/clojure/set.clj.d.ts

@@ -0,0 +1,20 @@
+export function union(): unknown;
+export function union(s: unknown): unknown;
+export function union(s1: unknown, s2: unknown): unknown;
+export function union(s1: unknown, s2: unknown, ...sets: unknown[]): unknown;
+export function intersection(s: unknown): unknown;
+export function intersection(s1: unknown, s2: unknown): unknown;
+export function intersection(s1: unknown, s2: unknown, ...sets: unknown[]): unknown;
+export function difference(s: unknown): unknown;
+export function difference(s1: unknown, s2: unknown): unknown;
+export function difference(s1: unknown, s2: unknown, ...sets: unknown[]): unknown;
+export function select(pred: unknown, s: unknown): unknown;
+export function project(xrel: unknown, ks: unknown): unknown;
+export function rename_keys(m: unknown, kmap: unknown): unknown;
+export function rename(xrel: unknown, kmap: unknown): unknown;
+export function index(xrel: unknown, ks: unknown): unknown;
+export function map_invert(m: unknown): unknown;
+export function join(xrel: unknown, yrel: unknown): unknown;
+export function join(xrel: unknown, yrel: unknown, km: unknown): unknown;
+export function subset_QMARK_(s1: unknown, s2: unknown): unknown;
+export function superset_QMARK_(s1: unknown, s2: unknown): unknown;

package/src/clojure/string.clj.d.ts

@@ -1,3 +1,17 @@
+export const str_split_STAR_: unknown;
+export const str_upper_case_STAR_: unknown;
+export const str_lower_case_STAR_: unknown;
+export const str_trim_STAR_: unknown;
+export const str_triml_STAR_: unknown;
+export const str_trimr_STAR_: unknown;
+export const str_reverse_STAR_: unknown;
+export const str_starts_with_STAR_: unknown;
+export const str_ends_with_STAR_: unknown;
+export const str_includes_STAR_: unknown;
+export const str_index_of_STAR_: unknown;
+export const str_last_index_of_STAR_: unknown;
+export const str_replace_STAR_: unknown;
+export const str_replace_first_STAR_: unknown;
 export function join(coll: unknown): unknown;
 export function join(separator: unknown, coll: unknown): unknown;
 export function split(s: unknown, sep: unknown): unknown;

package/src/clojure/walk.clj

@@ -0,0 +1,68 @@
+(ns clojure.walk)
+
+(defn walk
+  "Traverses form, an arbitrary data structure. inner and outer are
+  functions. Applies inner to each element of form, building up a
+  data structure of the same type, then applies outer to the result."
+  [inner outer form]
+  (cond
+    (list? form) (outer (apply list (map inner form)))
+    (vector? form) (outer (into [] (map inner) form))
+    (map? form) (outer (into {} (map (fn [e] [(inner (first e)) (inner (second e))]) form)))
+    (set? form) (outer (into #{} (map inner) form))
+    :else (outer form)))
+
+(defn postwalk
+  "Performs a depth-first, post-order traversal of form. Calls f on
+  each sub-form, uses f's return value in place of the original."
+  [f form]
+  (walk (fn [x] (postwalk f x)) f form))
+
+(defn prewalk
+  "Like postwalk, but does pre-order traversal."
+  [f form]
+  (walk (fn [x] (prewalk f x)) identity (f form)))
+
+(defn postwalk-replace
+  "Recursively transforms form by replacing keys in smap with their
+  values. Like clojure/replace but works on any data structure."
+  [smap form]
+  (postwalk (fn [x] (if (contains? smap x) (get smap x) x)) form))
+
+(defn prewalk-replace
+  "Recursively transforms form by replacing keys in smap with their
+  values. Like clojure/replace but works on any data structure."
+  [smap form]
+  (prewalk (fn [x] (if (contains? smap x) (get smap x) x)) form))
+
+(defn keywordize-keys
+  "Recursively transforms all map keys from strings to keywords."
+  [m]
+  (postwalk
+   (fn [x]
+     (if (map? x)
+       (into {} (map (fn [e]
+                       (let [k (first e)]
+                         (if (string? k)
+                           [(keyword k) (second e)]
+                           e)))
+                     x))
+       x))
+   m))
+
+(defn stringify-keys
+  "Recursively transforms all map keys from keywords to strings."
+  [m]
+  (postwalk
+   (fn [x]
+     (if (map? x)
+       (into {}
+             (map
+              (fn [e]
+                (let [k (first e)]
+                  (if (keyword? k)
+                    [(name k) (second e)]
+                    e)))
+              x))
+       x))
+   m))

package/src/clojure/walk.clj.d.ts

@@ -0,0 +1,7 @@
+export function walk(inner: unknown, outer: unknown, form: unknown): unknown;
+export function postwalk(f: unknown, form: unknown): unknown;
+export function prewalk(f: unknown, form: unknown): unknown;
+export function postwalk_replace(smap: unknown, form: unknown): unknown;
+export function prewalk_replace(smap: unknown, form: unknown): unknown;
+export function keywordize_keys(m: unknown): unknown;
+export function stringify_keys(m: unknown): unknown;

package/src/core/assertions.ts

@@ -2,16 +2,22 @@ import {
   valueKeywords,
   type CljAtom,
   type CljBoolean,
+  type CljCons,
+  type CljDelay,
   type CljFunction,
+  type CljJsValue,
   type CljKeyword,
+  type CljLazySeq,
   type CljList,
   type CljMacro,
   type CljMap,
   type CljMultiMethod,
+  type CljNamespace,
   type CljNativeFunction,
   type CljNumber,
   type CljReduced,
   type CljRegex,
+  type CljSet,
   type CljString,
   type CljSymbol,
   type CljValue,
@@ -22,9 +28,11 @@ import {
 import { specialFormKeywords } from './evaluator/special-forms.ts'
 
 export const isNil = (value: CljValue): boolean => value.kind === 'nil'
+export const isBoolean = (value: CljValue): value is CljBoolean =>
+  value.kind === 'boolean'
 export const isFalsy = (value: CljValue): boolean => {
   if (value.kind === 'nil') return true
-  if (value.kind === 'boolean') return !value.value
+  if (isBoolean(value)) return !value.value
   return false
 }
 export const isTruthy = (value: CljValue): boolean => {
@@ -54,9 +62,13 @@ export const isAFunction = (
 ): value is CljFunction | CljNativeFunction =>
   isFunction(value) || isNativeFunction(value)
 
+export const isJsValue = (value: CljValue): value is CljJsValue =>
+  value.kind === 'js-value'
+
 /** True for any value that can be invoked like a function (IFn). */
 export const isCallable = (value: CljValue): boolean =>
-  isAFunction(value) || isKeyword(value) || isMap(value)
+  isAFunction(value) || isKeyword(value) || isMap(value) ||
+  (isJsValue(value) && typeof value.value === 'function')
 export const isMultiMethod = (value: CljValue): value is CljMultiMethod =>
   value.kind === 'multi-method'
 export const isAtom = (value: CljValue): value is CljAtom =>
@@ -68,15 +80,36 @@ export const isVolatile = (value: CljValue): value is CljVolatile =>
 export const isRegex = (value: CljValue): value is CljRegex =>
   value.kind === 'regex'
 export const isVar = (value: CljValue): value is CljVar => value.kind === 'var'
+export const isSet = (value: CljValue): value is CljSet =>
+  value.kind === valueKeywords.set
+export const isDelay = (value: CljValue): value is CljDelay =>
+  value.kind === 'delay'
+export const isLazySeq = (value: CljValue): value is CljLazySeq =>
+  value.kind === 'lazy-seq'
+export const isCons = (value: CljValue): value is CljCons =>
+  value.kind === 'cons'
+export const isNamespace = (value: CljValue): value is CljNamespace =>
+  value.kind === 'namespace'
 export const isCollection = (
   value: CljValue
-): value is CljList | CljVector | CljMap =>
-  isVector(value) || isMap(value) || isList(value)
+): value is CljList | CljVector | CljMap | CljSet | CljCons =>
+  isVector(value) ||
+  isMap(value) ||
+  isList(value) ||
+  isSet(value) ||
+  isCons(value)
 
 export const isSeqable = (
   value: CljValue
-): value is CljList | CljVector | CljMap | CljString =>
-  isCollection(value) || value.kind === 'string'
+): value is
+  | CljList
+  | CljVector
+  | CljMap
+  | CljSet
+  | CljString
+  | CljLazySeq
+  | CljCons =>
+  isCollection(value) || value.kind === 'string' || isLazySeq(value)
 
 export const isCljValue = (value: any): value is CljValue => {
   return (
@@ -87,6 +120,26 @@ export const isCljValue = (value: any): value is CljValue => {
   )
 }
 
+/** Realize a lazy-seq for equality comparison (trampoline to handle chains). */
+function realizeLazySeqForEquality(ls: CljLazySeq): CljValue {
+  let current: CljValue = ls
+  while (current.kind === 'lazy-seq') {
+    const lazy = current as CljLazySeq
+    if (lazy.realized) {
+      current = lazy.value!
+    } else if (lazy.thunk) {
+      lazy.value = lazy.thunk()
+      lazy.thunk = null
+      lazy.realized = true
+      current = lazy.value!
+    } else {
+      // No thunk and not realized — treat as nil
+      return { kind: 'nil', value: null }
+    }
+  }
+  return current
+}
+
 const equalityHandlers = {
   [valueKeywords.number]: (a: CljNumber, b: CljNumber) => a.value === b.value,
   [valueKeywords.string]: (a: CljString, b: CljString) => a.value === b.value,
@@ -126,8 +179,24 @@ const equalityHandlers = {
   // (= #"foo" #"foo") => false — each literal is a distinct object
   [valueKeywords.regex]: (a: CljRegex, b: CljRegex) => a === b,
   [valueKeywords.var]: (a: CljVar, b: CljVar) => a === b,
+  [valueKeywords.set]: (a: CljSet, b: CljSet) => {
+    if (a.values.length !== b.values.length) return false
+    return a.values.every((av) => b.values.some((bv) => isEqual(av, bv)))
+  },
+  [valueKeywords.delay]: (a: CljDelay, b: CljDelay) => a === b,
+  [valueKeywords.lazySeq]: (a: CljLazySeq, b: CljLazySeq) => {
+    // Realize both and compare structurally
+    const aVal = realizeLazySeqForEquality(a)
+    const bVal = realizeLazySeqForEquality(b)
+    return isEqual(aVal, bVal)
+  },
+  [valueKeywords.cons]: (a: CljCons, b: CljCons) =>
+    isEqual(a.head, b.head) && isEqual(a.tail, b.tail),
+  [valueKeywords.namespace]: (a: CljNamespace, b: CljNamespace) => a === b,
 }
 
+export const isString = (value: CljValue): value is CljString =>
+  value.kind === 'string'
 export const isEqual = (a: CljValue, b: CljValue): boolean => {
   if (a.kind !== b.kind) return false
 
@@ -135,3 +204,42 @@ export const isEqual = (a: CljValue, b: CljValue): boolean => {
   if (!handler) return false
   return handler(a as never, b as never)
 }
+export const isNumber = (value: CljValue): value is CljNumber =>
+  value.kind === 'number'
+
+// Main assertion interface for the entire package
+export const is = {
+  nil: isNil,
+  number: isNumber,
+  string: isString,
+  boolean: isBoolean,
+  falsy: isFalsy,
+  truthy: isTruthy,
+  specialForm: isSpecialForm,
+  symbol: isSymbol,
+  vector: isVector,
+  list: isList,
+  function: isFunction,
+  nativeFunction: isNativeFunction,
+  macro: isMacro,
+  map: isMap,
+  keyword: isKeyword,
+  aFunction: isAFunction,
+  callable: isCallable,
+  multiMethod: isMultiMethod,
+  atom: isAtom,
+  reduced: isReduced,
+  volatile: isVolatile,
+  regex: isRegex,
+  var: isVar,
+  set: isSet,
+  delay: isDelay,
+  lazySeq: isLazySeq,
+  cons: isCons,
+  namespace: isNamespace,
+  collection: isCollection,
+  seqable: isSeqable,
+  cljValue: isCljValue,
+  equal: isEqual,
+  jsValue: isJsValue,
+}