From bfa2cbf49d160c5e322c50dc682a62b7d03f3084 Mon Sep 17 00:00:00 2001 From: Yogthos Date: Sat, 27 Jun 2026 05:48:17 -0400 Subject: [PATCH] Small maps preserve insertion order jolt maps were HAMTs with hash iteration order; Clojure keeps small maps as PersistentArrayMap (insertion order), converting to PersistentHashMap past a threshold. Map literals, array-map, assoc, into/transient, merge, zipmap, select-keys, update-keys/vals, frequencies and group-by now iterate in insertion order for <=8 entries, matching the JVM. hash-map and >8-entry maps stay hash order; sets stay hash order. The pmap record gains an order field (the insertion-order key list, or #f once hashed); the HAMT still backs the values so equality/hash/lookup are unchanged. pmap-fold visits an array-mode map last-to-first so the runtime's cons-accumulate idiom reconstructs insertion order without touching its many call sites, and hash-mode output stays byte-identical; pmap-fold-fwd visits in order for the few sites that build a value directly. Transient maps track insertion order and promote to hash past max(8, source-count), matching TransientArrayMap. The hash-map native-op retargets to a hash-order builder so (hash-map ...) stays hash-ordered while {...} literals are ordered; syntax-quote builds maps via the hash builder (Clojure expands `{...} to apply hash-map). The core overlay map builders seed from {} instead of (hash-map) to keep order. Threshold is 8 for any key (the keyword exception in newer Clojure isn't in 1.12.5). honeysql now passes 832/0/0; 19 JVM-certified corpus rows added. --- host/chez/collections.ss | 86 ++++++++++++++++++++++++++---- host/chez/host-contract.ss | 2 +- host/chez/natives-coll.ss | 13 ++--- host/chez/natives-meta.ss | 2 +- host/chez/reader.ss | 2 +- host/chez/seed/image.ss | 64 +++++++++++----------- host/chez/seed/prelude.ss | 48 ++++++++--------- host/chez/syntax-quote.ss | 4 +- host/chez/transients.ss | 55 +++++++++++++------ jolt-core/clojure/core/21-coll.clj | 9 ++-- jolt-core/clojure/core/22-coll.clj | 13 ++--- jolt-core/jolt/backend_scheme.clj | 2 +- test/chez/corpus.edn | 19 +++++++ 13 files changed, 217 insertions(+), 102 deletions(-) diff --git a/host/chez/collections.ss b/host/chez/collections.ss index e4b6622..9f922eb 100644 --- a/host/chez/collections.ss +++ b/host/chez/collections.ss @@ -287,26 +287,92 @@ ;; ============================================================================ ;; persistent map / set over the HAMT ;; ============================================================================ -(define-record-type pmap (fields root cnt) (nongenerative chez-pmap-v1)) -(define empty-pmap (make-pmap empty-hnode 0)) +;; A small map keeps its keys in INSERTION order (Clojure's PersistentArrayMap), +;; converting to hash order past a threshold (PersistentHashMap). The HAMT root +;; always backs the values; `order` is the auxiliary insertion-order key list when +;; the map is in array mode, or #f once it has grown into hash mode. Equality and +;; hashing fold over the entries order-independently, so this only affects +;; iteration order (seq/keys/vals/print), matching the JVM. +(define-record-type pmap (fields root cnt order) (nongenerative chez-pmap-v2)) +(define empty-pmap (make-pmap empty-hnode 0 '())) ; {} = empty array map +(define empty-pmap-hash (make-pmap empty-hnode 0 #f)) ; hash-order backing (sets) (define pmap-absent (list 'absent)) ; unique missing-key sentinel +;; PersistentArrayMap threshold: assoc of a new key promotes to hash mode once the +;; map already holds 8 entries (array.length >= 16 in the reference). +(define array-map-limit 8) +(define (append-key ord k) (append ord (list k))) +(define (remove-key ord k) (let loop ((o ord)) (cond ((null? o) '()) ((jolt= (car o) k) (cdr o)) (else (cons (car o) (loop (cdr o))))))) + +;; growth rule (PersistentArrayMap.assoc): a new key appends to the order while in +;; array mode under the limit; otherwise the result is hash-ordered. Replacing an +;; existing key (or assoc onto an already-hash map) keeps the current order. (define (pmap-assoc m k v) + (let* ((added (box #f)) (r (node-assoc (pmap-root m) 0 (key-hash k) k v added)) + (cnt (pmap-cnt m)) (ord (pmap-order m))) + (if (unbox added) + (if (and ord (fxhash m) (if (pmap-order m) (make-pmap (pmap-root m) (pmap-cnt m) #f) m)) (define (pmap-dissoc m k) - (let* ((removed (box #f)) (r (node-dissoc (pmap-root m) 0 (key-hash k) k removed))) - (make-pmap r (if (unbox removed) (fx- (pmap-cnt m) 1) (pmap-cnt m))))) + (let* ((removed (box #f)) (r (node-dissoc (pmap-root m) 0 (key-hash k) k removed)) + (ord (pmap-order m))) + (if (unbox removed) + (make-pmap r (fx- (pmap-cnt m) 1) (if ord (remove-key ord k) #f)) + m))) (define (pmap-get m k default) (node-get (pmap-root m) 0 (key-hash k) k default)) (define (pmap-contains? m k) (not (eq? pmap-absent (node-get (pmap-root m) 0 (key-hash k) k pmap-absent)))) -(define (pmap-fold m proc acc) (node-fold (pmap-root m) proc acc)) +;; The universal fold idiom across the runtime is `(pmap-fold m (lambda (k v a) +;; (cons ... a)) '())`, which accumulates in REVERSE visitation order. So that this +;; reconstructs the map's INSERTION order, pmap-fold visits an array-mode map's keys +;; in reverse insertion order; a hash-mode map visits HAMT order (its iteration +;; order is unspecified, so reverse-of-HAMT is equivalent and matches prior +;; behaviour). Use pmap-fold-fwd when building a value directly in iteration order. +(define (pmap-fold m proc acc) + (let ((ord (pmap-order m))) + (if ord + (fold-right (lambda (k a) (proc k (pmap-get m k jolt-nil) a)) acc ord) ; visits last->first + (node-fold (pmap-root m) proc acc)))) +;; visit entries in iteration (insertion) order — for code that builds a new map / +;; ordered value directly rather than via cons-accumulation. +(define (pmap-fold-fwd m proc acc) + (let ((ord (pmap-order m))) + (if ord + (let loop ((ks ord) (a acc)) + (if (null? ks) a (loop (cdr ks) (proc (car ks) (pmap-get m (car ks) jolt-nil) a)))) + (node-fold (pmap-root m) proc acc)))) +;; map LITERAL ({...}): array map up to 8 entries, hash map beyond (RT.map). (define (jolt-hash-map . kvs) (let loop ((m empty-pmap) (kvs kvs)) - (cond ((null? kvs) m) + (cond ((null? kvs) (if (fx>? (pmap-cnt m) array-map-limit) (pmap->hash m) m)) ((null? (cdr kvs)) (error 'hash-map "odd number of map literal entries")) - (else (loop (pmap-assoc m (car kvs) (cadr kvs)) (cddr kvs)))))) + (else (loop (pmap-put-ordered m (car kvs) (cadr kvs)) (cddr kvs)))))) +;; array-map ctor: insertion-ordered regardless of size (createAsIfByAssoc). +(define (jolt-array-map-build kvs) + (let loop ((m empty-pmap) (kvs kvs)) + (cond ((null? kvs) m) + ((null? (cdr kvs)) (error 'array-map "odd number of map entries")) + (else (loop (pmap-put-ordered m (car kvs) (cadr kvs)) (cddr kvs)))))) +;; hash-map ctor: hash order (PersistentHashMap). +(define (jolt-hash-map-build kvs) + (let loop ((m empty-pmap-hash) (kvs kvs)) + (cond ((null? kvs) m) + ((null? (cdr kvs)) (error 'hash-map "odd number of map entries")) + (else (loop (pmap-put-hash m (car kvs) (cadr kvs)) (cddr kvs)))))) (define-record-type pset (fields m) (nongenerative chez-pset-v1)) -(define empty-pset (make-pset empty-pmap)) +(define empty-pset (make-pset empty-pmap-hash)) ; sets are hash-ordered (define (pset-conj s e) (if (pmap-contains? (pset-m s) e) s (make-pset (pmap-assoc (pset-m s) e e)))) (define (pset-disj s e) (make-pset (pmap-dissoc (pset-m s) e))) (define (pset-contains? s e) (pmap-contains? (pset-m s) e)) @@ -327,7 +393,7 @@ ((empty-list-t? coll) (cseq-list x jolt-nil)) ((pmap? coll) (cond ((jolt-nil? x) coll) ; (conj m nil) = m - ((pmap? x) (pmap-fold x (lambda (k v m) (pmap-assoc m k v)) coll)) ; merge + ((pmap? x) (pmap-fold-fwd x (lambda (k v m) (pmap-assoc m k v)) coll)) ; merge in x's order ((and (pvec? x) (fx=? 2 (pvec-count x))) (pmap-assoc coll (pvec-nth-d x 0 jolt-nil) (pvec-nth-d x 1 jolt-nil))) (else (error 'conj "conj on a map expects a [k v] pair or a map")))) diff --git a/host/chez/host-contract.ss b/host/chez/host-contract.ss index b994dd1..57eed46 100644 --- a/host/chez/host-contract.ss +++ b/host/chez/host-contract.ss @@ -198,7 +198,7 @@ (or (jolt-nil? dm) (jolt-nil? (jolt-get dm hc-kw-line)))) (jolt-with-meta dst (if (pmap? dm) - (pmap-fold sp (lambda (k v acc) (jolt-assoc1 acc k v)) dm) + (pmap-fold-fwd sp (lambda (k v acc) (jolt-assoc1 acc k v)) dm) sp)) dst)) dst)) diff --git a/host/chez/natives-coll.ss b/host/chez/natives-coll.ss index a621b63..c678cd4 100644 --- a/host/chez/natives-coll.ss +++ b/host/chez/natives-coll.ss @@ -4,11 +4,12 @@ ;; binds the public clojure.core names to them. Loaded after def-var! (rt.ss) + ;; the collections + seq tiers. hash-map/array-map/hash-set/set/rand semantics. -;; hash-map / hash-set: variadic kvs / elems straight onto the existing ctors. -;; array-map: Clojure preserves insertion order, but jolt's `=` is structural and -;; the parity corpus compares by value, so a pmap is observationally equal for -;; the tested cases; keys-ordering is a separate (untested-here) concern. -(define (jolt-array-map . kvs) (apply jolt-hash-map kvs)) +;; array-map: insertion-ordered, any size (Clojure's PersistentArrayMap, via +;; createAsIfByAssoc). hash-map: hash order (PersistentHashMap). The map LITERAL +;; ctor (jolt-hash-map, emitted for {...}) is array-ordered up to 8 entries and +;; hash beyond, matching RT.map. +(define (jolt-array-map . kvs) (jolt-array-map-build kvs)) +(define (jolt-hash-map-fn . kvs) (jolt-hash-map-build kvs)) ;; set: realize any seqable to a list, then dedup through the set ctor. nil -> #{}. (define (jolt-set coll) @@ -20,7 +21,7 @@ (let ((r (random 1.0))) (if (null? n) r (* r (exact->inexact (car n)))))) -(def-var! "clojure.core" "hash-map" jolt-hash-map) +(def-var! "clojure.core" "hash-map" jolt-hash-map-fn) (def-var! "clojure.core" "hash-set" jolt-hash-set) (def-var! "clojure.core" "array-map" jolt-array-map) (def-var! "clojure.core" "set" jolt-set) diff --git a/host/chez/natives-meta.ss b/host/chez/natives-meta.ss index 67556cc..8942f33 100644 --- a/host/chez/natives-meta.ss +++ b/host/chez/natives-meta.ss @@ -31,7 +31,7 @@ (define (meta-copy x) (cond ((pvec? x) (make-pvec (pvec-v x) (pvec-ent x))) - ((pmap? x) (make-pmap (pmap-root x) (pmap-cnt x))) + ((pmap? x) (make-pmap (pmap-root x) (pmap-cnt x) (pmap-order x))) ((pset? x) (make-pset (pset-m x))) ((jrec? x) (make-jrec (jrec-desc x) (jrec-vec-copy (jrec-vals x)) (jrec-ext x))) ;; a reify shares its (read-only) method table + protos but gets a fresh diff --git a/host/chez/reader.ss b/host/chez/reader.ss index eea2003..2612b47 100644 --- a/host/chez/reader.ss +++ b/host/chez/reader.ss @@ -299,7 +299,7 @@ (define (rdr-merge-meta old new) (if (pmap? old) - (pmap-fold new (lambda (k v acc) (jolt-assoc1 acc k v)) old) + (pmap-fold-fwd new (lambda (k v acc) (jolt-assoc1 acc k v)) old) new)) (define (rdr-attach-meta target meta) diff --git a/host/chez/seed/image.ss b/host/chez/seed/image.ss index f653964..4321027 100644 --- a/host/chez/seed/image.ss +++ b/host/chez/seed/image.ss @@ -125,7 +125,7 @@ (guard (e (#t #f)) (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec8874 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8875 ((ctx ctx) (form form) (env env)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.ir" "const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-symbol") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "vector-node") (let* ((_a$8877 (var-deref "clojure.core" "mapv")) (_a$8878 (lambda (p__99_) (let fnrec8876 ((p__99_ p__99_)) (analyze ctx p__99_ env)))) (_a$8879 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8877 _a$8878 _a$8879)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8883 (var-deref "clojure.core" "mapv")) (_a$8884 (lambda (p) (let fnrec8880 ((p p)) (let* ((_o$8881 (analyze ctx (jolt-first p) env)) (_o$8882 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8881 _o$8882))))) (_a$8885 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8883 _a$8884 _a$8885)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "set-node") (let* ((_a$8887 (var-deref "clojure.core" "mapv")) (_a$8888 (lambda (p__100_) (let fnrec8886 ((p__100_ p__100_)) (analyze ctx p__100_ env)))) (_a$8889 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8887 _a$8888 _a$8889)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-list") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (let* ((_o$8890 (keyword #f "op")) (_o$8891 (keyword #f "regex")) (_o$8892 (keyword #f "source")) (_o$8893 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8890 _o$8891 _o$8892 _o$8893)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8894 (keyword #f "op")) (_o$8895 (keyword #f "inst")) (_o$8896 (keyword #f "source")) (_o$8897 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8894 _o$8895 _o$8896 _o$8897)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8898 (keyword #f "op")) (_o$8899 (keyword #f "uuid")) (_o$8900 (keyword #f "source")) (_o$8901 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8898 _o$8899 _o$8900 _o$8901)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8902 (keyword #f "op")) (_o$8903 (keyword #f "bigdec")) (_o$8904 (keyword #f "source")) (_o$8905 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8902 _o$8903 _o$8904 _o$8905)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$8906 (keyword #f "op")) (_o$8907 (keyword #f "the-ns")) (_o$8908 (keyword #f "name")) (_o$8909 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$8906 _o$8907 _o$8908 _o$8909)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "unsupported form") jolt-nil))))))))))))))))) analyze))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "native-ops" (let* ((_o$7127 "+") (_o$7128 "+") (_o$7129 "-") (_o$7130 "-") (_o$7131 "*") (_o$7132 "*") (_o$7133 "/") (_o$7134 "/") (_o$7135 "<") (_o$7136 "<") (_o$7137 ">") (_o$7138 ">") (_o$7139 "<=") (_o$7140 "<=") (_o$7141 ">=") (_o$7142 ">=") (_o$7143 "=") (_o$7144 "jolt=") (_o$7145 "inc") (_o$7146 "jolt-inc") (_o$7147 "dec") (_o$7148 "jolt-dec") (_o$7149 "not") (_o$7150 "jolt-not") (_o$7151 "min") (_o$7152 "min") (_o$7153 "max") (_o$7154 "max") (_o$7155 "mod") (_o$7156 "modulo") (_o$7157 "rem") (_o$7158 "remainder") (_o$7159 "quot") (_o$7160 "quotient") (_o$7161 "vector") (_o$7162 "jolt-vector") (_o$7163 "hash-map") (_o$7164 "jolt-hash-map") (_o$7165 "hash-set") (_o$7166 "jolt-hash-set") (_o$7167 "conj") (_o$7168 "jolt-conj") (_o$7169 "get") (_o$7170 "jolt-get") (_o$7171 "nth") (_o$7172 "jolt-nth") (_o$7173 "count") (_o$7174 "jolt-count") (_o$7175 "assoc") (_o$7176 "jolt-assoc") (_o$7177 "dissoc") (_o$7178 "jolt-dissoc") (_o$7179 "contains?") (_o$7180 "jolt-contains?") (_o$7181 "empty?") (_o$7182 "jolt-empty?") (_o$7183 "peek") (_o$7184 "jolt-peek") (_o$7185 "pop") (_o$7186 "jolt-pop") (_o$7187 "first") (_o$7188 "jolt-first") (_o$7189 "rest") (_o$7190 "jolt-rest") (_o$7191 "next") (_o$7192 "jolt-next") (_o$7193 "seq") (_o$7194 "jolt-seq") (_o$7195 "cons") (_o$7196 "jolt-cons") (_o$7197 "list") (_o$7198 "jolt-list") (_o$7199 "reverse") (_o$7200 "jolt-reverse") (_o$7201 "last") (_o$7202 "jolt-last") (_o$7203 "map") (_o$7204 "jolt-map") (_o$7205 "filter") (_o$7206 "jolt-filter") (_o$7207 "remove") (_o$7208 "jolt-remove") (_o$7209 "reduce") (_o$7210 "jolt-reduce") (_o$7211 "into") (_o$7212 "jolt-into") (_o$7213 "concat") (_o$7214 "jolt-concat") (_o$7215 "apply") (_o$7216 "jolt-apply") (_o$7217 "range") (_o$7218 "jolt-range") (_o$7219 "take") (_o$7220 "jolt-take") (_o$7221 "drop") (_o$7222 "jolt-drop") (_o$7223 "keys") (_o$7224 "jolt-keys") (_o$7225 "vals") (_o$7226 "jolt-vals") (_o$7227 "even?") (_o$7228 "jolt-even?") (_o$7229 "odd?") (_o$7230 "jolt-odd?") (_o$7231 "pos?") (_o$7232 "jolt-pos?") (_o$7233 "neg?") (_o$7234 "jolt-neg?") (_o$7235 "zero?") (_o$7236 "jolt-zero?") (_o$7237 "identity") (_o$7238 "jolt-identity") (_o$7239 "nil?") (_o$7240 "jolt-nil?") (_o$7241 "some?") (_o$7242 "jolt-some?") (_o$7243 "ex-info") (_o$7244 "jolt-ex-info") (_o$7245 "protocol-dispatch1") (_o$7246 "protocol-dispatch1") (_o$7247 "protocol-dispatch2") (_o$7248 "protocol-dispatch2") (_o$7249 "protocol-dispatch3") (_o$7250 "protocol-dispatch3")) (jolt-hash-map _o$7127 _o$7128 _o$7129 _o$7130 _o$7131 _o$7132 _o$7133 _o$7134 _o$7135 _o$7136 _o$7137 _o$7138 _o$7139 _o$7140 _o$7141 _o$7142 _o$7143 _o$7144 _o$7145 _o$7146 _o$7147 _o$7148 _o$7149 _o$7150 _o$7151 _o$7152 _o$7153 _o$7154 _o$7155 _o$7156 _o$7157 _o$7158 _o$7159 _o$7160 _o$7161 _o$7162 _o$7163 _o$7164 _o$7165 _o$7166 _o$7167 _o$7168 _o$7169 _o$7170 _o$7171 _o$7172 _o$7173 _o$7174 _o$7175 _o$7176 _o$7177 _o$7178 _o$7179 _o$7180 _o$7181 _o$7182 _o$7183 _o$7184 _o$7185 _o$7186 _o$7187 _o$7188 _o$7189 _o$7190 _o$7191 _o$7192 _o$7193 _o$7194 _o$7195 _o$7196 _o$7197 _o$7198 _o$7199 _o$7200 _o$7201 _o$7202 _o$7203 _o$7204 _o$7205 _o$7206 _o$7207 _o$7208 _o$7209 _o$7210 _o$7211 _o$7212 _o$7213 _o$7214 _o$7215 _o$7216 _o$7217 _o$7218 _o$7219 _o$7220 _o$7221 _o$7222 _o$7223 _o$7224 _o$7225 _o$7226 _o$7227 _o$7228 _o$7229 _o$7230 _o$7231 _o$7232 _o$7233 _o$7234 _o$7235 _o$7236 _o$7237 _o$7238 _o$7239 _o$7240 _o$7241 _o$7242 _o$7243 _o$7244 _o$7245 _o$7246 _o$7247 _o$7248 _o$7249 _o$7250)) (let* ((_o$7251 (keyword #f "private")) (_o$7252 #t)) (jolt-hash-map _o$7251 _o$7252)))) + (def-var-with-meta! "jolt.backend-scheme" "native-ops" (let* ((_o$7127 "+") (_o$7128 "+") (_o$7129 "-") (_o$7130 "-") (_o$7131 "*") (_o$7132 "*") (_o$7133 "/") (_o$7134 "/") (_o$7135 "<") (_o$7136 "<") (_o$7137 ">") (_o$7138 ">") (_o$7139 "<=") (_o$7140 "<=") (_o$7141 ">=") (_o$7142 ">=") (_o$7143 "=") (_o$7144 "jolt=") (_o$7145 "inc") (_o$7146 "jolt-inc") (_o$7147 "dec") (_o$7148 "jolt-dec") (_o$7149 "not") (_o$7150 "jolt-not") (_o$7151 "min") (_o$7152 "min") (_o$7153 "max") (_o$7154 "max") (_o$7155 "mod") (_o$7156 "modulo") (_o$7157 "rem") (_o$7158 "remainder") (_o$7159 "quot") (_o$7160 "quotient") (_o$7161 "vector") (_o$7162 "jolt-vector") (_o$7163 "hash-map") (_o$7164 "jolt-hash-map-fn") (_o$7165 "hash-set") (_o$7166 "jolt-hash-set") (_o$7167 "conj") (_o$7168 "jolt-conj") (_o$7169 "get") (_o$7170 "jolt-get") (_o$7171 "nth") (_o$7172 "jolt-nth") (_o$7173 "count") (_o$7174 "jolt-count") (_o$7175 "assoc") (_o$7176 "jolt-assoc") (_o$7177 "dissoc") (_o$7178 "jolt-dissoc") (_o$7179 "contains?") (_o$7180 "jolt-contains?") (_o$7181 "empty?") (_o$7182 "jolt-empty?") (_o$7183 "peek") (_o$7184 "jolt-peek") (_o$7185 "pop") (_o$7186 "jolt-pop") (_o$7187 "first") (_o$7188 "jolt-first") (_o$7189 "rest") (_o$7190 "jolt-rest") (_o$7191 "next") (_o$7192 "jolt-next") (_o$7193 "seq") (_o$7194 "jolt-seq") (_o$7195 "cons") (_o$7196 "jolt-cons") (_o$7197 "list") (_o$7198 "jolt-list") (_o$7199 "reverse") (_o$7200 "jolt-reverse") (_o$7201 "last") (_o$7202 "jolt-last") (_o$7203 "map") (_o$7204 "jolt-map") (_o$7205 "filter") (_o$7206 "jolt-filter") (_o$7207 "remove") (_o$7208 "jolt-remove") (_o$7209 "reduce") (_o$7210 "jolt-reduce") (_o$7211 "into") (_o$7212 "jolt-into") (_o$7213 "concat") (_o$7214 "jolt-concat") (_o$7215 "apply") (_o$7216 "jolt-apply") (_o$7217 "range") (_o$7218 "jolt-range") (_o$7219 "take") (_o$7220 "jolt-take") (_o$7221 "drop") (_o$7222 "jolt-drop") (_o$7223 "keys") (_o$7224 "jolt-keys") (_o$7225 "vals") (_o$7226 "jolt-vals") (_o$7227 "even?") (_o$7228 "jolt-even?") (_o$7229 "odd?") (_o$7230 "jolt-odd?") (_o$7231 "pos?") (_o$7232 "jolt-pos?") (_o$7233 "neg?") (_o$7234 "jolt-neg?") (_o$7235 "zero?") (_o$7236 "jolt-zero?") (_o$7237 "identity") (_o$7238 "jolt-identity") (_o$7239 "nil?") (_o$7240 "jolt-nil?") (_o$7241 "some?") (_o$7242 "jolt-some?") (_o$7243 "ex-info") (_o$7244 "jolt-ex-info") (_o$7245 "protocol-dispatch1") (_o$7246 "protocol-dispatch1") (_o$7247 "protocol-dispatch2") (_o$7248 "protocol-dispatch2") (_o$7249 "protocol-dispatch3") (_o$7250 "protocol-dispatch3")) (jolt-hash-map _o$7127 _o$7128 _o$7129 _o$7130 _o$7131 _o$7132 _o$7133 _o$7134 _o$7135 _o$7136 _o$7137 _o$7138 _o$7139 _o$7140 _o$7141 _o$7142 _o$7143 _o$7144 _o$7145 _o$7146 _o$7147 _o$7148 _o$7149 _o$7150 _o$7151 _o$7152 _o$7153 _o$7154 _o$7155 _o$7156 _o$7157 _o$7158 _o$7159 _o$7160 _o$7161 _o$7162 _o$7163 _o$7164 _o$7165 _o$7166 _o$7167 _o$7168 _o$7169 _o$7170 _o$7171 _o$7172 _o$7173 _o$7174 _o$7175 _o$7176 _o$7177 _o$7178 _o$7179 _o$7180 _o$7181 _o$7182 _o$7183 _o$7184 _o$7185 _o$7186 _o$7187 _o$7188 _o$7189 _o$7190 _o$7191 _o$7192 _o$7193 _o$7194 _o$7195 _o$7196 _o$7197 _o$7198 _o$7199 _o$7200 _o$7201 _o$7202 _o$7203 _o$7204 _o$7205 _o$7206 _o$7207 _o$7208 _o$7209 _o$7210 _o$7211 _o$7212 _o$7213 _o$7214 _o$7215 _o$7216 _o$7217 _o$7218 _o$7219 _o$7220 _o$7221 _o$7222 _o$7223 _o$7224 _o$7225 _o$7226 _o$7227 _o$7228 _o$7229 _o$7230 _o$7231 _o$7232 _o$7233 _o$7234 _o$7235 _o$7236 _o$7237 _o$7238 _o$7239 _o$7240 _o$7241 _o$7242 _o$7243 _o$7244 _o$7245 _o$7246 _o$7247 _o$7248 _o$7249 _o$7250)) (let* ((_o$7251 (keyword #f "private")) (_o$7252 #t)) (jolt-hash-map _o$7251 _o$7252)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.backend-scheme" "core-value-procs" (jolt-invoke (var-deref "clojure.core" "merge") (var-deref "jolt.backend-scheme" "native-ops") (let* ((_o$7253 "+") (_o$7254 "jolt-add") (_o$7255 "-") (_o$7256 "jolt-sub") (_o$7257 "*") (_o$7258 "jolt-mul") (_o$7259 "/") (_o$7260 "jolt-div") (_o$7261 "min") (_o$7262 "jolt-min") (_o$7263 "max") (_o$7264 "jolt-max")) (jolt-hash-map _o$7253 _o$7254 _o$7255 _o$7256 _o$7257 _o$7258 _o$7259 _o$7260 _o$7261 _o$7262 _o$7263 _o$7264))) (let* ((_o$7265 (keyword #f "private")) (_o$7266 #t)) (jolt-hash-map _o$7265 _o$7266)))) (guard (e (#t #f)) @@ -293,7 +293,7 @@ (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.numeric" "arity-env" (letrec ((arity-env (lambda (tenv a) (let fnrec6688 ((tenv tenv) (a a)) (let* ((nh (let* ((_a$6689 (jolt-hash-map)) (_a$6690 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$6689 _a$6690))) (pe (let* ((_a$6692 (lambda (e p) (let fnrec6691 ((e e) (p p)) (jolt-assoc e p (jolt-get nh p))))) (_a$6693 tenv) (_a$6694 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$6692 _a$6693 _a$6694)))) (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) jolt-nil) pe)))))) arity-env) (let* ((_o$6695 (keyword #f "private")) (_o$6696 #t)) (jolt-hash-map _o$6695 _o$6696)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.numeric" "an-invoke" (letrec ((an-invoke (lambda (node tenv) (let fnrec6697 ((node node) (tenv tenv)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (nm (if (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)) (jolt-get fnode (keyword #f "name")) jolt-nil)) (ars (let* ((_a$6699 (var-deref "clojure.core" "mapv")) (_a$6700 (lambda (a) (let fnrec6698 ((a a)) (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv)))) (_a$6701 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$6699 _a$6700 _a$6701))) (argnodes (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6702 ((r r)) (jolt-nth r 1))) ars)) (node1 (jolt-assoc node (keyword #f "args") argnodes)) (n (jolt-count ars))) (if (jolt= (keyword #f "double") (jolt-get node (keyword #f "num-read"))) (let* ((_o$6703 (keyword #f "double")) (_o$6704 node1)) (jolt-vector _o$6703 _o$6704)) (if (jolt-truthy? (jolt-get fnode (keyword #f "num-ret"))) (let* ((_o$6705 (jolt-get fnode (keyword #f "num-ret"))) (_o$6706 node1)) (jolt-vector _o$6705 _o$6706)) (if (jolt-nil? nm) (let* ((_o$6707 jolt-nil) (_o$6708 node1)) (jolt-vector _o$6707 _o$6708)) (if (jolt-truthy? (keyword #f "else")) (let* ((cls (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6709 ((r r)) (let* ((k (jolt-nth r 0)) (nd (jolt-nth r 1))) (if (jolt= k (keyword #f "double")) (keyword #f "double") (if (jolt= k (keyword #f "long")) (keyword #f "long") (if (jolt= k (keyword #f "bigdec")) (keyword #f "bigdec") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") nd)) (keyword #f "wild") (if (jolt-truthy? (keyword #f "else")) (keyword #f "no") jolt-nil)))))))) ars)) (ok? (lambda (allowed need) (let fnrec6710 ((allowed allowed) (need need)) (let* ((and__25__auto (jolt-pos? n))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (c) (let fnrec6711 ((c c)) (let* ((or__26__auto (jolt= c (keyword #f "wild")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= c allowed))))) cls))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "some") (lambda (c) (let fnrec6712 ((c c)) (jolt= c need))) cls) and__25__auto)) and__25__auto))))) (ds (jolt-invoke (var-deref "jolt.passes.numeric" "dbl-spec") nm n)) (ls (jolt-invoke (var-deref "jolt.passes.numeric" "lng-spec") nm n)) (bs (jolt-invoke (var-deref "jolt.passes.numeric" "bd-spec") nm n))) (if (jolt-truthy? (let* ((and__25__auto ds)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "double") (keyword #f "double")) and__25__auto))) (let* ((args_PRIME_ (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (nd) (let fnrec6713 ((nd nd)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") nd)) (jolt-assoc nd (keyword #f "val") (jolt-invoke (var-deref "clojure.core" "double") (jolt-get nd (keyword #f "val")))) nd))) argnodes))) (let* ((_o$6714 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ds)) (_o$6715 (jolt-assoc node1 (keyword #f "args") args_PRIME_ (keyword #f "num-kind") (keyword #f "double")))) (jolt-vector _o$6714 _o$6715))) (if (jolt-truthy? (let* ((and__25__auto ls)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "long") (keyword #f "long")) and__25__auto))) (let* ((_o$6716 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ls)) (_o$6717 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "long")))) (jolt-vector _o$6716 _o$6717)) (if (jolt-truthy? (let* ((and__25__auto bs)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "bigdec") (keyword #f "bigdec")) and__25__auto))) (let* ((_o$6718 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") bs)) (_o$6719 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "bigdec")))) (jolt-vector _o$6718 _o$6719)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6720 jolt-nil) (_o$6721 node1)) (jolt-vector _o$6720 _o$6721)) jolt-nil))))) jolt-nil))))))))) an-invoke) (let* ((_o$6722 (keyword #f "doc")) (_o$6723 "Annotate an :invoke with its numeric kind. An arithmetic core op specializes to\n the Chez fl*/fx* op only when every operand is the same kind (:double or :long),\n except an integer literal is :wild \x2014; valid in either \x2014; so (+ ^double x 2) stays\n double. A call to a ^double/^long-returning var yields that kind without lowering\n the call (its body already coerces the return).") (_o$6724 (keyword #f "private")) (_o$6725 #t)) (jolt-hash-map _o$6722 _o$6723 _o$6724 _o$6725)))) + (def-var-with-meta! "jolt.passes.numeric" "an-invoke" (letrec ((an-invoke (lambda (node tenv) (let fnrec6697 ((node node) (tenv tenv)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (nm (if (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)) (jolt-get fnode (keyword #f "name")) jolt-nil)) (ars (let* ((_a$6699 (var-deref "clojure.core" "mapv")) (_a$6700 (lambda (a) (let fnrec6698 ((a a)) (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv)))) (_a$6701 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$6699 _a$6700 _a$6701))) (argnodes (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6702 ((r r)) (jolt-nth r 1))) ars)) (node1 (jolt-assoc node (keyword #f "args") argnodes)) (n (jolt-count ars))) (if (jolt= (keyword #f "double") (jolt-get node (keyword #f "num-read"))) (let* ((_o$6703 (keyword #f "double")) (_o$6704 node1)) (jolt-vector _o$6703 _o$6704)) (if (jolt-truthy? (jolt-get fnode (keyword #f "num-ret"))) (let* ((_o$6705 (jolt-get fnode (keyword #f "num-ret"))) (_o$6706 node1)) (jolt-vector _o$6705 _o$6706)) (if (jolt-nil? nm) (let* ((_o$6707 jolt-nil) (_o$6708 node1)) (jolt-vector _o$6707 _o$6708)) (if (jolt-truthy? (keyword #f "else")) (let* ((cls (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6709 ((r r)) (let* ((k (jolt-nth r 0)) (nd (jolt-nth r 1))) (if (jolt= k (keyword #f "double")) (keyword #f "double") (if (jolt= k (keyword #f "long")) (keyword #f "long") (if (jolt= k (keyword #f "bigdec")) (keyword #f "bigdec") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") nd)) (keyword #f "wild") (if (jolt-truthy? (keyword #f "else")) (keyword #f "no") jolt-nil)))))))) ars)) (ok? (lambda (allowed need) (let fnrec6710 ((allowed allowed) (need need)) (let* ((and__25__auto (jolt-pos? n))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (c) (let fnrec6711 ((c c)) (let* ((or__26__auto (jolt= c (keyword #f "wild")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= c allowed))))) cls))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "some") (lambda (c) (let fnrec6712 ((c c)) (jolt= c need))) cls) and__25__auto)) and__25__auto))))) (ds (jolt-invoke (var-deref "jolt.passes.numeric" "dbl-spec") nm n)) (ls (jolt-invoke (var-deref "jolt.passes.numeric" "lng-spec") nm n)) (bs (jolt-invoke (var-deref "jolt.passes.numeric" "bd-spec") nm n))) (if (jolt-truthy? (let* ((and__25__auto ds)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "double") (keyword #f "double")) and__25__auto))) (let* ((args_PRIME_ (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (nd) (let fnrec6713 ((nd nd)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") nd)) (jolt-assoc nd (keyword #f "val") (jolt-invoke (var-deref "clojure.core" "double") (jolt-get nd (keyword #f "val")))) nd))) argnodes))) (let* ((_o$6714 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ds)) (_o$6715 (jolt-assoc node1 (keyword #f "args") args_PRIME_ (keyword #f "num-kind") (keyword #f "double")))) (jolt-vector _o$6714 _o$6715))) (if (jolt-truthy? (let* ((and__25__auto ls)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "long") (keyword #f "long")) and__25__auto))) (let* ((_o$6716 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ls)) (_o$6717 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "long")))) (jolt-vector _o$6716 _o$6717)) (if (jolt-truthy? (let* ((and__25__auto bs)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "bigdec") (keyword #f "bigdec")) and__25__auto))) (let* ((_o$6718 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") bs)) (_o$6719 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "bigdec")))) (jolt-vector _o$6718 _o$6719)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6720 jolt-nil) (_o$6721 node1)) (jolt-vector _o$6720 _o$6721)) jolt-nil))))) jolt-nil))))))))) an-invoke) (let* ((_o$6722 (keyword #f "private")) (_o$6723 #t) (_o$6724 (keyword #f "doc")) (_o$6725 "Annotate an :invoke with its numeric kind. An arithmetic core op specializes to\n the Chez fl*/fx* op only when every operand is the same kind (:double or :long),\n except an integer literal is :wild \x2014; valid in either \x2014; so (+ ^double x 2) stays\n double. A call to a ^double/^long-returning var yields that kind without lowering\n the call (its body already coerces the return).")) (jolt-hash-map _o$6722 _o$6723 _o$6724 _o$6725)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.numeric" "an" (letrec ((an (lambda (node tenv) (let fnrec6726 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$6727 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "float-lit?") node)) (keyword #f "double") jolt-nil)) (_o$6728 node)) (jolt-vector _o$6727 _o$6728)) (if (jolt= op (keyword #f "bigdec")) (let* ((_o$6729 (keyword #f "bigdec")) (_o$6730 node)) (jolt-vector _o$6729 _o$6730)) (if (jolt= op (keyword #f "local")) (let* ((_o$6731 (jolt-get tenv (jolt-get node (keyword #f "name")))) (_o$6732 node)) (jolt-vector _o$6731 _o$6732)) (if (jolt= op (keyword #f "coerce")) (let* ((_o$6733 (jolt-get node (keyword #f "kind"))) (_o$6734 (jolt-assoc node (keyword #f "expr") (jolt-nth (an (jolt-get node (keyword #f "expr")) tenv) 1)))) (jolt-vector _o$6733 _o$6734)) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.numeric" "an-invoke") node tenv) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$6745 (lambda (acc b) (let fnrec6735 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (an (jolt-nth b 1) te))) (let* ((_o$6741 (let* ((_a$6736 te) (_a$6737 (jolt-nth b 0)) (_a$6738 (jolt-nth ir 0))) (jolt-assoc _a$6736 _a$6737 _a$6738))) (_o$6742 (jolt-conj binds (let* ((_o$6739 (jolt-nth b 0)) (_o$6740 (jolt-nth ir 1))) (jolt-vector _o$6739 _o$6740))))) (jolt-vector _o$6741 _o$6742)))))) (_a$6746 (let* ((_o$6743 tenv) (_o$6744 (jolt-vector))) (jolt-vector _o$6743 _o$6744))) (_a$6747 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6745 _a$6746 _a$6747))) (br (let* ((_a$6748 (jolt-get node (keyword #f "body"))) (_a$6749 (jolt-nth res 0))) (an _a$6748 _a$6749)))) (let* ((_o$6755 (jolt-nth br 0)) (_o$6756 (let* ((_a$6750 node) (_a$6751 (keyword #f "bindings")) (_a$6752 (jolt-nth res 1)) (_a$6753 (keyword #f "body")) (_a$6754 (jolt-nth br 1))) (jolt-assoc _a$6750 _a$6751 _a$6752 _a$6753 _a$6754)))) (jolt-vector _o$6755 _o$6756))) (if (jolt= op (keyword #f "loop")) (let* ((binds (jolt-get node (keyword #f "bindings"))) (names (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6757 ((b b)) (jolt-nth b 0))) binds)) (ik (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6758 ((b b)) (jolt-nth (an (jolt-nth b 1) tenv) 0))) binds)) (rlists (jolt-invoke (var-deref "jolt.passes.numeric" "recur-arg-lists") (jolt-get node (keyword #f "body")))) (seed (let* ((_a$6764 (var-deref "clojure.core" "mapv")) (_a$6765 (lambda (j) (let fnrec6759 ((j j)) (let* ((k (jolt-nth ik j)) (b (jolt-nth binds j))) (if (jolt-truthy? k) k (if (jolt-truthy? (let* ((and__25__auto (jolt-seq rlists))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth b 1)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (args) (let fnrec6760 ((args args)) (let* ((_a$6761 (var-deref "jolt.passes.numeric" "counter-step?")) (_a$6762 (jolt-nth args j)) (_a$6763 (jolt-nth b 0))) (jolt-invoke _a$6761 _a$6762 _a$6763)))) rlists) and__25__auto)) and__25__auto))) (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) (_a$6766 (jolt-range (jolt-count names)))) (jolt-invoke _a$6764 _a$6765 _a$6766))) (lk (jolt-invoke (var-deref "jolt.passes.numeric" "loop-kinds") names seed (jolt-get node (keyword #f "body")) tenv)) (te (let* ((_a$6771 (lambda (t i) (let fnrec6767 ((t t) (i i)) (let* ((_a$6768 t) (_a$6769 (jolt-nth names i)) (_a$6770 (jolt-nth lk i))) (jolt-assoc _a$6768 _a$6769 _a$6770))))) (_a$6772 tenv) (_a$6773 (jolt-range (jolt-count names)))) (jolt-reduce _a$6771 _a$6772 _a$6773)))) (let* ((_o$6782 jolt-nil) (_o$6783 (let* ((_a$6777 node) (_a$6778 (keyword #f "bindings")) (_a$6779 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6774 ((b b)) (let* ((_o$6775 (jolt-nth b 0)) (_o$6776 (jolt-nth (an (jolt-nth b 1) tenv) 1))) (jolt-vector _o$6775 _o$6776)))) binds)) (_a$6780 (keyword #f "body")) (_a$6781 (jolt-nth (an (jolt-get node (keyword #f "body")) te) 1))) (jolt-assoc _a$6777 _a$6778 _a$6779 _a$6780 _a$6781)))) (jolt-vector _o$6782 _o$6783))) (if (jolt= op (keyword #f "if")) (let* ((tr (an (jolt-get node (keyword #f "test")) tenv)) (thn (an (jolt-get node (keyword #f "then")) tenv)) (els (an (jolt-get node (keyword #f "else")) tenv)) (tk (jolt-nth thn 0)) (ek (jolt-nth els 0))) (let* ((_o$6791 (if (jolt= tk ek) tk jolt-nil)) (_o$6792 (let* ((_a$6784 node) (_a$6785 (keyword #f "test")) (_a$6786 (jolt-nth tr 1)) (_a$6787 (keyword #f "then")) (_a$6788 (jolt-nth thn 1)) (_a$6789 (keyword #f "else")) (_a$6790 (jolt-nth els 1))) (jolt-assoc _a$6784 _a$6785 _a$6786 _a$6787 _a$6788 _a$6789 _a$6790)))) (jolt-vector _o$6791 _o$6792))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$6794 (var-deref "clojure.core" "mapv")) (_a$6795 (lambda (s) (let fnrec6793 ((s s)) (jolt-nth (an s tenv) 1)))) (_a$6796 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$6794 _a$6795 _a$6796))) (r (an (jolt-get node (keyword #f "ret")) tenv))) (let* ((_o$6797 (jolt-nth r 0)) (_o$6798 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$6797 _o$6798))) (if (jolt= op (keyword #f "fn")) (let* ((_o$6805 jolt-nil) (_o$6806 (jolt-assoc node (keyword #f "arities") (let* ((_a$6802 (var-deref "clojure.core" "mapv")) (_a$6803 (lambda (a) (let fnrec6799 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-nth (let* ((_a$6800 (jolt-get a (keyword #f "body"))) (_a$6801 (jolt-invoke (var-deref "jolt.passes.numeric" "arity-env") tenv a))) (an _a$6800 _a$6801)) 1))))) (_a$6804 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$6802 _a$6803 _a$6804))))) (jolt-vector _o$6805 _o$6806)) (if (jolt= op (keyword #f "def")) (let* ((_o$6807 jolt-nil) (_o$6808 (jolt-assoc node (keyword #f "init") (jolt-nth (an (jolt-get node (keyword #f "init")) tenv) 1)))) (jolt-vector _o$6807 _o$6808)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6810 jolt-nil) (_o$6811 (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6809 ((c c)) (jolt-nth (an c tenv) 1))) node))) (jolt-vector _o$6810 _o$6811)) jolt-nil))))))))))))))))) an) (let* ((_o$6812 (keyword #f "private")) (_o$6813 #t)) (jolt-hash-map _o$6812 _o$6813)))) (guard (e (#t #f)) @@ -315,15 +315,15 @@ (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.inline" "inline-budget" 120 (let* ((_o$6833 (keyword #f "private")) (_o$6834 #t)) (jolt-hash-map _o$6833 _o$6834)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "body-size" (letrec ((body-size (lambda (node) (let fnrec6835 ((node node)) (if (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") (jolt-get node (keyword #f "op")))) 100000 (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (acc c) (let fnrec6836 ((acc acc) (c c)) (+ acc (body-size c)))) 1 node)))))) body-size) (let* ((_o$6837 (keyword #f "doc")) (_o$6838 "Node count of an inline-eligible body. A disallowed op contributes a number\n larger than any budget, so the caller's (<= size budget) test fails and we\n never try to inline (or alpha-rename) such a body. Only reached for safe ops,\n so the shared child fold covers it exactly (leaves fold to 1).") (_o$6839 (keyword #f "private")) (_o$6840 #t)) (jolt-hash-map _o$6837 _o$6838 _o$6839 _o$6840)))) + (def-var-with-meta! "jolt.passes.inline" "body-size" (letrec ((body-size (lambda (node) (let fnrec6835 ((node node)) (if (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") (jolt-get node (keyword #f "op")))) 100000 (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (acc c) (let fnrec6836 ((acc acc) (c c)) (+ acc (body-size c)))) 1 node)))))) body-size) (let* ((_o$6837 (keyword #f "private")) (_o$6838 #t) (_o$6839 (keyword #f "doc")) (_o$6840 "Node count of an inline-eligible body. A disallowed op contributes a number\n larger than any budget, so the caller's (<= size budget) test fails and we\n never try to inline (or alpha-rename) such a body. Only reached for safe ops,\n so the shared child fold covers it exactly (leaves fold to 1).")) (jolt-hash-map _o$6837 _o$6838 _o$6839 _o$6840)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "subst" (letrec ((subst (lambda (node env) (let fnrec6841 ((node node) (env env)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "local")) (let* ((r (jolt-get env (jolt-get node (keyword #f "name"))))) (if (jolt-truthy? r) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get r (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-get node (keyword #f "hint")))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-get r (keyword #f "hint"))) and__25__auto)) and__25__auto))) (jolt-assoc r (keyword #f "hint") (jolt-get node (keyword #f "hint"))) r) node)) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$6853 (lambda (acc b) (let fnrec6842 ((acc acc) (b b)) (let* ((e (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (nm (jolt-nth b 0)) (init (subst (jolt-nth b 1) e)) (f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") nm))) (let* ((_o$6849 (jolt-assoc e nm (let* ((_o$6843 (keyword #f "op")) (_o$6844 (keyword #f "local")) (_o$6845 (keyword #f "name")) (_o$6846 f)) (jolt-hash-map _o$6843 _o$6844 _o$6845 _o$6846)))) (_o$6850 (jolt-conj binds (let* ((_o$6847 f) (_o$6848 init)) (jolt-vector _o$6847 _o$6848))))) (jolt-vector _o$6849 _o$6850)))))) (_a$6854 (let* ((_o$6851 env) (_o$6852 (jolt-vector))) (jolt-vector _o$6851 _o$6852))) (_a$6855 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6853 _a$6854 _a$6855)))) (let* ((_a$6858 node) (_a$6859 (keyword #f "bindings")) (_a$6860 (jolt-nth res 1)) (_a$6861 (keyword #f "body")) (_a$6862 (let* ((_a$6856 (jolt-get node (keyword #f "body"))) (_a$6857 (jolt-nth res 0))) (subst _a$6856 _a$6857)))) (jolt-assoc _a$6858 _a$6859 _a$6860 _a$6861 _a$6862))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6863 ((c c)) (subst c env))) node) jolt-nil)))))))) subst) (let* ((_o$6864 (keyword #f "doc")) (_o$6865 "Substitute locals in node per env (a map name -> replacement IR node), and\n alpha-rename every inner :let binder to a globally fresh name (so the spliced\n body shares no name with the caller). env seeds the params: a trivial arg\n (local/const) maps a param straight to the arg node (copy propagation \x2014; this\n is what lets scalar-replace see a map-literal arg through the call boundary);\n a non-trivial arg maps the param to a fresh :local that a wrapping let binds.") (_o$6866 (keyword #f "private")) (_o$6867 #t)) (jolt-hash-map _o$6864 _o$6865 _o$6866 _o$6867)))) + (def-var-with-meta! "jolt.passes.inline" "subst" (letrec ((subst (lambda (node env) (let fnrec6841 ((node node) (env env)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "local")) (let* ((r (jolt-get env (jolt-get node (keyword #f "name"))))) (if (jolt-truthy? r) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get r (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-get node (keyword #f "hint")))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-get r (keyword #f "hint"))) and__25__auto)) and__25__auto))) (jolt-assoc r (keyword #f "hint") (jolt-get node (keyword #f "hint"))) r) node)) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$6853 (lambda (acc b) (let fnrec6842 ((acc acc) (b b)) (let* ((e (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (nm (jolt-nth b 0)) (init (subst (jolt-nth b 1) e)) (f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") nm))) (let* ((_o$6849 (jolt-assoc e nm (let* ((_o$6843 (keyword #f "op")) (_o$6844 (keyword #f "local")) (_o$6845 (keyword #f "name")) (_o$6846 f)) (jolt-hash-map _o$6843 _o$6844 _o$6845 _o$6846)))) (_o$6850 (jolt-conj binds (let* ((_o$6847 f) (_o$6848 init)) (jolt-vector _o$6847 _o$6848))))) (jolt-vector _o$6849 _o$6850)))))) (_a$6854 (let* ((_o$6851 env) (_o$6852 (jolt-vector))) (jolt-vector _o$6851 _o$6852))) (_a$6855 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6853 _a$6854 _a$6855)))) (let* ((_a$6858 node) (_a$6859 (keyword #f "bindings")) (_a$6860 (jolt-nth res 1)) (_a$6861 (keyword #f "body")) (_a$6862 (let* ((_a$6856 (jolt-get node (keyword #f "body"))) (_a$6857 (jolt-nth res 0))) (subst _a$6856 _a$6857)))) (jolt-assoc _a$6858 _a$6859 _a$6860 _a$6861 _a$6862))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6863 ((c c)) (subst c env))) node) jolt-nil)))))))) subst) (let* ((_o$6864 (keyword #f "private")) (_o$6865 #t) (_o$6866 (keyword #f "doc")) (_o$6867 "Substitute locals in node per env (a map name -> replacement IR node), and\n alpha-rename every inner :let binder to a globally fresh name (so the spliced\n body shares no name with the caller). env seeds the params: a trivial arg\n (local/const) maps a param straight to the arg node (copy propagation \x2014; this\n is what lets scalar-replace see a map-literal arg through the call boundary);\n a non-trivial arg maps the param to a fresh :local that a wrapping let binds.")) (jolt-hash-map _o$6864 _o$6865 _o$6866 _o$6867)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.inline" "trivial-arg?" (letrec ((trivial-arg? (lambda (n) (let fnrec6868 ((n n)) (let* ((op (jolt-get n (keyword #f "op")))) (let* ((or__26__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "const"))))))))) trivial-arg?) (let* ((_o$6869 (keyword #f "private")) (_o$6870 #t)) (jolt-hash-map _o$6869 _o$6870)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "body-closed?" (letrec ((body-closed? (lambda (node scope) (let fnrec6871 ((node node) (scope scope)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "local")) (jolt-contains? scope (jolt-get node (keyword #f "name"))) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$6877 (lambda (acc b) (let fnrec6872 ((acc acc) (b b)) (let* ((sc (jolt-nth acc 0)) (ok (jolt-nth acc 1))) (if (jolt-not ok) acc (let* ((_o$6873 (jolt-conj sc (jolt-nth b 0))) (_o$6874 (body-closed? (jolt-nth b 1) sc))) (jolt-vector _o$6873 _o$6874))))))) (_a$6878 (let* ((_o$6875 scope) (_o$6876 #t)) (jolt-vector _o$6875 _o$6876))) (_a$6879 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6877 _a$6878 _a$6879)))) (let* ((and__25__auto (jolt-nth res 1))) (if (jolt-truthy? and__25__auto) (let* ((_a$6880 (jolt-get node (keyword #f "body"))) (_a$6881 (jolt-nth res 0))) (body-closed? _a$6880 _a$6881)) and__25__auto))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") op)) (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (ok c) (let fnrec6882 ((ok ok) (c c)) (let* ((and__25__auto ok)) (if (jolt-truthy? and__25__auto) (body-closed? c scope) and__25__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))) body-closed?) (let* ((_o$6883 (keyword #f "doc")) (_o$6884 "True if every :local in node is bound \x2014; by a param (in the initial scope set)\n or by an enclosing :let within the body. A self-recursive fn fails this: the\n analyzer binds the fn's own name as a local, so its body has a FREE local (the\n self-reference) that would dangle once the body is spliced elsewhere.") (_o$6885 (keyword #f "private")) (_o$6886 #t)) (jolt-hash-map _o$6883 _o$6884 _o$6885 _o$6886)))) + (def-var-with-meta! "jolt.passes.inline" "body-closed?" (letrec ((body-closed? (lambda (node scope) (let fnrec6871 ((node node) (scope scope)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "local")) (jolt-contains? scope (jolt-get node (keyword #f "name"))) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$6877 (lambda (acc b) (let fnrec6872 ((acc acc) (b b)) (let* ((sc (jolt-nth acc 0)) (ok (jolt-nth acc 1))) (if (jolt-not ok) acc (let* ((_o$6873 (jolt-conj sc (jolt-nth b 0))) (_o$6874 (body-closed? (jolt-nth b 1) sc))) (jolt-vector _o$6873 _o$6874))))))) (_a$6878 (let* ((_o$6875 scope) (_o$6876 #t)) (jolt-vector _o$6875 _o$6876))) (_a$6879 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6877 _a$6878 _a$6879)))) (let* ((and__25__auto (jolt-nth res 1))) (if (jolt-truthy? and__25__auto) (let* ((_a$6880 (jolt-get node (keyword #f "body"))) (_a$6881 (jolt-nth res 0))) (body-closed? _a$6880 _a$6881)) and__25__auto))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") op)) (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (ok c) (let fnrec6882 ((ok ok) (c c)) (let* ((and__25__auto ok)) (if (jolt-truthy? and__25__auto) (body-closed? c scope) and__25__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))) body-closed?) (let* ((_o$6883 (keyword #f "private")) (_o$6884 #t) (_o$6885 (keyword #f "doc")) (_o$6886 "True if every :local in node is bound \x2014; by a param (in the initial scope set)\n or by an enclosing :let within the body. A self-recursive fn fails this: the\n analyzer binds the fn's own name as a local, so its body has a FREE local (the\n self-reference) that would dangle once the body is spliced elsewhere.")) (jolt-hash-map _o$6883 _o$6884 _o$6885 _o$6886)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "try-inline" (letrec ((try-inline (lambda (node ctx) (let fnrec6887 ((node node) (ctx ctx)) (let* ((f (jolt-get node (keyword #f "fn")))) (if (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))) (let* ((stash (let* ((_a$6888 (var-deref "jolt.host" "inline-ir")) (_a$6889 ctx) (_a$6890 (jolt-get f (keyword #f "ns"))) (_a$6891 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6888 _a$6889 _a$6890 _a$6891)))) (if (jolt-truthy? stash) (let* ((params (jolt-get stash (keyword #f "params"))) (body (jolt-get stash (keyword #f "body"))) (nh (let* ((_a$6896 (lambda (m pr) (let fnrec6892 ((m m) (pr pr)) (let* ((_a$6893 m) (_a$6894 (jolt-nth pr 0)) (_a$6895 (jolt-nth pr 1))) (jolt-assoc _a$6893 _a$6894 _a$6895))))) (_a$6897 (jolt-hash-map)) (_a$6898 (jolt-get stash (keyword #f "nhints")))) (jolt-reduce _a$6896 _a$6897 _a$6898))) (ret (jolt-get stash (keyword #f "ret"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (let* ((_a$6899 (jolt-count params)) (_a$6900 (jolt-count args))) (jolt= _a$6899 _a$6900)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (<= (jolt-invoke (var-deref "jolt.passes.inline" "body-size") body) (var-deref "jolt.passes.inline" "inline-budget")))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "body-closed?") body (jolt-reduce jolt-conj (jolt-hash-set) params)) and__25__auto)) and__25__auto))) (let* ((n (jolt-count params)) (res (let* ((i 0) (env (jolt-hash-map)) (binds (jolt-vector))) (let loop6901 ((i i) (env env) (binds binds)) (if (< i n) (let* ((p (jolt-nth params i)) (a (jolt-nth args i)) (k (jolt-get nh p))) (if (jolt-truthy? k) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$6908 (jolt-inc i)) (_a$6909 (jolt-assoc env p (let* ((_o$6902 (keyword #f "op")) (_o$6903 (keyword #f "local")) (_o$6904 (keyword #f "name")) (_o$6905 f)) (jolt-hash-map _o$6902 _o$6903 _o$6904 _o$6905)))) (_a$6910 (jolt-conj binds (let* ((_o$6906 f) (_o$6907 (jolt-invoke (var-deref "jolt.ir" "coerce-node") k a))) (jolt-vector _o$6906 _o$6907))))) (loop6901 _a$6908 _a$6909 _a$6910))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "trivial-arg?") a)) (let* ((_a$6911 (jolt-inc i)) (_a$6912 (jolt-assoc env p a)) (_a$6913 binds)) (loop6901 _a$6911 _a$6912 _a$6913)) (if (jolt-truthy? (keyword #f "else")) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$6920 (jolt-inc i)) (_a$6921 (jolt-assoc env p (let* ((_o$6914 (keyword #f "op")) (_o$6915 (keyword #f "local")) (_o$6916 (keyword #f "name")) (_o$6917 f)) (jolt-hash-map _o$6914 _o$6915 _o$6916 _o$6917)))) (_a$6922 (jolt-conj binds (let* ((_o$6918 f) (_o$6919 a)) (jolt-vector _o$6918 _o$6919))))) (loop6901 _a$6920 _a$6921 _a$6922))) jolt-nil)))) (let* ((_o$6923 env) (_o$6924 binds)) (jolt-vector _o$6923 _o$6924)))))) (env (jolt-nth res 0)) (binds (jolt-nth res 1)) (rbody0 (jolt-invoke (var-deref "jolt.passes.inline" "subst") body env)) (rbody (if (jolt-truthy? ret) (jolt-invoke (var-deref "jolt.ir" "coerce-node") ret rbody0) rbody0))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (if (jolt= 0 (jolt-count binds)) rbody (let* ((_o$6925 (keyword #f "op")) (_o$6926 (keyword #f "let")) (_o$6927 (keyword #f "bindings")) (_o$6928 binds) (_o$6929 (keyword #f "body")) (_o$6930 rbody)) (jolt-hash-map _o$6925 _o$6926 _o$6927 _o$6928 _o$6929 _o$6930))))) node)) node)) node)))))) try-inline) (let* ((_o$6931 (keyword #f "doc")) (_o$6932 "node is an :invoke whose children are already inlined. If its :fn is a var\n with a stashed, in-budget, arity-matching inline body, return the spliced\n let; else node.") (_o$6933 (keyword #f "private")) (_o$6934 #t)) (jolt-hash-map _o$6931 _o$6932 _o$6933 _o$6934)))) + (def-var-with-meta! "jolt.passes.inline" "try-inline" (letrec ((try-inline (lambda (node ctx) (let fnrec6887 ((node node) (ctx ctx)) (let* ((f (jolt-get node (keyword #f "fn")))) (if (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))) (let* ((stash (let* ((_a$6888 (var-deref "jolt.host" "inline-ir")) (_a$6889 ctx) (_a$6890 (jolt-get f (keyword #f "ns"))) (_a$6891 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6888 _a$6889 _a$6890 _a$6891)))) (if (jolt-truthy? stash) (let* ((params (jolt-get stash (keyword #f "params"))) (body (jolt-get stash (keyword #f "body"))) (nh (let* ((_a$6896 (lambda (m pr) (let fnrec6892 ((m m) (pr pr)) (let* ((_a$6893 m) (_a$6894 (jolt-nth pr 0)) (_a$6895 (jolt-nth pr 1))) (jolt-assoc _a$6893 _a$6894 _a$6895))))) (_a$6897 (jolt-hash-map)) (_a$6898 (jolt-get stash (keyword #f "nhints")))) (jolt-reduce _a$6896 _a$6897 _a$6898))) (ret (jolt-get stash (keyword #f "ret"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (let* ((_a$6899 (jolt-count params)) (_a$6900 (jolt-count args))) (jolt= _a$6899 _a$6900)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (<= (jolt-invoke (var-deref "jolt.passes.inline" "body-size") body) (var-deref "jolt.passes.inline" "inline-budget")))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "body-closed?") body (jolt-reduce jolt-conj (jolt-hash-set) params)) and__25__auto)) and__25__auto))) (let* ((n (jolt-count params)) (res (let* ((i 0) (env (jolt-hash-map)) (binds (jolt-vector))) (let loop6901 ((i i) (env env) (binds binds)) (if (< i n) (let* ((p (jolt-nth params i)) (a (jolt-nth args i)) (k (jolt-get nh p))) (if (jolt-truthy? k) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$6908 (jolt-inc i)) (_a$6909 (jolt-assoc env p (let* ((_o$6902 (keyword #f "op")) (_o$6903 (keyword #f "local")) (_o$6904 (keyword #f "name")) (_o$6905 f)) (jolt-hash-map _o$6902 _o$6903 _o$6904 _o$6905)))) (_a$6910 (jolt-conj binds (let* ((_o$6906 f) (_o$6907 (jolt-invoke (var-deref "jolt.ir" "coerce-node") k a))) (jolt-vector _o$6906 _o$6907))))) (loop6901 _a$6908 _a$6909 _a$6910))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "trivial-arg?") a)) (let* ((_a$6911 (jolt-inc i)) (_a$6912 (jolt-assoc env p a)) (_a$6913 binds)) (loop6901 _a$6911 _a$6912 _a$6913)) (if (jolt-truthy? (keyword #f "else")) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$6920 (jolt-inc i)) (_a$6921 (jolt-assoc env p (let* ((_o$6914 (keyword #f "op")) (_o$6915 (keyword #f "local")) (_o$6916 (keyword #f "name")) (_o$6917 f)) (jolt-hash-map _o$6914 _o$6915 _o$6916 _o$6917)))) (_a$6922 (jolt-conj binds (let* ((_o$6918 f) (_o$6919 a)) (jolt-vector _o$6918 _o$6919))))) (loop6901 _a$6920 _a$6921 _a$6922))) jolt-nil)))) (let* ((_o$6923 env) (_o$6924 binds)) (jolt-vector _o$6923 _o$6924)))))) (env (jolt-nth res 0)) (binds (jolt-nth res 1)) (rbody0 (jolt-invoke (var-deref "jolt.passes.inline" "subst") body env)) (rbody (if (jolt-truthy? ret) (jolt-invoke (var-deref "jolt.ir" "coerce-node") ret rbody0) rbody0))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (if (jolt= 0 (jolt-count binds)) rbody (let* ((_o$6925 (keyword #f "op")) (_o$6926 (keyword #f "let")) (_o$6927 (keyword #f "bindings")) (_o$6928 binds) (_o$6929 (keyword #f "body")) (_o$6930 rbody)) (jolt-hash-map _o$6925 _o$6926 _o$6927 _o$6928 _o$6929 _o$6930))))) node)) node)) node)))))) try-inline) (let* ((_o$6931 (keyword #f "private")) (_o$6932 #t) (_o$6933 (keyword #f "doc")) (_o$6934 "node is an :invoke whose children are already inlined. If its :fn is a var\n with a stashed, in-budget, arity-matching inline body, return the spliced\n let; else node.")) (jolt-hash-map _o$6931 _o$6932 _o$6933 _o$6934)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.inline" "inline-node" (letrec ((inline-node (lambda (node ctx) (let fnrec6935 ((node node) (ctx ctx)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (jolt-invoke (var-deref "jolt.passes.inline" "try-inline") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6936 ((c c)) (inline-node c ctx))) node) ctx) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6937 ((c c)) (inline-node c ctx))) node)))))) inline-node) (let* ((_o$6938 (keyword #f "doc")) (_o$6939 "Bottom-up: inline children first, then attempt to inline this node.")) (jolt-hash-map _o$6938 _o$6939)))) (guard (e (#t #f)) @@ -337,41 +337,41 @@ (guard (e (#t #f)) (declare-var! "jolt.passes.inline" "ctor-shape")) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "pure?" (letrec ((pure? (lambda (node) (let fnrec6987 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((and__25__auto (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "pure-fn?") (jolt-get node (keyword #f "fn"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") node))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") pure? (jolt-get node (keyword #f "args"))) and__25__auto)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") op)) (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (ok c) (let fnrec6988 ((ok ok) (c c)) (let* ((and__25__auto ok)) (if (jolt-truthy? and__25__auto) (pure? c) and__25__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil)))))))) pure?) (let* ((_o$6989 (keyword #f "doc")) (_o$6990 "Conservative: true only for expressions with no side effects that are safe to\n duplicate or discard. A var/host ref is a pure read; an invoke is pure for a\n known-pure fn (arithmetic, comparison, keyword lookup, get) or a record\n constructor (an immutable struct alloc) whose args are themselves pure.") (_o$6991 (keyword #f "private")) (_o$6992 #t)) (jolt-hash-map _o$6989 _o$6990 _o$6991 _o$6992)))) + (def-var-with-meta! "jolt.passes.inline" "pure?" (letrec ((pure? (lambda (node) (let fnrec6987 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((and__25__auto (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "pure-fn?") (jolt-get node (keyword #f "fn"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") node))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") pure? (jolt-get node (keyword #f "args"))) and__25__auto)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") op)) (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (ok c) (let fnrec6988 ((ok ok) (c c)) (let* ((and__25__auto ok)) (if (jolt-truthy? and__25__auto) (pure? c) and__25__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil)))))))) pure?) (let* ((_o$6989 (keyword #f "private")) (_o$6990 #t) (_o$6991 (keyword #f "doc")) (_o$6992 "Conservative: true only for expressions with no side effects that are safe to\n duplicate or discard. A var/host ref is a pure read; an invoke is pure for a\n known-pure fn (arithmetic, comparison, keyword lookup, get) or a record\n constructor (an immutable struct alloc) whose args are themselves pure.")) (jolt-hash-map _o$6989 _o$6990 _o$6991 _o$6992)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.inline" "const-key-map?" (letrec ((const-key-map? (lambda (node) (let fnrec6993 ((node node)) (let* ((prs (jolt-get node (keyword #f "pairs")))) (let* ((and__25__auto (> (jolt-count prs) 0))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (pr) (let fnrec6994 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) prs) and__25__auto))))))) const-key-map?) (let* ((_o$6995 (keyword #f "private")) (_o$6996 #t)) (jolt-hash-map _o$6995 _o$6996)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.inline" "all-vals-pure?" (letrec ((all-vals-pure? (lambda (node) (let fnrec6997 ((node node)) (let* ((_a$6999 (var-deref "clojure.core" "every?")) (_a$7000 (lambda (pr) (let fnrec6998 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.inline" "pure?") (jolt-nth pr 1))))) (_a$7001 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$6999 _a$7000 _a$7001)))))) all-vals-pure?) (let* ((_o$7002 (keyword #f "private")) (_o$7003 #t)) (jolt-hash-map _o$7002 _o$7003)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "map-val" (letrec ((map-val (lambda (mapnode k) (let fnrec7004 ((mapnode mapnode) (k k)) (let* ((prs (jolt-get mapnode (keyword #f "pairs"))) (n (jolt-count prs))) (let* ((i 0)) (let loop7005 ((i i)) (if (< i n) (let* ((pr (jolt-nth prs i))) (if (jolt= (jolt-get (jolt-nth pr 0) (keyword #f "val")) k) (jolt-nth pr 1) (loop7005 (jolt-inc i)))) (let* ((_o$7006 (keyword #f "op")) (_o$7007 (keyword #f "const")) (_o$7008 (keyword #f "val")) (_o$7009 jolt-nil)) (jolt-hash-map _o$7006 _o$7007 _o$7008 _o$7009)))))))))) map-val) (let* ((_o$7010 (keyword #f "doc")) (_o$7011 "The value IR at scalar key k in a const-key map node, or a nil constant when k\n is absent (struct-eligible literal: a missing key reads nil, like the back end).") (_o$7012 (keyword #f "private")) (_o$7013 #t)) (jolt-hash-map _o$7010 _o$7011 _o$7012 _o$7013)))) + (def-var-with-meta! "jolt.passes.inline" "map-val" (letrec ((map-val (lambda (mapnode k) (let fnrec7004 ((mapnode mapnode) (k k)) (let* ((prs (jolt-get mapnode (keyword #f "pairs"))) (n (jolt-count prs))) (let* ((i 0)) (let loop7005 ((i i)) (if (< i n) (let* ((pr (jolt-nth prs i))) (if (jolt= (jolt-get (jolt-nth pr 0) (keyword #f "val")) k) (jolt-nth pr 1) (loop7005 (jolt-inc i)))) (let* ((_o$7006 (keyword #f "op")) (_o$7007 (keyword #f "const")) (_o$7008 (keyword #f "val")) (_o$7009 jolt-nil)) (jolt-hash-map _o$7006 _o$7007 _o$7008 _o$7009)))))))))) map-val) (let* ((_o$7010 (keyword #f "private")) (_o$7011 #t) (_o$7012 (keyword #f "doc")) (_o$7013 "The value IR at scalar key k in a const-key map node, or a nil constant when k\n is absent (struct-eligible literal: a missing key reads nil, like the back end).")) (jolt-hash-map _o$7010 _o$7011 _o$7012 _o$7013)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "lookup-key" (letrec ((lookup-key (lambda (node nm) (let fnrec7014 ((node node) (nm nm)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-get f (keyword #f "val")) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") f))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 2 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth args 1)) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-get (jolt-nth args 1) (keyword #f "val")) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) jolt-nil))))) lookup-key) (let* ((_o$7015 (keyword #f "doc")) (_o$7016 "If node is a constant-keyword lookup of (:local nm) \x2014; either (:k nm) or\n (get nm :k) \x2014; return the keyword k; else nil.") (_o$7017 (keyword #f "private")) (_o$7018 #t)) (jolt-hash-map _o$7015 _o$7016 _o$7017 _o$7018)))) + (def-var-with-meta! "jolt.passes.inline" "lookup-key" (letrec ((lookup-key (lambda (node nm) (let fnrec7014 ((node node) (nm nm)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-get f (keyword #f "val")) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") f))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 2 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth args 1)) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-get (jolt-nth args 1) (keyword #f "val")) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) jolt-nil))))) lookup-key) (let* ((_o$7015 (keyword #f "private")) (_o$7016 #t) (_o$7017 (keyword #f "doc")) (_o$7018 "If node is a constant-keyword lookup of (:local nm) \x2014; either (:k nm) or\n (get nm :k) \x2014; return the keyword k; else nil.")) (jolt-hash-map _o$7015 _o$7016 _o$7017 _o$7018)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.inline" "any-binding-named?" (letrec ((any-binding-named? (lambda (binds nm) (let fnrec7019 ((binds binds) (nm nm)) (let* ((i 0)) (let loop7020 ((i i)) (if (< i (jolt-count binds)) (if (jolt= nm (jolt-nth (jolt-nth binds i) 0)) #t (loop7020 (jolt-inc i))) #f))))))) any-binding-named?) (let* ((_o$7021 (keyword #f "private")) (_o$7022 #t)) (jolt-hash-map _o$7021 _o$7022)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.inline" "any-name?" (letrec ((any-name? (lambda (names nm) (let fnrec7023 ((names names) (nm nm)) (let* ((i 0)) (let loop7024 ((i i)) (if (< i (jolt-count names)) (if (jolt= nm (jolt-nth names i)) #t (loop7024 (jolt-inc i))) #f))))))) any-name?) (let* ((_o$7025 (keyword #f "private")) (_o$7026 #t)) (jolt-hash-map _o$7025 _o$7026)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "local-escapes?" (letrec ((local-escapes? (lambda (node nm) (let fnrec7027 ((node node) (nm nm)) (let* ((op (jolt-get node (keyword #f "op"))) (k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (let* ((args (jolt-get node (keyword #f "args")))) (if (> (jolt-count args) 1) (let* ((i 1)) (let loop7028 ((i i)) (if (< i (jolt-count args)) (if (jolt-truthy? (local-escapes? (jolt-nth args i) nm)) #t (loop7028 (jolt-inc i))) #f))) #f)) (if (jolt= op (keyword #f "local")) (jolt= nm (jolt-get node (keyword #f "name"))) (if (jolt= op (keyword #f "const")) #f (if (jolt= op (keyword #f "var")) #f (if (jolt= op (keyword #f "host")) #f (if (jolt= op (keyword #f "the-var")) #f (if (jolt= op (keyword #f "quote")) #f (if (jolt= op (keyword #f "if")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "test")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "then")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "else")) nm))))) (if (jolt= op (keyword #f "do")) (let* ((or__26__auto (let* ((i 0) (ss (jolt-get node (keyword #f "statements")))) (let loop7029 ((i i) (ss ss)) (if (< i (jolt-count ss)) (if (jolt-truthy? (local-escapes? (jolt-nth ss i) nm)) #t (loop7029 (jolt-inc i) ss)) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "ret")) nm))) (if (jolt= op (keyword #f "throw")) (local-escapes? (jolt-get node (keyword #f "expr")) nm) (if (jolt= op (keyword #f "invoke")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "fn")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop7030 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop7030 (jolt-inc i) as)) #f))))) (if (jolt= op (keyword #f "vector")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop7031 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop7031 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "set")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop7032 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop7032 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "map")) (let* ((i 0) (ps (jolt-get node (keyword #f "pairs")))) (let loop7033 ((i i) (ps ps)) (if (< i (jolt-count ps)) (if (jolt-truthy? (let* ((or__26__auto (local-escapes? (jolt-nth (jolt-nth ps i) 0) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-nth (jolt-nth ps i) 1) nm)))) #t (loop7033 (jolt-inc i) ps)) #f))) (if (jolt= op (keyword #f "let")) (let* ((binds (jolt-get node (keyword #f "bindings")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") binds nm)) #t (let* ((or__26__auto (let* ((i 0)) (let loop7034 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop7034 (jolt-inc i))) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "body")) nm))))) (if (jolt= op (keyword #f "recur")) (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop7035 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop7035 (jolt-inc i) as)) #f))) (if (jolt= op (keyword #f "loop")) (let* ((binds (jolt-get node (keyword #f "bindings")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") binds nm)) #t (let* ((or__26__auto (let* ((i 0)) (let loop7036 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop7036 (jolt-inc i))) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "body")) nm))))) (if (jolt= op (keyword #f "fn")) (let* ((i 0) (ars (jolt-get node (keyword #f "arities")))) (let loop7037 ((i i) (ars ars)) (if (< i (jolt-count ars)) (let* ((ar (jolt-nth ars i)) (ps (jolt-get ar (keyword #f "params")))) (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "any-name?") ps nm))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm (jolt-get ar (keyword #f "rest")))))) #t (if (jolt-truthy? (local-escapes? (jolt-get ar (keyword #f "body")) nm)) #t (loop7037 (jolt-inc i) ars)))) #f))) (if (jolt= op (keyword #f "try")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "body")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (let* ((cb (jolt-get node (keyword #f "catch-body")))) (let* ((and__25__auto cb)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= nm (jolt-get node (keyword #f "catch-sym")))))) (if (jolt-truthy? and__25__auto) (local-escapes? cb nm) and__25__auto)) and__25__auto))))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((f (jolt-get node (keyword #f "finally")))) (let* ((and__25__auto f)) (if (jolt-truthy? and__25__auto) (local-escapes? f nm) and__25__auto))))))) (if (jolt= op (keyword #f "def")) (local-escapes? (jolt-get node (keyword #f "init")) nm) (if (jolt-truthy? (keyword #f "else")) #t jolt-nil)))))))))))))))))))))))))) local-escapes?) (let* ((_o$7038 (keyword #f "doc")) (_o$7039 "Does local nm escape in node \x2014; i.e. is it used anywhere other than as the\n subject of a constant-keyword lookup? Precise over straight-line expression\n ops; conservatively true for loop/fn/try/recur/def (and any rebinding of nm),\n so scalar replacement only fires where the whole use region is simple.\n\n Stays an explicit per-op walk (not the shared reduce-ir-children fold): its\n default is conservatively TRUE, and the lookup-subject and rebinding cases\n inspect node shape beyond child purity \x2014; folding an unhandled op over its\n children would under-report escape and is unsound for scalar replacement.") (_o$7040 (keyword #f "private")) (_o$7041 #t)) (jolt-hash-map _o$7038 _o$7039 _o$7040 _o$7041)))) + (def-var-with-meta! "jolt.passes.inline" "local-escapes?" (letrec ((local-escapes? (lambda (node nm) (let fnrec7027 ((node node) (nm nm)) (let* ((op (jolt-get node (keyword #f "op"))) (k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (let* ((args (jolt-get node (keyword #f "args")))) (if (> (jolt-count args) 1) (let* ((i 1)) (let loop7028 ((i i)) (if (< i (jolt-count args)) (if (jolt-truthy? (local-escapes? (jolt-nth args i) nm)) #t (loop7028 (jolt-inc i))) #f))) #f)) (if (jolt= op (keyword #f "local")) (jolt= nm (jolt-get node (keyword #f "name"))) (if (jolt= op (keyword #f "const")) #f (if (jolt= op (keyword #f "var")) #f (if (jolt= op (keyword #f "host")) #f (if (jolt= op (keyword #f "the-var")) #f (if (jolt= op (keyword #f "quote")) #f (if (jolt= op (keyword #f "if")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "test")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "then")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "else")) nm))))) (if (jolt= op (keyword #f "do")) (let* ((or__26__auto (let* ((i 0) (ss (jolt-get node (keyword #f "statements")))) (let loop7029 ((i i) (ss ss)) (if (< i (jolt-count ss)) (if (jolt-truthy? (local-escapes? (jolt-nth ss i) nm)) #t (loop7029 (jolt-inc i) ss)) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "ret")) nm))) (if (jolt= op (keyword #f "throw")) (local-escapes? (jolt-get node (keyword #f "expr")) nm) (if (jolt= op (keyword #f "invoke")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "fn")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop7030 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop7030 (jolt-inc i) as)) #f))))) (if (jolt= op (keyword #f "vector")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop7031 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop7031 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "set")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop7032 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop7032 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "map")) (let* ((i 0) (ps (jolt-get node (keyword #f "pairs")))) (let loop7033 ((i i) (ps ps)) (if (< i (jolt-count ps)) (if (jolt-truthy? (let* ((or__26__auto (local-escapes? (jolt-nth (jolt-nth ps i) 0) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-nth (jolt-nth ps i) 1) nm)))) #t (loop7033 (jolt-inc i) ps)) #f))) (if (jolt= op (keyword #f "let")) (let* ((binds (jolt-get node (keyword #f "bindings")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") binds nm)) #t (let* ((or__26__auto (let* ((i 0)) (let loop7034 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop7034 (jolt-inc i))) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "body")) nm))))) (if (jolt= op (keyword #f "recur")) (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop7035 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop7035 (jolt-inc i) as)) #f))) (if (jolt= op (keyword #f "loop")) (let* ((binds (jolt-get node (keyword #f "bindings")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") binds nm)) #t (let* ((or__26__auto (let* ((i 0)) (let loop7036 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop7036 (jolt-inc i))) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "body")) nm))))) (if (jolt= op (keyword #f "fn")) (let* ((i 0) (ars (jolt-get node (keyword #f "arities")))) (let loop7037 ((i i) (ars ars)) (if (< i (jolt-count ars)) (let* ((ar (jolt-nth ars i)) (ps (jolt-get ar (keyword #f "params")))) (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "any-name?") ps nm))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm (jolt-get ar (keyword #f "rest")))))) #t (if (jolt-truthy? (local-escapes? (jolt-get ar (keyword #f "body")) nm)) #t (loop7037 (jolt-inc i) ars)))) #f))) (if (jolt= op (keyword #f "try")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "body")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (let* ((cb (jolt-get node (keyword #f "catch-body")))) (let* ((and__25__auto cb)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= nm (jolt-get node (keyword #f "catch-sym")))))) (if (jolt-truthy? and__25__auto) (local-escapes? cb nm) and__25__auto)) and__25__auto))))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((f (jolt-get node (keyword #f "finally")))) (let* ((and__25__auto f)) (if (jolt-truthy? and__25__auto) (local-escapes? f nm) and__25__auto))))))) (if (jolt= op (keyword #f "def")) (local-escapes? (jolt-get node (keyword #f "init")) nm) (if (jolt-truthy? (keyword #f "else")) #t jolt-nil)))))))))))))))))))))))))) local-escapes?) (let* ((_o$7038 (keyword #f "private")) (_o$7039 #t) (_o$7040 (keyword #f "doc")) (_o$7041 "Does local nm escape in node \x2014; i.e. is it used anywhere other than as the\n subject of a constant-keyword lookup? Precise over straight-line expression\n ops; conservatively true for loop/fn/try/recur/def (and any rebinding of nm),\n so scalar replacement only fires where the whole use region is simple.\n\n Stays an explicit per-op walk (not the shared reduce-ir-children fold): its\n default is conservatively TRUE, and the lookup-subject and rebinding cases\n inspect node shape beyond child purity \x2014; folding an unhandled op over its\n children would under-report escape and is unsound for scalar replacement.")) (jolt-hash-map _o$7038 _o$7039 _o$7040 _o$7041)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "ctor-shape" (letrec ((ctor-shape (lambda (node) (let fnrec7042 ((node node)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((f (jolt-get node (keyword #f "fn")))) (if (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))) (let* ((rs (let* ((_a$7047 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "rec-shapes"))) (_a$7048 (let* ((_a$7043 (var-deref "clojure.core" "str")) (_a$7044 (jolt-get f (keyword #f "ns"))) (_a$7045 "/") (_a$7046 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$7043 _a$7044 _a$7045 _a$7046)))) (jolt-get _a$7047 _a$7048)))) (if (jolt-truthy? (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((_a$7049 (jolt-count (jolt-get rs (keyword #f "fields")))) (_a$7050 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt= _a$7049 _a$7050)) and__25__auto))) rs jolt-nil)) jolt-nil)) jolt-nil))))) ctor-shape) (let* ((_o$7051 (keyword #f "doc")) (_o$7052 "If node is a record-constructor :invoke (its :fn a :var whose ns/name is a\n registered ctor key, with arg count matching the declared field count), return\n that record's shape entry; else nil.") (_o$7053 (keyword #f "private")) (_o$7054 #t)) (jolt-hash-map _o$7051 _o$7052 _o$7053 _o$7054)))) + (def-var-with-meta! "jolt.passes.inline" "ctor-shape" (letrec ((ctor-shape (lambda (node) (let fnrec7042 ((node node)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((f (jolt-get node (keyword #f "fn")))) (if (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))) (let* ((rs (let* ((_a$7047 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "rec-shapes"))) (_a$7048 (let* ((_a$7043 (var-deref "clojure.core" "str")) (_a$7044 (jolt-get f (keyword #f "ns"))) (_a$7045 "/") (_a$7046 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$7043 _a$7044 _a$7045 _a$7046)))) (jolt-get _a$7047 _a$7048)))) (if (jolt-truthy? (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((_a$7049 (jolt-count (jolt-get rs (keyword #f "fields")))) (_a$7050 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt= _a$7049 _a$7050)) and__25__auto))) rs jolt-nil)) jolt-nil)) jolt-nil))))) ctor-shape) (let* ((_o$7051 (keyword #f "private")) (_o$7052 #t) (_o$7053 (keyword #f "doc")) (_o$7054 "If node is a record-constructor :invoke (its :fn a :var whose ns/name is a\n registered ctor key, with arg count matching the declared field count), return\n that record's shape entry; else nil.")) (jolt-hash-map _o$7051 _o$7052 _o$7053 _o$7054)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.inline" "ctor-all-args-pure?" (letrec ((ctor-all-args-pure? (lambda (node) (let fnrec7055 ((node node)) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.inline" "pure?") (jolt-get node (keyword #f "args"))))))) ctor-all-args-pure?) (let* ((_o$7056 (keyword #f "private")) (_o$7057 #t)) (jolt-hash-map _o$7056 _o$7057)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "field-index" (letrec ((field-index (lambda (fields k) (let fnrec7058 ((fields fields) (k k)) (let* ((n (jolt-count fields))) (let* ((i 0)) (let loop7059 ((i i)) (if (< i n) (if (jolt= (jolt-nth fields i) k) i (loop7059 (jolt-inc i))) jolt-nil)))))))) field-index) (let* ((_o$7060 (keyword #f "doc")) (_o$7061 "Index of scalar key k in the declared field tuple fields, or nil.") (_o$7062 (keyword #f "private")) (_o$7063 #t)) (jolt-hash-map _o$7060 _o$7061 _o$7062 _o$7063)))) + (def-var-with-meta! "jolt.passes.inline" "field-index" (letrec ((field-index (lambda (fields k) (let fnrec7058 ((fields fields) (k k)) (let* ((n (jolt-count fields))) (let* ((i 0)) (let loop7059 ((i i)) (if (< i n) (if (jolt= (jolt-nth fields i) k) i (loop7059 (jolt-inc i))) jolt-nil)))))))) field-index) (let* ((_o$7060 (keyword #f "private")) (_o$7061 #t) (_o$7062 (keyword #f "doc")) (_o$7063 "Index of scalar key k in the declared field tuple fields, or nil.")) (jolt-hash-map _o$7060 _o$7061 _o$7062 _o$7063)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "ctor-val" (letrec ((ctor-val (lambda (ctor rs k) (let fnrec7064 ((ctor ctor) (rs rs) (k k)) (let* ((_a$7065 (jolt-get ctor (keyword #f "args"))) (_a$7066 (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k))) (jolt-nth _a$7065 _a$7066)))))) ctor-val) (let* ((_o$7067 (keyword #f "doc")) (_o$7068 "The positional arg IR at declared field k of record ctor node (shape rs). Only\n called for a key known to be a field, so the index is always present.") (_o$7069 (keyword #f "private")) (_o$7070 #t)) (jolt-hash-map _o$7067 _o$7068 _o$7069 _o$7070)))) + (def-var-with-meta! "jolt.passes.inline" "ctor-val" (letrec ((ctor-val (lambda (ctor rs k) (let fnrec7064 ((ctor ctor) (rs rs) (k k)) (let* ((_a$7065 (jolt-get ctor (keyword #f "args"))) (_a$7066 (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k))) (jolt-nth _a$7065 _a$7066)))))) ctor-val) (let* ((_o$7067 (keyword #f "private")) (_o$7068 #t) (_o$7069 (keyword #f "doc")) (_o$7070 "The positional arg IR at declared field k of record ctor node (shape rs). Only\n called for a key known to be a field, so the index is always present.")) (jolt-hash-map _o$7067 _o$7068 _o$7069 _o$7070)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "collect-keys!" (letrec ((collect-keys! (lambda (node nm acc) (let fnrec7071 ((node node) (nm nm) (acc acc)) (let* ((k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (jolt-invoke (var-deref "clojure.core" "swap!") acc jolt-conj k) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec7072 ((c c)) (begin (collect-keys! c nm acc) c))) node))))))) collect-keys!) (let* ((_o$7073 (keyword #f "doc")) (_o$7074 "Accumulate (into atom acc) every constant-keyword lookup key applied to local\n nm in node. The caller has proven (via local-escapes?) that nm appears only as\n a lookup subject and is never rebound, so a uniform recursion suffices: at a\n lookup of nm we record the key and stop (its subject is nm itself); elsewhere\n we recurse into children.") (_o$7075 (keyword #f "private")) (_o$7076 #t)) (jolt-hash-map _o$7073 _o$7074 _o$7075 _o$7076)))) + (def-var-with-meta! "jolt.passes.inline" "collect-keys!" (letrec ((collect-keys! (lambda (node nm acc) (let fnrec7071 ((node node) (nm nm) (acc acc)) (let* ((k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (jolt-invoke (var-deref "clojure.core" "swap!") acc jolt-conj k) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec7072 ((c c)) (begin (collect-keys! c nm acc) c))) node))))))) collect-keys!) (let* ((_o$7073 (keyword #f "private")) (_o$7074 #t) (_o$7075 (keyword #f "doc")) (_o$7076 "Accumulate (into atom acc) every constant-keyword lookup key applied to local\n nm in node. The caller has proven (via local-escapes?) that nm appears only as\n a lookup subject and is never rebound, so a uniform recursion suffices: at a\n lookup of nm we record the key and stop (its subject is nm itself); elsewhere\n we recurse into children.")) (jolt-hash-map _o$7073 _o$7074 _o$7075 _o$7076)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "lookups-all-fields?" (letrec ((lookups-all-fields? (lambda (nodes nm fields) (let fnrec7077 ((nodes nodes) (nm nm) (fields fields)) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (node) (let fnrec7078 ((node node)) (let* ((acc (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set)))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "collect-keys!") node nm acc) (let* ((_a$7080 (var-deref "clojure.core" "every?")) (_a$7081 (lambda (k) (let fnrec7079 ((k k)) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") fields k)))) (_a$7082 (jolt-invoke (var-deref "clojure.core" "deref") acc))) (jolt-invoke _a$7080 _a$7081 _a$7082)))))) nodes))))) lookups-all-fields?) (let* ((_o$7083 (keyword #f "doc")) (_o$7084 "True if every lookup of nm across nodes uses a declared field in fields \x2014; the\n record-only guard that keeps a :jolt/deftype/unknown-key read (not a positional\n arg) from being folded to the wrong value.") (_o$7085 (keyword #f "private")) (_o$7086 #t)) (jolt-hash-map _o$7083 _o$7084 _o$7085 _o$7086)))) + (def-var-with-meta! "jolt.passes.inline" "lookups-all-fields?" (letrec ((lookups-all-fields? (lambda (nodes nm fields) (let fnrec7077 ((nodes nodes) (nm nm) (fields fields)) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (node) (let fnrec7078 ((node node)) (let* ((acc (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set)))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "collect-keys!") node nm acc) (let* ((_a$7080 (var-deref "clojure.core" "every?")) (_a$7081 (lambda (k) (let fnrec7079 ((k k)) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") fields k)))) (_a$7082 (jolt-invoke (var-deref "clojure.core" "deref") acc))) (jolt-invoke _a$7080 _a$7081 _a$7082)))))) nodes))))) lookups-all-fields?) (let* ((_o$7083 (keyword #f "private")) (_o$7084 #t) (_o$7085 (keyword #f "doc")) (_o$7086 "True if every lookup of nm across nodes uses a declared field in fields \x2014; the\n record-only guard that keeps a :jolt/deftype/unknown-key read (not a positional\n arg) from being folded to the wrong value.")) (jolt-hash-map _o$7083 _o$7084 _o$7085 _o$7086)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "src-val" (letrec ((src-val (lambda (src k) (let fnrec7087 ((src src) (k k)) (if (jolt= (keyword #f "map") (jolt-get src (keyword #f "op"))) (jolt-invoke (var-deref "jolt.passes.inline" "map-val") src k) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-val") src (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") src) k)))))) src-val) (let* ((_o$7088 (keyword #f "doc")) (_o$7089 "Field value at k from a foldable struct source \x2014; a const-key map (absent key\n -> nil, struct-map semantics) or a record ctor (k is always a declared field\n here, guaranteed by lookups-all-fields?).") (_o$7090 (keyword #f "private")) (_o$7091 #t)) (jolt-hash-map _o$7088 _o$7089 _o$7090 _o$7091)))) + (def-var-with-meta! "jolt.passes.inline" "src-val" (letrec ((src-val (lambda (src k) (let fnrec7087 ((src src) (k k)) (if (jolt= (keyword #f "map") (jolt-get src (keyword #f "op"))) (jolt-invoke (var-deref "jolt.passes.inline" "map-val") src k) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-val") src (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") src) k)))))) src-val) (let* ((_o$7088 (keyword #f "private")) (_o$7089 #t) (_o$7090 (keyword #f "doc")) (_o$7091 "Field value at k from a foldable struct source \x2014; a const-key map (absent key\n -> nil, struct-map semantics) or a record ctor (k is always a declared field\n here, guaranteed by lookups-all-fields?).")) (jolt-hash-map _o$7088 _o$7089 _o$7090 _o$7091)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "subst-lookup" (letrec ((subst-lookup (lambda (node nm src) (let fnrec7092 ((node node) (nm nm) (src src)) (let* ((k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (jolt-invoke (var-deref "jolt.passes.inline" "src-val") src k) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec7093 ((c c)) (subst-lookup c nm src))) node))))))) subst-lookup) (let* ((_o$7094 (keyword #f "doc")) (_o$7095 "Replace every (:k nm)/(get nm :k) in node with the source value at k. The\n caller guarantees (via local-escapes?) that nm is never rebound here and\n appears only as a lookup subject, so no shadowing logic is needed.") (_o$7096 (keyword #f "private")) (_o$7097 #t)) (jolt-hash-map _o$7094 _o$7095 _o$7096 _o$7097)))) + (def-var-with-meta! "jolt.passes.inline" "subst-lookup" (letrec ((subst-lookup (lambda (node nm src) (let fnrec7092 ((node node) (nm nm) (src src)) (let* ((k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (jolt-invoke (var-deref "jolt.passes.inline" "src-val") src k) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec7093 ((c c)) (subst-lookup c nm src))) node))))))) subst-lookup) (let* ((_o$7094 (keyword #f "private")) (_o$7095 #t) (_o$7096 (keyword #f "doc")) (_o$7097 "Replace every (:k nm)/(get nm :k) in node with the source value at k. The\n caller guarantees (via local-escapes?) that nm is never rebound here and\n appears only as a lookup subject, so no shadowing logic is needed.")) (jolt-hash-map _o$7094 _o$7095 _o$7096 _o$7097)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "fold-kw-literal" (letrec ((fold-kw-literal (lambda (node) (let fnrec7098 ((node node)) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count args)) and__25__auto))) (let* ((m (jolt-nth args 0)) (k (jolt-get f (keyword #f "val")))) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "map") (jolt-get m (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") m))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") m) and__25__auto)) and__25__auto))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (jolt-invoke (var-deref "jolt.passes.inline" "map-val") m k)) (let* ((rs (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") m))) (if (jolt-truthy? (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") m))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k) and__25__auto)) and__25__auto))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-val") m rs k)) node)))) node)))))) fold-kw-literal) (let* ((_o$7099 (keyword #f "doc")) (_o$7100 "(a) (:k ) -> the value at k. is a const-key pure map\n ((:k {:k a ..}) -> a) or a pure record ctor ((:k (->Rec a ..)) -> the arg for\n field k). Siblings are duplicated/discarded, so all must be pure; a record\n lookup folds only for a declared field.") (_o$7101 (keyword #f "private")) (_o$7102 #t)) (jolt-hash-map _o$7099 _o$7100 _o$7101 _o$7102)))) + (def-var-with-meta! "jolt.passes.inline" "fold-kw-literal" (letrec ((fold-kw-literal (lambda (node) (let fnrec7098 ((node node)) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count args)) and__25__auto))) (let* ((m (jolt-nth args 0)) (k (jolt-get f (keyword #f "val")))) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "map") (jolt-get m (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") m))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") m) and__25__auto)) and__25__auto))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (jolt-invoke (var-deref "jolt.passes.inline" "map-val") m k)) (let* ((rs (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") m))) (if (jolt-truthy? (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") m))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k) and__25__auto)) and__25__auto))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-val") m rs k)) node)))) node)))))) fold-kw-literal) (let* ((_o$7099 (keyword #f "private")) (_o$7100 #t) (_o$7101 (keyword #f "doc")) (_o$7102 "(a) (:k ) -> the value at k. is a const-key pure map\n ((:k {:k a ..}) -> a) or a pure record ctor ((:k (->Rec a ..)) -> the arg for\n field k). Siblings are duplicated/discarded, so all must be pure; a record\n lookup folds only for a declared field.")) (jolt-hash-map _o$7099 _o$7100 _o$7101 _o$7102)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "elim-let-structs" (letrec ((elim-let-structs (lambda (node) (let fnrec7103 ((node node)) (let* ((binds (jolt-get node (keyword #f "bindings"))) (n (jolt-count binds)) (body (jolt-get node (keyword #f "body")))) (let* ((i 0)) (let loop7104 ((i i)) (if (< i n) (let* ((b (jolt-nth binds i)) (nm (jolt-nth b 0)) (init (jolt-nth b 1)) (ismap (let* ((and__25__auto (jolt= (keyword #f "map") (jolt-get init (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") init))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") init) and__25__auto)) and__25__auto))) (rs (if (jolt-not ismap) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") init) jolt-nil)) (isrec (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") init) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto isrec)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n) nm)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (let* ((j (jolt-inc i))) (let loop7105 ((j j)) (if (< j n) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") (jolt-nth (jolt-nth binds j) 1) nm)) #t (loop7105 (jolt-inc j))) #f)))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") body nm)))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((_a$7110 (var-deref "jolt.passes.inline" "lookups-all-fields?")) (_a$7111 (jolt-conj (let* ((_a$7107 (var-deref "clojure.core" "mapv")) (_a$7108 (lambda (bb) (let fnrec7106 ((bb bb)) (jolt-nth bb 1)))) (_a$7109 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$7107 _a$7108 _a$7109)) body)) (_a$7112 nm) (_a$7113 (jolt-get rs (keyword #f "fields")))) (jolt-invoke _a$7110 _a$7111 _a$7112 _a$7113)))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((head (jolt-invoke (var-deref "clojure.core" "subvec") binds 0 i)) (tail (let* ((_a$7117 (var-deref "clojure.core" "mapv")) (_a$7118 (lambda (bb) (let fnrec7114 ((bb bb)) (let* ((_o$7115 (jolt-nth bb 0)) (_o$7116 (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") (jolt-nth bb 1) nm init))) (jolt-vector _o$7115 _o$7116))))) (_a$7119 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$7117 _a$7118 _a$7119))) (newbinds (jolt-reduce jolt-conj head tail)) (newbody (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") body nm init))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (if (jolt= 0 (jolt-count newbinds)) newbody (jolt-assoc node (keyword #f "bindings") newbinds (keyword #f "body") newbody)))) (loop7104 (jolt-inc i)))) node)))))))) elim-let-structs) (let* ((_o$7120 (keyword #f "doc")) (_o$7121 "(b) Drop the first non-escaping let binding whose init is a foldable struct\n source \x2014; a pure const-key map literal or a pure record ctor \x2014; substituting its\n field reads into the remaining bindings and body. Fixpoint re-runs us for the\n rest, so one elimination per call keeps it simple. For a record every lookup\n of the binding must hit a declared field, else we keep the allocation.") (_o$7122 (keyword #f "private")) (_o$7123 #t)) (jolt-hash-map _o$7120 _o$7121 _o$7122 _o$7123)))) + (def-var-with-meta! "jolt.passes.inline" "elim-let-structs" (letrec ((elim-let-structs (lambda (node) (let fnrec7103 ((node node)) (let* ((binds (jolt-get node (keyword #f "bindings"))) (n (jolt-count binds)) (body (jolt-get node (keyword #f "body")))) (let* ((i 0)) (let loop7104 ((i i)) (if (< i n) (let* ((b (jolt-nth binds i)) (nm (jolt-nth b 0)) (init (jolt-nth b 1)) (ismap (let* ((and__25__auto (jolt= (keyword #f "map") (jolt-get init (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") init))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") init) and__25__auto)) and__25__auto))) (rs (if (jolt-not ismap) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") init) jolt-nil)) (isrec (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") init) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto isrec)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n) nm)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (let* ((j (jolt-inc i))) (let loop7105 ((j j)) (if (< j n) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") (jolt-nth (jolt-nth binds j) 1) nm)) #t (loop7105 (jolt-inc j))) #f)))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") body nm)))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((_a$7110 (var-deref "jolt.passes.inline" "lookups-all-fields?")) (_a$7111 (jolt-conj (let* ((_a$7107 (var-deref "clojure.core" "mapv")) (_a$7108 (lambda (bb) (let fnrec7106 ((bb bb)) (jolt-nth bb 1)))) (_a$7109 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$7107 _a$7108 _a$7109)) body)) (_a$7112 nm) (_a$7113 (jolt-get rs (keyword #f "fields")))) (jolt-invoke _a$7110 _a$7111 _a$7112 _a$7113)))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((head (jolt-invoke (var-deref "clojure.core" "subvec") binds 0 i)) (tail (let* ((_a$7117 (var-deref "clojure.core" "mapv")) (_a$7118 (lambda (bb) (let fnrec7114 ((bb bb)) (let* ((_o$7115 (jolt-nth bb 0)) (_o$7116 (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") (jolt-nth bb 1) nm init))) (jolt-vector _o$7115 _o$7116))))) (_a$7119 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$7117 _a$7118 _a$7119))) (newbinds (jolt-reduce jolt-conj head tail)) (newbody (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") body nm init))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (if (jolt= 0 (jolt-count newbinds)) newbody (jolt-assoc node (keyword #f "bindings") newbinds (keyword #f "body") newbody)))) (loop7104 (jolt-inc i)))) node)))))))) elim-let-structs) (let* ((_o$7120 (keyword #f "private")) (_o$7121 #t) (_o$7122 (keyword #f "doc")) (_o$7123 "(b) Drop the first non-escaping let binding whose init is a foldable struct\n source \x2014; a pure const-key map literal or a pure record ctor \x2014; substituting its\n field reads into the remaining bindings and body. Fixpoint re-runs us for the\n rest, so one elimination per call keeps it simple. For a record every lookup\n of the binding must hit a declared field, else we keep the allocation.")) (jolt-hash-map _o$7120 _o$7121 _o$7122 _o$7123)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.inline" "scalar-replace" (letrec ((scalar-replace (lambda (node) (let fnrec7124 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.inline" "fold-kw-literal") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node)) (if (jolt= op (keyword #f "let")) (jolt-invoke (var-deref "jolt.passes.inline" "elim-let-structs") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node) jolt-nil)))))))) scalar-replace) (let* ((_o$7125 (keyword #f "doc")) (_o$7126 "Bottom-up: scalar-replace children, then apply (a) at invokes / (b) at lets.")) (jolt-hash-map _o$7125 _o$7126)))) (guard (e (#t #f)) @@ -509,33 +509,33 @@ (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.types" "hof-table" (let* ((_o$5706 "map") (_o$5707 (let* ((_o$5690 (keyword #f "epos")) (_o$5691 0)) (jolt-hash-map _o$5690 _o$5691))) (_o$5708 "mapv") (_o$5709 (let* ((_o$5692 (keyword #f "epos")) (_o$5693 0)) (jolt-hash-map _o$5692 _o$5693))) (_o$5710 "filter") (_o$5711 (let* ((_o$5694 (keyword #f "epos")) (_o$5695 0)) (jolt-hash-map _o$5694 _o$5695))) (_o$5712 "filterv") (_o$5713 (let* ((_o$5696 (keyword #f "epos")) (_o$5697 0)) (jolt-hash-map _o$5696 _o$5697))) (_o$5714 "keep") (_o$5715 (let* ((_o$5698 (keyword #f "epos")) (_o$5699 0)) (jolt-hash-map _o$5698 _o$5699))) (_o$5716 "remove") (_o$5717 (let* ((_o$5700 (keyword #f "epos")) (_o$5701 0)) (jolt-hash-map _o$5700 _o$5701))) (_o$5718 "run!") (_o$5719 (let* ((_o$5702 (keyword #f "epos")) (_o$5703 0)) (jolt-hash-map _o$5702 _o$5703))) (_o$5720 "mapcat") (_o$5721 (let* ((_o$5704 (keyword #f "epos")) (_o$5705 0)) (jolt-hash-map _o$5704 _o$5705)))) (jolt-hash-map _o$5706 _o$5707 _o$5708 _o$5709 _o$5710 _o$5711 _o$5712 _o$5713 _o$5714 _o$5715 _o$5716 _o$5717 _o$5718 _o$5719 _o$5720 _o$5721)) (let* ((_o$5722 (keyword #f "private")) (_o$5723 #t)) (jolt-hash-map _o$5722 _o$5723)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "infer-fn-seeded" (letrec ((infer-fn-seeded (lambda (node seeds tenv env) (let fnrec5724 ((node node) (seeds seeds) (tenv tenv) (env env)) (let* ((res (let* ((_a$5735 (var-deref "clojure.core" "mapv")) (_a$5736 (lambda (a) (let fnrec5725 ((a a)) (let* ((params (jolt-get a (keyword #f "params"))) (pe (let* ((_a$5730 (lambda (e i) (let fnrec5726 ((e e) (i i)) (let* ((_a$5727 e) (_a$5728 (jolt-nth params i)) (_a$5729 (let* ((s (jolt-get seeds i))) (if (jolt-truthy? s) s (keyword #f "any"))))) (jolt-assoc _a$5727 _a$5728 _a$5729))))) (_a$5731 tenv) (_a$5732 (jolt-range (jolt-count params)))) (jolt-reduce _a$5730 _a$5731 _a$5732))) (pe (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) (keyword #f "any")) pe)) (br (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-get a (keyword #f "body")) pe env))) (let* ((_o$5733 (jolt-invoke (var-deref "jolt.passes.types" "ty") br)) (_o$5734 (jolt-assoc a (keyword #f "body") (jolt-invoke (var-deref "jolt.passes.types" "nd") br)))) (jolt-vector _o$5733 _o$5734)))))) (_a$5737 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$5735 _a$5736 _a$5737))) (rets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5738 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) res)) (ret (if (jolt-empty? rets) (keyword #f "any") (let* ((_a$5739 (var-deref "jolt.passes.types.lattice" "join")) (_a$5740 (jolt-first rets)) (_a$5741 (jolt-rest rets))) (jolt-reduce _a$5739 _a$5740 _a$5741))))) (let* ((_o$5743 ret) (_o$5744 (jolt-assoc node (keyword #f "arities") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5742 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) res)))) (jolt-vector _o$5743 _o$5744))))))) infer-fn-seeded) (let* ((_o$5745 (keyword #f "doc")) (_o$5746 "Infer a fn-literal passed to a HOF, seeding the given params to element/accum\n types (seeds: param-index -> type), other params :any, captured locals from\n tenv. Returns [ret-type node'] \x2014; ret is the lub of arity tail types, used to\n type the HOF result (e.g. reduce's accumulator, mapv's element).") (_o$5747 (keyword #f "private")) (_o$5748 #t)) (jolt-hash-map _o$5745 _o$5746 _o$5747 _o$5748)))) + (def-var-with-meta! "jolt.passes.types" "infer-fn-seeded" (letrec ((infer-fn-seeded (lambda (node seeds tenv env) (let fnrec5724 ((node node) (seeds seeds) (tenv tenv) (env env)) (let* ((res (let* ((_a$5735 (var-deref "clojure.core" "mapv")) (_a$5736 (lambda (a) (let fnrec5725 ((a a)) (let* ((params (jolt-get a (keyword #f "params"))) (pe (let* ((_a$5730 (lambda (e i) (let fnrec5726 ((e e) (i i)) (let* ((_a$5727 e) (_a$5728 (jolt-nth params i)) (_a$5729 (let* ((s (jolt-get seeds i))) (if (jolt-truthy? s) s (keyword #f "any"))))) (jolt-assoc _a$5727 _a$5728 _a$5729))))) (_a$5731 tenv) (_a$5732 (jolt-range (jolt-count params)))) (jolt-reduce _a$5730 _a$5731 _a$5732))) (pe (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) (keyword #f "any")) pe)) (br (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-get a (keyword #f "body")) pe env))) (let* ((_o$5733 (jolt-invoke (var-deref "jolt.passes.types" "ty") br)) (_o$5734 (jolt-assoc a (keyword #f "body") (jolt-invoke (var-deref "jolt.passes.types" "nd") br)))) (jolt-vector _o$5733 _o$5734)))))) (_a$5737 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$5735 _a$5736 _a$5737))) (rets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5738 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) res)) (ret (if (jolt-empty? rets) (keyword #f "any") (let* ((_a$5739 (var-deref "jolt.passes.types.lattice" "join")) (_a$5740 (jolt-first rets)) (_a$5741 (jolt-rest rets))) (jolt-reduce _a$5739 _a$5740 _a$5741))))) (let* ((_o$5743 ret) (_o$5744 (jolt-assoc node (keyword #f "arities") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5742 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) res)))) (jolt-vector _o$5743 _o$5744))))))) infer-fn-seeded) (let* ((_o$5745 (keyword #f "private")) (_o$5746 #t) (_o$5747 (keyword #f "doc")) (_o$5748 "Infer a fn-literal passed to a HOF, seeding the given params to element/accum\n types (seeds: param-index -> type), other params :any, captured locals from\n tenv. Returns [ret-type node'] \x2014; ret is the lub of arity tail types, used to\n type the HOF result (e.g. reduce's accumulator, mapv's element).")) (jolt-hash-map _o$5745 _o$5746 _o$5747 _o$5748)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "infer-pred-fold" (letrec ((infer-pred-fold (lambda (node fnode cn args tenv env) (let fnrec5749 ((node node) (fnode fnode) (cn cn) (args args) (tenv tenv) (env env)) (let* ((ar (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (v (jolt-invoke (var-deref "jolt.passes.types" "pred-on") cn (jolt-invoke (var-deref "jolt.passes.types" "ty") ar)))) (if (jolt-truthy? (let* ((and__25__auto (jolt-not (jolt-nil? v)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types" "pure-node?") (jolt-invoke (var-deref "jolt.passes.types" "nd") ar)) and__25__auto))) (let* ((_o$5754 (keyword #f "any")) (_o$5755 (let* ((_o$5750 (keyword #f "op")) (_o$5751 (keyword #f "const")) (_o$5752 (keyword #f "val")) (_o$5753 v)) (jolt-hash-map _o$5750 _o$5751 _o$5752 _o$5753)))) (jolt-vector _o$5754 _o$5755)) (let* ((_o$5756 (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env)) (_o$5757 (jolt-assoc node (keyword #f "args") (jolt-vector (jolt-invoke (var-deref "jolt.passes.types" "nd") ar))))) (jolt-vector _o$5756 _o$5757)))))))) infer-pred-fold) (let* ((_o$5758 (keyword #f "doc")) (_o$5759 "A type predicate over a single side-effect-free arg whose type PROVES the answer\n folds to a boolean constant \x2014; eliminating the call, and (once const-fold runs\n after inference) collapsing any `if` it gates. Falls back to the normal call path\n when the answer isn't provable or the arg is impure.") (_o$5760 (keyword #f "private")) (_o$5761 #t)) (jolt-hash-map _o$5758 _o$5759 _o$5760 _o$5761)))) + (def-var-with-meta! "jolt.passes.types" "infer-pred-fold" (letrec ((infer-pred-fold (lambda (node fnode cn args tenv env) (let fnrec5749 ((node node) (fnode fnode) (cn cn) (args args) (tenv tenv) (env env)) (let* ((ar (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (v (jolt-invoke (var-deref "jolt.passes.types" "pred-on") cn (jolt-invoke (var-deref "jolt.passes.types" "ty") ar)))) (if (jolt-truthy? (let* ((and__25__auto (jolt-not (jolt-nil? v)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types" "pure-node?") (jolt-invoke (var-deref "jolt.passes.types" "nd") ar)) and__25__auto))) (let* ((_o$5754 (keyword #f "any")) (_o$5755 (let* ((_o$5750 (keyword #f "op")) (_o$5751 (keyword #f "const")) (_o$5752 (keyword #f "val")) (_o$5753 v)) (jolt-hash-map _o$5750 _o$5751 _o$5752 _o$5753)))) (jolt-vector _o$5754 _o$5755)) (let* ((_o$5756 (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env)) (_o$5757 (jolt-assoc node (keyword #f "args") (jolt-vector (jolt-invoke (var-deref "jolt.passes.types" "nd") ar))))) (jolt-vector _o$5756 _o$5757)))))))) infer-pred-fold) (let* ((_o$5758 (keyword #f "private")) (_o$5759 #t) (_o$5760 (keyword #f "doc")) (_o$5761 "A type predicate over a single side-effect-free arg whose type PROVES the answer\n folds to a boolean constant \x2014; eliminating the call, and (once const-fold runs\n after inference) collapsing any `if` it gates. Falls back to the normal call path\n when the answer isn't provable or the arg is impure.")) (jolt-hash-map _o$5758 _o$5759 _o$5760 _o$5761)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "infer-kw-lookup" (letrec ((infer-kw-lookup (lambda (node fnode args n tenv env) (let fnrec5762 ((node node) (fnode fnode) (args args) (n n) (tenv tenv) (env env)) (let* ((mr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (mt (jolt-invoke (var-deref "jolt.passes.types" "ty") mr)) (msub (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") mt)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mark-struct") (jolt-invoke (var-deref "jolt.passes.types" "nd") mr) mt) (jolt-invoke (var-deref "jolt.passes.types" "nd") mr))) (ft (jolt-invoke (var-deref "jolt.passes.types.lattice" "field-type") mt (jolt-get fnode (keyword #f "val")))) (dr (if (jolt= n 2) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env) jolt-nil)) (rt (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (node_PRIME_ (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$5763 msub) (_o$5764 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$5763 _o$5764)) (jolt-vector msub))))) (let* ((_o$5765 rt) (_o$5766 (if (jolt= rt (keyword #f "double")) (jolt-assoc node_PRIME_ (keyword #f "num-read") (keyword #f "double")) node_PRIME_))) (jolt-vector _o$5765 _o$5766))))))) infer-kw-lookup) (let* ((_o$5767 (keyword #f "doc")) (_o$5768 "(:k m) / (:k m default): the result is m's field type, and if m is a struct the\n subject is tagged so the back end drops the guard \x2014; this types nested access end\n to end (RFC 0005).") (_o$5769 (keyword #f "private")) (_o$5770 #t)) (jolt-hash-map _o$5767 _o$5768 _o$5769 _o$5770)))) + (def-var-with-meta! "jolt.passes.types" "infer-kw-lookup" (letrec ((infer-kw-lookup (lambda (node fnode args n tenv env) (let fnrec5762 ((node node) (fnode fnode) (args args) (n n) (tenv tenv) (env env)) (let* ((mr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (mt (jolt-invoke (var-deref "jolt.passes.types" "ty") mr)) (msub (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") mt)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mark-struct") (jolt-invoke (var-deref "jolt.passes.types" "nd") mr) mt) (jolt-invoke (var-deref "jolt.passes.types" "nd") mr))) (ft (jolt-invoke (var-deref "jolt.passes.types.lattice" "field-type") mt (jolt-get fnode (keyword #f "val")))) (dr (if (jolt= n 2) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env) jolt-nil)) (rt (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (node_PRIME_ (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$5763 msub) (_o$5764 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$5763 _o$5764)) (jolt-vector msub))))) (let* ((_o$5765 rt) (_o$5766 (if (jolt= rt (keyword #f "double")) (jolt-assoc node_PRIME_ (keyword #f "num-read") (keyword #f "double")) node_PRIME_))) (jolt-vector _o$5765 _o$5766))))))) infer-kw-lookup) (let* ((_o$5767 (keyword #f "private")) (_o$5768 #t) (_o$5769 (keyword #f "doc")) (_o$5770 "(:k m) / (:k m default): the result is m's field type, and if m is a struct the\n subject is tagged so the back end drops the guard \x2014; this types nested access end\n to end (RFC 0005).")) (jolt-hash-map _o$5767 _o$5768 _o$5769 _o$5770)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "infer-get-lookup" (letrec ((infer-get-lookup (lambda (node args n tenv env) (let fnrec5771 ((node node) (args args) (n n) (tenv tenv) (env env)) (let* ((mr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (mt (jolt-invoke (var-deref "jolt.passes.types" "ty") mr)) (msub (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") mt)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mark-struct") (jolt-invoke (var-deref "jolt.passes.types" "nd") mr) mt) (jolt-invoke (var-deref "jolt.passes.types" "nd") mr))) (kr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env)) (ft (jolt-invoke (var-deref "jolt.passes.types.lattice" "field-type") mt (jolt-get (jolt-nth args 1) (keyword #f "val")))) (dr (if (jolt= n 3) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 2) tenv env) jolt-nil)) (rt (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (node_PRIME_ (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$5772 msub) (_o$5773 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr)) (_o$5774 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$5772 _o$5773 _o$5774)) (let* ((_o$5775 msub) (_o$5776 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr))) (jolt-vector _o$5775 _o$5776)))))) (let* ((_o$5777 rt) (_o$5778 (if (jolt= rt (keyword #f "double")) (jolt-assoc node_PRIME_ (keyword #f "num-read") (keyword #f "double")) node_PRIME_))) (jolt-vector _o$5777 _o$5778))))))) infer-get-lookup) (let* ((_o$5779 (keyword #f "doc")) (_o$5780 "(get m :k [default]): the keyword-lookup result type, when the key is a constant\n keyword.") (_o$5781 (keyword #f "private")) (_o$5782 #t)) (jolt-hash-map _o$5779 _o$5780 _o$5781 _o$5782)))) + (def-var-with-meta! "jolt.passes.types" "infer-get-lookup" (letrec ((infer-get-lookup (lambda (node args n tenv env) (let fnrec5771 ((node node) (args args) (n n) (tenv tenv) (env env)) (let* ((mr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (mt (jolt-invoke (var-deref "jolt.passes.types" "ty") mr)) (msub (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") mt)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mark-struct") (jolt-invoke (var-deref "jolt.passes.types" "nd") mr) mt) (jolt-invoke (var-deref "jolt.passes.types" "nd") mr))) (kr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env)) (ft (jolt-invoke (var-deref "jolt.passes.types.lattice" "field-type") mt (jolt-get (jolt-nth args 1) (keyword #f "val")))) (dr (if (jolt= n 3) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 2) tenv env) jolt-nil)) (rt (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (node_PRIME_ (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$5772 msub) (_o$5773 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr)) (_o$5774 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$5772 _o$5773 _o$5774)) (let* ((_o$5775 msub) (_o$5776 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr))) (jolt-vector _o$5775 _o$5776)))))) (let* ((_o$5777 rt) (_o$5778 (if (jolt= rt (keyword #f "double")) (jolt-assoc node_PRIME_ (keyword #f "num-read") (keyword #f "double")) node_PRIME_))) (jolt-vector _o$5777 _o$5778))))))) infer-get-lookup) (let* ((_o$5779 (keyword #f "private")) (_o$5780 #t) (_o$5781 (keyword #f "doc")) (_o$5782 "(get m :k [default]): the keyword-lookup result type, when the key is a constant\n keyword.")) (jolt-hash-map _o$5779 _o$5780 _o$5781 _o$5782)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "infer-reduce-hof" (letrec ((infer-reduce-hof (lambda (node args n tenv env) (let fnrec5783 ((node node) (args args) (n n) (tenv tenv) (env env)) (let* ((three (>= n 3)) (coll-r (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args (if (jolt-truthy? three) 2 1)) tenv env)) (init-r (if (jolt-truthy? three) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env) jolt-nil)) (et (let* ((ct (jolt-invoke (var-deref "jolt.passes.types" "ty") coll-r))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") ct)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") ct) (keyword #f "any")))) (init-t (if (jolt-truthy? init-r) (jolt-invoke (var-deref "jolt.passes.types" "ty") init-r) (keyword #f "any"))) (fn-r (let* ((_a$5788 (var-deref "jolt.passes.types" "infer-fn-seeded")) (_a$5789 (jolt-nth args 0)) (_a$5790 (let* ((_o$5784 0) (_o$5785 init-t) (_o$5786 1) (_o$5787 et)) (jolt-hash-map _o$5784 _o$5785 _o$5786 _o$5787))) (_a$5791 tenv) (_a$5792 env)) (jolt-invoke _a$5788 _a$5789 _a$5790 _a$5791 _a$5792)))) (let* ((_o$5798 (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") init-t (jolt-invoke (var-deref "jolt.passes.types" "ty") fn-r))) (_o$5799 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? three) (let* ((_o$5793 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$5794 (jolt-invoke (var-deref "jolt.passes.types" "nd") init-r)) (_o$5795 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$5793 _o$5794 _o$5795)) (let* ((_o$5796 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$5797 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$5796 _o$5797)))))) (jolt-vector _o$5798 _o$5799))))))) infer-reduce-hof) (let* ((_o$5800 (keyword #f "doc")) (_o$5801 "reduce over a typed vector with a fn-literal: seed the closure's accumulator\n (param 0) to the init type and its element (param 1) to the vector's element\n type, so its body \x2014; and any calls it makes \x2014; see those types.") (_o$5802 (keyword #f "private")) (_o$5803 #t)) (jolt-hash-map _o$5800 _o$5801 _o$5802 _o$5803)))) + (def-var-with-meta! "jolt.passes.types" "infer-reduce-hof" (letrec ((infer-reduce-hof (lambda (node args n tenv env) (let fnrec5783 ((node node) (args args) (n n) (tenv tenv) (env env)) (let* ((three (>= n 3)) (coll-r (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args (if (jolt-truthy? three) 2 1)) tenv env)) (init-r (if (jolt-truthy? three) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env) jolt-nil)) (et (let* ((ct (jolt-invoke (var-deref "jolt.passes.types" "ty") coll-r))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") ct)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") ct) (keyword #f "any")))) (init-t (if (jolt-truthy? init-r) (jolt-invoke (var-deref "jolt.passes.types" "ty") init-r) (keyword #f "any"))) (fn-r (let* ((_a$5788 (var-deref "jolt.passes.types" "infer-fn-seeded")) (_a$5789 (jolt-nth args 0)) (_a$5790 (let* ((_o$5784 0) (_o$5785 init-t) (_o$5786 1) (_o$5787 et)) (jolt-hash-map _o$5784 _o$5785 _o$5786 _o$5787))) (_a$5791 tenv) (_a$5792 env)) (jolt-invoke _a$5788 _a$5789 _a$5790 _a$5791 _a$5792)))) (let* ((_o$5798 (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") init-t (jolt-invoke (var-deref "jolt.passes.types" "ty") fn-r))) (_o$5799 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? three) (let* ((_o$5793 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$5794 (jolt-invoke (var-deref "jolt.passes.types" "nd") init-r)) (_o$5795 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$5793 _o$5794 _o$5795)) (let* ((_o$5796 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$5797 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$5796 _o$5797)))))) (jolt-vector _o$5798 _o$5799))))))) infer-reduce-hof) (let* ((_o$5800 (keyword #f "private")) (_o$5801 #t) (_o$5802 (keyword #f "doc")) (_o$5803 "reduce over a typed vector with a fn-literal: seed the closure's accumulator\n (param 0) to the init type and its element (param 1) to the vector's element\n type, so its body \x2014; and any calls it makes \x2014; see those types.")) (jolt-hash-map _o$5800 _o$5801 _o$5802 _o$5803)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "infer-seq-hof" (letrec ((infer-seq-hof (lambda (node cn args tenv env) (let fnrec5804 ((node node) (cn cn) (args args) (tenv tenv) (env env)) (let* ((coll-r (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env)) (et (let* ((ct (jolt-invoke (var-deref "jolt.passes.types" "ty") coll-r))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") ct)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") ct) (keyword #f "any")))) (fn-r (let* ((_a$5807 (var-deref "jolt.passes.types" "infer-fn-seeded")) (_a$5808 (jolt-nth args 0)) (_a$5809 (let* ((_o$5805 (jolt-get (jolt-get (var-deref "jolt.passes.types" "hof-table") cn) (keyword #f "epos"))) (_o$5806 et)) (jolt-hash-map _o$5805 _o$5806))) (_a$5810 tenv) (_a$5811 env)) (jolt-invoke _a$5807 _a$5808 _a$5809 _a$5810 _a$5811))) (rt (if (jolt= cn "mapv") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (jolt-invoke (var-deref "jolt.passes.types" "ty") fn-r)) (if (jolt= cn "filterv") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") et) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil))))) (let* ((_o$5814 rt) (_o$5815 (jolt-assoc node (keyword #f "args") (let* ((_o$5812 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$5813 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$5812 _o$5813))))) (jolt-vector _o$5814 _o$5815))))))) infer-seq-hof) (let* ((_o$5816 (keyword #f "doc")) (_o$5817 "map/mapv/filter/... over a typed vector with a fn-literal: seed the fn's element\n param; mapv/filterv produce a typed vector.") (_o$5818 (keyword #f "private")) (_o$5819 #t)) (jolt-hash-map _o$5816 _o$5817 _o$5818 _o$5819)))) + (def-var-with-meta! "jolt.passes.types" "infer-seq-hof" (letrec ((infer-seq-hof (lambda (node cn args tenv env) (let fnrec5804 ((node node) (cn cn) (args args) (tenv tenv) (env env)) (let* ((coll-r (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env)) (et (let* ((ct (jolt-invoke (var-deref "jolt.passes.types" "ty") coll-r))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") ct)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") ct) (keyword #f "any")))) (fn-r (let* ((_a$5807 (var-deref "jolt.passes.types" "infer-fn-seeded")) (_a$5808 (jolt-nth args 0)) (_a$5809 (let* ((_o$5805 (jolt-get (jolt-get (var-deref "jolt.passes.types" "hof-table") cn) (keyword #f "epos"))) (_o$5806 et)) (jolt-hash-map _o$5805 _o$5806))) (_a$5810 tenv) (_a$5811 env)) (jolt-invoke _a$5807 _a$5808 _a$5809 _a$5810 _a$5811))) (rt (if (jolt= cn "mapv") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (jolt-invoke (var-deref "jolt.passes.types" "ty") fn-r)) (if (jolt= cn "filterv") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") et) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil))))) (let* ((_o$5814 rt) (_o$5815 (jolt-assoc node (keyword #f "args") (let* ((_o$5812 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$5813 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$5812 _o$5813))))) (jolt-vector _o$5814 _o$5815))))))) infer-seq-hof) (let* ((_o$5816 (keyword #f "private")) (_o$5817 #t) (_o$5818 (keyword #f "doc")) (_o$5819 "map/mapv/filter/... over a typed vector with a fn-literal: seed the fn's element\n param; mapv/filterv produce a typed vector.")) (jolt-hash-map _o$5816 _o$5817 _o$5818 _o$5819)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "infer-conj-into" (letrec ((infer-conj-into (lambda (node fnode cn args n tenv env) (let fnrec5820 ((node node) (fnode fnode) (cn cn) (args args) (n n) (tenv tenv) (env env)) (let* ((ares (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec5821 ((a a)) (jolt-invoke (var-deref "jolt.passes.types" "infer") a tenv env))) args)) (base (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0))) (rest-ts (let* ((_a$5823 (var-deref "clojure.core" "mapv")) (_a$5824 (lambda (r) (let fnrec5822 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r)))) (_a$5825 (jolt-rest ares))) (jolt-invoke _a$5823 _a$5824 _a$5825))) (rt (if (jolt-truthy? (let* ((and__25__auto (jolt= cn "conj"))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") base) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (jolt-reduce (var-deref "jolt.passes.types.lattice" "join") (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") base) rest-ts)) (if (jolt-truthy? (let* ((and__25__auto (jolt= cn "into"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") base))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 2 n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") (jolt-nth rest-ts 0)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (let* ((_a$5826 (var-deref "jolt.passes.types.lattice" "join")) (_a$5827 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") base)) (_a$5828 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") (jolt-nth rest-ts 0)))) (jolt-invoke _a$5826 _a$5827 _a$5828))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env) jolt-nil))))) (let* ((_o$5830 rt) (_o$5831 (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5829 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (jolt-vector _o$5830 _o$5831))))))) infer-conj-into) (let* ((_o$5832 (keyword #f "doc")) (_o$5833 "conj/into: track the element type of a vector being grown.") (_o$5834 (keyword #f "private")) (_o$5835 #t)) (jolt-hash-map _o$5832 _o$5833 _o$5834 _o$5835)))) + (def-var-with-meta! "jolt.passes.types" "infer-conj-into" (letrec ((infer-conj-into (lambda (node fnode cn args n tenv env) (let fnrec5820 ((node node) (fnode fnode) (cn cn) (args args) (n n) (tenv tenv) (env env)) (let* ((ares (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec5821 ((a a)) (jolt-invoke (var-deref "jolt.passes.types" "infer") a tenv env))) args)) (base (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0))) (rest-ts (let* ((_a$5823 (var-deref "clojure.core" "mapv")) (_a$5824 (lambda (r) (let fnrec5822 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r)))) (_a$5825 (jolt-rest ares))) (jolt-invoke _a$5823 _a$5824 _a$5825))) (rt (if (jolt-truthy? (let* ((and__25__auto (jolt= cn "conj"))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") base) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (jolt-reduce (var-deref "jolt.passes.types.lattice" "join") (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") base) rest-ts)) (if (jolt-truthy? (let* ((and__25__auto (jolt= cn "into"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") base))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 2 n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") (jolt-nth rest-ts 0)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (let* ((_a$5826 (var-deref "jolt.passes.types.lattice" "join")) (_a$5827 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") base)) (_a$5828 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") (jolt-nth rest-ts 0)))) (jolt-invoke _a$5826 _a$5827 _a$5828))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env) jolt-nil))))) (let* ((_o$5830 rt) (_o$5831 (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5829 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (jolt-vector _o$5830 _o$5831))))))) infer-conj-into) (let* ((_o$5832 (keyword #f "private")) (_o$5833 #t) (_o$5834 (keyword #f "doc")) (_o$5835 "conj/into: track the element type of a vector being grown.")) (jolt-hash-map _o$5832 _o$5833 _o$5834 _o$5835)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "infer-call" (letrec ((infer-call (lambda (node fnode iscall-var cn args n tenv env) (let fnrec5836 ((node node) (fnode fnode) (iscall-var iscall-var) (cn cn) (args args) (n n) (tenv tenv) (env env)) (let* ((fr (if (jolt-not iscall-var) (jolt-invoke (var-deref "jolt.passes.types" "infer") fnode tenv env) jolt-nil)) (fnode_PRIME_ (if (jolt-truthy? iscall-var) fnode (jolt-invoke (var-deref "jolt.passes.types" "nd") fr))) (callee-t (if (jolt-truthy? iscall-var) (let* ((_a$5837 (jolt-get env (keyword #f "vtypes"))) (_a$5838 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$5837 _a$5838)) (jolt-invoke (var-deref "jolt.passes.types" "ty") fr))) (ares (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec5839 ((a a)) (jolt-invoke (var-deref "jolt.passes.types" "infer") a tenv env))) args))) (begin (if (jolt-truthy? iscall-var) (let* ((_a$5845 (var-deref "clojure.core" "swap!")) (_a$5846 (jolt-get env (keyword #f "calls"))) (_a$5847 jolt-conj) (_a$5848 (let* ((_o$5843 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (_o$5844 (if (let* ((_a$5840 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (_a$5841 (jolt-get env (keyword #f "self-key")))) (jolt= _a$5840 _a$5841)) (jolt-invoke (var-deref "jolt.passes.types" "self-rec-argtys") args ares (jolt-get env (keyword #f "self-params"))) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5842 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) ares)))) (jolt-vector _o$5843 _o$5844)))) (jolt-invoke _a$5845 _a$5846 _a$5847 _a$5848)) jolt-nil) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-get env (keyword #f "self-key")))) (if (jolt-truthy? and__25__auto) (let* ((_a$5849 (jolt-get fnode (keyword #f "name"))) (_a$5850 (jolt-get env (keyword #f "self-name")))) (jolt= _a$5849 _a$5850)) and__25__auto)) and__25__auto))) (let* ((_a$5853 (var-deref "clojure.core" "swap!")) (_a$5854 (jolt-get env (keyword #f "calls"))) (_a$5855 jolt-conj) (_a$5856 (let* ((_o$5851 (jolt-get env (keyword #f "self-key"))) (_o$5852 (jolt-invoke (var-deref "jolt.passes.types" "self-rec-argtys") args ares (jolt-get env (keyword #f "self-params"))))) (jolt-vector _o$5851 _o$5852)))) (jolt-invoke _a$5853 _a$5854 _a$5855 _a$5856)) jolt-nil) (if (jolt-truthy? (jolt-get env (keyword #f "checking?"))) (let* ((ats (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5857 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) ares)) (pos (jolt-get node (keyword #f "pos")))) (begin (if (jolt-truthy? cn) (jolt-invoke (var-deref "jolt.passes.types.check" "check-invoke") cn args ats pos env) jolt-nil) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.check" "not-callable?") callee-t)) (let* ((_a$5866 (var-deref "clojure.core" "swap!")) (_a$5867 (jolt-get env (keyword #f "diags"))) (_a$5868 jolt-conj) (_a$5869 (let* ((_o$5858 (keyword #f "op")) (_o$5859 (keyword #f "call")) (_o$5860 (keyword #f "type")) (_o$5861 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") callee-t)) (_o$5862 (keyword #f "pos")) (_o$5863 pos) (_o$5864 (keyword #f "msg")) (_o$5865 (jolt-invoke (var-deref "clojure.core" "str") "cannot call " (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") callee-t) " as a function"))) (jolt-hash-map _o$5858 _o$5859 _o$5860 _o$5861 _o$5862 _o$5863 _o$5864 _o$5865)))) (jolt-invoke _a$5866 _a$5867 _a$5868 _a$5869)) jolt-nil) (if (jolt-truthy? (let* ((and__25__auto (jolt-get env (keyword #f "strict?")))) (if (jolt-truthy? and__25__auto) iscall-var and__25__auto))) (let* ((k (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (usig (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "user-sigs"))) k))) (if (jolt-truthy? usig) (jolt-invoke (var-deref "jolt.passes.types" "check-user-call") k usig ats pos env) jolt-nil)) jolt-nil))) jolt-nil) (let* ((pm (let* ((and__25__auto iscall-var)) (if (jolt-truthy? and__25__auto) (let* ((_a$5870 (jolt-get env (keyword #f "protocol-methods"))) (_a$5871 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$5870 _a$5871)) and__25__auto))) (rtype (if (jolt-truthy? (let* ((and__25__auto pm)) (if (jolt-truthy? and__25__auto) (jolt-pos? n) and__25__auto))) (jolt-get (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0)) (keyword #f "type")) jolt-nil)) (base (jolt-assoc node (keyword #f "fn") fnode_PRIME_ (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5872 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (let* ((_o$5880 (if (jolt= cn "range") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (keyword #f "num")) (if (jolt-truthy? (let* ((and__25__auto cn)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-contains? (var-deref "jolt.passes.types" "elem-fns") cn))) (if (jolt-truthy? and__25__auto) (> n 0) and__25__auto)) and__25__auto))) (let* ((a0 (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") a0)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") a0) (keyword #f "any"))) (if (jolt-truthy? (let* ((and__25__auto cn)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-contains? (var-deref "jolt.passes.types" "dbl-arith-ops") cn))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types" "dbl-arith?") ares args) and__25__auto)) and__25__auto))) (keyword #f "double") (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env) jolt-nil))))) (_o$5881 (if (jolt-truthy? rtype) (let* ((_a$5873 base) (_a$5874 (keyword #f "devirt-type")) (_a$5875 rtype) (_a$5876 (keyword #f "devirt-proto")) (_a$5877 (jolt-nth pm 0)) (_a$5878 (keyword #f "devirt-method")) (_a$5879 (jolt-nth pm 1))) (jolt-assoc _a$5873 _a$5874 _a$5875 _a$5876 _a$5877 _a$5878 _a$5879)) base))) (jolt-vector _o$5880 _o$5881))))))))) infer-call) (let* ((_o$5882 (keyword #f "doc")) (_o$5883 "Everything else: type the args, collect the call (var callee) for whole-program\n inference, run the success-type check, and use the declared/estimated return type.\n range produces a numeric vector; an element-returning fn over a typed vector\n yields the element type. A protocol-method call whose receiver (arg 0) is a known\n record type is annotated [type-tag proto method] for devirtualization \x2014; the back\n end looks up the impl at emit time and calls it directly, skipping the registry\n dispatch (~19x cheaper).") (_o$5884 (keyword #f "private")) (_o$5885 #t)) (jolt-hash-map _o$5882 _o$5883 _o$5884 _o$5885)))) + (def-var-with-meta! "jolt.passes.types" "infer-call" (letrec ((infer-call (lambda (node fnode iscall-var cn args n tenv env) (let fnrec5836 ((node node) (fnode fnode) (iscall-var iscall-var) (cn cn) (args args) (n n) (tenv tenv) (env env)) (let* ((fr (if (jolt-not iscall-var) (jolt-invoke (var-deref "jolt.passes.types" "infer") fnode tenv env) jolt-nil)) (fnode_PRIME_ (if (jolt-truthy? iscall-var) fnode (jolt-invoke (var-deref "jolt.passes.types" "nd") fr))) (callee-t (if (jolt-truthy? iscall-var) (let* ((_a$5837 (jolt-get env (keyword #f "vtypes"))) (_a$5838 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$5837 _a$5838)) (jolt-invoke (var-deref "jolt.passes.types" "ty") fr))) (ares (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec5839 ((a a)) (jolt-invoke (var-deref "jolt.passes.types" "infer") a tenv env))) args))) (begin (if (jolt-truthy? iscall-var) (let* ((_a$5845 (var-deref "clojure.core" "swap!")) (_a$5846 (jolt-get env (keyword #f "calls"))) (_a$5847 jolt-conj) (_a$5848 (let* ((_o$5843 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (_o$5844 (if (let* ((_a$5840 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (_a$5841 (jolt-get env (keyword #f "self-key")))) (jolt= _a$5840 _a$5841)) (jolt-invoke (var-deref "jolt.passes.types" "self-rec-argtys") args ares (jolt-get env (keyword #f "self-params"))) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5842 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) ares)))) (jolt-vector _o$5843 _o$5844)))) (jolt-invoke _a$5845 _a$5846 _a$5847 _a$5848)) jolt-nil) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-get env (keyword #f "self-key")))) (if (jolt-truthy? and__25__auto) (let* ((_a$5849 (jolt-get fnode (keyword #f "name"))) (_a$5850 (jolt-get env (keyword #f "self-name")))) (jolt= _a$5849 _a$5850)) and__25__auto)) and__25__auto))) (let* ((_a$5853 (var-deref "clojure.core" "swap!")) (_a$5854 (jolt-get env (keyword #f "calls"))) (_a$5855 jolt-conj) (_a$5856 (let* ((_o$5851 (jolt-get env (keyword #f "self-key"))) (_o$5852 (jolt-invoke (var-deref "jolt.passes.types" "self-rec-argtys") args ares (jolt-get env (keyword #f "self-params"))))) (jolt-vector _o$5851 _o$5852)))) (jolt-invoke _a$5853 _a$5854 _a$5855 _a$5856)) jolt-nil) (if (jolt-truthy? (jolt-get env (keyword #f "checking?"))) (let* ((ats (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5857 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) ares)) (pos (jolt-get node (keyword #f "pos")))) (begin (if (jolt-truthy? cn) (jolt-invoke (var-deref "jolt.passes.types.check" "check-invoke") cn args ats pos env) jolt-nil) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.check" "not-callable?") callee-t)) (let* ((_a$5866 (var-deref "clojure.core" "swap!")) (_a$5867 (jolt-get env (keyword #f "diags"))) (_a$5868 jolt-conj) (_a$5869 (let* ((_o$5858 (keyword #f "op")) (_o$5859 (keyword #f "call")) (_o$5860 (keyword #f "type")) (_o$5861 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") callee-t)) (_o$5862 (keyword #f "pos")) (_o$5863 pos) (_o$5864 (keyword #f "msg")) (_o$5865 (jolt-invoke (var-deref "clojure.core" "str") "cannot call " (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") callee-t) " as a function"))) (jolt-hash-map _o$5858 _o$5859 _o$5860 _o$5861 _o$5862 _o$5863 _o$5864 _o$5865)))) (jolt-invoke _a$5866 _a$5867 _a$5868 _a$5869)) jolt-nil) (if (jolt-truthy? (let* ((and__25__auto (jolt-get env (keyword #f "strict?")))) (if (jolt-truthy? and__25__auto) iscall-var and__25__auto))) (let* ((k (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (usig (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "user-sigs"))) k))) (if (jolt-truthy? usig) (jolt-invoke (var-deref "jolt.passes.types" "check-user-call") k usig ats pos env) jolt-nil)) jolt-nil))) jolt-nil) (let* ((pm (let* ((and__25__auto iscall-var)) (if (jolt-truthy? and__25__auto) (let* ((_a$5870 (jolt-get env (keyword #f "protocol-methods"))) (_a$5871 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$5870 _a$5871)) and__25__auto))) (rtype (if (jolt-truthy? (let* ((and__25__auto pm)) (if (jolt-truthy? and__25__auto) (jolt-pos? n) and__25__auto))) (jolt-get (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0)) (keyword #f "type")) jolt-nil)) (base (jolt-assoc node (keyword #f "fn") fnode_PRIME_ (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5872 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (let* ((_o$5880 (if (jolt= cn "range") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (keyword #f "num")) (if (jolt-truthy? (let* ((and__25__auto cn)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-contains? (var-deref "jolt.passes.types" "elem-fns") cn))) (if (jolt-truthy? and__25__auto) (> n 0) and__25__auto)) and__25__auto))) (let* ((a0 (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") a0)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") a0) (keyword #f "any"))) (if (jolt-truthy? (let* ((and__25__auto cn)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-contains? (var-deref "jolt.passes.types" "dbl-arith-ops") cn))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types" "dbl-arith?") ares args) and__25__auto)) and__25__auto))) (keyword #f "double") (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env) jolt-nil))))) (_o$5881 (if (jolt-truthy? rtype) (let* ((_a$5873 base) (_a$5874 (keyword #f "devirt-type")) (_a$5875 rtype) (_a$5876 (keyword #f "devirt-proto")) (_a$5877 (jolt-nth pm 0)) (_a$5878 (keyword #f "devirt-method")) (_a$5879 (jolt-nth pm 1))) (jolt-assoc _a$5873 _a$5874 _a$5875 _a$5876 _a$5877 _a$5878 _a$5879)) base))) (jolt-vector _o$5880 _o$5881))))))))) infer-call) (let* ((_o$5882 (keyword #f "private")) (_o$5883 #t) (_o$5884 (keyword #f "doc")) (_o$5885 "Everything else: type the args, collect the call (var callee) for whole-program\n inference, run the success-type check, and use the declared/estimated return type.\n range produces a numeric vector; an element-returning fn over a typed vector\n yields the element type. A protocol-method call whose receiver (arg 0) is a known\n record type is annotated [type-tag proto method] for devirtualization \x2014; the back\n end looks up the impl at emit time and calls it directly, skipping the registry\n dispatch (~19x cheaper).")) (jolt-hash-map _o$5882 _o$5883 _o$5884 _o$5885)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "infer-invoke" (letrec ((infer-invoke (lambda (node tenv env) (let fnrec5886 ((node node) (tenv tenv) (env env)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (iscall-var (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op")))) (cn (if (jolt-truthy? (let* ((and__25__auto iscall-var)) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto))) (jolt-get fnode (keyword #f "name")) jolt-nil)) (args (jolt-get node (keyword #f "args"))) (n (jolt-count args))) (if (jolt-truthy? (let* ((and__25__auto iscall-var)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-contains? (var-deref "jolt.passes.types" "fold-preds") cn))) (if (jolt-truthy? and__25__auto) (jolt= n 1) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-pred-fold") node fnode cn args tenv env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") fnode))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (<= n 2) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-kw-lookup") node fnode args n tenv env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") fnode))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get (jolt-nth args 1) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get (jolt-nth args 1) (keyword #f "val"))) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-get-lookup") node args n tenv env) (if (let* ((and__25__auto (jolt= cn "reduce"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get (jolt-nth args 0) (keyword #f "op"))) and__25__auto)) and__25__auto)) (jolt-invoke (var-deref "jolt.passes.types" "infer-reduce-hof") node args n tenv env) (if (jolt-truthy? (let* ((and__25__auto cn)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-get (var-deref "jolt.passes.types" "hof-table") cn))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get (jolt-nth args 0) (keyword #f "op"))) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-seq-hof") node cn args tenv env) (if (let* ((and__25__auto (let* ((or__26__auto (jolt= cn "conj"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= cn "into"))))) (if (jolt-truthy? and__25__auto) (>= n 1) and__25__auto)) (jolt-invoke (var-deref "jolt.passes.types" "infer-conj-into") node fnode cn args n tenv env) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "infer-call") node fnode iscall-var cn args n tenv env) jolt-nil)))))))))))) infer-invoke) (let* ((_o$5887 (keyword #f "doc")) (_o$5888 "Split the callee/args once and dispatch by callee shape to a pattern helper.") (_o$5889 (keyword #f "private")) (_o$5890 #t)) (jolt-hash-map _o$5887 _o$5888 _o$5889 _o$5890)))) + (def-var-with-meta! "jolt.passes.types" "infer-invoke" (letrec ((infer-invoke (lambda (node tenv env) (let fnrec5886 ((node node) (tenv tenv) (env env)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (iscall-var (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op")))) (cn (if (jolt-truthy? (let* ((and__25__auto iscall-var)) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto))) (jolt-get fnode (keyword #f "name")) jolt-nil)) (args (jolt-get node (keyword #f "args"))) (n (jolt-count args))) (if (jolt-truthy? (let* ((and__25__auto iscall-var)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-contains? (var-deref "jolt.passes.types" "fold-preds") cn))) (if (jolt-truthy? and__25__auto) (jolt= n 1) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-pred-fold") node fnode cn args tenv env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") fnode))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (<= n 2) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-kw-lookup") node fnode args n tenv env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") fnode))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get (jolt-nth args 1) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get (jolt-nth args 1) (keyword #f "val"))) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-get-lookup") node args n tenv env) (if (let* ((and__25__auto (jolt= cn "reduce"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get (jolt-nth args 0) (keyword #f "op"))) and__25__auto)) and__25__auto)) (jolt-invoke (var-deref "jolt.passes.types" "infer-reduce-hof") node args n tenv env) (if (jolt-truthy? (let* ((and__25__auto cn)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-get (var-deref "jolt.passes.types" "hof-table") cn))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get (jolt-nth args 0) (keyword #f "op"))) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-seq-hof") node cn args tenv env) (if (let* ((and__25__auto (let* ((or__26__auto (jolt= cn "conj"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= cn "into"))))) (if (jolt-truthy? and__25__auto) (>= n 1) and__25__auto)) (jolt-invoke (var-deref "jolt.passes.types" "infer-conj-into") node fnode cn args n tenv env) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "infer-call") node fnode iscall-var cn args n tenv env) jolt-nil)))))))))))) infer-invoke) (let* ((_o$5887 (keyword #f "private")) (_o$5888 #t) (_o$5889 (keyword #f "doc")) (_o$5890 "Split the callee/args once and dispatch by callee shape to a pattern helper.")) (jolt-hash-map _o$5887 _o$5888 _o$5889 _o$5890)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "infer" (letrec ((infer (lambda (node tenv env) (let fnrec5891 ((node node) (tenv tenv) (env env)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$5892 (let* ((v (jolt-get node (keyword #f "val")))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "float?") v) and__25__auto))) (keyword #f "double") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (keyword #f "num") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (keyword #f "str") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (keyword #f "kw") (if (jolt-nil? v) (keyword #f "nil") (if (jolt= #f v) (keyword #f "any") (if (jolt-truthy? (keyword #f "else")) (keyword #f "truthy") jolt-nil))))))))) (_o$5893 node)) (jolt-vector _o$5892 _o$5893)) (if (jolt= op (keyword #f "local")) (let* ((t (jolt-get tenv (jolt-get node (keyword #f "name"))))) (let* ((_o$5894 (if (jolt-truthy? t) t (keyword #f "any"))) (_o$5895 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") t)) (let* ((n (jolt-assoc node (keyword #f "hint") (keyword #f "struct")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "type-shape") t)) (jolt-assoc n (keyword #f "shape") (jolt-invoke (var-deref "jolt.passes.types.lattice" "type-shape") t)) n)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t)) (jolt-assoc node (keyword #f "hint") (keyword #f "vector")) (if (jolt-truthy? (keyword #f "else")) node jolt-nil))))) (jolt-vector _o$5894 _o$5895))) (if (jolt= op (keyword #f "map")) (let* ((pairs (jolt-get node (keyword #f "pairs"))) (res (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (pr) (let fnrec5896 ((pr pr)) (let* ((kr (infer (jolt-nth pr 0) tenv env)) (vr (infer (jolt-nth pr 1) tenv env))) (let* ((_o$5897 (jolt-nth kr 1)) (_o$5898 (jolt-nth vr 1)) (_o$5899 (jolt-nth vr 0)) (_o$5900 (jolt-get (jolt-nth pr 0) (keyword #f "val")))) (jolt-vector _o$5897 _o$5898 _o$5899 _o$5900))))) pairs)) (struct? (let* ((and__25__auto (> (jolt-count res) 0))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (pr) (let fnrec5901 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) pairs))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (r) (let fnrec5902 ((r r)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "truthy-type?") (jolt-nth r 2)))) res) and__25__auto)) and__25__auto))) (base (if (jolt-truthy? struct?) (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") (let* ((_a$5907 (lambda (m r) (let fnrec5903 ((m m) (r r)) (let* ((_a$5904 m) (_a$5905 (jolt-nth r 3)) (_a$5906 (jolt-nth r 2))) (jolt-assoc _a$5904 _a$5905 _a$5906))))) (_a$5908 (jolt-hash-map)) (_a$5909 res)) (jolt-reduce _a$5907 _a$5908 _a$5909))) (var-deref "jolt.passes.types.lattice" "type-depth")) jolt-nil)) (shp (if (jolt-truthy? (let* ((and__25__auto (jolt-get env (keyword #f "map-shapes?")))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto base)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") base) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "shape-order") (jolt-keys (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") base))) jolt-nil)) (t (if (jolt-truthy? base) (if (jolt-truthy? shp) (jolt-assoc base (keyword #f "shape") shp) base) (keyword #f "any"))) (node_PRIME_ (jolt-assoc node (keyword #f "pairs") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5910 ((r r)) (let* ((_o$5911 (jolt-nth r 0)) (_o$5912 (jolt-nth r 1))) (jolt-vector _o$5911 _o$5912)))) res)))) (let* ((_o$5913 t) (_o$5914 (if (jolt-truthy? shp) (jolt-assoc node_PRIME_ (keyword #f "shape") shp) node_PRIME_))) (jolt-vector _o$5913 _o$5914))) (if (jolt= op (keyword #f "vector")) (let* ((irs (let* ((_a$5916 (var-deref "clojure.core" "mapv")) (_a$5917 (lambda (x) (let fnrec5915 ((x x)) (infer x tenv env)))) (_a$5918 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$5916 _a$5917 _a$5918))) (ets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5919 ((r r)) (jolt-nth r 0))) irs)) (el (if (jolt-empty? ets) (keyword #f "any") (let* ((_a$5920 (var-deref "jolt.passes.types.lattice" "join")) (_a$5921 (jolt-first ets)) (_a$5922 (jolt-rest ets))) (jolt-reduce _a$5920 _a$5921 _a$5922))))) (let* ((_o$5924 (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") el) (var-deref "jolt.passes.types.lattice" "type-depth"))) (_o$5925 (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5923 ((r r)) (jolt-nth r 1))) irs)))) (jolt-vector _o$5924 _o$5925))) (if (jolt= op (keyword #f "set")) (let* ((irs (let* ((_a$5927 (var-deref "clojure.core" "mapv")) (_a$5928 (lambda (x) (let fnrec5926 ((x x)) (infer x tenv env)))) (_a$5929 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$5927 _a$5928 _a$5929))) (ets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5930 ((r r)) (jolt-nth r 0))) irs)) (el (if (jolt-empty? ets) (keyword #f "any") (let* ((_a$5931 (var-deref "jolt.passes.types.lattice" "join")) (_a$5932 (jolt-first ets)) (_a$5933 (jolt-rest ets))) (jolt-reduce _a$5931 _a$5932 _a$5933))))) (let* ((_o$5935 (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-set") el) (var-deref "jolt.passes.types.lattice" "type-depth"))) (_o$5936 (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5934 ((r r)) (jolt-nth r 1))) irs)))) (jolt-vector _o$5935 _o$5936))) (if (jolt= op (keyword #f "if")) (let* ((test (jolt-get node (keyword #f "test"))) (tr (infer test tenv env)) (nr (jolt-invoke (var-deref "jolt.passes.types" "if-narrow") test tenv)) (thn (let* ((_a$5937 (jolt-get node (keyword #f "then"))) (_a$5938 (jolt-nth nr 0)) (_a$5939 env)) (infer _a$5937 _a$5938 _a$5939))) (els (let* ((_a$5940 (jolt-get node (keyword #f "else"))) (_a$5941 (jolt-nth nr 1)) (_a$5942 env)) (infer _a$5940 _a$5941 _a$5942)))) (let* ((_o$5953 (let* ((_a$5943 (var-deref "jolt.passes.types.lattice" "join")) (_a$5944 (jolt-nth thn 0)) (_a$5945 (jolt-nth els 0))) (jolt-invoke _a$5943 _a$5944 _a$5945))) (_o$5954 (let* ((_a$5946 node) (_a$5947 (keyword #f "test")) (_a$5948 (jolt-nth tr 1)) (_a$5949 (keyword #f "then")) (_a$5950 (jolt-nth thn 1)) (_a$5951 (keyword #f "else")) (_a$5952 (jolt-nth els 1))) (jolt-assoc _a$5946 _a$5947 _a$5948 _a$5949 _a$5950 _a$5951 _a$5952)))) (jolt-vector _o$5953 _o$5954))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$5956 (var-deref "clojure.core" "mapv")) (_a$5957 (lambda (s) (let fnrec5955 ((s s)) (jolt-nth (infer s tenv env) 1)))) (_a$5958 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$5956 _a$5957 _a$5958))) (r (infer (jolt-get node (keyword #f "ret")) tenv env))) (let* ((_o$5959 (jolt-nth r 0)) (_o$5960 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$5959 _o$5960))) (if (jolt= op (keyword #f "throw")) (let* ((_o$5961 (keyword #f "any")) (_o$5962 (jolt-assoc node (keyword #f "expr") (jolt-nth (infer (jolt-get node (keyword #f "expr")) tenv env) 1)))) (jolt-vector _o$5961 _o$5962)) (if (jolt= op (keyword #f "var")) (begin (let* ((_a$5963 (var-deref "clojure.core" "swap!")) (_a$5964 (jolt-get env (keyword #f "escapes"))) (_a$5965 jolt-conj) (_a$5966 (jolt-invoke (var-deref "jolt.passes.types" "var-key") node))) (jolt-invoke _a$5963 _a$5964 _a$5965 _a$5966)) (let* ((_o$5969 (let* ((vt (let* ((_a$5967 (jolt-get env (keyword #f "vtypes"))) (_a$5968 (jolt-invoke (var-deref "jolt.passes.types" "var-key") node))) (jolt-get _a$5967 _a$5968)))) (if (jolt-truthy? vt) vt (keyword #f "any")))) (_o$5970 node)) (jolt-vector _o$5969 _o$5970))) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.types" "infer-invoke") node tenv env) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$5981 (lambda (acc b) (let fnrec5971 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (infer (jolt-nth b 1) te env))) (let* ((_o$5977 (let* ((_a$5972 te) (_a$5973 (jolt-nth b 0)) (_a$5974 (jolt-nth ir 0))) (jolt-assoc _a$5972 _a$5973 _a$5974))) (_o$5978 (jolt-conj binds (let* ((_o$5975 (jolt-nth b 0)) (_o$5976 (jolt-nth ir 1))) (jolt-vector _o$5975 _o$5976))))) (jolt-vector _o$5977 _o$5978)))))) (_a$5982 (let* ((_o$5979 tenv) (_o$5980 (jolt-vector))) (jolt-vector _o$5979 _o$5980))) (_a$5983 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$5981 _a$5982 _a$5983))) (br (let* ((_a$5984 (jolt-get node (keyword #f "body"))) (_a$5985 (jolt-nth res 0)) (_a$5986 env)) (infer _a$5984 _a$5985 _a$5986)))) (let* ((_o$5992 (jolt-nth br 0)) (_o$5993 (let* ((_a$5987 node) (_a$5988 (keyword #f "bindings")) (_a$5989 (jolt-nth res 1)) (_a$5990 (keyword #f "body")) (_a$5991 (jolt-nth br 1))) (jolt-assoc _a$5987 _a$5988 _a$5989 _a$5990 _a$5991)))) (jolt-vector _o$5992 _o$5993))) (if (jolt= op (keyword #f "loop")) (let* ((lenv (jolt-assoc env (keyword #f "in-loop?") #t))) (let* ((_o$6005 (keyword #f "any")) (_o$6006 (let* ((_a$6000 node) (_a$6001 (keyword #f "bindings")) (_a$6002 (let* ((_a$5997 (var-deref "clojure.core" "mapv")) (_a$5998 (lambda (b) (let fnrec5994 ((b b)) (let* ((_o$5995 (jolt-nth b 0)) (_o$5996 (jolt-nth (infer (jolt-nth b 1) tenv env) 1))) (jolt-vector _o$5995 _o$5996))))) (_a$5999 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$5997 _a$5998 _a$5999))) (_a$6003 (keyword #f "body")) (_a$6004 (jolt-nth (infer (jolt-get node (keyword #f "body")) tenv lenv) 1))) (jolt-assoc _a$6000 _a$6001 _a$6002 _a$6003 _a$6004)))) (jolt-vector _o$6005 _o$6006))) (if (jolt= op (keyword #f "recur")) (let* ((ares (let* ((_a$6008 (var-deref "clojure.core" "mapv")) (_a$6009 (lambda (a) (let fnrec6007 ((a a)) (infer a tenv env)))) (_a$6010 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$6008 _a$6009 _a$6010)))) (begin (if (jolt-truthy? (let* ((and__25__auto (jolt-not (jolt-get env (keyword #f "in-loop?"))))) (if (jolt-truthy? and__25__auto) (jolt-get env (keyword #f "self-key")) and__25__auto))) (let* ((_a$6017 (var-deref "clojure.core" "swap!")) (_a$6018 (jolt-get env (keyword #f "calls"))) (_a$6019 jolt-conj) (_a$6020 (let* ((_o$6015 (jolt-get env (keyword #f "self-key"))) (_o$6016 (let* ((_a$6011 (var-deref "jolt.passes.types" "self-rec-argtys")) (_a$6012 (jolt-get node (keyword #f "args"))) (_a$6013 ares) (_a$6014 (jolt-get env (keyword #f "self-params")))) (jolt-invoke _a$6011 _a$6012 _a$6013 _a$6014)))) (jolt-vector _o$6015 _o$6016)))) (jolt-invoke _a$6017 _a$6018 _a$6019 _a$6020)) jolt-nil) (let* ((_o$6022 (keyword #f "any")) (_o$6023 (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6021 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (jolt-vector _o$6022 _o$6023)))) (if (jolt= op (keyword #f "fn")) (let* ((fenv (jolt-assoc env (keyword #f "self-name") jolt-nil (keyword #f "self-key") jolt-nil (keyword #f "self-params") jolt-nil (keyword #f "in-loop?") #f))) (let* ((_o$6039 (keyword #f "any")) (_o$6040 (jolt-assoc node (keyword #f "arities") (let* ((_a$6036 (var-deref "clojure.core" "mapv")) (_a$6037 (lambda (a) (let fnrec6024 ((a a)) (let* ((shapes (jolt-get env (keyword #f "record-shapes"))) (phm (let* ((_a$6029 (lambda (m pr) (let fnrec6025 ((m m) (pr pr)) (let* ((_a$6026 m) (_a$6027 (jolt-nth pr 0)) (_a$6028 (jolt-nth pr 1))) (jolt-assoc _a$6026 _a$6027 _a$6028))))) (_a$6030 (jolt-hash-map)) (_a$6031 (jolt-get a (keyword #f "phints")))) (jolt-reduce _a$6029 _a$6030 _a$6031))) (pe (let* ((_a$6033 (lambda (e p) (let fnrec6032 ((e e) (p p)) (jolt-assoc e p (let* ((ent (jolt-get shapes (jolt-get phm p)))) (if (jolt-truthy? ent) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") ent (var-deref "jolt.passes.types.lattice" "type-depth") shapes) (keyword #f "any"))))))) (_a$6034 tenv) (_a$6035 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$6033 _a$6034 _a$6035))) (pe (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) (keyword #f "any")) pe))) (jolt-assoc a (keyword #f "body") (jolt-nth (infer (jolt-get a (keyword #f "body")) pe fenv) 1)))))) (_a$6038 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$6036 _a$6037 _a$6038))))) (jolt-vector _o$6039 _o$6040))) (if (jolt= op (keyword #f "def")) (begin (if (jolt-truthy? (jolt-get env (keyword #f "checking?"))) (jolt-invoke (var-deref "jolt.passes.types.check" "register-user-fn!") node env) jolt-nil) (let* ((_o$6041 (keyword #f "any")) (_o$6042 (jolt-assoc node (keyword #f "init") (jolt-nth (infer (jolt-get node (keyword #f "init")) tenv env) 1)))) (jolt-vector _o$6041 _o$6042))) (if (jolt= op (keyword #f "try")) (let* ((_o$6050 (keyword #f "any")) (_o$6051 (let* ((_a$6043 node) (_a$6044 (keyword #f "body")) (_a$6045 (jolt-nth (infer (jolt-get node (keyword #f "body")) tenv env) 1)) (_a$6046 (keyword #f "catch-body")) (_a$6047 (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-nth (infer (jolt-get node (keyword #f "catch-body")) tenv env) 1) jolt-nil)) (_a$6048 (keyword #f "finally")) (_a$6049 (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-nth (infer (jolt-get node (keyword #f "finally")) tenv env) 1) jolt-nil))) (jolt-assoc _a$6043 _a$6044 _a$6045 _a$6046 _a$6047 _a$6048 _a$6049)))) (jolt-vector _o$6050 _o$6051)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6052 (keyword #f "any")) (_o$6053 node)) (jolt-vector _o$6052 _o$6053)) jolt-nil)))))))))))))))))))))) infer) (let* ((_o$6054 (keyword #f "doc")) (_o$6055 "Returns [type node'] \x2014; the inferred type of node and node with struct-safe\n :local references annotated :hint :struct. tenv maps in-scope local names to\n inferred types; env carries the inference config and this run's accumulators.") (_o$6056 (keyword #f "private")) (_o$6057 #t)) (jolt-hash-map _o$6054 _o$6055 _o$6056 _o$6057)))) + (def-var-with-meta! "jolt.passes.types" "infer" (letrec ((infer (lambda (node tenv env) (let fnrec5891 ((node node) (tenv tenv) (env env)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$5892 (let* ((v (jolt-get node (keyword #f "val")))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "float?") v) and__25__auto))) (keyword #f "double") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (keyword #f "num") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (keyword #f "str") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (keyword #f "kw") (if (jolt-nil? v) (keyword #f "nil") (if (jolt= #f v) (keyword #f "any") (if (jolt-truthy? (keyword #f "else")) (keyword #f "truthy") jolt-nil))))))))) (_o$5893 node)) (jolt-vector _o$5892 _o$5893)) (if (jolt= op (keyword #f "local")) (let* ((t (jolt-get tenv (jolt-get node (keyword #f "name"))))) (let* ((_o$5894 (if (jolt-truthy? t) t (keyword #f "any"))) (_o$5895 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") t)) (let* ((n (jolt-assoc node (keyword #f "hint") (keyword #f "struct")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "type-shape") t)) (jolt-assoc n (keyword #f "shape") (jolt-invoke (var-deref "jolt.passes.types.lattice" "type-shape") t)) n)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t)) (jolt-assoc node (keyword #f "hint") (keyword #f "vector")) (if (jolt-truthy? (keyword #f "else")) node jolt-nil))))) (jolt-vector _o$5894 _o$5895))) (if (jolt= op (keyword #f "map")) (let* ((pairs (jolt-get node (keyword #f "pairs"))) (res (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (pr) (let fnrec5896 ((pr pr)) (let* ((kr (infer (jolt-nth pr 0) tenv env)) (vr (infer (jolt-nth pr 1) tenv env))) (let* ((_o$5897 (jolt-nth kr 1)) (_o$5898 (jolt-nth vr 1)) (_o$5899 (jolt-nth vr 0)) (_o$5900 (jolt-get (jolt-nth pr 0) (keyword #f "val")))) (jolt-vector _o$5897 _o$5898 _o$5899 _o$5900))))) pairs)) (struct? (let* ((and__25__auto (> (jolt-count res) 0))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (pr) (let fnrec5901 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) pairs))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (r) (let fnrec5902 ((r r)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "truthy-type?") (jolt-nth r 2)))) res) and__25__auto)) and__25__auto))) (base (if (jolt-truthy? struct?) (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") (let* ((_a$5907 (lambda (m r) (let fnrec5903 ((m m) (r r)) (let* ((_a$5904 m) (_a$5905 (jolt-nth r 3)) (_a$5906 (jolt-nth r 2))) (jolt-assoc _a$5904 _a$5905 _a$5906))))) (_a$5908 (jolt-hash-map)) (_a$5909 res)) (jolt-reduce _a$5907 _a$5908 _a$5909))) (var-deref "jolt.passes.types.lattice" "type-depth")) jolt-nil)) (shp (if (jolt-truthy? (let* ((and__25__auto (jolt-get env (keyword #f "map-shapes?")))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto base)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") base) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "shape-order") (jolt-keys (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") base))) jolt-nil)) (t (if (jolt-truthy? base) (if (jolt-truthy? shp) (jolt-assoc base (keyword #f "shape") shp) base) (keyword #f "any"))) (node_PRIME_ (jolt-assoc node (keyword #f "pairs") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5910 ((r r)) (let* ((_o$5911 (jolt-nth r 0)) (_o$5912 (jolt-nth r 1))) (jolt-vector _o$5911 _o$5912)))) res)))) (let* ((_o$5913 t) (_o$5914 (if (jolt-truthy? shp) (jolt-assoc node_PRIME_ (keyword #f "shape") shp) node_PRIME_))) (jolt-vector _o$5913 _o$5914))) (if (jolt= op (keyword #f "vector")) (let* ((irs (let* ((_a$5916 (var-deref "clojure.core" "mapv")) (_a$5917 (lambda (x) (let fnrec5915 ((x x)) (infer x tenv env)))) (_a$5918 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$5916 _a$5917 _a$5918))) (ets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5919 ((r r)) (jolt-nth r 0))) irs)) (el (if (jolt-empty? ets) (keyword #f "any") (let* ((_a$5920 (var-deref "jolt.passes.types.lattice" "join")) (_a$5921 (jolt-first ets)) (_a$5922 (jolt-rest ets))) (jolt-reduce _a$5920 _a$5921 _a$5922))))) (let* ((_o$5924 (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") el) (var-deref "jolt.passes.types.lattice" "type-depth"))) (_o$5925 (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5923 ((r r)) (jolt-nth r 1))) irs)))) (jolt-vector _o$5924 _o$5925))) (if (jolt= op (keyword #f "set")) (let* ((irs (let* ((_a$5927 (var-deref "clojure.core" "mapv")) (_a$5928 (lambda (x) (let fnrec5926 ((x x)) (infer x tenv env)))) (_a$5929 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$5927 _a$5928 _a$5929))) (ets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5930 ((r r)) (jolt-nth r 0))) irs)) (el (if (jolt-empty? ets) (keyword #f "any") (let* ((_a$5931 (var-deref "jolt.passes.types.lattice" "join")) (_a$5932 (jolt-first ets)) (_a$5933 (jolt-rest ets))) (jolt-reduce _a$5931 _a$5932 _a$5933))))) (let* ((_o$5935 (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-set") el) (var-deref "jolt.passes.types.lattice" "type-depth"))) (_o$5936 (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5934 ((r r)) (jolt-nth r 1))) irs)))) (jolt-vector _o$5935 _o$5936))) (if (jolt= op (keyword #f "if")) (let* ((test (jolt-get node (keyword #f "test"))) (tr (infer test tenv env)) (nr (jolt-invoke (var-deref "jolt.passes.types" "if-narrow") test tenv)) (thn (let* ((_a$5937 (jolt-get node (keyword #f "then"))) (_a$5938 (jolt-nth nr 0)) (_a$5939 env)) (infer _a$5937 _a$5938 _a$5939))) (els (let* ((_a$5940 (jolt-get node (keyword #f "else"))) (_a$5941 (jolt-nth nr 1)) (_a$5942 env)) (infer _a$5940 _a$5941 _a$5942)))) (let* ((_o$5953 (let* ((_a$5943 (var-deref "jolt.passes.types.lattice" "join")) (_a$5944 (jolt-nth thn 0)) (_a$5945 (jolt-nth els 0))) (jolt-invoke _a$5943 _a$5944 _a$5945))) (_o$5954 (let* ((_a$5946 node) (_a$5947 (keyword #f "test")) (_a$5948 (jolt-nth tr 1)) (_a$5949 (keyword #f "then")) (_a$5950 (jolt-nth thn 1)) (_a$5951 (keyword #f "else")) (_a$5952 (jolt-nth els 1))) (jolt-assoc _a$5946 _a$5947 _a$5948 _a$5949 _a$5950 _a$5951 _a$5952)))) (jolt-vector _o$5953 _o$5954))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$5956 (var-deref "clojure.core" "mapv")) (_a$5957 (lambda (s) (let fnrec5955 ((s s)) (jolt-nth (infer s tenv env) 1)))) (_a$5958 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$5956 _a$5957 _a$5958))) (r (infer (jolt-get node (keyword #f "ret")) tenv env))) (let* ((_o$5959 (jolt-nth r 0)) (_o$5960 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$5959 _o$5960))) (if (jolt= op (keyword #f "throw")) (let* ((_o$5961 (keyword #f "any")) (_o$5962 (jolt-assoc node (keyword #f "expr") (jolt-nth (infer (jolt-get node (keyword #f "expr")) tenv env) 1)))) (jolt-vector _o$5961 _o$5962)) (if (jolt= op (keyword #f "var")) (begin (let* ((_a$5963 (var-deref "clojure.core" "swap!")) (_a$5964 (jolt-get env (keyword #f "escapes"))) (_a$5965 jolt-conj) (_a$5966 (jolt-invoke (var-deref "jolt.passes.types" "var-key") node))) (jolt-invoke _a$5963 _a$5964 _a$5965 _a$5966)) (let* ((_o$5969 (let* ((vt (let* ((_a$5967 (jolt-get env (keyword #f "vtypes"))) (_a$5968 (jolt-invoke (var-deref "jolt.passes.types" "var-key") node))) (jolt-get _a$5967 _a$5968)))) (if (jolt-truthy? vt) vt (keyword #f "any")))) (_o$5970 node)) (jolt-vector _o$5969 _o$5970))) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.types" "infer-invoke") node tenv env) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$5981 (lambda (acc b) (let fnrec5971 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (infer (jolt-nth b 1) te env))) (let* ((_o$5977 (let* ((_a$5972 te) (_a$5973 (jolt-nth b 0)) (_a$5974 (jolt-nth ir 0))) (jolt-assoc _a$5972 _a$5973 _a$5974))) (_o$5978 (jolt-conj binds (let* ((_o$5975 (jolt-nth b 0)) (_o$5976 (jolt-nth ir 1))) (jolt-vector _o$5975 _o$5976))))) (jolt-vector _o$5977 _o$5978)))))) (_a$5982 (let* ((_o$5979 tenv) (_o$5980 (jolt-vector))) (jolt-vector _o$5979 _o$5980))) (_a$5983 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$5981 _a$5982 _a$5983))) (br (let* ((_a$5984 (jolt-get node (keyword #f "body"))) (_a$5985 (jolt-nth res 0)) (_a$5986 env)) (infer _a$5984 _a$5985 _a$5986)))) (let* ((_o$5992 (jolt-nth br 0)) (_o$5993 (let* ((_a$5987 node) (_a$5988 (keyword #f "bindings")) (_a$5989 (jolt-nth res 1)) (_a$5990 (keyword #f "body")) (_a$5991 (jolt-nth br 1))) (jolt-assoc _a$5987 _a$5988 _a$5989 _a$5990 _a$5991)))) (jolt-vector _o$5992 _o$5993))) (if (jolt= op (keyword #f "loop")) (let* ((lenv (jolt-assoc env (keyword #f "in-loop?") #t))) (let* ((_o$6005 (keyword #f "any")) (_o$6006 (let* ((_a$6000 node) (_a$6001 (keyword #f "bindings")) (_a$6002 (let* ((_a$5997 (var-deref "clojure.core" "mapv")) (_a$5998 (lambda (b) (let fnrec5994 ((b b)) (let* ((_o$5995 (jolt-nth b 0)) (_o$5996 (jolt-nth (infer (jolt-nth b 1) tenv env) 1))) (jolt-vector _o$5995 _o$5996))))) (_a$5999 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$5997 _a$5998 _a$5999))) (_a$6003 (keyword #f "body")) (_a$6004 (jolt-nth (infer (jolt-get node (keyword #f "body")) tenv lenv) 1))) (jolt-assoc _a$6000 _a$6001 _a$6002 _a$6003 _a$6004)))) (jolt-vector _o$6005 _o$6006))) (if (jolt= op (keyword #f "recur")) (let* ((ares (let* ((_a$6008 (var-deref "clojure.core" "mapv")) (_a$6009 (lambda (a) (let fnrec6007 ((a a)) (infer a tenv env)))) (_a$6010 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$6008 _a$6009 _a$6010)))) (begin (if (jolt-truthy? (let* ((and__25__auto (jolt-not (jolt-get env (keyword #f "in-loop?"))))) (if (jolt-truthy? and__25__auto) (jolt-get env (keyword #f "self-key")) and__25__auto))) (let* ((_a$6017 (var-deref "clojure.core" "swap!")) (_a$6018 (jolt-get env (keyword #f "calls"))) (_a$6019 jolt-conj) (_a$6020 (let* ((_o$6015 (jolt-get env (keyword #f "self-key"))) (_o$6016 (let* ((_a$6011 (var-deref "jolt.passes.types" "self-rec-argtys")) (_a$6012 (jolt-get node (keyword #f "args"))) (_a$6013 ares) (_a$6014 (jolt-get env (keyword #f "self-params")))) (jolt-invoke _a$6011 _a$6012 _a$6013 _a$6014)))) (jolt-vector _o$6015 _o$6016)))) (jolt-invoke _a$6017 _a$6018 _a$6019 _a$6020)) jolt-nil) (let* ((_o$6022 (keyword #f "any")) (_o$6023 (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6021 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (jolt-vector _o$6022 _o$6023)))) (if (jolt= op (keyword #f "fn")) (let* ((fenv (jolt-assoc env (keyword #f "self-name") jolt-nil (keyword #f "self-key") jolt-nil (keyword #f "self-params") jolt-nil (keyword #f "in-loop?") #f))) (let* ((_o$6039 (keyword #f "any")) (_o$6040 (jolt-assoc node (keyword #f "arities") (let* ((_a$6036 (var-deref "clojure.core" "mapv")) (_a$6037 (lambda (a) (let fnrec6024 ((a a)) (let* ((shapes (jolt-get env (keyword #f "record-shapes"))) (phm (let* ((_a$6029 (lambda (m pr) (let fnrec6025 ((m m) (pr pr)) (let* ((_a$6026 m) (_a$6027 (jolt-nth pr 0)) (_a$6028 (jolt-nth pr 1))) (jolt-assoc _a$6026 _a$6027 _a$6028))))) (_a$6030 (jolt-hash-map)) (_a$6031 (jolt-get a (keyword #f "phints")))) (jolt-reduce _a$6029 _a$6030 _a$6031))) (pe (let* ((_a$6033 (lambda (e p) (let fnrec6032 ((e e) (p p)) (jolt-assoc e p (let* ((ent (jolt-get shapes (jolt-get phm p)))) (if (jolt-truthy? ent) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") ent (var-deref "jolt.passes.types.lattice" "type-depth") shapes) (keyword #f "any"))))))) (_a$6034 tenv) (_a$6035 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$6033 _a$6034 _a$6035))) (pe (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) (keyword #f "any")) pe))) (jolt-assoc a (keyword #f "body") (jolt-nth (infer (jolt-get a (keyword #f "body")) pe fenv) 1)))))) (_a$6038 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$6036 _a$6037 _a$6038))))) (jolt-vector _o$6039 _o$6040))) (if (jolt= op (keyword #f "def")) (begin (if (jolt-truthy? (jolt-get env (keyword #f "checking?"))) (jolt-invoke (var-deref "jolt.passes.types.check" "register-user-fn!") node env) jolt-nil) (let* ((_o$6041 (keyword #f "any")) (_o$6042 (jolt-assoc node (keyword #f "init") (jolt-nth (infer (jolt-get node (keyword #f "init")) tenv env) 1)))) (jolt-vector _o$6041 _o$6042))) (if (jolt= op (keyword #f "try")) (let* ((_o$6050 (keyword #f "any")) (_o$6051 (let* ((_a$6043 node) (_a$6044 (keyword #f "body")) (_a$6045 (jolt-nth (infer (jolt-get node (keyword #f "body")) tenv env) 1)) (_a$6046 (keyword #f "catch-body")) (_a$6047 (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-nth (infer (jolt-get node (keyword #f "catch-body")) tenv env) 1) jolt-nil)) (_a$6048 (keyword #f "finally")) (_a$6049 (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-nth (infer (jolt-get node (keyword #f "finally")) tenv env) 1) jolt-nil))) (jolt-assoc _a$6043 _a$6044 _a$6045 _a$6046 _a$6047 _a$6048 _a$6049)))) (jolt-vector _o$6050 _o$6051)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6052 (keyword #f "any")) (_o$6053 node)) (jolt-vector _o$6052 _o$6053)) jolt-nil)))))))))))))))))))))) infer) (let* ((_o$6054 (keyword #f "private")) (_o$6055 #t) (_o$6056 (keyword #f "doc")) (_o$6057 "Returns [type node'] \x2014; the inferred type of node and node with struct-safe\n :local references annotated :hint :struct. tenv maps in-scope local names to\n inferred types; env carries the inference config and this run's accumulators.")) (jolt-hash-map _o$6054 _o$6055 _o$6056 _o$6057)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.types" "infer-top" (letrec ((infer-top (lambda (node env) (let fnrec6058 ((node node) (env env)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.types" "infer") node (jolt-hash-map) env) 1))))) infer-top) (let* ((_o$6059 (keyword #f "private")) (_o$6060 #t)) (jolt-hash-map _o$6059 _o$6060)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "all-any-env" (letrec ((all-any-env (lambda (params) (let fnrec6061 ((params params)) (let* ((_a$6063 (lambda (e p) (let fnrec6062 ((e e) (p p)) (jolt-assoc e p (keyword #f "any"))))) (_a$6064 (jolt-hash-map)) (_a$6065 params)) (jolt-reduce _a$6063 _a$6064 _a$6065)))))) all-any-env) (let* ((_o$6066 (keyword #f "doc")) (_o$6067 "tenv binding every param name to :any (the all-ambiguous baseline).") (_o$6068 (keyword #f "private")) (_o$6069 #t)) (jolt-hash-map _o$6066 _o$6067 _o$6068 _o$6069)))) + (def-var-with-meta! "jolt.passes.types" "all-any-env" (letrec ((all-any-env (lambda (params) (let fnrec6061 ((params params)) (let* ((_a$6063 (lambda (e p) (let fnrec6062 ((e e) (p p)) (jolt-assoc e p (keyword #f "any"))))) (_a$6064 (jolt-hash-map)) (_a$6065 params)) (jolt-reduce _a$6063 _a$6064 _a$6065)))))) all-any-env) (let* ((_o$6066 (keyword #f "private")) (_o$6067 #t) (_o$6068 (keyword #f "doc")) (_o$6069 "tenv binding every param name to :any (the all-ambiguous baseline).")) (jolt-hash-map _o$6066 _o$6067 _o$6068 _o$6069)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "isolated-diag-count" (letrec ((isolated-diag-count (lambda (body tenv env) (let fnrec6070 ((body body) (tenv tenv) (env env)) (let* ((sub (jolt-assoc env (keyword #f "diags") (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))))) (begin (jolt-invoke (var-deref "jolt.passes.types" "infer") body tenv sub) (jolt-count (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get sub (keyword #f "diags")))))))))) isolated-diag-count) (let* ((_o$6071 (keyword #f "doc")) (_o$6072 "Count of diagnostics typing body under tenv produces. Runs under a SUB-ENV\n with its own diags cell, so this probe never leaks into the real report (the\n shared calls/escapes/guard cells are intentionally still threaded \x2014; they are\n not read here). Runs the same checking inference as check-form.") (_o$6073 (keyword #f "private")) (_o$6074 #t)) (jolt-hash-map _o$6071 _o$6072 _o$6073 _o$6074)))) + (def-var-with-meta! "jolt.passes.types" "isolated-diag-count" (letrec ((isolated-diag-count (lambda (body tenv env) (let fnrec6070 ((body body) (tenv tenv) (env env)) (let* ((sub (jolt-assoc env (keyword #f "diags") (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))))) (begin (jolt-invoke (var-deref "jolt.passes.types" "infer") body tenv sub) (jolt-count (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get sub (keyword #f "diags")))))))))) isolated-diag-count) (let* ((_o$6071 (keyword #f "private")) (_o$6072 #t) (_o$6073 (keyword #f "doc")) (_o$6074 "Count of diagnostics typing body under tenv produces. Runs under a SUB-ENV\n with its own diags cell, so this probe never leaks into the real report (the\n shared calls/escapes/guard cells are intentionally still threaded \x2014; they are\n not read here). Runs the same checking inference as check-form.")) (jolt-hash-map _o$6071 _o$6072 _o$6073 _o$6074)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "check-user-call" (letrec ((check-user-call (lambda (key sig arg-types pos env) (let fnrec6075 ((key key) (sig sig) (arg-types arg-types) (pos pos) (env env)) (let* ((cset (jolt-get env (keyword #f "checking-set")))) (if (jolt-not (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") cset) key)) (let* ((prev (jolt-invoke (var-deref "clojure.core" "deref") cset))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") cset (jolt-conj prev key)) (let* ((params (jolt-get sig (keyword #f "params"))) (body (jolt-get sig (keyword #f "body"))) (npar (jolt-count params)) (nargs (jolt-count arg-types)) (memo (jolt-get env (keyword #f "diag-memo")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") npar nargs)) (let* ((_a$6084 (var-deref "clojure.core" "swap!")) (_a$6085 (jolt-get env (keyword #f "diags"))) (_a$6086 jolt-conj) (_a$6087 (let* ((_o$6076 (keyword #f "op")) (_o$6077 (keyword #f "user-call")) (_o$6078 (keyword #f "type")) (_o$6079 (keyword #f "arity")) (_o$6080 (keyword #f "pos")) (_o$6081 pos) (_o$6082 (keyword #f "msg")) (_o$6083 (jolt-invoke (var-deref "clojure.core" "str") "wrong number of args (" nargs ") passed to `" (jolt-get sig (keyword #f "name")) "` (expected " npar ")"))) (jolt-hash-map _o$6076 _o$6077 _o$6078 _o$6079 _o$6080 _o$6081 _o$6082 _o$6083)))) (jolt-invoke _a$6084 _a$6085 _a$6086 _a$6087)) (let* ((base-env (jolt-invoke (var-deref "jolt.passes.types" "all-any-env") params)) (base (let* ((bk (let* ((_o$6088 (keyword #f "base")) (_o$6089 key)) (jolt-vector _o$6088 _o$6089)))) (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") memo) bk) (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") memo) bk) (let* ((b (jolt-invoke (var-deref "jolt.passes.types" "isolated-diag-count") body base-env env))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") memo jolt-assoc bk b) b)))))) (let* ((_a$6117 (lambda (_ i) (let fnrec6090 ((_ _) (i i)) (begin (let* ((at (jolt-nth arg-types i))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "not=") at (keyword #f "any")))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "not=") at (keyword #f "truthy")) and__25__auto))) (let* ((mk (let* ((_o$6091 (keyword #f "arg")) (_o$6092 key) (_o$6093 i) (_o$6094 at)) (jolt-vector _o$6091 _o$6092 _o$6093 _o$6094))) (rejects (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") memo) mk) (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") memo) mk) (let* ((r (> (jolt-invoke (var-deref "jolt.passes.types" "isolated-diag-count") body (jolt-assoc base-env (jolt-nth params i) at) env) base))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") memo jolt-assoc mk r) r))))) (if (jolt-truthy? rejects) (let* ((_a$6113 (var-deref "clojure.core" "swap!")) (_a$6114 (jolt-get env (keyword #f "diags"))) (_a$6115 jolt-conj) (_a$6116 (let* ((_o$6103 (keyword #f "op")) (_o$6104 (keyword #f "user-call")) (_o$6105 (keyword #f "argpos")) (_o$6106 i) (_o$6107 (keyword #f "type")) (_o$6108 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") at)) (_o$6109 (keyword #f "pos")) (_o$6110 pos) (_o$6111 (keyword #f "msg")) (_o$6112 (let* ((_a$6095 (var-deref "clojure.core" "str")) (_a$6096 "argument ") (_a$6097 (jolt-inc i)) (_a$6098 " to `") (_a$6099 (jolt-get sig (keyword #f "name"))) (_a$6100 "` is ") (_a$6101 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") at)) (_a$6102 ", which its body provably rejects")) (jolt-invoke _a$6095 _a$6096 _a$6097 _a$6098 _a$6099 _a$6100 _a$6101 _a$6102)))) (jolt-hash-map _o$6103 _o$6104 _o$6105 _o$6106 _o$6107 _o$6108 _o$6109 _o$6110 _o$6111 _o$6112)))) (jolt-invoke _a$6113 _a$6114 _a$6115 _a$6116)) jolt-nil)) jolt-nil)) jolt-nil)))) (_a$6118 jolt-nil) (_a$6119 (jolt-range npar))) (jolt-reduce _a$6117 _a$6118 _a$6119))))) (jolt-invoke (var-deref "clojure.core" "reset!") cset prev))) jolt-nil)))))) check-user-call) (let* ((_o$6120 (keyword #f "doc")) (_o$6121 "Strict mode: report a call to a registered user fn that provably throws \x2014;\n either a WRONG ARITY (the registered fn has one fixed arity, so a different\n arg count always throws) or an argument whose concrete type the body\n rejects. For the latter, re-check the body with ONLY that parameter bound to\n its arg type (others :any); a diagnostic the all-:any body did not already\n have means the argument alone is provably wrong. Monotonic \x2014; binding a\n concrete type can only ADD error-domain hits \x2014; so no false positive.\n Cycle-guarded (env's checking-set) so mutually recursive fns terminate.") (_o$6122 (keyword #f "private")) (_o$6123 #t)) (jolt-hash-map _o$6120 _o$6121 _o$6122 _o$6123)))) + (def-var-with-meta! "jolt.passes.types" "check-user-call" (letrec ((check-user-call (lambda (key sig arg-types pos env) (let fnrec6075 ((key key) (sig sig) (arg-types arg-types) (pos pos) (env env)) (let* ((cset (jolt-get env (keyword #f "checking-set")))) (if (jolt-not (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") cset) key)) (let* ((prev (jolt-invoke (var-deref "clojure.core" "deref") cset))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") cset (jolt-conj prev key)) (let* ((params (jolt-get sig (keyword #f "params"))) (body (jolt-get sig (keyword #f "body"))) (npar (jolt-count params)) (nargs (jolt-count arg-types)) (memo (jolt-get env (keyword #f "diag-memo")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") npar nargs)) (let* ((_a$6084 (var-deref "clojure.core" "swap!")) (_a$6085 (jolt-get env (keyword #f "diags"))) (_a$6086 jolt-conj) (_a$6087 (let* ((_o$6076 (keyword #f "op")) (_o$6077 (keyword #f "user-call")) (_o$6078 (keyword #f "type")) (_o$6079 (keyword #f "arity")) (_o$6080 (keyword #f "pos")) (_o$6081 pos) (_o$6082 (keyword #f "msg")) (_o$6083 (jolt-invoke (var-deref "clojure.core" "str") "wrong number of args (" nargs ") passed to `" (jolt-get sig (keyword #f "name")) "` (expected " npar ")"))) (jolt-hash-map _o$6076 _o$6077 _o$6078 _o$6079 _o$6080 _o$6081 _o$6082 _o$6083)))) (jolt-invoke _a$6084 _a$6085 _a$6086 _a$6087)) (let* ((base-env (jolt-invoke (var-deref "jolt.passes.types" "all-any-env") params)) (base (let* ((bk (let* ((_o$6088 (keyword #f "base")) (_o$6089 key)) (jolt-vector _o$6088 _o$6089)))) (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") memo) bk) (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") memo) bk) (let* ((b (jolt-invoke (var-deref "jolt.passes.types" "isolated-diag-count") body base-env env))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") memo jolt-assoc bk b) b)))))) (let* ((_a$6117 (lambda (_ i) (let fnrec6090 ((_ _) (i i)) (begin (let* ((at (jolt-nth arg-types i))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "not=") at (keyword #f "any")))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "not=") at (keyword #f "truthy")) and__25__auto))) (let* ((mk (let* ((_o$6091 (keyword #f "arg")) (_o$6092 key) (_o$6093 i) (_o$6094 at)) (jolt-vector _o$6091 _o$6092 _o$6093 _o$6094))) (rejects (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") memo) mk) (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") memo) mk) (let* ((r (> (jolt-invoke (var-deref "jolt.passes.types" "isolated-diag-count") body (jolt-assoc base-env (jolt-nth params i) at) env) base))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") memo jolt-assoc mk r) r))))) (if (jolt-truthy? rejects) (let* ((_a$6113 (var-deref "clojure.core" "swap!")) (_a$6114 (jolt-get env (keyword #f "diags"))) (_a$6115 jolt-conj) (_a$6116 (let* ((_o$6103 (keyword #f "op")) (_o$6104 (keyword #f "user-call")) (_o$6105 (keyword #f "argpos")) (_o$6106 i) (_o$6107 (keyword #f "type")) (_o$6108 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") at)) (_o$6109 (keyword #f "pos")) (_o$6110 pos) (_o$6111 (keyword #f "msg")) (_o$6112 (let* ((_a$6095 (var-deref "clojure.core" "str")) (_a$6096 "argument ") (_a$6097 (jolt-inc i)) (_a$6098 " to `") (_a$6099 (jolt-get sig (keyword #f "name"))) (_a$6100 "` is ") (_a$6101 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") at)) (_a$6102 ", which its body provably rejects")) (jolt-invoke _a$6095 _a$6096 _a$6097 _a$6098 _a$6099 _a$6100 _a$6101 _a$6102)))) (jolt-hash-map _o$6103 _o$6104 _o$6105 _o$6106 _o$6107 _o$6108 _o$6109 _o$6110 _o$6111 _o$6112)))) (jolt-invoke _a$6113 _a$6114 _a$6115 _a$6116)) jolt-nil)) jolt-nil)) jolt-nil)))) (_a$6118 jolt-nil) (_a$6119 (jolt-range npar))) (jolt-reduce _a$6117 _a$6118 _a$6119))))) (jolt-invoke (var-deref "clojure.core" "reset!") cset prev))) jolt-nil)))))) check-user-call) (let* ((_o$6120 (keyword #f "private")) (_o$6121 #t) (_o$6122 (keyword #f "doc")) (_o$6123 "Strict mode: report a call to a registered user fn that provably throws \x2014;\n either a WRONG ARITY (the registered fn has one fixed arity, so a different\n arg count always throws) or an argument whose concrete type the body\n rejects. For the latter, re-check the body with ONLY that parameter bound to\n its arg type (others :any); a diagnostic the all-:any body did not already\n have means the argument alone is provably wrong. Monotonic \x2014; binding a\n concrete type can only ADD error-domain hits \x2014; so no false positive.\n Cycle-guarded (env's checking-set) so mutually recursive fns terminate.")) (jolt-hash-map _o$6120 _o$6121 _o$6122 _o$6123)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.types" "set-rtenv!" (letrec ((set-rtenv! (lambda (m) (let fnrec6124 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "rtenv") (let* ((or__26__auto m)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))))))) set-rtenv!) (let* ((_o$6125 (keyword #f "doc")) (_o$6126 "Install the current return-type estimates (a map \"ns/name\" -> type) used to\n type call results during the fixpoint.")) (jolt-hash-map _o$6125 _o$6126)))) (guard (e (#t #f)) diff --git a/host/chez/seed/prelude.ss b/host/chez/seed/prelude.ss index d0c60b3..7975c78 100644 --- a/host/chez/seed/prelude.ss +++ b/host/chez/seed/prelude.ss @@ -393,9 +393,9 @@ (guard (e (#t #f)) (def-var! "clojure.core" "inst-ms" (letrec ((inst-ms (lambda (x) (let fnrec4434 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "inst?") x)) (jolt-get x (keyword #f "ms")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "inst-ms requires an inst, got: " x))))))) inst-ms))) (guard (e (#t #f)) - (def-var! "clojure.core" "update-keys" (letrec ((update-keys (lambda (m f) (let fnrec4435 ((m m) (f f)) (let* ((_a$4437 (var-deref "clojure.core" "reduce-kv")) (_a$4438 (lambda (acc k v) (let fnrec4436 ((acc acc) (k k) (v v)) (jolt-assoc acc (jolt-invoke f k) v)))) (_a$4439 (jolt-hash-map )) (_a$4440 m)) (jolt-invoke _a$4437 _a$4438 _a$4439 _a$4440)))))) update-keys))) + (def-var! "clojure.core" "update-keys" (letrec ((update-keys (lambda (m f) (let fnrec4435 ((m m) (f f)) (let* ((_a$4437 (var-deref "clojure.core" "reduce-kv")) (_a$4438 (lambda (acc k v) (let fnrec4436 ((acc acc) (k k) (v v)) (jolt-assoc acc (jolt-invoke f k) v)))) (_a$4439 (jolt-hash-map)) (_a$4440 m)) (jolt-invoke _a$4437 _a$4438 _a$4439 _a$4440)))))) update-keys))) (guard (e (#t #f)) - (def-var! "clojure.core" "update-vals" (letrec ((update-vals (lambda (m f) (let fnrec4441 ((m m) (f f)) (let* ((_a$4443 (var-deref "clojure.core" "reduce-kv")) (_a$4444 (lambda (acc k v) (let fnrec4442 ((acc acc) (k k) (v v)) (jolt-assoc acc k (jolt-invoke f v))))) (_a$4445 (jolt-hash-map )) (_a$4446 m)) (jolt-invoke _a$4443 _a$4444 _a$4445 _a$4446)))))) update-vals))) + (def-var! "clojure.core" "update-vals" (letrec ((update-vals (lambda (m f) (let fnrec4441 ((m m) (f f)) (let* ((_a$4443 (var-deref "clojure.core" "reduce-kv")) (_a$4444 (lambda (acc k v) (let fnrec4442 ((acc acc) (k k) (v v)) (jolt-assoc acc k (jolt-invoke f v))))) (_a$4445 (jolt-hash-map)) (_a$4446 m)) (jolt-invoke _a$4443 _a$4444 _a$4445 _a$4446)))))) update-vals))) (guard (e (#t #f)) (def-var! "clojure.core" "partitionv" (letrec ((partitionv (case-lambda ((n coll) (let fnrec4447 ((n n) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition") n coll)))) ((n step coll) (let fnrec4448 ((n n) (step step) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition") n step coll)))) ((n step pad coll) (let fnrec4449 ((n n) (step step) (pad pad) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition") n step pad coll))))))) partitionv))) (guard (e (#t #f)) @@ -457,17 +457,17 @@ (guard (e (#t #f)) (def-var! "clojure.core" "false?" (letrec ((false? (lambda (x) (let fnrec4515 ((x x)) (jolt= #f x))))) false?))) (guard (e (#t #f)) - (def-var! "clojure.core" "select-keys" (letrec ((select-keys (lambda (map keyseq) (let fnrec4516 ((map map) (keyseq keyseq)) (let* ((_a$4518 (lambda (m k) (let fnrec4517 ((m m) (k k)) (if (jolt-contains? map k) (jolt-assoc m k (jolt-get map k)) m)))) (_a$4519 (jolt-hash-map )) (_a$4520 keyseq)) (jolt-reduce _a$4518 _a$4519 _a$4520)))))) select-keys))) + (def-var! "clojure.core" "select-keys" (letrec ((select-keys (lambda (map keyseq) (let fnrec4516 ((map map) (keyseq keyseq)) (let* ((_a$4518 (lambda (m k) (let fnrec4517 ((m m) (k k)) (if (jolt-contains? map k) (jolt-assoc m k (jolt-get map k)) m)))) (_a$4519 (jolt-hash-map)) (_a$4520 keyseq)) (jolt-reduce _a$4518 _a$4519 _a$4520)))))) select-keys))) (guard (e (#t #f)) - (def-var! "clojure.core" "zipmap" (letrec ((zipmap (lambda (keys vals) (let fnrec4521 ((keys keys) (vals vals)) (let* ((m (jolt-hash-map )) (ks (jolt-seq keys)) (vs (jolt-seq vals))) (let loop4522 ((m m) (ks ks) (vs vs)) (if (jolt-truthy? (let* ((and__25__auto ks)) (if (jolt-truthy? and__25__auto) vs and__25__auto))) (let* ((_a$4526 (let* ((_a$4523 m) (_a$4524 (jolt-first ks)) (_a$4525 (jolt-first vs))) (jolt-assoc _a$4523 _a$4524 _a$4525))) (_a$4527 (jolt-next ks)) (_a$4528 (jolt-next vs))) (loop4522 _a$4526 _a$4527 _a$4528)) m))))))) zipmap))) + (def-var! "clojure.core" "zipmap" (letrec ((zipmap (lambda (keys vals) (let fnrec4521 ((keys keys) (vals vals)) (let* ((m (jolt-hash-map)) (ks (jolt-seq keys)) (vs (jolt-seq vals))) (let loop4522 ((m m) (ks ks) (vs vs)) (if (jolt-truthy? (let* ((and__25__auto ks)) (if (jolt-truthy? and__25__auto) vs and__25__auto))) (let* ((_a$4526 (let* ((_a$4523 m) (_a$4524 (jolt-first ks)) (_a$4525 (jolt-first vs))) (jolt-assoc _a$4523 _a$4524 _a$4525))) (_a$4527 (jolt-next ks)) (_a$4528 (jolt-next vs))) (loop4522 _a$4526 _a$4527 _a$4528)) m))))))) zipmap))) (guard (e (#t #f)) - (def-var! "clojure.core" "merge" (letrec ((merge (lambda maps (let fnrec4529 ((maps (list->cseq maps))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "some") jolt-identity maps)) (jolt-reduce (lambda (acc m) (let fnrec4530 ((acc acc) (m m)) (if (jolt-nil? m) acc (jolt-conj (let* ((or__26__auto acc)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map ))) m)))) maps) jolt-nil))))) merge))) + (def-var! "clojure.core" "merge" (letrec ((merge (lambda maps (let fnrec4529 ((maps (list->cseq maps))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "some") jolt-identity maps)) (jolt-reduce (lambda (acc m) (let fnrec4530 ((acc acc) (m m)) (if (jolt-nil? m) acc (jolt-conj (let* ((or__26__auto acc)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map))) m)))) maps) jolt-nil))))) merge))) (guard (e (#t #f)) - (def-var! "clojure.core" "merge-with" (letrec ((merge-with (lambda (f . maps) (let fnrec4531 ((f f) (maps (list->cseq maps))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "some") jolt-identity maps)) (let* ((merge-entry (lambda (m e) (let fnrec4532 ((m m) (e e)) (let* ((k (jolt-invoke (var-deref "clojure.core" "key") e)) (v (jolt-invoke (var-deref "clojure.core" "val") e))) (if (jolt-contains? m k) (jolt-assoc m k (jolt-invoke f (jolt-get m k) v)) (jolt-assoc m k v)))))) (merge2 (lambda (m1 m2) (let fnrec4533 ((m1 m1) (m2 m2)) (let* ((_a$4534 merge-entry) (_a$4535 (let* ((or__26__auto m1)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map )))) (_a$4536 (jolt-seq m2))) (jolt-reduce _a$4534 _a$4535 _a$4536)))))) (jolt-reduce merge2 maps)) jolt-nil))))) merge-with))) + (def-var! "clojure.core" "merge-with" (letrec ((merge-with (lambda (f . maps) (let fnrec4531 ((f f) (maps (list->cseq maps))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "some") jolt-identity maps)) (let* ((merge-entry (lambda (m e) (let fnrec4532 ((m m) (e e)) (let* ((k (jolt-invoke (var-deref "clojure.core" "key") e)) (v (jolt-invoke (var-deref "clojure.core" "val") e))) (if (jolt-contains? m k) (jolt-assoc m k (jolt-invoke f (jolt-get m k) v)) (jolt-assoc m k v)))))) (merge2 (lambda (m1 m2) (let fnrec4533 ((m1 m1) (m2 m2)) (let* ((_a$4534 merge-entry) (_a$4535 (let* ((or__26__auto m1)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))) (_a$4536 (jolt-seq m2))) (jolt-reduce _a$4534 _a$4535 _a$4536)))))) (jolt-reduce merge2 maps)) jolt-nil))))) merge-with))) (guard (e (#t #f)) - (def-var! "clojure.core" "get-in" (letrec ((get-in (case-lambda ((m ks) (let fnrec4537 ((m m) (ks ks)) (jolt-reduce jolt-get m ks))) ((m ks not-found) (let fnrec4538 ((m m) (ks ks) (not-found not-found)) (let* ((sentinel (jolt-hash-map ))) (let* ((m m) (ks (jolt-seq ks))) (let loop4539 ((m m) (ks ks)) (if (jolt-truthy? ks) (let* ((nxt (jolt-get m (jolt-first ks) sentinel))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "identical?") sentinel nxt)) not-found (loop4539 nxt (jolt-next ks)))) m))))))))) get-in))) + (def-var! "clojure.core" "get-in" (letrec ((get-in (case-lambda ((m ks) (let fnrec4537 ((m m) (ks ks)) (jolt-reduce jolt-get m ks))) ((m ks not-found) (let fnrec4538 ((m m) (ks ks) (not-found not-found)) (let* ((sentinel (jolt-hash-map-fn ))) (let* ((m m) (ks (jolt-seq ks))) (let loop4539 ((m m) (ks ks)) (if (jolt-truthy? ks) (let* ((nxt (jolt-get m (jolt-first ks) sentinel))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "identical?") sentinel nxt)) not-found (loop4539 nxt (jolt-next ks)))) m))))))))) get-in))) (guard (e (#t #f)) - (def-var! "clojure.core" "memoize" (letrec ((memoize (lambda (f) (let fnrec4540 ((f f)) (let* ((mem (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map )))) (lambda args (let fnrec4541 ((args (list->cseq args))) (let* ((e (jolt-invoke (var-deref "clojure.core" "find") (jolt-invoke (var-deref "clojure.core" "deref") mem) args))) (if (jolt-truthy? e) (jolt-invoke (var-deref "clojure.core" "val") e) (let* ((ret (jolt-apply f args))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") mem jolt-assoc args ret) ret))))))))))) memoize))) + (def-var! "clojure.core" "memoize" (letrec ((memoize (lambda (f) (let fnrec4540 ((f f)) (let* ((mem (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map-fn )))) (lambda args (let fnrec4541 ((args (list->cseq args))) (let* ((e (jolt-invoke (var-deref "clojure.core" "find") (jolt-invoke (var-deref "clojure.core" "deref") mem) args))) (if (jolt-truthy? e) (jolt-invoke (var-deref "clojure.core" "val") e) (let* ((ret (jolt-apply f args))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") mem jolt-assoc args ret) ret))))))))))) memoize))) (guard (e (#t #f)) (def-var! "clojure.core" "partial" (letrec ((partial (case-lambda ((f) (let fnrec4542 ((f f)) f)) ((f a) (let fnrec4543 ((f f) (a a)) (lambda args (let fnrec4544 ((args (list->cseq args))) (jolt-apply f a args))))) ((f a b) (let fnrec4545 ((f f) (a a) (b b)) (lambda args (let fnrec4546 ((args (list->cseq args))) (jolt-apply f a b args))))) ((f a b c) (let fnrec4547 ((f f) (a a) (b b) (c c)) (lambda args (let fnrec4548 ((args (list->cseq args))) (jolt-apply f a b c args))))) ((f a b c . more) (let fnrec4549 ((f f) (a a) (b b) (c c) (more (list->cseq more))) (lambda args (let fnrec4550 ((args (list->cseq args))) (jolt-apply f a b c (jolt-concat more args))))))))) partial))) (guard (e (#t #f)) @@ -543,7 +543,7 @@ (guard (e (#t #f)) (def-var! "clojure.core" "ensure-reduced" (letrec ((ensure-reduced (lambda (x) (let fnrec4601 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "reduced?") x)) x (jolt-invoke (var-deref "clojure.core" "reduced") x)))))) ensure-reduced))) (guard (e (#t #f)) - (def-var! "clojure.core" "halt-when" (letrec ((halt-when (case-lambda ((pred) (let fnrec4602 ((pred pred)) (halt-when pred jolt-nil))) ((pred retf) (let fnrec4603 ((pred pred) (retf retf)) (lambda (rf) (let fnrec4604 ((rf rf)) (case-lambda (() (let fnrec4605 () (jolt-invoke rf))) ((result) (let fnrec4606 ((result result)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "map?") result))) (if (jolt-truthy? and__25__auto) (jolt-contains? result (keyword "clojure.core" "halt")) and__25__auto))) (jolt-get result (keyword "clojure.core" "halt")) (jolt-invoke rf result)))) ((result input) (let fnrec4607 ((result result) (input input)) (if (jolt-truthy? (jolt-invoke pred input)) (jolt-invoke (var-deref "clojure.core" "reduced") (jolt-hash-map (keyword "clojure.core" "halt") (if (jolt-truthy? retf) (jolt-invoke retf (jolt-invoke rf result) input) input))) (jolt-invoke rf result input)))))))))))) halt-when))) + (def-var! "clojure.core" "halt-when" (letrec ((halt-when (case-lambda ((pred) (let fnrec4602 ((pred pred)) (halt-when pred jolt-nil))) ((pred retf) (let fnrec4603 ((pred pred) (retf retf)) (lambda (rf) (let fnrec4604 ((rf rf)) (case-lambda (() (let fnrec4605 () (jolt-invoke rf))) ((result) (let fnrec4606 ((result result)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "map?") result))) (if (jolt-truthy? and__25__auto) (jolt-contains? result (keyword "clojure.core" "halt")) and__25__auto))) (jolt-get result (keyword "clojure.core" "halt")) (jolt-invoke rf result)))) ((result input) (let fnrec4607 ((result result) (input input)) (if (jolt-truthy? (jolt-invoke pred input)) (jolt-invoke (var-deref "clojure.core" "reduced") (jolt-hash-map-fn (keyword "clojure.core" "halt") (if (jolt-truthy? retf) (jolt-invoke retf (jolt-invoke rf result) input) input))) (jolt-invoke rf result input)))))))))))) halt-when))) (guard (e (#t #f)) (def-var! "clojure.core" "parse-boolean" (letrec ((parse-boolean (lambda (s) (let fnrec4608 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") s)) (if (jolt= s "true") #t (if (jolt= s "false") #f (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "parse-boolean requires a string, got: " s))))))) parse-boolean))) (guard (e (#t #f)) @@ -947,13 +947,13 @@ (guard (e (#t #f)) (def-var-with-meta! "clojure.core" "reader-eof" (keyword "jolt" "reader-eof") (let* ((_o$2631 (keyword #f "private")) (_o$2632 #t)) (jolt-hash-map _o$2631 _o$2632)))) (guard (e (#t #f)) - (begin (def-var! "clojure.core" "IReader" (jolt-invoke (var-deref "clojure.core" "make-protocol") "IReader" (let* ((_o$2639 (keyword #f "-read+string")) (_o$2640 (let* ((_o$2633 (keyword #f "name")) (_o$2634 "-read+string")) (jolt-hash-map _o$2633 _o$2634))) (_o$2641 (keyword #f "-read-line")) (_o$2642 (let* ((_o$2635 (keyword #f "name")) (_o$2636 "-read-line")) (jolt-hash-map _o$2635 _o$2636))) (_o$2643 (keyword #f "-read-form")) (_o$2644 (let* ((_o$2637 (keyword #f "name")) (_o$2638 "-read-form")) (jolt-hash-map _o$2637 _o$2638)))) (jolt-hash-map _o$2639 _o$2640 _o$2641 _o$2642 _o$2643 _o$2644)))) (jolt-invoke (var-deref "clojure.core" "register-protocol-methods!") "IReader" (let* ((_o$2645 "-read-line") (_o$2646 "-read-form") (_o$2647 "-read+string")) (jolt-vector _o$2645 _o$2646 _o$2647))) (def-var! "clojure.core" "-read-line" (lambda (G__112) (let fnrec2648 ((G__112 G__112)) (protocol-dispatch1 "IReader" "-read-line" G__112)))) (def-var! "clojure.core" "-read-form" (lambda (G__113) (let fnrec2649 ((G__113 G__113)) (protocol-dispatch1 "IReader" "-read-form" G__113)))) (def-var! "clojure.core" "-read+string" (lambda (G__114 G__115 G__116) (let fnrec2650 ((G__114 G__114) (G__115 G__115) (G__116 G__116)) (protocol-dispatch3 "IReader" "-read+string" G__114 G__115 G__116)))))) + (begin (def-var! "clojure.core" "IReader" (jolt-invoke (var-deref "clojure.core" "make-protocol") "IReader" (let* ((_o$2639 (keyword #f "-read-line")) (_o$2640 (let* ((_o$2633 (keyword #f "name")) (_o$2634 "-read-line")) (jolt-hash-map _o$2633 _o$2634))) (_o$2641 (keyword #f "-read-form")) (_o$2642 (let* ((_o$2635 (keyword #f "name")) (_o$2636 "-read-form")) (jolt-hash-map _o$2635 _o$2636))) (_o$2643 (keyword #f "-read+string")) (_o$2644 (let* ((_o$2637 (keyword #f "name")) (_o$2638 "-read+string")) (jolt-hash-map _o$2637 _o$2638)))) (jolt-hash-map _o$2639 _o$2640 _o$2641 _o$2642 _o$2643 _o$2644)))) (jolt-invoke (var-deref "clojure.core" "register-protocol-methods!") "IReader" (let* ((_o$2645 "-read-line") (_o$2646 "-read-form") (_o$2647 "-read+string")) (jolt-vector _o$2645 _o$2646 _o$2647))) (def-var! "clojure.core" "-read-line" (lambda (G__112) (let fnrec2648 ((G__112 G__112)) (protocol-dispatch1 "IReader" "-read-line" G__112)))) (def-var! "clojure.core" "-read-form" (lambda (G__113) (let fnrec2649 ((G__113 G__113)) (protocol-dispatch1 "IReader" "-read-form" G__113)))) (def-var! "clojure.core" "-read+string" (lambda (G__114 G__115 G__116) (let fnrec2650 ((G__114 G__114) (G__115 G__115) (G__116 G__116)) (protocol-dispatch3 "IReader" "-read+string" G__114 G__115 G__116)))))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.core" "__string-reader" (letrec ((__string-reader (lambda (s) (let fnrec2651 ((s s)) (let* ((buf (jolt-invoke (var-deref "clojure.core" "atom") s))) (jolt-invoke (var-deref "clojure.core" "make-reified") (let* ((_o$2661 (keyword #f "-read+string")) (_o$2662 (lambda (_ eof-error? eof-value) (let fnrec2652 ((_ _) (eof-error? eof-error?) (eof-value eof-value)) (let* ((s (jolt-invoke (var-deref "clojure.core" "deref") buf)) (r (jolt-invoke (var-deref "clojure.core" "__parse-next") s))) (if (jolt-nil? r) (if (jolt-truthy? eof-error?) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) (let* ((_o$2653 eof-value) (_o$2654 "")) (jolt-vector _o$2653 _o$2654))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-nth r 1)) (let* ((_o$2657 (jolt-nth r 0)) (_o$2658 (jolt-invoke (var-deref "clojure.core" "subs") s 0 (let* ((_a$2655 (jolt-count s)) (_a$2656 (jolt-count (jolt-nth r 1)))) (- _a$2655 _a$2656))))) (jolt-vector _o$2657 _o$2658)))))))) (_o$2663 (keyword #f "-read-line")) (_o$2664 (lambda (_) (let fnrec2659 ((_ _)) (let* ((cur (jolt-invoke (var-deref "clojure.core" "deref") buf))) (if (jolt-pos? (jolt-count cur)) (let* ((i (jolt-invoke (var-deref "clojure.core" "str-find") "\n" cur))) (if (jolt-nil? i) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf "") cur) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-invoke (var-deref "clojure.core" "subs") cur (jolt-inc i))) (jolt-invoke (var-deref "clojure.core" "subs") cur 0 i)))) jolt-nil))))) (_o$2665 (keyword #f "-read-form")) (_o$2666 (lambda (_) (let fnrec2660 ((_ _)) (let* ((r (jolt-invoke (var-deref "clojure.core" "__parse-next") (jolt-invoke (var-deref "clojure.core" "deref") buf)))) (if (jolt-nil? r) (var-deref "clojure.core" "reader-eof") (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-nth r 1)) (jolt-nth r 0)))))))) (jolt-hash-map _o$2661 _o$2662 _o$2663 _o$2664 _o$2665 _o$2666)) "IReader")))))) __string-reader) (let* ((_o$2667 (keyword #f "doc")) (_o$2668 "A reader over string s (the with-in-str expansion calls this).")) (jolt-hash-map _o$2667 _o$2668)))) + (def-var-with-meta! "clojure.core" "__string-reader" (letrec ((__string-reader (lambda (s) (let fnrec2651 ((s s)) (let* ((buf (jolt-invoke (var-deref "clojure.core" "atom") s))) (jolt-invoke (var-deref "clojure.core" "make-reified") (let* ((_o$2661 (keyword #f "-read-line")) (_o$2662 (lambda (_) (let fnrec2652 ((_ _)) (let* ((cur (jolt-invoke (var-deref "clojure.core" "deref") buf))) (if (jolt-pos? (jolt-count cur)) (let* ((i (jolt-invoke (var-deref "clojure.core" "str-find") "\n" cur))) (if (jolt-nil? i) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf "") cur) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-invoke (var-deref "clojure.core" "subs") cur (jolt-inc i))) (jolt-invoke (var-deref "clojure.core" "subs") cur 0 i)))) jolt-nil))))) (_o$2663 (keyword #f "-read-form")) (_o$2664 (lambda (_) (let fnrec2653 ((_ _)) (let* ((r (jolt-invoke (var-deref "clojure.core" "__parse-next") (jolt-invoke (var-deref "clojure.core" "deref") buf)))) (if (jolt-nil? r) (var-deref "clojure.core" "reader-eof") (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-nth r 1)) (jolt-nth r 0))))))) (_o$2665 (keyword #f "-read+string")) (_o$2666 (lambda (_ eof-error? eof-value) (let fnrec2654 ((_ _) (eof-error? eof-error?) (eof-value eof-value)) (let* ((s (jolt-invoke (var-deref "clojure.core" "deref") buf)) (r (jolt-invoke (var-deref "clojure.core" "__parse-next") s))) (if (jolt-nil? r) (if (jolt-truthy? eof-error?) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) (let* ((_o$2655 eof-value) (_o$2656 "")) (jolt-vector _o$2655 _o$2656))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-nth r 1)) (let* ((_o$2659 (jolt-nth r 0)) (_o$2660 (jolt-invoke (var-deref "clojure.core" "subs") s 0 (let* ((_a$2657 (jolt-count s)) (_a$2658 (jolt-count (jolt-nth r 1)))) (- _a$2657 _a$2658))))) (jolt-vector _o$2659 _o$2660))))))))) (jolt-hash-map _o$2661 _o$2662 _o$2663 _o$2664 _o$2665 _o$2666)) "IReader")))))) __string-reader) (let* ((_o$2667 (keyword #f "doc")) (_o$2668 "A reader over string s (the with-in-str expansion calls this).")) (jolt-hash-map _o$2667 _o$2668)))) (guard (e (#t #f)) (def-var-with-meta! "clojure.core" "stdin-buf" (jolt-invoke (var-deref "clojure.core" "atom") "") (let* ((_o$2669 (keyword #f "private")) (_o$2670 #t)) (jolt-hash-map _o$2669 _o$2670)))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.core" "*in*" (jolt-invoke (var-deref "clojure.core" "make-reified") (let* ((_o$2684 (keyword #f "-read+string")) (_o$2685 (lambda (_ eof-error? eof-value) (let fnrec2671 ((_ _) (eof-error? eof-error?) (eof-value eof-value)) (let* () (let loop2672 () (let* ((s (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf"))) (r (jolt-invoke (var-deref "clojure.core" "__parse-next") s))) (if (jolt-nil? r) (let* ((line (jolt-invoke (var-deref "clojure.core" "__stdin-read-line")))) (if (jolt-nil? line) (if (jolt-truthy? eof-error?) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) (let* ((_o$2673 eof-value) (_o$2674 "")) (jolt-vector _o$2673 _o$2674))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "stdin-buf") (lambda (b) (let fnrec2675 ((b b)) (jolt-invoke (var-deref "clojure.core" "str") b line "\n")))) (loop2672 )))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-nth r 1)) (let* ((_o$2678 (jolt-nth r 0)) (_o$2679 (jolt-invoke (var-deref "clojure.core" "subs") s 0 (let* ((_a$2676 (jolt-count s)) (_a$2677 (jolt-count (jolt-nth r 1)))) (- _a$2676 _a$2677))))) (jolt-vector _o$2678 _o$2679)))))))))) (_o$2686 (keyword #f "-read-line")) (_o$2687 (lambda (_) (let fnrec2680 ((_ _)) (let* ((cur (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf")))) (if (jolt-pos? (jolt-count cur)) (let* ((i (jolt-invoke (var-deref "clojure.core" "str-find") "\n" cur))) (if (jolt-nil? i) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") "") cur) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-invoke (var-deref "clojure.core" "subs") cur (jolt-inc i))) (jolt-invoke (var-deref "clojure.core" "subs") cur 0 i)))) (jolt-invoke (var-deref "clojure.core" "__stdin-read-line"))))))) (_o$2688 (keyword #f "-read-form")) (_o$2689 (lambda (_) (let fnrec2681 ((_ _)) (let* () (let loop2682 () (let* ((r (jolt-invoke (var-deref "clojure.core" "__parse-next") (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf"))))) (if (jolt-nil? r) (let* ((line (jolt-invoke (var-deref "clojure.core" "__stdin-read-line")))) (if (jolt-nil? line) (var-deref "clojure.core" "reader-eof") (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "stdin-buf") (lambda (b) (let fnrec2683 ((b b)) (jolt-invoke (var-deref "clojure.core" "str") b line "\n")))) (loop2682 )))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-nth r 1)) (jolt-nth r 0)))))))))) (jolt-hash-map _o$2684 _o$2685 _o$2686 _o$2687 _o$2688 _o$2689)) "IReader") (let* ((_o$2690 (keyword #f "dynamic")) (_o$2691 #t)) (jolt-hash-map _o$2690 _o$2691)))) + (def-var-with-meta! "clojure.core" "*in*" (jolt-invoke (var-deref "clojure.core" "make-reified") (let* ((_o$2684 (keyword #f "-read-line")) (_o$2685 (lambda (_) (let fnrec2671 ((_ _)) (let* ((cur (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf")))) (if (jolt-pos? (jolt-count cur)) (let* ((i (jolt-invoke (var-deref "clojure.core" "str-find") "\n" cur))) (if (jolt-nil? i) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") "") cur) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-invoke (var-deref "clojure.core" "subs") cur (jolt-inc i))) (jolt-invoke (var-deref "clojure.core" "subs") cur 0 i)))) (jolt-invoke (var-deref "clojure.core" "__stdin-read-line"))))))) (_o$2686 (keyword #f "-read-form")) (_o$2687 (lambda (_) (let fnrec2672 ((_ _)) (let* () (let loop2673 () (let* ((r (jolt-invoke (var-deref "clojure.core" "__parse-next") (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf"))))) (if (jolt-nil? r) (let* ((line (jolt-invoke (var-deref "clojure.core" "__stdin-read-line")))) (if (jolt-nil? line) (var-deref "clojure.core" "reader-eof") (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "stdin-buf") (lambda (b) (let fnrec2674 ((b b)) (jolt-invoke (var-deref "clojure.core" "str") b line "\n")))) (loop2673 )))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-nth r 1)) (jolt-nth r 0))))))))) (_o$2688 (keyword #f "-read+string")) (_o$2689 (lambda (_ eof-error? eof-value) (let fnrec2675 ((_ _) (eof-error? eof-error?) (eof-value eof-value)) (let* () (let loop2676 () (let* ((s (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf"))) (r (jolt-invoke (var-deref "clojure.core" "__parse-next") s))) (if (jolt-nil? r) (let* ((line (jolt-invoke (var-deref "clojure.core" "__stdin-read-line")))) (if (jolt-nil? line) (if (jolt-truthy? eof-error?) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) (let* ((_o$2677 eof-value) (_o$2678 "")) (jolt-vector _o$2677 _o$2678))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "stdin-buf") (lambda (b) (let fnrec2679 ((b b)) (jolt-invoke (var-deref "clojure.core" "str") b line "\n")))) (loop2676 )))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-nth r 1)) (let* ((_o$2682 (jolt-nth r 0)) (_o$2683 (jolt-invoke (var-deref "clojure.core" "subs") s 0 (let* ((_a$2680 (jolt-count s)) (_a$2681 (jolt-count (jolt-nth r 1)))) (- _a$2680 _a$2681))))) (jolt-vector _o$2682 _o$2683))))))))))) (jolt-hash-map _o$2684 _o$2685 _o$2686 _o$2687 _o$2688 _o$2689)) "IReader") (let* ((_o$2690 (keyword #f "dynamic")) (_o$2691 #t)) (jolt-hash-map _o$2690 _o$2691)))) (guard (e (#t #f)) (def-var-with-meta! "clojure.core" "read-line" (letrec ((read-line (lambda () (let fnrec2692 () (jolt-invoke (var-deref "clojure.core" "-read-line") (var-deref "clojure.core" "*in*")))))) read-line) (let* ((_o$2693 (keyword #f "doc")) (_o$2694 "Reads the next line from the stream that is the current value of *in*.\n Returns nil at EOF.")) (jolt-hash-map _o$2693 _o$2694)))) (guard (e (#t #f)) @@ -1067,7 +1067,7 @@ (guard (e (#t #f)) (def-var-with-meta! "clojure.edn" "read-string" (letrec ((read-string (case-lambda ((s) (let fnrec2417 ((s s)) (jolt-invoke (var-deref "clojure.edn" "read-edn") (jolt-hash-map) s))) ((opts s) (let fnrec2418 ((opts opts) (s s)) (jolt-invoke (var-deref "clojure.edn" "read-edn") opts s)))))) read-string) (let* ((_o$2419 (keyword #f "doc")) (_o$2420 "Reads one object from the string s. Returns the :eof option value (default\n nil) for nil or blank input. opts is an options map; :eof sets the value\n returned at end of input.")) (jolt-hash-map _o$2419 _o$2420)))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.edn" "drain-reader" (letrec ((drain-reader (lambda (reader) (let fnrec2421 ((reader reader)) (let* ((acc (jolt-invoke (var-deref "clojure.core" "transient") (jolt-vector))) (c (record-method-dispatch reader "read" (jolt-vector)))) (let loop2422 ((acc acc) (c c)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "==") -1 c)) (jolt-apply (var-deref "clojure.core" "str") (jolt-map (var-deref "clojure.core" "char") (jolt-invoke (var-deref "clojure.core" "persistent!") acc))) (let* ((_a$2423 (jolt-invoke (var-deref "clojure.core" "conj!") acc c)) (_a$2424 (record-method-dispatch reader "read" (jolt-vector)))) (loop2422 _a$2423 _a$2424))))))))) drain-reader) (let* ((_o$2425 (keyword #f "doc")) (_o$2426 "All remaining content of a reader as a string. Shim readers (StringReader,\n PushbackReader, io/reader results) expose char-wise .read; a raw file\n handle is read whole.") (_o$2427 (keyword #f "private")) (_o$2428 #t)) (jolt-hash-map _o$2425 _o$2426 _o$2427 _o$2428)))) + (def-var-with-meta! "clojure.edn" "drain-reader" (letrec ((drain-reader (lambda (reader) (let fnrec2421 ((reader reader)) (let* ((acc (jolt-invoke (var-deref "clojure.core" "transient") (jolt-vector))) (c (record-method-dispatch reader "read" (jolt-vector)))) (let loop2422 ((acc acc) (c c)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "==") -1 c)) (jolt-apply (var-deref "clojure.core" "str") (jolt-map (var-deref "clojure.core" "char") (jolt-invoke (var-deref "clojure.core" "persistent!") acc))) (let* ((_a$2423 (jolt-invoke (var-deref "clojure.core" "conj!") acc c)) (_a$2424 (record-method-dispatch reader "read" (jolt-vector)))) (loop2422 _a$2423 _a$2424))))))))) drain-reader) (let* ((_o$2425 (keyword #f "private")) (_o$2426 #t) (_o$2427 (keyword #f "doc")) (_o$2428 "All remaining content of a reader as a string. Shim readers (StringReader,\n PushbackReader, io/reader results) expose char-wise .read; a raw file\n handle is read whole.")) (jolt-hash-map _o$2425 _o$2426 _o$2427 _o$2428)))) (guard (e (#t #f)) (def-var-with-meta! "clojure.edn" "read" (letrec ((read (case-lambda ((reader) (let fnrec2429 ((reader reader)) (read (jolt-hash-map) reader))) ((opts reader) (let fnrec2430 ((opts opts) (reader reader)) (jolt-invoke (var-deref "clojure.edn" "read-edn") opts (jolt-invoke (var-deref "clojure.edn" "drain-reader") reader))))))) read) (let* ((_o$2431 (keyword #f "doc")) (_o$2432 "Reads one EDN object from reader (a PushbackReader or any jolt reader).\n Returns the :eof option value (default nil) at end of input.")) (jolt-hash-map _o$2431 _o$2432)))) (guard (e (#t #f)) @@ -1108,7 +1108,7 @@ (mark-macro! "clojure.pprint" "deftype")) (guard (e (#t #f)) (def-var! "clojure.pprint" "pprint-logical-block" - (lambda args (let fnrec129 ((args (list->cseq args))) (let* ((G__9 (let* ((body args) (acc (jolt-vector))) (let loop130 ((body body) (acc acc)) (if (jolt-truthy? (let* ((_a$134 (let* ((_o$131 (keyword #f "prefix")) (_o$132 (keyword #f "per-line-prefix")) (_o$133 (keyword #f "suffix"))) (jolt-hash-set _o$131 _o$132 _o$133))) (_a$135 (jolt-first body))) (jolt-get _a$134 _a$135))) (let* ((_a$136 (jolt-drop 2 body)) (_a$137 (jolt-concat acc (jolt-take 2 body)))) (loop130 _a$136 _a$137)) (let* ((_o$138 (jolt-apply jolt-hash-map acc)) (_o$139 body)) (jolt-vector _o$138 _o$139)))))) (options (jolt-nth G__9 0 jolt-nil)) (body (jolt-nth G__9 1 jolt-nil))) (let* ((_a$172 (var-deref "clojure.core" "__sqcat")) (_a$173 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$174 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$167 (var-deref "clojure.core" "__sqcat")) (_a$168 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$169 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "level-exceeded"))))) (_a$170 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$140 (var-deref "clojure.core" "__sqcat")) (_a$141 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "-write"))) (_a$142 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "*out*"))) (_a$143 (jolt-invoke (var-deref "clojure.core" "__sq1") "#"))) (jolt-invoke _a$140 _a$141 _a$142 _a$143)))) (_a$171 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$161 (var-deref "clojure.core" "__sqcat")) (_a$162 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "binding"))) (_a$163 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$147 (var-deref "clojure.core" "__sqvec")) (_a$148 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "*current-level*"))) (_a$149 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$144 (var-deref "clojure.core" "__sqcat")) (_a$145 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "inc"))) (_a$146 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "*current-level*")))) (jolt-invoke _a$144 _a$145 _a$146)))) (_a$150 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "*current-length*"))) (_a$151 (jolt-invoke (var-deref "clojure.core" "__sq1") 0))) (jolt-invoke _a$147 _a$148 _a$149 _a$150 _a$151)))) (_a$164 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$152 (var-deref "clojure.core" "__sqcat")) (_a$153 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "start-block"))) (_a$154 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "*out*"))) (_a$155 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-get options (keyword #f "prefix")))) (_a$156 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-get options (keyword #f "per-line-prefix")))) (_a$157 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-get options (keyword #f "suffix"))))) (jolt-invoke _a$152 _a$153 _a$154 _a$155 _a$156 _a$157)))) (_a$165 body) (_a$166 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$158 (var-deref "clojure.core" "__sqcat")) (_a$159 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "end-block"))) (_a$160 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "*out*")))) (jolt-invoke _a$158 _a$159 _a$160))))) (jolt-invoke _a$161 _a$162 _a$163 _a$164 _a$165 _a$166))))) (jolt-invoke _a$167 _a$168 _a$169 _a$170 _a$171)))) (_a$175 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$172 _a$173 _a$174 _a$175)))))) + (lambda args (let fnrec129 ((args (list->cseq args))) (let* ((G__9 (let* ((body args) (acc (jolt-vector))) (let loop130 ((body body) (acc acc)) (if (jolt-truthy? (let* ((_a$134 (let* ((_o$131 (keyword #f "prefix")) (_o$132 (keyword #f "per-line-prefix")) (_o$133 (keyword #f "suffix"))) (jolt-hash-set _o$131 _o$132 _o$133))) (_a$135 (jolt-first body))) (jolt-get _a$134 _a$135))) (let* ((_a$136 (jolt-drop 2 body)) (_a$137 (jolt-concat acc (jolt-take 2 body)))) (loop130 _a$136 _a$137)) (let* ((_o$138 (jolt-apply jolt-hash-map-fn acc)) (_o$139 body)) (jolt-vector _o$138 _o$139)))))) (options (jolt-nth G__9 0 jolt-nil)) (body (jolt-nth G__9 1 jolt-nil))) (let* ((_a$172 (var-deref "clojure.core" "__sqcat")) (_a$173 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$174 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$167 (var-deref "clojure.core" "__sqcat")) (_a$168 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$169 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "level-exceeded"))))) (_a$170 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$140 (var-deref "clojure.core" "__sqcat")) (_a$141 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "-write"))) (_a$142 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "*out*"))) (_a$143 (jolt-invoke (var-deref "clojure.core" "__sq1") "#"))) (jolt-invoke _a$140 _a$141 _a$142 _a$143)))) (_a$171 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$161 (var-deref "clojure.core" "__sqcat")) (_a$162 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "binding"))) (_a$163 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$147 (var-deref "clojure.core" "__sqvec")) (_a$148 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "*current-level*"))) (_a$149 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$144 (var-deref "clojure.core" "__sqcat")) (_a$145 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "inc"))) (_a$146 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "*current-level*")))) (jolt-invoke _a$144 _a$145 _a$146)))) (_a$150 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "*current-length*"))) (_a$151 (jolt-invoke (var-deref "clojure.core" "__sq1") 0))) (jolt-invoke _a$147 _a$148 _a$149 _a$150 _a$151)))) (_a$164 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$152 (var-deref "clojure.core" "__sqcat")) (_a$153 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "start-block"))) (_a$154 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "*out*"))) (_a$155 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-get options (keyword #f "prefix")))) (_a$156 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-get options (keyword #f "per-line-prefix")))) (_a$157 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-get options (keyword #f "suffix"))))) (jolt-invoke _a$152 _a$153 _a$154 _a$155 _a$156 _a$157)))) (_a$165 body) (_a$166 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$158 (var-deref "clojure.core" "__sqcat")) (_a$159 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.pprint" "end-block"))) (_a$160 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "*out*")))) (jolt-invoke _a$158 _a$159 _a$160))))) (jolt-invoke _a$161 _a$162 _a$163 _a$164 _a$165 _a$166))))) (jolt-invoke _a$167 _a$168 _a$169 _a$170 _a$171)))) (_a$175 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$172 _a$173 _a$174 _a$175)))))) (mark-macro! "clojure.pprint" "pprint-logical-block")) (guard (e (#t #f)) (def-var! "clojure.pprint" "print-length-loop" @@ -1161,9 +1161,9 @@ (guard (e (#t #f)) (begin (def-var! "clojure.pprint" "IPrettyFlush" (jolt-invoke (var-deref "clojure.core" "make-protocol") "IPrettyFlush" (let* ((_o$352 (keyword #f "-ppflush")) (_o$353 (let* ((_o$350 (keyword #f "name")) (_o$351 "-ppflush")) (jolt-hash-map _o$350 _o$351)))) (jolt-hash-map _o$352 _o$353)))) (jolt-invoke (var-deref "clojure.core" "register-protocol-methods!") "IPrettyFlush" (jolt-vector "-ppflush")) (def-var! "clojure.pprint" "-ppflush" (lambda (G__22) (let fnrec354 ((G__22 G__22)) (protocol-dispatch1 "IPrettyFlush" "-ppflush" G__22)))))) (guard (e (#t #f)) - (begin (def-var! "clojure.pprint" "IPrettyWriter" (jolt-invoke (var-deref "clojure.core" "make-protocol") "IPrettyWriter" (let* ((_o$359 (keyword #f "-pflush")) (_o$360 (let* ((_o$355 (keyword #f "name")) (_o$356 "-pflush")) (jolt-hash-map _o$355 _o$356))) (_o$361 (keyword #f "-write")) (_o$362 (let* ((_o$357 (keyword #f "name")) (_o$358 "-write")) (jolt-hash-map _o$357 _o$358)))) (jolt-hash-map _o$359 _o$360 _o$361 _o$362)))) (jolt-invoke (var-deref "clojure.core" "register-protocol-methods!") "IPrettyWriter" (let* ((_o$363 "-write") (_o$364 "-pflush")) (jolt-vector _o$363 _o$364))) (def-var! "clojure.pprint" "-write" (lambda (G__23 G__24) (let fnrec365 ((G__23 G__23) (G__24 G__24)) (protocol-dispatch2 "IPrettyWriter" "-write" G__23 G__24)))) (def-var! "clojure.pprint" "-pflush" (lambda (G__25) (let fnrec366 ((G__25 G__25)) (protocol-dispatch1 "IPrettyWriter" "-pflush" G__25)))))) + (begin (def-var! "clojure.pprint" "IPrettyWriter" (jolt-invoke (var-deref "clojure.core" "make-protocol") "IPrettyWriter" (let* ((_o$359 (keyword #f "-write")) (_o$360 (let* ((_o$355 (keyword #f "name")) (_o$356 "-write")) (jolt-hash-map _o$355 _o$356))) (_o$361 (keyword #f "-pflush")) (_o$362 (let* ((_o$357 (keyword #f "name")) (_o$358 "-pflush")) (jolt-hash-map _o$357 _o$358)))) (jolt-hash-map _o$359 _o$360 _o$361 _o$362)))) (jolt-invoke (var-deref "clojure.core" "register-protocol-methods!") "IPrettyWriter" (let* ((_o$363 "-write") (_o$364 "-pflush")) (jolt-vector _o$363 _o$364))) (def-var! "clojure.pprint" "-write" (lambda (G__23 G__24) (let fnrec365 ((G__23 G__23) (G__24 G__24)) (protocol-dispatch2 "IPrettyWriter" "-write" G__23 G__24)))) (def-var! "clojure.pprint" "-pflush" (lambda (G__25) (let fnrec366 ((G__25 G__25)) (protocol-dispatch1 "IPrettyWriter" "-pflush" G__25)))))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.pprint" "*default-page-width*" 72 (let* ((_o$367 (keyword #f "dynamic")) (_o$368 #t) (_o$369 (keyword #f "private")) (_o$370 #t)) (jolt-hash-map _o$367 _o$368 _o$369 _o$370)))) + (def-var-with-meta! "clojure.pprint" "*default-page-width*" 72 (let* ((_o$367 (keyword #f "private")) (_o$368 #t) (_o$369 (keyword #f "dynamic")) (_o$370 #t)) (jolt-hash-map _o$367 _o$368 _o$369 _o$370)))) (guard (e (#t #f)) (def-var-with-meta! "clojure.pprint" "get-field" (letrec ((get-field (lambda (this sym) (let fnrec371 ((this this) (sym sym)) (jolt-invoke sym (jolt-invoke (var-deref "clojure.core" "deref") (record-method-dispatch this "-fields" (jolt-vector)))))))) get-field) (let* ((_o$372 (keyword #f "private")) (_o$373 #t)) (jolt-hash-map _o$372 _o$373)))) (guard (e (#t #f)) @@ -1285,11 +1285,11 @@ (guard (e (#t #f)) (def-var-with-meta! "clojure.pprint" "*print-miser-width*" 40 (let* ((_o$900 (keyword #f "dynamic")) (_o$901 #t)) (jolt-hash-map _o$900 _o$901)))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.pprint" "*print-lines*" jolt-nil (let* ((_o$902 (keyword #f "dynamic")) (_o$903 #t) (_o$904 (keyword #f "private")) (_o$905 #t)) (jolt-hash-map _o$902 _o$903 _o$904 _o$905)))) + (def-var-with-meta! "clojure.pprint" "*print-lines*" jolt-nil (let* ((_o$902 (keyword #f "private")) (_o$903 #t) (_o$904 (keyword #f "dynamic")) (_o$905 #t)) (jolt-hash-map _o$902 _o$903 _o$904 _o$905)))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.pprint" "*print-circle*" jolt-nil (let* ((_o$906 (keyword #f "dynamic")) (_o$907 #t) (_o$908 (keyword #f "private")) (_o$909 #t)) (jolt-hash-map _o$906 _o$907 _o$908 _o$909)))) + (def-var-with-meta! "clojure.pprint" "*print-circle*" jolt-nil (let* ((_o$906 (keyword #f "private")) (_o$907 #t) (_o$908 (keyword #f "dynamic")) (_o$909 #t)) (jolt-hash-map _o$906 _o$907 _o$908 _o$909)))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.pprint" "*print-shared*" jolt-nil (let* ((_o$910 (keyword #f "dynamic")) (_o$911 #t) (_o$912 (keyword #f "private")) (_o$913 #t)) (jolt-hash-map _o$910 _o$911 _o$912 _o$913)))) + (def-var-with-meta! "clojure.pprint" "*print-shared*" jolt-nil (let* ((_o$910 (keyword #f "private")) (_o$911 #t) (_o$912 (keyword #f "dynamic")) (_o$913 #t)) (jolt-hash-map _o$910 _o$911 _o$912 _o$913)))) (guard (e (#t #f)) (def-var-with-meta! "clojure.pprint" "*print-suppress-namespaces*" jolt-nil (let* ((_o$914 (keyword #f "dynamic")) (_o$915 #t)) (jolt-hash-map _o$914 _o$915)))) (guard (e (#t #f)) @@ -1297,9 +1297,9 @@ (guard (e (#t #f)) (def-var-with-meta! "clojure.pprint" "*print-base*" 10 (let* ((_o$918 (keyword #f "dynamic")) (_o$919 #t)) (jolt-hash-map _o$918 _o$919)))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.pprint" "*current-level*" 0 (let* ((_o$920 (keyword #f "dynamic")) (_o$921 #t) (_o$922 (keyword #f "private")) (_o$923 #t)) (jolt-hash-map _o$920 _o$921 _o$922 _o$923)))) + (def-var-with-meta! "clojure.pprint" "*current-level*" 0 (let* ((_o$920 (keyword #f "private")) (_o$921 #t) (_o$922 (keyword #f "dynamic")) (_o$923 #t)) (jolt-hash-map _o$920 _o$921 _o$922 _o$923)))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.pprint" "*current-length*" jolt-nil (let* ((_o$924 (keyword #f "dynamic")) (_o$925 #t) (_o$926 (keyword #f "private")) (_o$927 #t)) (jolt-hash-map _o$924 _o$925 _o$926 _o$927)))) + (def-var-with-meta! "clojure.pprint" "*current-length*" jolt-nil (let* ((_o$924 (keyword #f "private")) (_o$925 #t) (_o$926 (keyword #f "dynamic")) (_o$927 #t)) (jolt-hash-map _o$924 _o$925 _o$926 _o$927)))) (guard (e (#t #f)) (def-var-with-meta! "clojure.pprint" "*print-length*" jolt-nil (let* ((_o$928 (keyword #f "dynamic")) (_o$929 #t)) (jolt-hash-map _o$928 _o$929)))) (guard (e (#t #f)) @@ -1317,7 +1317,7 @@ (guard (e (#t #f)) (def-var-with-meta! "clojure.pprint" "write-out" (letrec ((write-out (lambda (object) (let fnrec982 ((object object)) (let* ((length-reached (let* ((and__25__auto (var-deref "clojure.pprint" "*current-length*"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (var-deref "clojure.pprint" "*print-length*"))) (if (jolt-truthy? and__25__auto) (>= (var-deref "clojure.pprint" "*current-length*") (var-deref "clojure.pprint" "*print-length*")) and__25__auto)) and__25__auto)))) (begin (if (jolt-not (var-deref "clojure.pprint" "*print-pretty*")) (jolt-invoke (var-deref "clojure.pprint" "pr") object) (if (jolt-truthy? length-reached) (jolt-invoke (var-deref "clojure.pprint" "-write") (var-deref "clojure.core" "*out*") "...") (begin (if (jolt-truthy? (var-deref "clojure.pprint" "*current-length*")) (jolt-var-set (jolt-var "clojure.pprint" "*current-length*") (jolt-inc (var-deref "clojure.pprint" "*current-length*"))) jolt-nil) (jolt-invoke (var-deref "clojure.pprint" "*print-pprint-dispatch*") object)))) length-reached)))))) write-out) (let* ((_o$983 (keyword #f "doc")) (_o$984 "Write an object to *out* subject to the current bindings of the printer control\n variables. *out* must be a PrettyWriter when pretty printing is enabled.")) (jolt-hash-map _o$983 _o$984)))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.pprint" "write" (letrec ((write (lambda (object . kw-args) (let fnrec985 ((object object) (kw-args (list->cseq kw-args))) (let* ((options (let* ((_a$988 (var-deref "clojure.core" "merge")) (_a$989 (let* ((_o$986 (keyword #f "stream")) (_o$987 #t)) (jolt-hash-map _o$986 _o$987))) (_a$990 (jolt-apply jolt-hash-map kw-args))) (jolt-invoke _a$988 _a$989 _a$990)))) (let* ((frame__20__auto (let* ((_a$991 (var-deref "clojure.core" "array-map")) (_a$992 (jolt-var "clojure.pprint" "*print-base*")) (_a$993 (jolt-get options (keyword #f "base") (var-deref "clojure.pprint" "*print-base*"))) (_a$994 (jolt-var "clojure.pprint" "*print-circle*")) (_a$995 (jolt-get options (keyword #f "circle") (var-deref "clojure.pprint" "*print-circle*"))) (_a$996 (jolt-var "clojure.pprint" "*print-length*")) (_a$997 (jolt-get options (keyword #f "length") (var-deref "clojure.pprint" "*print-length*"))) (_a$998 (jolt-var "clojure.pprint" "*print-level*")) (_a$999 (jolt-get options (keyword #f "level") (var-deref "clojure.pprint" "*print-level*"))) (_a$1000 (jolt-var "clojure.pprint" "*print-lines*")) (_a$1001 (jolt-get options (keyword #f "lines") (var-deref "clojure.pprint" "*print-lines*"))) (_a$1002 (jolt-var "clojure.pprint" "*print-miser-width*")) (_a$1003 (jolt-get options (keyword #f "miser-width") (var-deref "clojure.pprint" "*print-miser-width*"))) (_a$1004 (jolt-var "clojure.pprint" "*print-pprint-dispatch*")) (_a$1005 (jolt-get options (keyword #f "dispatch") (var-deref "clojure.pprint" "*print-pprint-dispatch*"))) (_a$1006 (jolt-var "clojure.pprint" "*print-pretty*")) (_a$1007 (jolt-get options (keyword #f "pretty") (var-deref "clojure.pprint" "*print-pretty*"))) (_a$1008 (jolt-var "clojure.pprint" "*print-radix*")) (_a$1009 (jolt-get options (keyword #f "radix") (var-deref "clojure.pprint" "*print-radix*"))) (_a$1010 (jolt-var "clojure.core" "*print-readably*")) (_a$1011 (jolt-get options (keyword #f "readably") (var-deref "clojure.core" "*print-readably*"))) (_a$1012 (jolt-var "clojure.pprint" "*print-right-margin*")) (_a$1013 (jolt-get options (keyword #f "right-margin") (var-deref "clojure.pprint" "*print-right-margin*"))) (_a$1014 (jolt-var "clojure.pprint" "*print-suppress-namespaces*")) (_a$1015 (jolt-get options (keyword #f "suppress-namespaces") (var-deref "clojure.pprint" "*print-suppress-namespaces*")))) (jolt-invoke _a$991 _a$992 _a$993 _a$994 _a$995 _a$996 _a$997 _a$998 _a$999 _a$1000 _a$1001 _a$1002 _a$1003 _a$1004 _a$1005 _a$1006 _a$1007 _a$1008 _a$1009 _a$1010 _a$1011 _a$1012 _a$1013 _a$1014 _a$1015)))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (let* ((sb (host-new "StringBuilder")) (optval (if (jolt-contains? options (keyword #f "stream")) (jolt-get options (keyword #f "stream")) #t)) (base-writer (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "true?") optval))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-nil? optval)))) (jolt-invoke (var-deref "clojure.pprint" "->StringBufferWriter") sb) optval))) (begin (if (jolt-truthy? (var-deref "clojure.pprint" "*print-pretty*")) (let* ((base-writer__11__auto base-writer) (new-writer__12__auto (jolt-not (jolt-invoke (var-deref "clojure.pprint" "pretty-writer?") base-writer__11__auto)))) (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "clojure.core" "*out*") (if (jolt-truthy? new-writer__12__auto) (jolt-invoke (var-deref "clojure.pprint" "make-pretty-writer") base-writer__11__auto (var-deref "clojure.pprint" "*print-right-margin*") (var-deref "clojure.pprint" "*print-miser-width*")) base-writer__11__auto)))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.core" "__with-pprint-routing") (lambda () (let fnrec1016 () (begin (jolt-invoke (var-deref "clojure.pprint" "write-out") object) (jolt-invoke (var-deref "clojure.pprint" "-ppflush") (var-deref "clojure.core" "*out*"))))))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "clojure.core" "*out*") base-writer))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.pprint" "pr") object)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "true?") optval)) (jolt-invoke (var-deref "clojure.core" "print") (jolt-invoke (var-deref "clojure.core" "str") sb)) jolt-nil) (if (jolt-nil? optval) (jolt-invoke (var-deref "clojure.core" "str") sb) jolt-nil)))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))))))) write) (let* ((_o$1017 (keyword #f "doc")) (_o$1018 "Write an object subject to the current bindings of the printer control\n variables. Returns the string result if :stream is nil, nil otherwise.")) (jolt-hash-map _o$1017 _o$1018)))) + (def-var-with-meta! "clojure.pprint" "write" (letrec ((write (lambda (object . kw-args) (let fnrec985 ((object object) (kw-args (list->cseq kw-args))) (let* ((options (let* ((_a$988 (var-deref "clojure.core" "merge")) (_a$989 (let* ((_o$986 (keyword #f "stream")) (_o$987 #t)) (jolt-hash-map _o$986 _o$987))) (_a$990 (jolt-apply jolt-hash-map-fn kw-args))) (jolt-invoke _a$988 _a$989 _a$990)))) (let* ((frame__20__auto (let* ((_a$991 (var-deref "clojure.core" "array-map")) (_a$992 (jolt-var "clojure.pprint" "*print-base*")) (_a$993 (jolt-get options (keyword #f "base") (var-deref "clojure.pprint" "*print-base*"))) (_a$994 (jolt-var "clojure.pprint" "*print-circle*")) (_a$995 (jolt-get options (keyword #f "circle") (var-deref "clojure.pprint" "*print-circle*"))) (_a$996 (jolt-var "clojure.pprint" "*print-length*")) (_a$997 (jolt-get options (keyword #f "length") (var-deref "clojure.pprint" "*print-length*"))) (_a$998 (jolt-var "clojure.pprint" "*print-level*")) (_a$999 (jolt-get options (keyword #f "level") (var-deref "clojure.pprint" "*print-level*"))) (_a$1000 (jolt-var "clojure.pprint" "*print-lines*")) (_a$1001 (jolt-get options (keyword #f "lines") (var-deref "clojure.pprint" "*print-lines*"))) (_a$1002 (jolt-var "clojure.pprint" "*print-miser-width*")) (_a$1003 (jolt-get options (keyword #f "miser-width") (var-deref "clojure.pprint" "*print-miser-width*"))) (_a$1004 (jolt-var "clojure.pprint" "*print-pprint-dispatch*")) (_a$1005 (jolt-get options (keyword #f "dispatch") (var-deref "clojure.pprint" "*print-pprint-dispatch*"))) (_a$1006 (jolt-var "clojure.pprint" "*print-pretty*")) (_a$1007 (jolt-get options (keyword #f "pretty") (var-deref "clojure.pprint" "*print-pretty*"))) (_a$1008 (jolt-var "clojure.pprint" "*print-radix*")) (_a$1009 (jolt-get options (keyword #f "radix") (var-deref "clojure.pprint" "*print-radix*"))) (_a$1010 (jolt-var "clojure.core" "*print-readably*")) (_a$1011 (jolt-get options (keyword #f "readably") (var-deref "clojure.core" "*print-readably*"))) (_a$1012 (jolt-var "clojure.pprint" "*print-right-margin*")) (_a$1013 (jolt-get options (keyword #f "right-margin") (var-deref "clojure.pprint" "*print-right-margin*"))) (_a$1014 (jolt-var "clojure.pprint" "*print-suppress-namespaces*")) (_a$1015 (jolt-get options (keyword #f "suppress-namespaces") (var-deref "clojure.pprint" "*print-suppress-namespaces*")))) (jolt-invoke _a$991 _a$992 _a$993 _a$994 _a$995 _a$996 _a$997 _a$998 _a$999 _a$1000 _a$1001 _a$1002 _a$1003 _a$1004 _a$1005 _a$1006 _a$1007 _a$1008 _a$1009 _a$1010 _a$1011 _a$1012 _a$1013 _a$1014 _a$1015)))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (let* ((sb (host-new "StringBuilder")) (optval (if (jolt-contains? options (keyword #f "stream")) (jolt-get options (keyword #f "stream")) #t)) (base-writer (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "true?") optval))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-nil? optval)))) (jolt-invoke (var-deref "clojure.pprint" "->StringBufferWriter") sb) optval))) (begin (if (jolt-truthy? (var-deref "clojure.pprint" "*print-pretty*")) (let* ((base-writer__11__auto base-writer) (new-writer__12__auto (jolt-not (jolt-invoke (var-deref "clojure.pprint" "pretty-writer?") base-writer__11__auto)))) (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "clojure.core" "*out*") (if (jolt-truthy? new-writer__12__auto) (jolt-invoke (var-deref "clojure.pprint" "make-pretty-writer") base-writer__11__auto (var-deref "clojure.pprint" "*print-right-margin*") (var-deref "clojure.pprint" "*print-miser-width*")) base-writer__11__auto)))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.core" "__with-pprint-routing") (lambda () (let fnrec1016 () (begin (jolt-invoke (var-deref "clojure.pprint" "write-out") object) (jolt-invoke (var-deref "clojure.pprint" "-ppflush") (var-deref "clojure.core" "*out*"))))))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "clojure.core" "*out*") base-writer))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.pprint" "pr") object)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "true?") optval)) (jolt-invoke (var-deref "clojure.core" "print") (jolt-invoke (var-deref "clojure.core" "str") sb)) jolt-nil) (if (jolt-nil? optval) (jolt-invoke (var-deref "clojure.core" "str") sb) jolt-nil)))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))))))) write) (let* ((_o$1017 (keyword #f "doc")) (_o$1018 "Write an object subject to the current bindings of the printer control\n variables. Returns the string result if :stream is nil, nil otherwise.")) (jolt-hash-map _o$1017 _o$1018)))) (guard (e (#t #f)) (def-var-with-meta! "clojure.pprint" "pprint" (letrec ((pprint (case-lambda ((object) (let fnrec1019 ((object object)) (let* ((sb (host-new "StringBuilder"))) (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "clojure.core" "*out*") (jolt-invoke (var-deref "clojure.pprint" "->StringBufferWriter") sb)))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (begin (pprint object (var-deref "clojure.core" "*out*")) (jolt-invoke (var-deref "clojure.core" "print") (jolt-invoke (var-deref "clojure.core" "str") sb)))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))))) ((object writer) (let fnrec1020 ((object object) (writer writer)) (let* ((base-writer__11__auto writer) (new-writer__12__auto (jolt-not (jolt-invoke (var-deref "clojure.pprint" "pretty-writer?") base-writer__11__auto)))) (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "clojure.core" "*out*") (if (jolt-truthy? new-writer__12__auto) (jolt-invoke (var-deref "clojure.pprint" "make-pretty-writer") base-writer__11__auto (var-deref "clojure.pprint" "*print-right-margin*") (var-deref "clojure.pprint" "*print-miser-width*")) base-writer__11__auto)))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.core" "__with-pprint-routing") (lambda () (let fnrec1021 () (begin (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "clojure.pprint" "*print-pretty*") #t))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.pprint" "write-out") object)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))) (if (jolt-not (jolt= 0 (jolt-invoke (var-deref "clojure.pprint" "get-column") (var-deref "clojure.core" "*out*")))) (jolt-invoke (var-deref "clojure.pprint" "-write") (var-deref "clojure.core" "*out*") "\n") jolt-nil) (jolt-invoke (var-deref "clojure.pprint" "-ppflush") (var-deref "clojure.core" "*out*"))))))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))))))))) pprint) (let* ((_o$1022 (keyword #f "doc")) (_o$1023 "Pretty print object. With one arg, prints to *out* (captured by with-out-str).\n The 2-arg form writes to the supplied pretty-writer.")) (jolt-hash-map _o$1022 _o$1023)))) (guard (e (#t #f)) @@ -1341,7 +1341,7 @@ (guard (e (#t #f)) (def-var-with-meta! "clojure.pprint" "cl-format" (letrec ((cl-format (lambda (writer format-in . args) (let fnrec1048 ((writer writer) (format-in format-in) (args (list->cseq args))) (let* ((compiled-format (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") format-in)) (jolt-invoke (var-deref "clojure.pprint" "compile-format") format-in) format-in)) (navigator (jolt-invoke (var-deref "clojure.pprint" "init-navigator") args))) (jolt-invoke (var-deref "clojure.pprint" "execute-format") writer compiled-format navigator)))))) cl-format) (let* ((_o$1049 (keyword #f "doc")) (_o$1050 "A Common Lisp compatible format function. If writer is nil, returns the\n formatted string; if true, prints to *out*; otherwise writes to writer.")) (jolt-hash-map _o$1049 _o$1050)))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.pprint" "*format-str*" jolt-nil (let* ((_o$1051 (keyword #f "dynamic")) (_o$1052 #t) (_o$1053 (keyword #f "private")) (_o$1054 #t)) (jolt-hash-map _o$1051 _o$1052 _o$1053 _o$1054)))) + (def-var-with-meta! "clojure.pprint" "*format-str*" jolt-nil (let* ((_o$1051 (keyword #f "private")) (_o$1052 #t) (_o$1053 (keyword #f "dynamic")) (_o$1054 #t)) (jolt-hash-map _o$1051 _o$1052 _o$1053 _o$1054)))) (guard (e (#t #f)) (def-var-with-meta! "clojure.pprint" "format-error" (letrec ((format-error (lambda (message offset) (let fnrec1055 ((message message) (offset offset)) (let* ((full-message (jolt-invoke (var-deref "clojure.core" "str") message "\n" (var-deref "clojure.pprint" "*format-str*") "\n" (jolt-apply (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "repeat") offset (integer->char 32))) "^" "\n"))) (jolt-throw (host-new "Exception" full-message))))))) format-error) (let* ((_o$1056 (keyword #f "private")) (_o$1057 #t)) (jolt-hash-map _o$1056 _o$1057)))) (guard (e (#t #f)) @@ -1433,7 +1433,7 @@ (lambda directives (let fnrec1379 ((directives (list->cseq directives))) (let* ((process (lambda (G__73) (let fnrec1380 ((G__73 G__73)) (let* ((G__74 G__73) (char (jolt-nth G__74 0 jolt-nil)) (params (jolt-nth G__74 1 jolt-nil)) (flags (jolt-nth G__74 2 jolt-nil)) (bracket-info (jolt-nth G__74 3 jolt-nil)) (generator-fn (jolt-invoke (var-deref "clojure.core" "nthnext") G__74 4))) (let* ((_o$1391 char) (_o$1392 (let* ((_o$1381 (keyword #f "directive")) (_o$1382 char) (_o$1383 (keyword #f "params")) (_o$1384 (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "array-map")) params)) (_o$1385 (keyword #f "flags")) (_o$1386 flags) (_o$1387 (keyword #f "bracket-info")) (_o$1388 bracket-info) (_o$1389 (keyword #f "generator-fn")) (_o$1390 (jolt-concat (jolt-list (jolt-symbol #f "fn") (jolt-vector (jolt-symbol #f "params") (jolt-symbol #f "offset"))) generator-fn))) (jolt-hash-map _o$1381 _o$1382 _o$1383 _o$1384 _o$1385 _o$1386 _o$1387 _o$1388 _o$1389 _o$1390)))) (jolt-vector _o$1391 _o$1392))))))) (let* ((_a$1396 (var-deref "clojure.core" "__sqcat")) (_a$1397 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1398 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "directive-table"))) (_a$1399 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1393 (var-deref "clojure.core" "__sqcat")) (_a$1394 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "hash-map"))) (_a$1395 (jolt-invoke (var-deref "clojure.core" "mapcat") process directives))) (jolt-invoke _a$1393 _a$1394 _a$1395))))) (jolt-invoke _a$1396 _a$1397 _a$1398 _a$1399)))))) (mark-macro! "clojure.pprint" "defdirectives")) (guard (e (#t #f)) - (def-var! "clojure.pprint" "directive-table" (let* ((_a$1952 (integer->char 65)) (_a$1953 (let* ((_o$1422 (keyword #f "bracket-info")) (_o$1423 (jolt-hash-map)) (_o$1424 (keyword #f "flags")) (_o$1425 (let* ((_o$1400 (keyword #f "at")) (_o$1401 (keyword #f "colon")) (_o$1402 (keyword #f "both"))) (jolt-hash-set _o$1400 _o$1401 _o$1402))) (_o$1426 (keyword #f "generator-fn")) (_o$1427 (lambda (params offset) (let fnrec1403 ((params params) (offset offset)) (lambda (p__11_ p__12_ p__13_) (let fnrec1404 ((p__11_ p__11_) (p__12_ p__12_) (p__13_ p__13_)) (jolt-invoke (var-deref "clojure.pprint" "format-ascii") (var-deref "clojure.core" "print-str") p__11_ p__12_ p__13_)))))) (_o$1428 (keyword #f "directive")) (_o$1429 (integer->char 65)) (_o$1430 (keyword #f "params")) (_o$1431 (let* ((_a$1413 (var-deref "clojure.core" "array-map")) (_a$1414 (keyword #f "mincol")) (_a$1415 (let* ((_o$1405 0) (_o$1406 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1405 _o$1406))) (_a$1416 (keyword #f "colinc")) (_a$1417 (let* ((_o$1407 1) (_o$1408 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1407 _o$1408))) (_a$1418 (keyword #f "minpad")) (_a$1419 (let* ((_o$1409 0) (_o$1410 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1409 _o$1410))) (_a$1420 (keyword #f "padchar")) (_a$1421 (let* ((_o$1411 (integer->char 32)) (_o$1412 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1411 _o$1412)))) (jolt-invoke _a$1413 _a$1414 _a$1415 _a$1416 _a$1417 _a$1418 _a$1419 _a$1420 _a$1421)))) (jolt-hash-map _o$1422 _o$1423 _o$1424 _o$1425 _o$1426 _o$1427 _o$1428 _o$1429 _o$1430 _o$1431))) (_a$1954 (integer->char 83)) (_a$1955 (let* ((_o$1454 (keyword #f "bracket-info")) (_o$1455 (jolt-hash-map)) (_o$1456 (keyword #f "flags")) (_o$1457 (let* ((_o$1432 (keyword #f "at")) (_o$1433 (keyword #f "colon")) (_o$1434 (keyword #f "both"))) (jolt-hash-set _o$1432 _o$1433 _o$1434))) (_o$1458 (keyword #f "generator-fn")) (_o$1459 (lambda (params offset) (let fnrec1435 ((params params) (offset offset)) (lambda (p__14_ p__15_ p__16_) (let fnrec1436 ((p__14_ p__14_) (p__15_ p__15_) (p__16_ p__16_)) (jolt-invoke (var-deref "clojure.pprint" "format-ascii") (var-deref "clojure.core" "pr-str") p__14_ p__15_ p__16_)))))) (_o$1460 (keyword #f "directive")) (_o$1461 (integer->char 83)) (_o$1462 (keyword #f "params")) (_o$1463 (let* ((_a$1445 (var-deref "clojure.core" "array-map")) (_a$1446 (keyword #f "mincol")) (_a$1447 (let* ((_o$1437 0) (_o$1438 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1437 _o$1438))) (_a$1448 (keyword #f "colinc")) (_a$1449 (let* ((_o$1439 1) (_o$1440 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1439 _o$1440))) (_a$1450 (keyword #f "minpad")) (_a$1451 (let* ((_o$1441 0) (_o$1442 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1441 _o$1442))) (_a$1452 (keyword #f "padchar")) (_a$1453 (let* ((_o$1443 (integer->char 32)) (_o$1444 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1443 _o$1444)))) (jolt-invoke _a$1445 _a$1446 _a$1447 _a$1448 _a$1449 _a$1450 _a$1451 _a$1452 _a$1453)))) (jolt-hash-map _o$1454 _o$1455 _o$1456 _o$1457 _o$1458 _o$1459 _o$1460 _o$1461 _o$1462 _o$1463))) (_a$1956 (integer->char 68)) (_a$1957 (let* ((_o$1486 (keyword #f "bracket-info")) (_o$1487 (jolt-hash-map)) (_o$1488 (keyword #f "flags")) (_o$1489 (let* ((_o$1464 (keyword #f "at")) (_o$1465 (keyword #f "colon")) (_o$1466 (keyword #f "both"))) (jolt-hash-set _o$1464 _o$1465 _o$1466))) (_o$1490 (keyword #f "generator-fn")) (_o$1491 (lambda (params offset) (let fnrec1467 ((params params) (offset offset)) (lambda (p__17_ p__18_ p__19_) (let fnrec1468 ((p__17_ p__17_) (p__18_ p__18_) (p__19_ p__19_)) (jolt-invoke (var-deref "clojure.pprint" "format-integer") 10 p__17_ p__18_ p__19_)))))) (_o$1492 (keyword #f "directive")) (_o$1493 (integer->char 68)) (_o$1494 (keyword #f "params")) (_o$1495 (let* ((_a$1477 (var-deref "clojure.core" "array-map")) (_a$1478 (keyword #f "mincol")) (_a$1479 (let* ((_o$1469 0) (_o$1470 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1469 _o$1470))) (_a$1480 (keyword #f "padchar")) (_a$1481 (let* ((_o$1471 (integer->char 32)) (_o$1472 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1471 _o$1472))) (_a$1482 (keyword #f "commachar")) (_a$1483 (let* ((_o$1473 (integer->char 44)) (_o$1474 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1473 _o$1474))) (_a$1484 (keyword #f "commainterval")) (_a$1485 (let* ((_o$1475 3) (_o$1476 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1475 _o$1476)))) (jolt-invoke _a$1477 _a$1478 _a$1479 _a$1480 _a$1481 _a$1482 _a$1483 _a$1484 _a$1485)))) (jolt-hash-map _o$1486 _o$1487 _o$1488 _o$1489 _o$1490 _o$1491 _o$1492 _o$1493 _o$1494 _o$1495))) (_a$1958 (integer->char 66)) (_a$1959 (let* ((_o$1518 (keyword #f "bracket-info")) (_o$1519 (jolt-hash-map)) (_o$1520 (keyword #f "flags")) (_o$1521 (let* ((_o$1496 (keyword #f "at")) (_o$1497 (keyword #f "colon")) (_o$1498 (keyword #f "both"))) (jolt-hash-set _o$1496 _o$1497 _o$1498))) (_o$1522 (keyword #f "generator-fn")) (_o$1523 (lambda (params offset) (let fnrec1499 ((params params) (offset offset)) (lambda (p__20_ p__21_ p__22_) (let fnrec1500 ((p__20_ p__20_) (p__21_ p__21_) (p__22_ p__22_)) (jolt-invoke (var-deref "clojure.pprint" "format-integer") 2 p__20_ p__21_ p__22_)))))) (_o$1524 (keyword #f "directive")) (_o$1525 (integer->char 66)) (_o$1526 (keyword #f "params")) (_o$1527 (let* ((_a$1509 (var-deref "clojure.core" "array-map")) (_a$1510 (keyword #f "mincol")) (_a$1511 (let* ((_o$1501 0) (_o$1502 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1501 _o$1502))) (_a$1512 (keyword #f "padchar")) (_a$1513 (let* ((_o$1503 (integer->char 32)) (_o$1504 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1503 _o$1504))) (_a$1514 (keyword #f "commachar")) (_a$1515 (let* ((_o$1505 (integer->char 44)) (_o$1506 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1505 _o$1506))) (_a$1516 (keyword #f "commainterval")) (_a$1517 (let* ((_o$1507 3) (_o$1508 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1507 _o$1508)))) (jolt-invoke _a$1509 _a$1510 _a$1511 _a$1512 _a$1513 _a$1514 _a$1515 _a$1516 _a$1517)))) (jolt-hash-map _o$1518 _o$1519 _o$1520 _o$1521 _o$1522 _o$1523 _o$1524 _o$1525 _o$1526 _o$1527))) (_a$1960 (integer->char 79)) (_a$1961 (let* ((_o$1550 (keyword #f "bracket-info")) (_o$1551 (jolt-hash-map)) (_o$1552 (keyword #f "flags")) (_o$1553 (let* ((_o$1528 (keyword #f "at")) (_o$1529 (keyword #f "colon")) (_o$1530 (keyword #f "both"))) (jolt-hash-set _o$1528 _o$1529 _o$1530))) (_o$1554 (keyword #f "generator-fn")) (_o$1555 (lambda (params offset) (let fnrec1531 ((params params) (offset offset)) (lambda (p__23_ p__24_ p__25_) (let fnrec1532 ((p__23_ p__23_) (p__24_ p__24_) (p__25_ p__25_)) (jolt-invoke (var-deref "clojure.pprint" "format-integer") 8 p__23_ p__24_ p__25_)))))) (_o$1556 (keyword #f "directive")) (_o$1557 (integer->char 79)) (_o$1558 (keyword #f "params")) (_o$1559 (let* ((_a$1541 (var-deref "clojure.core" "array-map")) (_a$1542 (keyword #f "mincol")) (_a$1543 (let* ((_o$1533 0) (_o$1534 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1533 _o$1534))) (_a$1544 (keyword #f "padchar")) (_a$1545 (let* ((_o$1535 (integer->char 32)) (_o$1536 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1535 _o$1536))) (_a$1546 (keyword #f "commachar")) (_a$1547 (let* ((_o$1537 (integer->char 44)) (_o$1538 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1537 _o$1538))) (_a$1548 (keyword #f "commainterval")) (_a$1549 (let* ((_o$1539 3) (_o$1540 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1539 _o$1540)))) (jolt-invoke _a$1541 _a$1542 _a$1543 _a$1544 _a$1545 _a$1546 _a$1547 _a$1548 _a$1549)))) (jolt-hash-map _o$1550 _o$1551 _o$1552 _o$1553 _o$1554 _o$1555 _o$1556 _o$1557 _o$1558 _o$1559))) (_a$1962 (integer->char 88)) (_a$1963 (let* ((_o$1582 (keyword #f "bracket-info")) (_o$1583 (jolt-hash-map)) (_o$1584 (keyword #f "flags")) (_o$1585 (let* ((_o$1560 (keyword #f "at")) (_o$1561 (keyword #f "colon")) (_o$1562 (keyword #f "both"))) (jolt-hash-set _o$1560 _o$1561 _o$1562))) (_o$1586 (keyword #f "generator-fn")) (_o$1587 (lambda (params offset) (let fnrec1563 ((params params) (offset offset)) (lambda (p__26_ p__27_ p__28_) (let fnrec1564 ((p__26_ p__26_) (p__27_ p__27_) (p__28_ p__28_)) (jolt-invoke (var-deref "clojure.pprint" "format-integer") 16 p__26_ p__27_ p__28_)))))) (_o$1588 (keyword #f "directive")) (_o$1589 (integer->char 88)) (_o$1590 (keyword #f "params")) (_o$1591 (let* ((_a$1573 (var-deref "clojure.core" "array-map")) (_a$1574 (keyword #f "mincol")) (_a$1575 (let* ((_o$1565 0) (_o$1566 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1565 _o$1566))) (_a$1576 (keyword #f "padchar")) (_a$1577 (let* ((_o$1567 (integer->char 32)) (_o$1568 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1567 _o$1568))) (_a$1578 (keyword #f "commachar")) (_a$1579 (let* ((_o$1569 (integer->char 44)) (_o$1570 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1569 _o$1570))) (_a$1580 (keyword #f "commainterval")) (_a$1581 (let* ((_o$1571 3) (_o$1572 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1571 _o$1572)))) (jolt-invoke _a$1573 _a$1574 _a$1575 _a$1576 _a$1577 _a$1578 _a$1579 _a$1580 _a$1581)))) (jolt-hash-map _o$1582 _o$1583 _o$1584 _o$1585 _o$1586 _o$1587 _o$1588 _o$1589 _o$1590 _o$1591))) (_a$1964 (integer->char 37)) (_a$1965 (let* ((_o$1597 (keyword #f "bracket-info")) (_o$1598 (jolt-hash-map)) (_o$1599 (keyword #f "flags")) (_o$1600 (jolt-hash-set)) (_o$1601 (keyword #f "generator-fn")) (_o$1602 (lambda (params offset) (let fnrec1592 ((params params) (offset offset)) (lambda (params arg-navigator offsets) (let fnrec1593 ((params params) (arg-navigator arg-navigator) (offsets offsets)) (begin (let* ((n__19__auto (jolt-get params (keyword #f "count")))) (let* ((i 0)) (let loop1594 ((i i)) (if (< i n__19__auto) (begin (jolt-invoke (var-deref "clojure.pprint" "prn")) (loop1594 (jolt-inc i))) jolt-nil)))) arg-navigator)))))) (_o$1603 (keyword #f "directive")) (_o$1604 (integer->char 37)) (_o$1605 (keyword #f "params")) (_o$1606 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "count") (let* ((_o$1595 1) (_o$1596 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1595 _o$1596))))) (jolt-hash-map _o$1597 _o$1598 _o$1599 _o$1600 _o$1601 _o$1602 _o$1603 _o$1604 _o$1605 _o$1606))) (_a$1966 (integer->char 38)) (_a$1967 (let* ((_o$1612 (keyword #f "bracket-info")) (_o$1613 (jolt-hash-map)) (_o$1614 (keyword #f "flags")) (_o$1615 (jolt-hash-set (keyword #f "pretty"))) (_o$1616 (keyword #f "generator-fn")) (_o$1617 (lambda (params offset) (let fnrec1607 ((params params) (offset offset)) (lambda (params arg-navigator offsets) (let fnrec1608 ((params params) (arg-navigator arg-navigator) (offsets offsets)) (begin (let* ((cnt (jolt-get params (keyword #f "count")))) (begin (if (jolt-pos? cnt) (jolt-invoke (var-deref "clojure.pprint" "fresh-line")) jolt-nil) (let* ((n__19__auto (jolt-dec cnt))) (let* ((i 0)) (let loop1609 ((i i)) (if (< i n__19__auto) (begin (jolt-invoke (var-deref "clojure.pprint" "prn")) (loop1609 (jolt-inc i))) jolt-nil)))))) arg-navigator)))))) (_o$1618 (keyword #f "directive")) (_o$1619 (integer->char 38)) (_o$1620 (keyword #f "params")) (_o$1621 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "count") (let* ((_o$1610 1) (_o$1611 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1610 _o$1611))))) (jolt-hash-map _o$1612 _o$1613 _o$1614 _o$1615 _o$1616 _o$1617 _o$1618 _o$1619 _o$1620 _o$1621))) (_a$1968 (integer->char 124)) (_a$1969 (let* ((_o$1627 (keyword #f "bracket-info")) (_o$1628 (jolt-hash-map)) (_o$1629 (keyword #f "flags")) (_o$1630 (jolt-hash-set)) (_o$1631 (keyword #f "generator-fn")) (_o$1632 (lambda (params offset) (let fnrec1622 ((params params) (offset offset)) (lambda (params arg-navigator offsets) (let fnrec1623 ((params params) (arg-navigator arg-navigator) (offsets offsets)) (begin (let* ((n__19__auto (jolt-get params (keyword #f "count")))) (let* ((i 0)) (let loop1624 ((i i)) (if (< i n__19__auto) (begin (jolt-invoke (var-deref "clojure.pprint" "print") (integer->char 12)) (loop1624 (jolt-inc i))) jolt-nil)))) arg-navigator)))))) (_o$1633 (keyword #f "directive")) (_o$1634 (integer->char 124)) (_o$1635 (keyword #f "params")) (_o$1636 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "count") (let* ((_o$1625 1) (_o$1626 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1625 _o$1626))))) (jolt-hash-map _o$1627 _o$1628 _o$1629 _o$1630 _o$1631 _o$1632 _o$1633 _o$1634 _o$1635 _o$1636))) (_a$1970 (integer->char 126)) (_a$1971 (let* ((_o$1641 (keyword #f "bracket-info")) (_o$1642 (jolt-hash-map)) (_o$1643 (keyword #f "flags")) (_o$1644 (jolt-hash-set)) (_o$1645 (keyword #f "generator-fn")) (_o$1646 (lambda (params offset) (let fnrec1637 ((params params) (offset offset)) (lambda (params arg-navigator offsets) (let fnrec1638 ((params params) (arg-navigator arg-navigator) (offsets offsets)) (let* ((n (jolt-get params (keyword #f "n")))) (begin (jolt-invoke (var-deref "clojure.pprint" "print") (jolt-apply (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "repeat") n (integer->char 126)))) arg-navigator))))))) (_o$1647 (keyword #f "directive")) (_o$1648 (integer->char 126)) (_o$1649 (keyword #f "params")) (_o$1650 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "n") (let* ((_o$1639 1) (_o$1640 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1639 _o$1640))))) (jolt-hash-map _o$1641 _o$1642 _o$1643 _o$1644 _o$1645 _o$1646 _o$1647 _o$1648 _o$1649 _o$1650))) (_a$1972 (integer->char 10)) (_a$1973 (let* ((_o$1655 (keyword #f "bracket-info")) (_o$1656 (jolt-hash-map)) (_o$1657 (keyword #f "flags")) (_o$1658 (let* ((_o$1651 (keyword #f "colon")) (_o$1652 (keyword #f "at"))) (jolt-hash-set _o$1651 _o$1652))) (_o$1659 (keyword #f "generator-fn")) (_o$1660 (lambda (params offset) (let fnrec1653 ((params params) (offset offset)) (lambda (params arg-navigator offsets) (let fnrec1654 ((params params) (arg-navigator arg-navigator) (offsets offsets)) (begin (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (jolt-invoke (var-deref "clojure.pprint" "prn")) jolt-nil) arg-navigator)))))) (_o$1661 (keyword #f "directive")) (_o$1662 (integer->char 10)) (_o$1663 (keyword #f "params")) (_o$1664 (jolt-invoke (var-deref "clojure.core" "array-map")))) (jolt-hash-map _o$1655 _o$1656 _o$1657 _o$1658 _o$1659 _o$1660 _o$1661 _o$1662 _o$1663 _o$1664))) (_a$1974 (integer->char 84)) (_a$1975 (let* ((_o$1679 (keyword #f "bracket-info")) (_o$1680 (jolt-hash-map)) (_o$1681 (keyword #f "flags")) (_o$1682 (let* ((_o$1665 (keyword #f "at")) (_o$1666 (keyword #f "pretty"))) (jolt-hash-set _o$1665 _o$1666))) (_o$1683 (keyword #f "generator-fn")) (_o$1684 (lambda (params offset) (let fnrec1667 ((params params) (offset offset)) (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (lambda (p__29_ p__30_ p__31_) (let fnrec1668 ((p__29_ p__29_) (p__30_ p__30_) (p__31_ p__31_)) (jolt-invoke (var-deref "clojure.pprint" "relative-tabulation") p__29_ p__30_ p__31_))) (lambda (p__32_ p__33_ p__34_) (let fnrec1669 ((p__32_ p__32_) (p__33_ p__33_) (p__34_ p__34_)) (jolt-invoke (var-deref "clojure.pprint" "absolute-tabulation") p__32_ p__33_ p__34_))))))) (_o$1685 (keyword #f "directive")) (_o$1686 (integer->char 84)) (_o$1687 (keyword #f "params")) (_o$1688 (let* ((_a$1674 (var-deref "clojure.core" "array-map")) (_a$1675 (keyword #f "colnum")) (_a$1676 (let* ((_o$1670 1) (_o$1671 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1670 _o$1671))) (_a$1677 (keyword #f "colinc")) (_a$1678 (let* ((_o$1672 1) (_o$1673 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1672 _o$1673)))) (jolt-invoke _a$1674 _a$1675 _a$1676 _a$1677 _a$1678)))) (jolt-hash-map _o$1679 _o$1680 _o$1681 _o$1682 _o$1683 _o$1684 _o$1685 _o$1686 _o$1687 _o$1688))) (_a$1976 (integer->char 42)) (_a$1977 (let* ((_o$1695 (keyword #f "bracket-info")) (_o$1696 (jolt-hash-map)) (_o$1697 (keyword #f "flags")) (_o$1698 (let* ((_o$1689 (keyword #f "colon")) (_o$1690 (keyword #f "at"))) (jolt-hash-set _o$1689 _o$1690))) (_o$1699 (keyword #f "generator-fn")) (_o$1700 (lambda (params offset) (let fnrec1691 ((params params) (offset offset)) (lambda (params navigator offsets) (let fnrec1692 ((params params) (navigator navigator) (offsets offsets)) (let* ((n (jolt-get params (keyword #f "n")))) (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (jolt-invoke (var-deref "clojure.pprint" "absolute-reposition") navigator n) (jolt-invoke (var-deref "clojure.pprint" "relative-reposition") navigator (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (- n) n))))))))) (_o$1701 (keyword #f "directive")) (_o$1702 (integer->char 42)) (_o$1703 (keyword #f "params")) (_o$1704 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "n") (let* ((_o$1693 1) (_o$1694 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1693 _o$1694))))) (jolt-hash-map _o$1695 _o$1696 _o$1697 _o$1698 _o$1699 _o$1700 _o$1701 _o$1702 _o$1703 _o$1704))) (_a$1978 (integer->char 63)) (_a$1979 (let* ((_o$1708 (keyword #f "bracket-info")) (_o$1709 (jolt-hash-map)) (_o$1710 (keyword #f "flags")) (_o$1711 (jolt-hash-set (keyword #f "at"))) (_o$1712 (keyword #f "generator-fn")) (_o$1713 (lambda (params offset) (let fnrec1705 ((params params) (offset offset)) (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (lambda (params navigator offsets) (let fnrec1706 ((params params) (navigator navigator) (offsets offsets)) (let* ((G__75 (jolt-invoke (var-deref "clojure.pprint" "get-format-arg") navigator)) (subformat (jolt-nth G__75 0 jolt-nil)) (navigator (jolt-nth G__75 1 jolt-nil))) (jolt-invoke (var-deref "clojure.pprint" "execute-sub-format") subformat navigator (jolt-get params (keyword #f "base-args")))))) (lambda (params navigator offsets) (let fnrec1707 ((params params) (navigator navigator) (offsets offsets)) (let* ((G__76 (jolt-invoke (var-deref "clojure.pprint" "get-format-arg") navigator)) (subformat (jolt-nth G__76 0 jolt-nil)) (navigator (jolt-nth G__76 1 jolt-nil)) (G__77 (jolt-invoke (var-deref "clojure.pprint" "next-arg") navigator)) (subargs (jolt-nth G__77 0 jolt-nil)) (navigator (jolt-nth G__77 1 jolt-nil)) (sub-navigator (jolt-invoke (var-deref "clojure.pprint" "init-navigator") subargs))) (begin (jolt-invoke (var-deref "clojure.pprint" "execute-sub-format") subformat sub-navigator (jolt-get params (keyword #f "base-args"))) navigator)))))))) (_o$1714 (keyword #f "directive")) (_o$1715 (integer->char 63)) (_o$1716 (keyword #f "params")) (_o$1717 (jolt-invoke (var-deref "clojure.core" "array-map")))) (jolt-hash-map _o$1708 _o$1709 _o$1710 _o$1711 _o$1712 _o$1713 _o$1714 _o$1715 _o$1716 _o$1717))) (_a$1980 (integer->char 41)) (_a$1981 (let* ((_o$1719 (keyword #f "bracket-info")) (_o$1720 (jolt-hash-map)) (_o$1721 (keyword #f "flags")) (_o$1722 (jolt-hash-set)) (_o$1723 (keyword #f "generator-fn")) (_o$1724 (lambda (params offset) (let fnrec1718 ((params params) (offset offset)) jolt-nil))) (_o$1725 (keyword #f "directive")) (_o$1726 (integer->char 41)) (_o$1727 (keyword #f "params")) (_o$1728 (jolt-invoke (var-deref "clojure.core" "array-map")))) (jolt-hash-map _o$1719 _o$1720 _o$1721 _o$1722 _o$1723 _o$1724 _o$1725 _o$1726 _o$1727 _o$1728))) (_a$1982 (integer->char 91)) (_a$1983 (let* ((_o$1740 (keyword #f "bracket-info")) (_o$1741 (let* ((_o$1729 (keyword #f "right")) (_o$1730 (integer->char 93)) (_o$1731 (keyword #f "allows-separator")) (_o$1732 #t) (_o$1733 (keyword #f "else")) (_o$1734 (keyword #f "last"))) (jolt-hash-map _o$1729 _o$1730 _o$1731 _o$1732 _o$1733 _o$1734))) (_o$1742 (keyword #f "flags")) (_o$1743 (let* ((_o$1735 (keyword #f "colon")) (_o$1736 (keyword #f "at"))) (jolt-hash-set _o$1735 _o$1736))) (_o$1744 (keyword #f "generator-fn")) (_o$1745 (lambda (params offset) (let fnrec1737 ((params params) (offset offset)) (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (var-deref "clojure.pprint" "boolean-conditional") (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (var-deref "clojure.pprint" "check-arg-conditional") (if #t (var-deref "clojure.pprint" "choice-conditional") jolt-nil)))))) (_o$1746 (keyword #f "directive")) (_o$1747 (integer->char 91)) (_o$1748 (keyword #f "params")) (_o$1749 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "selector") (let* ((_o$1738 jolt-nil) (_o$1739 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1738 _o$1739))))) (jolt-hash-map _o$1740 _o$1741 _o$1742 _o$1743 _o$1744 _o$1745 _o$1746 _o$1747 _o$1748 _o$1749))) (_a$1984 (integer->char 59)) (_a$1985 (let* ((_o$1762 (keyword #f "bracket-info")) (_o$1763 (let* ((_o$1750 (keyword #f "separator")) (_o$1751 #t)) (jolt-hash-map _o$1750 _o$1751))) (_o$1764 (keyword #f "flags")) (_o$1765 (jolt-hash-set (keyword #f "colon"))) (_o$1766 (keyword #f "generator-fn")) (_o$1767 (lambda (params offset) (let fnrec1752 ((params params) (offset offset)) jolt-nil))) (_o$1768 (keyword #f "directive")) (_o$1769 (integer->char 59)) (_o$1770 (keyword #f "params")) (_o$1771 (let* ((_a$1757 (var-deref "clojure.core" "array-map")) (_a$1758 (keyword #f "min-remaining")) (_a$1759 (let* ((_o$1753 jolt-nil) (_o$1754 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1753 _o$1754))) (_a$1760 (keyword #f "max-columns")) (_a$1761 (let* ((_o$1755 jolt-nil) (_o$1756 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1755 _o$1756)))) (jolt-invoke _a$1757 _a$1758 _a$1759 _a$1760 _a$1761)))) (jolt-hash-map _o$1762 _o$1763 _o$1764 _o$1765 _o$1766 _o$1767 _o$1768 _o$1769 _o$1770 _o$1771))) (_a$1986 (integer->char 93)) (_a$1987 (let* ((_o$1773 (keyword #f "bracket-info")) (_o$1774 (jolt-hash-map)) (_o$1775 (keyword #f "flags")) (_o$1776 (jolt-hash-set)) (_o$1777 (keyword #f "generator-fn")) (_o$1778 (lambda (params offset) (let fnrec1772 ((params params) (offset offset)) jolt-nil))) (_o$1779 (keyword #f "directive")) (_o$1780 (integer->char 93)) (_o$1781 (keyword #f "params")) (_o$1782 (jolt-invoke (var-deref "clojure.core" "array-map")))) (jolt-hash-map _o$1773 _o$1774 _o$1775 _o$1776 _o$1777 _o$1778 _o$1779 _o$1780 _o$1781 _o$1782))) (_a$1988 (integer->char 123)) (_a$1989 (let* ((_o$1793 (keyword #f "bracket-info")) (_o$1794 (let* ((_o$1783 (keyword #f "right")) (_o$1784 (integer->char 125)) (_o$1785 (keyword #f "allows-separator")) (_o$1786 #f)) (jolt-hash-map _o$1783 _o$1784 _o$1785 _o$1786))) (_o$1795 (keyword #f "flags")) (_o$1796 (let* ((_o$1787 (keyword #f "colon")) (_o$1788 (keyword #f "at")) (_o$1789 (keyword #f "both"))) (jolt-hash-set _o$1787 _o$1788 _o$1789))) (_o$1797 (keyword #f "generator-fn")) (_o$1798 (lambda (params offset) (let fnrec1790 ((params params) (offset offset)) (if (jolt-truthy? (let* ((and__25__auto (jolt-get params (keyword #f "at")))) (if (jolt-truthy? and__25__auto) (jolt-get params (keyword #f "colon")) and__25__auto))) (var-deref "clojure.pprint" "iterate-main-sublists") (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (var-deref "clojure.pprint" "iterate-list-of-sublists") (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (var-deref "clojure.pprint" "iterate-main-list") (if #t (var-deref "clojure.pprint" "iterate-sublist") jolt-nil))))))) (_o$1799 (keyword #f "directive")) (_o$1800 (integer->char 123)) (_o$1801 (keyword #f "params")) (_o$1802 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "max-iterations") (let* ((_o$1791 jolt-nil) (_o$1792 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1791 _o$1792))))) (jolt-hash-map _o$1793 _o$1794 _o$1795 _o$1796 _o$1797 _o$1798 _o$1799 _o$1800 _o$1801 _o$1802))) (_a$1990 (integer->char 125)) (_a$1991 (let* ((_o$1804 (keyword #f "bracket-info")) (_o$1805 (jolt-hash-map)) (_o$1806 (keyword #f "flags")) (_o$1807 (jolt-hash-set (keyword #f "colon"))) (_o$1808 (keyword #f "generator-fn")) (_o$1809 (lambda (params offset) (let fnrec1803 ((params params) (offset offset)) jolt-nil))) (_o$1810 (keyword #f "directive")) (_o$1811 (integer->char 125)) (_o$1812 (keyword #f "params")) (_o$1813 (jolt-invoke (var-deref "clojure.core" "array-map")))) (jolt-hash-map _o$1804 _o$1805 _o$1806 _o$1807 _o$1808 _o$1809 _o$1810 _o$1811 _o$1812 _o$1813))) (_a$1992 (integer->char 60)) (_a$1993 (let* ((_o$1842 (keyword #f "bracket-info")) (_o$1843 (let* ((_o$1814 (keyword #f "right")) (_o$1815 (integer->char 62)) (_o$1816 (keyword #f "allows-separator")) (_o$1817 #t) (_o$1818 (keyword #f "else")) (_o$1819 (keyword #f "first"))) (jolt-hash-map _o$1814 _o$1815 _o$1816 _o$1817 _o$1818 _o$1819))) (_o$1844 (keyword #f "flags")) (_o$1845 (let* ((_o$1820 (keyword #f "colon")) (_o$1821 (keyword #f "at")) (_o$1822 (keyword #f "both")) (_o$1823 (keyword #f "pretty"))) (jolt-hash-set _o$1820 _o$1821 _o$1822 _o$1823))) (_o$1846 (keyword #f "generator-fn")) (_o$1847 (lambda (params offset) (let fnrec1824 ((params params) (offset offset)) (var-deref "clojure.pprint" "logical-block-or-justify")))) (_o$1848 (keyword #f "directive")) (_o$1849 (integer->char 60)) (_o$1850 (keyword #f "params")) (_o$1851 (let* ((_a$1833 (var-deref "clojure.core" "array-map")) (_a$1834 (keyword #f "mincol")) (_a$1835 (let* ((_o$1825 0) (_o$1826 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1825 _o$1826))) (_a$1836 (keyword #f "colinc")) (_a$1837 (let* ((_o$1827 1) (_o$1828 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1827 _o$1828))) (_a$1838 (keyword #f "minpad")) (_a$1839 (let* ((_o$1829 0) (_o$1830 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1829 _o$1830))) (_a$1840 (keyword #f "padchar")) (_a$1841 (let* ((_o$1831 (integer->char 32)) (_o$1832 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1831 _o$1832)))) (jolt-invoke _a$1833 _a$1834 _a$1835 _a$1836 _a$1837 _a$1838 _a$1839 _a$1840 _a$1841)))) (jolt-hash-map _o$1842 _o$1843 _o$1844 _o$1845 _o$1846 _o$1847 _o$1848 _o$1849 _o$1850 _o$1851))) (_a$1994 (integer->char 62)) (_a$1995 (let* ((_o$1853 (keyword #f "bracket-info")) (_o$1854 (jolt-hash-map)) (_o$1855 (keyword #f "flags")) (_o$1856 (jolt-hash-set (keyword #f "colon"))) (_o$1857 (keyword #f "generator-fn")) (_o$1858 (lambda (params offset) (let fnrec1852 ((params params) (offset offset)) jolt-nil))) (_o$1859 (keyword #f "directive")) (_o$1860 (integer->char 62)) (_o$1861 (keyword #f "params")) (_o$1862 (jolt-invoke (var-deref "clojure.core" "array-map")))) (jolt-hash-map _o$1853 _o$1854 _o$1855 _o$1856 _o$1857 _o$1858 _o$1859 _o$1860 _o$1861 _o$1862))) (_a$1996 (integer->char 94)) (_a$1997 (let* ((_o$1886 (keyword #f "bracket-info")) (_o$1887 (jolt-hash-map)) (_o$1888 (keyword #f "flags")) (_o$1889 (jolt-hash-set (keyword #f "colon"))) (_o$1890 (keyword #f "generator-fn")) (_o$1891 (lambda (params offset) (let fnrec1863 ((params params) (offset offset)) (lambda (params navigator offsets) (let fnrec1864 ((params params) (navigator navigator) (offsets offsets)) (let* ((arg1 (jolt-get params (keyword #f "arg1"))) (arg2 (jolt-get params (keyword #f "arg2"))) (arg3 (jolt-get params (keyword #f "arg3"))) (exit (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (keyword #f "colon-up-arrow") (keyword #f "up-arrow")))) (if (jolt-truthy? (let* ((and__25__auto arg1)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto arg2)) (if (jolt-truthy? and__25__auto) arg3 and__25__auto)) and__25__auto))) (if (<= arg1 arg2 arg3) (let* ((_o$1865 exit) (_o$1866 navigator)) (jolt-vector _o$1865 _o$1866)) navigator) (if (jolt-truthy? (let* ((and__25__auto arg1)) (if (jolt-truthy? and__25__auto) arg2 and__25__auto))) (if (jolt= arg1 arg2) (let* ((_o$1867 exit) (_o$1868 navigator)) (jolt-vector _o$1867 _o$1868)) navigator) (if (jolt-truthy? arg1) (if (jolt= arg1 0) (let* ((_o$1869 exit) (_o$1870 navigator)) (jolt-vector _o$1869 _o$1870)) navigator) (if #t (if (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (jolt-empty? (jolt-get (jolt-get params (keyword #f "base-args")) (keyword #f "rest"))) (jolt-empty? (jolt-get navigator (keyword #f "rest")))) (let* ((_o$1871 exit) (_o$1872 navigator)) (jolt-vector _o$1871 _o$1872)) navigator) jolt-nil)))))))))) (_o$1892 (keyword #f "directive")) (_o$1893 (integer->char 94)) (_o$1894 (keyword #f "params")) (_o$1895 (let* ((_a$1879 (var-deref "clojure.core" "array-map")) (_a$1880 (keyword #f "arg1")) (_a$1881 (let* ((_o$1873 jolt-nil) (_o$1874 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1873 _o$1874))) (_a$1882 (keyword #f "arg2")) (_a$1883 (let* ((_o$1875 jolt-nil) (_o$1876 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1875 _o$1876))) (_a$1884 (keyword #f "arg3")) (_a$1885 (let* ((_o$1877 jolt-nil) (_o$1878 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1877 _o$1878)))) (jolt-invoke _a$1879 _a$1880 _a$1881 _a$1882 _a$1883 _a$1884 _a$1885)))) (jolt-hash-map _o$1886 _o$1887 _o$1888 _o$1889 _o$1890 _o$1891 _o$1892 _o$1893 _o$1894 _o$1895))) (_a$1998 (integer->char 87)) (_a$1999 (let* ((_o$1915 (keyword #f "bracket-info")) (_o$1916 (jolt-hash-map)) (_o$1917 (keyword #f "flags")) (_o$1918 (let* ((_o$1896 (keyword #f "at")) (_o$1897 (keyword #f "colon")) (_o$1898 (keyword #f "both")) (_o$1899 (keyword #f "pretty"))) (jolt-hash-set _o$1896 _o$1897 _o$1898 _o$1899))) (_o$1919 (keyword #f "generator-fn")) (_o$1920 (lambda (params offset) (let fnrec1900 ((params params) (offset offset)) (if (jolt-truthy? (let* ((or__26__auto (jolt-get params (keyword #f "at")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-get params (keyword #f "colon"))))) (let* ((bindings (let* ((_a$1907 (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (let* ((_o$1901 (keyword #f "level")) (_o$1902 jolt-nil) (_o$1903 (keyword #f "length")) (_o$1904 jolt-nil)) (jolt-vector _o$1901 _o$1902 _o$1903 _o$1904)) (jolt-vector))) (_a$1908 (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (let* ((_o$1905 (keyword #f "pretty")) (_o$1906 #t)) (jolt-vector _o$1905 _o$1906)) (jolt-vector)))) (jolt-concat _a$1907 _a$1908)))) (lambda (params navigator offsets) (let fnrec1909 ((params params) (navigator navigator) (offsets offsets)) (let* ((G__78 (jolt-invoke (var-deref "clojure.pprint" "next-arg") navigator)) (arg (jolt-nth G__78 0 jolt-nil)) (navigator (jolt-nth G__78 1 jolt-nil))) (if (jolt-truthy? (jolt-apply (var-deref "clojure.pprint" "write") arg bindings)) (let* ((_o$1910 (keyword #f "up-arrow")) (_o$1911 navigator)) (jolt-vector _o$1910 _o$1911)) navigator))))) (lambda (params navigator offsets) (let fnrec1912 ((params params) (navigator navigator) (offsets offsets)) (let* ((G__79 (jolt-invoke (var-deref "clojure.pprint" "next-arg") navigator)) (arg (jolt-nth G__79 0 jolt-nil)) (navigator (jolt-nth G__79 1 jolt-nil))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.pprint" "write-out") arg)) (let* ((_o$1913 (keyword #f "up-arrow")) (_o$1914 navigator)) (jolt-vector _o$1913 _o$1914)) navigator)))))))) (_o$1921 (keyword #f "directive")) (_o$1922 (integer->char 87)) (_o$1923 (keyword #f "params")) (_o$1924 (jolt-invoke (var-deref "clojure.core" "array-map")))) (jolt-hash-map _o$1915 _o$1916 _o$1917 _o$1918 _o$1919 _o$1920 _o$1921 _o$1922 _o$1923 _o$1924))) (_a$2000 (integer->char 95)) (_a$2001 (let* ((_o$1929 (keyword #f "bracket-info")) (_o$1930 (jolt-hash-map)) (_o$1931 (keyword #f "flags")) (_o$1932 (let* ((_o$1925 (keyword #f "at")) (_o$1926 (keyword #f "colon")) (_o$1927 (keyword #f "both"))) (jolt-hash-set _o$1925 _o$1926 _o$1927))) (_o$1933 (keyword #f "generator-fn")) (_o$1934 (lambda (params offset) (let fnrec1928 ((params params) (offset offset)) (var-deref "clojure.pprint" "conditional-newline")))) (_o$1935 (keyword #f "directive")) (_o$1936 (integer->char 95)) (_o$1937 (keyword #f "params")) (_o$1938 (jolt-invoke (var-deref "clojure.core" "array-map")))) (jolt-hash-map _o$1929 _o$1930 _o$1931 _o$1932 _o$1933 _o$1934 _o$1935 _o$1936 _o$1937 _o$1938))) (_a$2002 (integer->char 73)) (_a$2003 (let* ((_o$1942 (keyword #f "bracket-info")) (_o$1943 (jolt-hash-map)) (_o$1944 (keyword #f "flags")) (_o$1945 (jolt-hash-set (keyword #f "colon"))) (_o$1946 (keyword #f "generator-fn")) (_o$1947 (lambda (params offset) (let fnrec1939 ((params params) (offset offset)) (var-deref "clojure.pprint" "set-indent")))) (_o$1948 (keyword #f "directive")) (_o$1949 (integer->char 73)) (_o$1950 (keyword #f "params")) (_o$1951 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "n") (let* ((_o$1940 0) (_o$1941 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1940 _o$1941))))) (jolt-hash-map _o$1942 _o$1943 _o$1944 _o$1945 _o$1946 _o$1947 _o$1948 _o$1949 _o$1950 _o$1951)))) (jolt-hash-map _a$1952 _a$1953 _a$1954 _a$1955 _a$1956 _a$1957 _a$1958 _a$1959 _a$1960 _a$1961 _a$1962 _a$1963 _a$1964 _a$1965 _a$1966 _a$1967 _a$1968 _a$1969 _a$1970 _a$1971 _a$1972 _a$1973 _a$1974 _a$1975 _a$1976 _a$1977 _a$1978 _a$1979 _a$1980 _a$1981 _a$1982 _a$1983 _a$1984 _a$1985 _a$1986 _a$1987 _a$1988 _a$1989 _a$1990 _a$1991 _a$1992 _a$1993 _a$1994 _a$1995 _a$1996 _a$1997 _a$1998 _a$1999 _a$2000 _a$2001 _a$2002 _a$2003)))) + (def-var! "clojure.pprint" "directive-table" (let* ((_a$1952 (integer->char 65)) (_a$1953 (let* ((_o$1422 (keyword #f "directive")) (_o$1423 (integer->char 65)) (_o$1424 (keyword #f "params")) (_o$1425 (let* ((_a$1408 (var-deref "clojure.core" "array-map")) (_a$1409 (keyword #f "mincol")) (_a$1410 (let* ((_o$1400 0) (_o$1401 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1400 _o$1401))) (_a$1411 (keyword #f "colinc")) (_a$1412 (let* ((_o$1402 1) (_o$1403 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1402 _o$1403))) (_a$1413 (keyword #f "minpad")) (_a$1414 (let* ((_o$1404 0) (_o$1405 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1404 _o$1405))) (_a$1415 (keyword #f "padchar")) (_a$1416 (let* ((_o$1406 (integer->char 32)) (_o$1407 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1406 _o$1407)))) (jolt-invoke _a$1408 _a$1409 _a$1410 _a$1411 _a$1412 _a$1413 _a$1414 _a$1415 _a$1416))) (_o$1426 (keyword #f "flags")) (_o$1427 (let* ((_o$1417 (keyword #f "at")) (_o$1418 (keyword #f "colon")) (_o$1419 (keyword #f "both"))) (jolt-hash-set _o$1417 _o$1418 _o$1419))) (_o$1428 (keyword #f "bracket-info")) (_o$1429 (jolt-hash-map)) (_o$1430 (keyword #f "generator-fn")) (_o$1431 (lambda (params offset) (let fnrec1420 ((params params) (offset offset)) (lambda (p__11_ p__12_ p__13_) (let fnrec1421 ((p__11_ p__11_) (p__12_ p__12_) (p__13_ p__13_)) (jolt-invoke (var-deref "clojure.pprint" "format-ascii") (var-deref "clojure.core" "print-str") p__11_ p__12_ p__13_))))))) (jolt-hash-map _o$1422 _o$1423 _o$1424 _o$1425 _o$1426 _o$1427 _o$1428 _o$1429 _o$1430 _o$1431))) (_a$1954 (integer->char 83)) (_a$1955 (let* ((_o$1454 (keyword #f "directive")) (_o$1455 (integer->char 83)) (_o$1456 (keyword #f "params")) (_o$1457 (let* ((_a$1440 (var-deref "clojure.core" "array-map")) (_a$1441 (keyword #f "mincol")) (_a$1442 (let* ((_o$1432 0) (_o$1433 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1432 _o$1433))) (_a$1443 (keyword #f "colinc")) (_a$1444 (let* ((_o$1434 1) (_o$1435 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1434 _o$1435))) (_a$1445 (keyword #f "minpad")) (_a$1446 (let* ((_o$1436 0) (_o$1437 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1436 _o$1437))) (_a$1447 (keyword #f "padchar")) (_a$1448 (let* ((_o$1438 (integer->char 32)) (_o$1439 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1438 _o$1439)))) (jolt-invoke _a$1440 _a$1441 _a$1442 _a$1443 _a$1444 _a$1445 _a$1446 _a$1447 _a$1448))) (_o$1458 (keyword #f "flags")) (_o$1459 (let* ((_o$1449 (keyword #f "at")) (_o$1450 (keyword #f "colon")) (_o$1451 (keyword #f "both"))) (jolt-hash-set _o$1449 _o$1450 _o$1451))) (_o$1460 (keyword #f "bracket-info")) (_o$1461 (jolt-hash-map)) (_o$1462 (keyword #f "generator-fn")) (_o$1463 (lambda (params offset) (let fnrec1452 ((params params) (offset offset)) (lambda (p__14_ p__15_ p__16_) (let fnrec1453 ((p__14_ p__14_) (p__15_ p__15_) (p__16_ p__16_)) (jolt-invoke (var-deref "clojure.pprint" "format-ascii") (var-deref "clojure.core" "pr-str") p__14_ p__15_ p__16_))))))) (jolt-hash-map _o$1454 _o$1455 _o$1456 _o$1457 _o$1458 _o$1459 _o$1460 _o$1461 _o$1462 _o$1463))) (_a$1956 (integer->char 68)) (_a$1957 (let* ((_o$1486 (keyword #f "directive")) (_o$1487 (integer->char 68)) (_o$1488 (keyword #f "params")) (_o$1489 (let* ((_a$1472 (var-deref "clojure.core" "array-map")) (_a$1473 (keyword #f "mincol")) (_a$1474 (let* ((_o$1464 0) (_o$1465 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1464 _o$1465))) (_a$1475 (keyword #f "padchar")) (_a$1476 (let* ((_o$1466 (integer->char 32)) (_o$1467 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1466 _o$1467))) (_a$1477 (keyword #f "commachar")) (_a$1478 (let* ((_o$1468 (integer->char 44)) (_o$1469 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1468 _o$1469))) (_a$1479 (keyword #f "commainterval")) (_a$1480 (let* ((_o$1470 3) (_o$1471 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1470 _o$1471)))) (jolt-invoke _a$1472 _a$1473 _a$1474 _a$1475 _a$1476 _a$1477 _a$1478 _a$1479 _a$1480))) (_o$1490 (keyword #f "flags")) (_o$1491 (let* ((_o$1481 (keyword #f "at")) (_o$1482 (keyword #f "colon")) (_o$1483 (keyword #f "both"))) (jolt-hash-set _o$1481 _o$1482 _o$1483))) (_o$1492 (keyword #f "bracket-info")) (_o$1493 (jolt-hash-map)) (_o$1494 (keyword #f "generator-fn")) (_o$1495 (lambda (params offset) (let fnrec1484 ((params params) (offset offset)) (lambda (p__17_ p__18_ p__19_) (let fnrec1485 ((p__17_ p__17_) (p__18_ p__18_) (p__19_ p__19_)) (jolt-invoke (var-deref "clojure.pprint" "format-integer") 10 p__17_ p__18_ p__19_))))))) (jolt-hash-map _o$1486 _o$1487 _o$1488 _o$1489 _o$1490 _o$1491 _o$1492 _o$1493 _o$1494 _o$1495))) (_a$1958 (integer->char 66)) (_a$1959 (let* ((_o$1518 (keyword #f "directive")) (_o$1519 (integer->char 66)) (_o$1520 (keyword #f "params")) (_o$1521 (let* ((_a$1504 (var-deref "clojure.core" "array-map")) (_a$1505 (keyword #f "mincol")) (_a$1506 (let* ((_o$1496 0) (_o$1497 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1496 _o$1497))) (_a$1507 (keyword #f "padchar")) (_a$1508 (let* ((_o$1498 (integer->char 32)) (_o$1499 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1498 _o$1499))) (_a$1509 (keyword #f "commachar")) (_a$1510 (let* ((_o$1500 (integer->char 44)) (_o$1501 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1500 _o$1501))) (_a$1511 (keyword #f "commainterval")) (_a$1512 (let* ((_o$1502 3) (_o$1503 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1502 _o$1503)))) (jolt-invoke _a$1504 _a$1505 _a$1506 _a$1507 _a$1508 _a$1509 _a$1510 _a$1511 _a$1512))) (_o$1522 (keyword #f "flags")) (_o$1523 (let* ((_o$1513 (keyword #f "at")) (_o$1514 (keyword #f "colon")) (_o$1515 (keyword #f "both"))) (jolt-hash-set _o$1513 _o$1514 _o$1515))) (_o$1524 (keyword #f "bracket-info")) (_o$1525 (jolt-hash-map)) (_o$1526 (keyword #f "generator-fn")) (_o$1527 (lambda (params offset) (let fnrec1516 ((params params) (offset offset)) (lambda (p__20_ p__21_ p__22_) (let fnrec1517 ((p__20_ p__20_) (p__21_ p__21_) (p__22_ p__22_)) (jolt-invoke (var-deref "clojure.pprint" "format-integer") 2 p__20_ p__21_ p__22_))))))) (jolt-hash-map _o$1518 _o$1519 _o$1520 _o$1521 _o$1522 _o$1523 _o$1524 _o$1525 _o$1526 _o$1527))) (_a$1960 (integer->char 79)) (_a$1961 (let* ((_o$1550 (keyword #f "directive")) (_o$1551 (integer->char 79)) (_o$1552 (keyword #f "params")) (_o$1553 (let* ((_a$1536 (var-deref "clojure.core" "array-map")) (_a$1537 (keyword #f "mincol")) (_a$1538 (let* ((_o$1528 0) (_o$1529 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1528 _o$1529))) (_a$1539 (keyword #f "padchar")) (_a$1540 (let* ((_o$1530 (integer->char 32)) (_o$1531 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1530 _o$1531))) (_a$1541 (keyword #f "commachar")) (_a$1542 (let* ((_o$1532 (integer->char 44)) (_o$1533 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1532 _o$1533))) (_a$1543 (keyword #f "commainterval")) (_a$1544 (let* ((_o$1534 3) (_o$1535 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1534 _o$1535)))) (jolt-invoke _a$1536 _a$1537 _a$1538 _a$1539 _a$1540 _a$1541 _a$1542 _a$1543 _a$1544))) (_o$1554 (keyword #f "flags")) (_o$1555 (let* ((_o$1545 (keyword #f "at")) (_o$1546 (keyword #f "colon")) (_o$1547 (keyword #f "both"))) (jolt-hash-set _o$1545 _o$1546 _o$1547))) (_o$1556 (keyword #f "bracket-info")) (_o$1557 (jolt-hash-map)) (_o$1558 (keyword #f "generator-fn")) (_o$1559 (lambda (params offset) (let fnrec1548 ((params params) (offset offset)) (lambda (p__23_ p__24_ p__25_) (let fnrec1549 ((p__23_ p__23_) (p__24_ p__24_) (p__25_ p__25_)) (jolt-invoke (var-deref "clojure.pprint" "format-integer") 8 p__23_ p__24_ p__25_))))))) (jolt-hash-map _o$1550 _o$1551 _o$1552 _o$1553 _o$1554 _o$1555 _o$1556 _o$1557 _o$1558 _o$1559))) (_a$1962 (integer->char 88)) (_a$1963 (let* ((_o$1582 (keyword #f "directive")) (_o$1583 (integer->char 88)) (_o$1584 (keyword #f "params")) (_o$1585 (let* ((_a$1568 (var-deref "clojure.core" "array-map")) (_a$1569 (keyword #f "mincol")) (_a$1570 (let* ((_o$1560 0) (_o$1561 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1560 _o$1561))) (_a$1571 (keyword #f "padchar")) (_a$1572 (let* ((_o$1562 (integer->char 32)) (_o$1563 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1562 _o$1563))) (_a$1573 (keyword #f "commachar")) (_a$1574 (let* ((_o$1564 (integer->char 44)) (_o$1565 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1564 _o$1565))) (_a$1575 (keyword #f "commainterval")) (_a$1576 (let* ((_o$1566 3) (_o$1567 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1566 _o$1567)))) (jolt-invoke _a$1568 _a$1569 _a$1570 _a$1571 _a$1572 _a$1573 _a$1574 _a$1575 _a$1576))) (_o$1586 (keyword #f "flags")) (_o$1587 (let* ((_o$1577 (keyword #f "at")) (_o$1578 (keyword #f "colon")) (_o$1579 (keyword #f "both"))) (jolt-hash-set _o$1577 _o$1578 _o$1579))) (_o$1588 (keyword #f "bracket-info")) (_o$1589 (jolt-hash-map)) (_o$1590 (keyword #f "generator-fn")) (_o$1591 (lambda (params offset) (let fnrec1580 ((params params) (offset offset)) (lambda (p__26_ p__27_ p__28_) (let fnrec1581 ((p__26_ p__26_) (p__27_ p__27_) (p__28_ p__28_)) (jolt-invoke (var-deref "clojure.pprint" "format-integer") 16 p__26_ p__27_ p__28_))))))) (jolt-hash-map _o$1582 _o$1583 _o$1584 _o$1585 _o$1586 _o$1587 _o$1588 _o$1589 _o$1590 _o$1591))) (_a$1964 (integer->char 37)) (_a$1965 (let* ((_o$1597 (keyword #f "directive")) (_o$1598 (integer->char 37)) (_o$1599 (keyword #f "params")) (_o$1600 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "count") (let* ((_o$1592 1) (_o$1593 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1592 _o$1593)))) (_o$1601 (keyword #f "flags")) (_o$1602 (jolt-hash-set)) (_o$1603 (keyword #f "bracket-info")) (_o$1604 (jolt-hash-map)) (_o$1605 (keyword #f "generator-fn")) (_o$1606 (lambda (params offset) (let fnrec1594 ((params params) (offset offset)) (lambda (params arg-navigator offsets) (let fnrec1595 ((params params) (arg-navigator arg-navigator) (offsets offsets)) (begin (let* ((n__19__auto (jolt-get params (keyword #f "count")))) (let* ((i 0)) (let loop1596 ((i i)) (if (< i n__19__auto) (begin (jolt-invoke (var-deref "clojure.pprint" "prn")) (loop1596 (jolt-inc i))) jolt-nil)))) arg-navigator))))))) (jolt-hash-map _o$1597 _o$1598 _o$1599 _o$1600 _o$1601 _o$1602 _o$1603 _o$1604 _o$1605 _o$1606))) (_a$1966 (integer->char 38)) (_a$1967 (let* ((_o$1612 (keyword #f "directive")) (_o$1613 (integer->char 38)) (_o$1614 (keyword #f "params")) (_o$1615 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "count") (let* ((_o$1607 1) (_o$1608 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1607 _o$1608)))) (_o$1616 (keyword #f "flags")) (_o$1617 (jolt-hash-set (keyword #f "pretty"))) (_o$1618 (keyword #f "bracket-info")) (_o$1619 (jolt-hash-map)) (_o$1620 (keyword #f "generator-fn")) (_o$1621 (lambda (params offset) (let fnrec1609 ((params params) (offset offset)) (lambda (params arg-navigator offsets) (let fnrec1610 ((params params) (arg-navigator arg-navigator) (offsets offsets)) (begin (let* ((cnt (jolt-get params (keyword #f "count")))) (begin (if (jolt-pos? cnt) (jolt-invoke (var-deref "clojure.pprint" "fresh-line")) jolt-nil) (let* ((n__19__auto (jolt-dec cnt))) (let* ((i 0)) (let loop1611 ((i i)) (if (< i n__19__auto) (begin (jolt-invoke (var-deref "clojure.pprint" "prn")) (loop1611 (jolt-inc i))) jolt-nil)))))) arg-navigator))))))) (jolt-hash-map _o$1612 _o$1613 _o$1614 _o$1615 _o$1616 _o$1617 _o$1618 _o$1619 _o$1620 _o$1621))) (_a$1968 (integer->char 124)) (_a$1969 (let* ((_o$1627 (keyword #f "directive")) (_o$1628 (integer->char 124)) (_o$1629 (keyword #f "params")) (_o$1630 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "count") (let* ((_o$1622 1) (_o$1623 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1622 _o$1623)))) (_o$1631 (keyword #f "flags")) (_o$1632 (jolt-hash-set)) (_o$1633 (keyword #f "bracket-info")) (_o$1634 (jolt-hash-map)) (_o$1635 (keyword #f "generator-fn")) (_o$1636 (lambda (params offset) (let fnrec1624 ((params params) (offset offset)) (lambda (params arg-navigator offsets) (let fnrec1625 ((params params) (arg-navigator arg-navigator) (offsets offsets)) (begin (let* ((n__19__auto (jolt-get params (keyword #f "count")))) (let* ((i 0)) (let loop1626 ((i i)) (if (< i n__19__auto) (begin (jolt-invoke (var-deref "clojure.pprint" "print") (integer->char 12)) (loop1626 (jolt-inc i))) jolt-nil)))) arg-navigator))))))) (jolt-hash-map _o$1627 _o$1628 _o$1629 _o$1630 _o$1631 _o$1632 _o$1633 _o$1634 _o$1635 _o$1636))) (_a$1970 (integer->char 126)) (_a$1971 (let* ((_o$1641 (keyword #f "directive")) (_o$1642 (integer->char 126)) (_o$1643 (keyword #f "params")) (_o$1644 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "n") (let* ((_o$1637 1) (_o$1638 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1637 _o$1638)))) (_o$1645 (keyword #f "flags")) (_o$1646 (jolt-hash-set)) (_o$1647 (keyword #f "bracket-info")) (_o$1648 (jolt-hash-map)) (_o$1649 (keyword #f "generator-fn")) (_o$1650 (lambda (params offset) (let fnrec1639 ((params params) (offset offset)) (lambda (params arg-navigator offsets) (let fnrec1640 ((params params) (arg-navigator arg-navigator) (offsets offsets)) (let* ((n (jolt-get params (keyword #f "n")))) (begin (jolt-invoke (var-deref "clojure.pprint" "print") (jolt-apply (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "repeat") n (integer->char 126)))) arg-navigator)))))))) (jolt-hash-map _o$1641 _o$1642 _o$1643 _o$1644 _o$1645 _o$1646 _o$1647 _o$1648 _o$1649 _o$1650))) (_a$1972 (integer->char 10)) (_a$1973 (let* ((_o$1655 (keyword #f "directive")) (_o$1656 (integer->char 10)) (_o$1657 (keyword #f "params")) (_o$1658 (jolt-invoke (var-deref "clojure.core" "array-map"))) (_o$1659 (keyword #f "flags")) (_o$1660 (let* ((_o$1651 (keyword #f "colon")) (_o$1652 (keyword #f "at"))) (jolt-hash-set _o$1651 _o$1652))) (_o$1661 (keyword #f "bracket-info")) (_o$1662 (jolt-hash-map)) (_o$1663 (keyword #f "generator-fn")) (_o$1664 (lambda (params offset) (let fnrec1653 ((params params) (offset offset)) (lambda (params arg-navigator offsets) (let fnrec1654 ((params params) (arg-navigator arg-navigator) (offsets offsets)) (begin (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (jolt-invoke (var-deref "clojure.pprint" "prn")) jolt-nil) arg-navigator))))))) (jolt-hash-map _o$1655 _o$1656 _o$1657 _o$1658 _o$1659 _o$1660 _o$1661 _o$1662 _o$1663 _o$1664))) (_a$1974 (integer->char 84)) (_a$1975 (let* ((_o$1679 (keyword #f "directive")) (_o$1680 (integer->char 84)) (_o$1681 (keyword #f "params")) (_o$1682 (let* ((_a$1669 (var-deref "clojure.core" "array-map")) (_a$1670 (keyword #f "colnum")) (_a$1671 (let* ((_o$1665 1) (_o$1666 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1665 _o$1666))) (_a$1672 (keyword #f "colinc")) (_a$1673 (let* ((_o$1667 1) (_o$1668 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1667 _o$1668)))) (jolt-invoke _a$1669 _a$1670 _a$1671 _a$1672 _a$1673))) (_o$1683 (keyword #f "flags")) (_o$1684 (let* ((_o$1674 (keyword #f "at")) (_o$1675 (keyword #f "pretty"))) (jolt-hash-set _o$1674 _o$1675))) (_o$1685 (keyword #f "bracket-info")) (_o$1686 (jolt-hash-map)) (_o$1687 (keyword #f "generator-fn")) (_o$1688 (lambda (params offset) (let fnrec1676 ((params params) (offset offset)) (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (lambda (p__29_ p__30_ p__31_) (let fnrec1677 ((p__29_ p__29_) (p__30_ p__30_) (p__31_ p__31_)) (jolt-invoke (var-deref "clojure.pprint" "relative-tabulation") p__29_ p__30_ p__31_))) (lambda (p__32_ p__33_ p__34_) (let fnrec1678 ((p__32_ p__32_) (p__33_ p__33_) (p__34_ p__34_)) (jolt-invoke (var-deref "clojure.pprint" "absolute-tabulation") p__32_ p__33_ p__34_)))))))) (jolt-hash-map _o$1679 _o$1680 _o$1681 _o$1682 _o$1683 _o$1684 _o$1685 _o$1686 _o$1687 _o$1688))) (_a$1976 (integer->char 42)) (_a$1977 (let* ((_o$1695 (keyword #f "directive")) (_o$1696 (integer->char 42)) (_o$1697 (keyword #f "params")) (_o$1698 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "n") (let* ((_o$1689 1) (_o$1690 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1689 _o$1690)))) (_o$1699 (keyword #f "flags")) (_o$1700 (let* ((_o$1691 (keyword #f "colon")) (_o$1692 (keyword #f "at"))) (jolt-hash-set _o$1691 _o$1692))) (_o$1701 (keyword #f "bracket-info")) (_o$1702 (jolt-hash-map)) (_o$1703 (keyword #f "generator-fn")) (_o$1704 (lambda (params offset) (let fnrec1693 ((params params) (offset offset)) (lambda (params navigator offsets) (let fnrec1694 ((params params) (navigator navigator) (offsets offsets)) (let* ((n (jolt-get params (keyword #f "n")))) (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (jolt-invoke (var-deref "clojure.pprint" "absolute-reposition") navigator n) (jolt-invoke (var-deref "clojure.pprint" "relative-reposition") navigator (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (- n) n)))))))))) (jolt-hash-map _o$1695 _o$1696 _o$1697 _o$1698 _o$1699 _o$1700 _o$1701 _o$1702 _o$1703 _o$1704))) (_a$1978 (integer->char 63)) (_a$1979 (let* ((_o$1708 (keyword #f "directive")) (_o$1709 (integer->char 63)) (_o$1710 (keyword #f "params")) (_o$1711 (jolt-invoke (var-deref "clojure.core" "array-map"))) (_o$1712 (keyword #f "flags")) (_o$1713 (jolt-hash-set (keyword #f "at"))) (_o$1714 (keyword #f "bracket-info")) (_o$1715 (jolt-hash-map)) (_o$1716 (keyword #f "generator-fn")) (_o$1717 (lambda (params offset) (let fnrec1705 ((params params) (offset offset)) (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (lambda (params navigator offsets) (let fnrec1706 ((params params) (navigator navigator) (offsets offsets)) (let* ((G__75 (jolt-invoke (var-deref "clojure.pprint" "get-format-arg") navigator)) (subformat (jolt-nth G__75 0 jolt-nil)) (navigator (jolt-nth G__75 1 jolt-nil))) (jolt-invoke (var-deref "clojure.pprint" "execute-sub-format") subformat navigator (jolt-get params (keyword #f "base-args")))))) (lambda (params navigator offsets) (let fnrec1707 ((params params) (navigator navigator) (offsets offsets)) (let* ((G__76 (jolt-invoke (var-deref "clojure.pprint" "get-format-arg") navigator)) (subformat (jolt-nth G__76 0 jolt-nil)) (navigator (jolt-nth G__76 1 jolt-nil)) (G__77 (jolt-invoke (var-deref "clojure.pprint" "next-arg") navigator)) (subargs (jolt-nth G__77 0 jolt-nil)) (navigator (jolt-nth G__77 1 jolt-nil)) (sub-navigator (jolt-invoke (var-deref "clojure.pprint" "init-navigator") subargs))) (begin (jolt-invoke (var-deref "clojure.pprint" "execute-sub-format") subformat sub-navigator (jolt-get params (keyword #f "base-args"))) navigator))))))))) (jolt-hash-map _o$1708 _o$1709 _o$1710 _o$1711 _o$1712 _o$1713 _o$1714 _o$1715 _o$1716 _o$1717))) (_a$1980 (integer->char 41)) (_a$1981 (let* ((_o$1719 (keyword #f "directive")) (_o$1720 (integer->char 41)) (_o$1721 (keyword #f "params")) (_o$1722 (jolt-invoke (var-deref "clojure.core" "array-map"))) (_o$1723 (keyword #f "flags")) (_o$1724 (jolt-hash-set)) (_o$1725 (keyword #f "bracket-info")) (_o$1726 (jolt-hash-map)) (_o$1727 (keyword #f "generator-fn")) (_o$1728 (lambda (params offset) (let fnrec1718 ((params params) (offset offset)) jolt-nil)))) (jolt-hash-map _o$1719 _o$1720 _o$1721 _o$1722 _o$1723 _o$1724 _o$1725 _o$1726 _o$1727 _o$1728))) (_a$1982 (integer->char 91)) (_a$1983 (let* ((_o$1740 (keyword #f "directive")) (_o$1741 (integer->char 91)) (_o$1742 (keyword #f "params")) (_o$1743 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "selector") (let* ((_o$1729 jolt-nil) (_o$1730 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1729 _o$1730)))) (_o$1744 (keyword #f "flags")) (_o$1745 (let* ((_o$1731 (keyword #f "colon")) (_o$1732 (keyword #f "at"))) (jolt-hash-set _o$1731 _o$1732))) (_o$1746 (keyword #f "bracket-info")) (_o$1747 (let* ((_o$1733 (keyword #f "right")) (_o$1734 (integer->char 93)) (_o$1735 (keyword #f "allows-separator")) (_o$1736 #t) (_o$1737 (keyword #f "else")) (_o$1738 (keyword #f "last"))) (jolt-hash-map _o$1733 _o$1734 _o$1735 _o$1736 _o$1737 _o$1738))) (_o$1748 (keyword #f "generator-fn")) (_o$1749 (lambda (params offset) (let fnrec1739 ((params params) (offset offset)) (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (var-deref "clojure.pprint" "boolean-conditional") (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (var-deref "clojure.pprint" "check-arg-conditional") (if #t (var-deref "clojure.pprint" "choice-conditional") jolt-nil))))))) (jolt-hash-map _o$1740 _o$1741 _o$1742 _o$1743 _o$1744 _o$1745 _o$1746 _o$1747 _o$1748 _o$1749))) (_a$1984 (integer->char 59)) (_a$1985 (let* ((_o$1762 (keyword #f "directive")) (_o$1763 (integer->char 59)) (_o$1764 (keyword #f "params")) (_o$1765 (let* ((_a$1754 (var-deref "clojure.core" "array-map")) (_a$1755 (keyword #f "min-remaining")) (_a$1756 (let* ((_o$1750 jolt-nil) (_o$1751 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1750 _o$1751))) (_a$1757 (keyword #f "max-columns")) (_a$1758 (let* ((_o$1752 jolt-nil) (_o$1753 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1752 _o$1753)))) (jolt-invoke _a$1754 _a$1755 _a$1756 _a$1757 _a$1758))) (_o$1766 (keyword #f "flags")) (_o$1767 (jolt-hash-set (keyword #f "colon"))) (_o$1768 (keyword #f "bracket-info")) (_o$1769 (let* ((_o$1759 (keyword #f "separator")) (_o$1760 #t)) (jolt-hash-map _o$1759 _o$1760))) (_o$1770 (keyword #f "generator-fn")) (_o$1771 (lambda (params offset) (let fnrec1761 ((params params) (offset offset)) jolt-nil)))) (jolt-hash-map _o$1762 _o$1763 _o$1764 _o$1765 _o$1766 _o$1767 _o$1768 _o$1769 _o$1770 _o$1771))) (_a$1986 (integer->char 93)) (_a$1987 (let* ((_o$1773 (keyword #f "directive")) (_o$1774 (integer->char 93)) (_o$1775 (keyword #f "params")) (_o$1776 (jolt-invoke (var-deref "clojure.core" "array-map"))) (_o$1777 (keyword #f "flags")) (_o$1778 (jolt-hash-set)) (_o$1779 (keyword #f "bracket-info")) (_o$1780 (jolt-hash-map)) (_o$1781 (keyword #f "generator-fn")) (_o$1782 (lambda (params offset) (let fnrec1772 ((params params) (offset offset)) jolt-nil)))) (jolt-hash-map _o$1773 _o$1774 _o$1775 _o$1776 _o$1777 _o$1778 _o$1779 _o$1780 _o$1781 _o$1782))) (_a$1988 (integer->char 123)) (_a$1989 (let* ((_o$1793 (keyword #f "directive")) (_o$1794 (integer->char 123)) (_o$1795 (keyword #f "params")) (_o$1796 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "max-iterations") (let* ((_o$1783 jolt-nil) (_o$1784 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1783 _o$1784)))) (_o$1797 (keyword #f "flags")) (_o$1798 (let* ((_o$1785 (keyword #f "colon")) (_o$1786 (keyword #f "at")) (_o$1787 (keyword #f "both"))) (jolt-hash-set _o$1785 _o$1786 _o$1787))) (_o$1799 (keyword #f "bracket-info")) (_o$1800 (let* ((_o$1788 (keyword #f "right")) (_o$1789 (integer->char 125)) (_o$1790 (keyword #f "allows-separator")) (_o$1791 #f)) (jolt-hash-map _o$1788 _o$1789 _o$1790 _o$1791))) (_o$1801 (keyword #f "generator-fn")) (_o$1802 (lambda (params offset) (let fnrec1792 ((params params) (offset offset)) (if (jolt-truthy? (let* ((and__25__auto (jolt-get params (keyword #f "at")))) (if (jolt-truthy? and__25__auto) (jolt-get params (keyword #f "colon")) and__25__auto))) (var-deref "clojure.pprint" "iterate-main-sublists") (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (var-deref "clojure.pprint" "iterate-list-of-sublists") (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (var-deref "clojure.pprint" "iterate-main-list") (if #t (var-deref "clojure.pprint" "iterate-sublist") jolt-nil)))))))) (jolt-hash-map _o$1793 _o$1794 _o$1795 _o$1796 _o$1797 _o$1798 _o$1799 _o$1800 _o$1801 _o$1802))) (_a$1990 (integer->char 125)) (_a$1991 (let* ((_o$1804 (keyword #f "directive")) (_o$1805 (integer->char 125)) (_o$1806 (keyword #f "params")) (_o$1807 (jolt-invoke (var-deref "clojure.core" "array-map"))) (_o$1808 (keyword #f "flags")) (_o$1809 (jolt-hash-set (keyword #f "colon"))) (_o$1810 (keyword #f "bracket-info")) (_o$1811 (jolt-hash-map)) (_o$1812 (keyword #f "generator-fn")) (_o$1813 (lambda (params offset) (let fnrec1803 ((params params) (offset offset)) jolt-nil)))) (jolt-hash-map _o$1804 _o$1805 _o$1806 _o$1807 _o$1808 _o$1809 _o$1810 _o$1811 _o$1812 _o$1813))) (_a$1992 (integer->char 60)) (_a$1993 (let* ((_o$1842 (keyword #f "directive")) (_o$1843 (integer->char 60)) (_o$1844 (keyword #f "params")) (_o$1845 (let* ((_a$1822 (var-deref "clojure.core" "array-map")) (_a$1823 (keyword #f "mincol")) (_a$1824 (let* ((_o$1814 0) (_o$1815 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1814 _o$1815))) (_a$1825 (keyword #f "colinc")) (_a$1826 (let* ((_o$1816 1) (_o$1817 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1816 _o$1817))) (_a$1827 (keyword #f "minpad")) (_a$1828 (let* ((_o$1818 0) (_o$1819 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1818 _o$1819))) (_a$1829 (keyword #f "padchar")) (_a$1830 (let* ((_o$1820 (integer->char 32)) (_o$1821 (var-deref "clojure.core" "Character"))) (jolt-vector _o$1820 _o$1821)))) (jolt-invoke _a$1822 _a$1823 _a$1824 _a$1825 _a$1826 _a$1827 _a$1828 _a$1829 _a$1830))) (_o$1846 (keyword #f "flags")) (_o$1847 (let* ((_o$1831 (keyword #f "colon")) (_o$1832 (keyword #f "at")) (_o$1833 (keyword #f "both")) (_o$1834 (keyword #f "pretty"))) (jolt-hash-set _o$1831 _o$1832 _o$1833 _o$1834))) (_o$1848 (keyword #f "bracket-info")) (_o$1849 (let* ((_o$1835 (keyword #f "right")) (_o$1836 (integer->char 62)) (_o$1837 (keyword #f "allows-separator")) (_o$1838 #t) (_o$1839 (keyword #f "else")) (_o$1840 (keyword #f "first"))) (jolt-hash-map _o$1835 _o$1836 _o$1837 _o$1838 _o$1839 _o$1840))) (_o$1850 (keyword #f "generator-fn")) (_o$1851 (lambda (params offset) (let fnrec1841 ((params params) (offset offset)) (var-deref "clojure.pprint" "logical-block-or-justify"))))) (jolt-hash-map _o$1842 _o$1843 _o$1844 _o$1845 _o$1846 _o$1847 _o$1848 _o$1849 _o$1850 _o$1851))) (_a$1994 (integer->char 62)) (_a$1995 (let* ((_o$1853 (keyword #f "directive")) (_o$1854 (integer->char 62)) (_o$1855 (keyword #f "params")) (_o$1856 (jolt-invoke (var-deref "clojure.core" "array-map"))) (_o$1857 (keyword #f "flags")) (_o$1858 (jolt-hash-set (keyword #f "colon"))) (_o$1859 (keyword #f "bracket-info")) (_o$1860 (jolt-hash-map)) (_o$1861 (keyword #f "generator-fn")) (_o$1862 (lambda (params offset) (let fnrec1852 ((params params) (offset offset)) jolt-nil)))) (jolt-hash-map _o$1853 _o$1854 _o$1855 _o$1856 _o$1857 _o$1858 _o$1859 _o$1860 _o$1861 _o$1862))) (_a$1996 (integer->char 94)) (_a$1997 (let* ((_o$1886 (keyword #f "directive")) (_o$1887 (integer->char 94)) (_o$1888 (keyword #f "params")) (_o$1889 (let* ((_a$1869 (var-deref "clojure.core" "array-map")) (_a$1870 (keyword #f "arg1")) (_a$1871 (let* ((_o$1863 jolt-nil) (_o$1864 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1863 _o$1864))) (_a$1872 (keyword #f "arg2")) (_a$1873 (let* ((_o$1865 jolt-nil) (_o$1866 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1865 _o$1866))) (_a$1874 (keyword #f "arg3")) (_a$1875 (let* ((_o$1867 jolt-nil) (_o$1868 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1867 _o$1868)))) (jolt-invoke _a$1869 _a$1870 _a$1871 _a$1872 _a$1873 _a$1874 _a$1875))) (_o$1890 (keyword #f "flags")) (_o$1891 (jolt-hash-set (keyword #f "colon"))) (_o$1892 (keyword #f "bracket-info")) (_o$1893 (jolt-hash-map)) (_o$1894 (keyword #f "generator-fn")) (_o$1895 (lambda (params offset) (let fnrec1876 ((params params) (offset offset)) (lambda (params navigator offsets) (let fnrec1877 ((params params) (navigator navigator) (offsets offsets)) (let* ((arg1 (jolt-get params (keyword #f "arg1"))) (arg2 (jolt-get params (keyword #f "arg2"))) (arg3 (jolt-get params (keyword #f "arg3"))) (exit (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (keyword #f "colon-up-arrow") (keyword #f "up-arrow")))) (if (jolt-truthy? (let* ((and__25__auto arg1)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto arg2)) (if (jolt-truthy? and__25__auto) arg3 and__25__auto)) and__25__auto))) (if (<= arg1 arg2 arg3) (let* ((_o$1878 exit) (_o$1879 navigator)) (jolt-vector _o$1878 _o$1879)) navigator) (if (jolt-truthy? (let* ((and__25__auto arg1)) (if (jolt-truthy? and__25__auto) arg2 and__25__auto))) (if (jolt= arg1 arg2) (let* ((_o$1880 exit) (_o$1881 navigator)) (jolt-vector _o$1880 _o$1881)) navigator) (if (jolt-truthy? arg1) (if (jolt= arg1 0) (let* ((_o$1882 exit) (_o$1883 navigator)) (jolt-vector _o$1882 _o$1883)) navigator) (if #t (if (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (jolt-empty? (jolt-get (jolt-get params (keyword #f "base-args")) (keyword #f "rest"))) (jolt-empty? (jolt-get navigator (keyword #f "rest")))) (let* ((_o$1884 exit) (_o$1885 navigator)) (jolt-vector _o$1884 _o$1885)) navigator) jolt-nil))))))))))) (jolt-hash-map _o$1886 _o$1887 _o$1888 _o$1889 _o$1890 _o$1891 _o$1892 _o$1893 _o$1894 _o$1895))) (_a$1998 (integer->char 87)) (_a$1999 (let* ((_o$1915 (keyword #f "directive")) (_o$1916 (integer->char 87)) (_o$1917 (keyword #f "params")) (_o$1918 (jolt-invoke (var-deref "clojure.core" "array-map"))) (_o$1919 (keyword #f "flags")) (_o$1920 (let* ((_o$1896 (keyword #f "at")) (_o$1897 (keyword #f "colon")) (_o$1898 (keyword #f "both")) (_o$1899 (keyword #f "pretty"))) (jolt-hash-set _o$1896 _o$1897 _o$1898 _o$1899))) (_o$1921 (keyword #f "bracket-info")) (_o$1922 (jolt-hash-map)) (_o$1923 (keyword #f "generator-fn")) (_o$1924 (lambda (params offset) (let fnrec1900 ((params params) (offset offset)) (if (jolt-truthy? (let* ((or__26__auto (jolt-get params (keyword #f "at")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-get params (keyword #f "colon"))))) (let* ((bindings (let* ((_a$1907 (if (jolt-truthy? (jolt-get params (keyword #f "at"))) (let* ((_o$1901 (keyword #f "level")) (_o$1902 jolt-nil) (_o$1903 (keyword #f "length")) (_o$1904 jolt-nil)) (jolt-vector _o$1901 _o$1902 _o$1903 _o$1904)) (jolt-vector))) (_a$1908 (if (jolt-truthy? (jolt-get params (keyword #f "colon"))) (let* ((_o$1905 (keyword #f "pretty")) (_o$1906 #t)) (jolt-vector _o$1905 _o$1906)) (jolt-vector)))) (jolt-concat _a$1907 _a$1908)))) (lambda (params navigator offsets) (let fnrec1909 ((params params) (navigator navigator) (offsets offsets)) (let* ((G__78 (jolt-invoke (var-deref "clojure.pprint" "next-arg") navigator)) (arg (jolt-nth G__78 0 jolt-nil)) (navigator (jolt-nth G__78 1 jolt-nil))) (if (jolt-truthy? (jolt-apply (var-deref "clojure.pprint" "write") arg bindings)) (let* ((_o$1910 (keyword #f "up-arrow")) (_o$1911 navigator)) (jolt-vector _o$1910 _o$1911)) navigator))))) (lambda (params navigator offsets) (let fnrec1912 ((params params) (navigator navigator) (offsets offsets)) (let* ((G__79 (jolt-invoke (var-deref "clojure.pprint" "next-arg") navigator)) (arg (jolt-nth G__79 0 jolt-nil)) (navigator (jolt-nth G__79 1 jolt-nil))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.pprint" "write-out") arg)) (let* ((_o$1913 (keyword #f "up-arrow")) (_o$1914 navigator)) (jolt-vector _o$1913 _o$1914)) navigator))))))))) (jolt-hash-map _o$1915 _o$1916 _o$1917 _o$1918 _o$1919 _o$1920 _o$1921 _o$1922 _o$1923 _o$1924))) (_a$2000 (integer->char 95)) (_a$2001 (let* ((_o$1929 (keyword #f "directive")) (_o$1930 (integer->char 95)) (_o$1931 (keyword #f "params")) (_o$1932 (jolt-invoke (var-deref "clojure.core" "array-map"))) (_o$1933 (keyword #f "flags")) (_o$1934 (let* ((_o$1925 (keyword #f "at")) (_o$1926 (keyword #f "colon")) (_o$1927 (keyword #f "both"))) (jolt-hash-set _o$1925 _o$1926 _o$1927))) (_o$1935 (keyword #f "bracket-info")) (_o$1936 (jolt-hash-map)) (_o$1937 (keyword #f "generator-fn")) (_o$1938 (lambda (params offset) (let fnrec1928 ((params params) (offset offset)) (var-deref "clojure.pprint" "conditional-newline"))))) (jolt-hash-map _o$1929 _o$1930 _o$1931 _o$1932 _o$1933 _o$1934 _o$1935 _o$1936 _o$1937 _o$1938))) (_a$2002 (integer->char 73)) (_a$2003 (let* ((_o$1942 (keyword #f "directive")) (_o$1943 (integer->char 73)) (_o$1944 (keyword #f "params")) (_o$1945 (jolt-invoke (var-deref "clojure.core" "array-map") (keyword #f "n") (let* ((_o$1939 0) (_o$1940 (var-deref "clojure.core" "Long"))) (jolt-vector _o$1939 _o$1940)))) (_o$1946 (keyword #f "flags")) (_o$1947 (jolt-hash-set (keyword #f "colon"))) (_o$1948 (keyword #f "bracket-info")) (_o$1949 (jolt-hash-map)) (_o$1950 (keyword #f "generator-fn")) (_o$1951 (lambda (params offset) (let fnrec1941 ((params params) (offset offset)) (var-deref "clojure.pprint" "set-indent"))))) (jolt-hash-map _o$1942 _o$1943 _o$1944 _o$1945 _o$1946 _o$1947 _o$1948 _o$1949 _o$1950 _o$1951)))) (jolt-hash-map-fn _a$1952 _a$1953 _a$1954 _a$1955 _a$1956 _a$1957 _a$1958 _a$1959 _a$1960 _a$1961 _a$1962 _a$1963 _a$1964 _a$1965 _a$1966 _a$1967 _a$1968 _a$1969 _a$1970 _a$1971 _a$1972 _a$1973 _a$1974 _a$1975 _a$1976 _a$1977 _a$1978 _a$1979 _a$1980 _a$1981 _a$1982 _a$1983 _a$1984 _a$1985 _a$1986 _a$1987 _a$1988 _a$1989 _a$1990 _a$1991 _a$1992 _a$1993 _a$1994 _a$1995 _a$1996 _a$1997 _a$1998 _a$1999 _a$2000 _a$2001 _a$2002 _a$2003)))) (guard (e (#t #f)) (def-var-with-meta! "clojure.pprint" "param-pattern" (jolt-regex "^([vV]|#|('.)|([+-]?\\d+)|(?=,))") (let* ((_o$2004 (keyword #f "private")) (_o$2005 #t)) (jolt-hash-map _o$2004 _o$2005)))) (guard (e (#t #f)) diff --git a/host/chez/syntax-quote.ss b/host/chez/syntax-quote.ss index a848cbb..edb74c5 100644 --- a/host/chez/syntax-quote.ss +++ b/host/chez/syntax-quote.ss @@ -41,7 +41,9 @@ ;; expansion still re-analyzes as a set literal. (define (jolt-sqset . parts) (apply jolt-hash-set (sq-flatten parts))) ;; map FORM: a plain pmap (the analyzer's form-map? = pmap with no :jolt/type). -(define (jolt-sqmap . parts) (apply jolt-hash-map parts)) +;; Clojure's syntaxQuote builds the map via `apply hash-map`, so a `{...} template +;; is HASH-ordered (unlike a {...} literal, which keeps insertion order). +(define (jolt-sqmap . parts) (jolt-hash-map-build parts)) (def-var! "clojure.core" "__sq1" jolt-sq1) (def-var! "clojure.core" "__sqcat" jolt-sqcat) diff --git a/host/chez/transients.ss b/host/chez/transients.ss index a90cf9a..d2023b5 100644 --- a/host/chez/transients.ss +++ b/host/chez/transients.ss @@ -16,11 +16,17 @@ ;; this record, not a pvec), which group-by relies on. Loaded after collections.ss ;; (persistent ops + key-hash) and converters.ss. +;; For a transient MAP, `n` holds the array-mode capacity (entries it can hold +;; before promoting to hash order) and `ord` the reverse insertion-order key list; +;; for a vector `n` is the element count. A transient array map promotes to hash +;; at max(8, source-count) entries (TransientArrayMap, array sized max(16, len)), +;; with no keyword exception — unlike the persistent assoc growth rule. (define-record-type jolt-transient - (fields kind (mutable buf) (mutable n) (mutable active)) - (nongenerative jolt-transient-v2)) + (fields kind (mutable buf) (mutable n) (mutable active) (mutable ord)) + (nongenerative jolt-transient-v3)) (define tvec-min-cap 8) +(define tmap-min-cap 8) (define (jolt-transient-new coll) (cond @@ -28,16 +34,27 @@ (let* ((v (pvec-v coll)) (cnt (vector-length v)) (cap (fxmax tvec-min-cap cnt)) (buf (make-vector cap jolt-nil))) (let loop ((i 0)) (when (fx? cnt cap) + ;; promoted past the array capacity: hash order + (let ((m empty-pmap-hash)) + (vector-for-each (lambda (k) (set! m (pmap-put-hash m k (hashtable-ref ht k jolt-nil)))) (hashtable-keys ht)) + m) + ;; array map: rebuild in insertion order + (let ((m empty-pmap)) + (for-each (lambda (k) (set! m (pmap-put-ordered m k (hashtable-ref ht k jolt-nil)))) + (reverse (jolt-transient-ord t))) + m)))) ((set) (let ((ht (jolt-transient-buf t)) (s empty-pset)) (vector-for-each (lambda (e) (set! s (pset-conj s e))) (hashtable-keys ht)) @@ -91,8 +116,8 @@ (define (tmap-conj-entry! t x) (cond ((jolt-nil? x) #t) - ((pvec? x) (hashtable-set! (jolt-transient-buf t) (pvec-nth-d x 0 jolt-nil) (pvec-nth-d x 1 jolt-nil))) - ((pmap? x) (pmap-fold x (lambda (k v acc) (hashtable-set! (jolt-transient-buf t) k v) acc) 0)) + ((pvec? x) (tmap-put! t (pvec-nth-d x 0 jolt-nil) (pvec-nth-d x 1 jolt-nil))) + ((pmap? x) (pmap-fold-fwd x (lambda (k v acc) (tmap-put! t k v) acc) 0)) (else (error #f "conj!: a transient map takes a map entry or a map" x)))) ;; (conj!) -> fresh transient vector; (conj! coll) -> the 1-arity transducer- @@ -119,14 +144,14 @@ (let ((kvs (assoc-pad kvs0))) (when (odd? (length kvs)) (error #f "assoc!: no value supplied for key")) (case (jolt-transient-kind t) - ((map) (let lp ((xs kvs)) (unless (null? xs) (hashtable-set! (jolt-transient-buf t) (car xs) (cadr xs)) (lp (cddr xs))))) + ((map) (let lp ((xs kvs)) (unless (null? xs) (tmap-put! t (car xs) (cadr xs)) (lp (cddr xs))))) ((vec) (let lp ((xs kvs)) (unless (null? xs) (tvec-assoc1! t (car xs) (cadr xs)) (lp (cddr xs))))) (else (jolt-transient-buf-set! t (apply jolt-assoc (jolt-transient-buf t) kvs))))) t) (define (jolt-dissoc! t . ks) (jolt-trans-check t "dissoc!") (case (jolt-transient-kind t) - ((map) (for-each (lambda (k) (hashtable-delete! (jolt-transient-buf t) k)) ks)) + ((map) (for-each (lambda (k) (tmap-del! t k)) ks)) (else (jolt-transient-buf-set! t (apply jolt-dissoc (jolt-transient-buf t) ks)))) t) (define (jolt-disj! t . xs) diff --git a/jolt-core/clojure/core/21-coll.clj b/jolt-core/clojure/core/21-coll.clj index 34e85fa..73f8ec5 100644 --- a/jolt-core/clojure/core/21-coll.clj +++ b/jolt-core/clojure/core/21-coll.clj @@ -224,13 +224,14 @@ (defn inst-ms [x] (if (inst? x) (get x :ms) (throw (str "inst-ms requires an inst, got: " x)))) -;; Clojure 1.11 map transformers. PHM base so transformed keys canonicalize -;; (collisions: last entry in seq order wins, matching the reference). +;; Clojure 1.11 map transformers. An empty-map base keeps insertion order; +;; transformed keys canonicalize via assoc (collisions: last entry in seq order +;; wins, matching the reference). (defn update-keys [m f] - (reduce-kv (fn [acc k v] (assoc acc (f k) v)) (hash-map) m)) + (reduce-kv (fn [acc k v] (assoc acc (f k) v)) {} m)) (defn update-vals [m f] - (reduce-kv (fn [acc k v] (assoc acc k (f v))) (hash-map) m)) + (reduce-kv (fn [acc k v] (assoc acc k (f v))) {} m)) ;; Vector-returning partition variants (1.11): lazy seqs OF vectors. (defn partitionv diff --git a/jolt-core/clojure/core/22-coll.clj b/jolt-core/clojure/core/22-coll.clj index 6692330..bbce752 100644 --- a/jolt-core/clojure/core/22-coll.clj +++ b/jolt-core/clojure/core/22-coll.clj @@ -21,14 +21,15 @@ (defn true? [x] (= true x)) (defn false? [x] (= false x)) -;; Presence-preserving: a key with a nil value is kept ((hash-map) base keeps -;; nil values and canonicalizes collection keys). +;; Presence-preserving and order-preserving: a key with a nil value is kept, and +;; the result follows keyseq order (an empty-map base keeps nil values and +;; canonicalizes collection keys). (defn select-keys [map keyseq] (reduce (fn [m k] (if (contains? map k) (assoc m k (get map k)) m)) - (hash-map) keyseq)) + {} keyseq)) (defn zipmap [keys vals] - (loop [m (hash-map) ks (seq keys) vs (seq vals)] + (loop [m {} ks (seq keys) vs (seq vals)] (if (and ks vs) (recur (assoc m (first ks) (first vs)) (next ks) (next vs)) m))) @@ -37,7 +38,7 @@ ;; no-ops; all-nil (or no args) is nil. (defn merge [& maps] (when (some identity maps) - (reduce (fn [acc m] (if (nil? m) acc (conj (or acc (hash-map)) m))) + (reduce (fn [acc m] (if (nil? m) acc (conj (or acc {}) m))) maps))) (defn merge-with [f & maps] @@ -49,7 +50,7 @@ (assoc m k (f (get m k) v)) (assoc m k v)))) merge2 (fn [m1 m2] - (reduce merge-entry (or m1 (hash-map)) (seq m2)))] + (reduce merge-entry (or m1 {}) (seq m2)))] (reduce merge2 maps)))) (defn get-in diff --git a/jolt-core/jolt/backend_scheme.clj b/jolt-core/jolt/backend_scheme.clj index 5653917..d67c421 100644 --- a/jolt-core/jolt/backend_scheme.clj +++ b/jolt-core/jolt/backend_scheme.clj @@ -23,7 +23,7 @@ "=" "jolt=" "inc" "jolt-inc" "dec" "jolt-dec" "not" "jolt-not" "min" "min" "max" "max" "mod" "modulo" "rem" "remainder" "quot" "quotient" - "vector" "jolt-vector" "hash-map" "jolt-hash-map" "hash-set" "jolt-hash-set" + "vector" "jolt-vector" "hash-map" "jolt-hash-map-fn" "hash-set" "jolt-hash-set" "conj" "jolt-conj" "get" "jolt-get" "nth" "jolt-nth" "count" "jolt-count" "assoc" "jolt-assoc" "dissoc" "jolt-dissoc" "contains?" "jolt-contains?" "empty?" "jolt-empty?" "peek" "jolt-peek" "pop" "jolt-pop" diff --git a/test/chez/corpus.edn b/test/chez/corpus.edn index 901fb75..69174b5 100644 --- a/test/chez/corpus.edn +++ b/test/chez/corpus.edn @@ -911,6 +911,25 @@ {:suite "maps / literal construction" :label "equality with phm" :expected "true" :actual "(= {:a 1 :b 2} (assoc {:a 1} :b 2))"} {:suite "maps / literal construction" :label "keys work after assoc" :expected "2" :actual "(:b (assoc {:a 1 :b 2} :c 3))"} {:suite "maps / literal construction" :label "literal in fn body" :expected "12" :actual "(do (defn mfp-mk [x] {:v (* x 2)}) (:v (mfp-mk 6)))"} + {:suite "maps / insertion order" :label "small literal keys" :expected "[:c :a :b]" :actual "(vec (keys {:c 3 :a 1 :b 2}))"} + {:suite "maps / insertion order" :label "small literal vals" :expected "[3 1 2]" :actual "(vec (vals {:c 3 :a 1 :b 2}))"} + {:suite "maps / insertion order" :label "seq follows keys" :expected "[:c :a :b]" :actual "(mapv key (seq {:c 3 :a 1 :b 2}))"} + {:suite "maps / insertion order" :label "array-map any size" :expected "[:z :y :x :w :v :u :t :s :r :q]" :actual "(vec (keys (array-map :z 1 :y 2 :x 3 :w 4 :v 5 :u 6 :t 7 :s 8 :r 9 :q 10)))"} + {:suite "maps / insertion order" :label "assoc appends new key" :expected "[:c :a :z]" :actual "(vec (keys (assoc {:c 3 :a 1} :z 9)))"} + {:suite "maps / insertion order" :label "assoc replace keeps position" :expected "[:c :a]" :actual "(vec (keys (assoc {:c 3 :a 1} :c 9)))"} + {:suite "maps / insertion order" :label "dissoc preserves order" :expected "[:c :b]" :actual "(vec (keys (dissoc {:c 3 :a 1 :b 2} :a)))"} + {:suite "maps / insertion order" :label "into onto empty (<=8)" :expected "[:c :a :b]" :actual "(vec (keys (into {} [[:c 3] [:a 1] [:b 2]])))"} + {:suite "maps / insertion order" :label "reduce assoc" :expected "[:e :d :c :b :a]" :actual "(vec (keys (reduce (fn [m k] (assoc m k k)) {} [:e :d :c :b :a])))"} + {:suite "maps / insertion order" :label "conj a map merges in order" :expected "[:a :b :c]" :actual "(vec (keys (conj {:a 1} {:b 2 :c 3})))"} + {:suite "maps / insertion order" :label "merge keeps right-hand order" :expected "[:a :c :b]" :actual "(vec (keys (merge {:a 1} {:c 3 :b 2})))"} + {:suite "maps / insertion order" :label "assoc stays ordered through 8 entries" :expected "true" :actual "(= (vec (keys (reduce (fn [m i] (assoc m (keyword (str \"k\" i)) i)) {} (range 8)))) (mapv (fn [i] (keyword (str \"k\" i))) (range 8)))"} + {:suite "maps / insertion order" :label "assoc promotes to hash past 8 entries" :expected "9" :actual "(count (reduce (fn [m i] (assoc m (keyword (str \"k\" i)) i)) {} (range 9)))"} + {:suite "maps / insertion order" :label "array-map keeps order past 8" :expected "[:k0 :k1 :k2 :k3 :k4 :k5 :k6 :k7 :k8 :k9 :k10 :k11]" :actual "(vec (keys (apply array-map (mapcat (fn [i] [(keyword (str \"k\" i)) i]) (range 12)))))"} + {:suite "maps / insertion order" :label "update-keys preserves order" :expected "[:a :b :c]" :actual "(vec (keys (update-vals (array-map :a 1 :b 2 :c 3) inc)))"} + {:suite "maps / insertion order" :label "zipmap from ordered keys/vals" :expected "[:c :a :b]" :actual "(vec (keys (zipmap (keys {:c 3 :a 1 :b 2}) (vals {:c 3 :a 1 :b 2}))))"} + {:suite "maps / insertion order" :label "select-keys follows keyseq" :expected "[:c :a]" :actual "(vec (keys (select-keys {:a 1 :b 2 :c 3} [:c :a])))"} + {:suite "maps / insertion order" :label "frequencies first-occurrence order" :expected "[:c :a :b]" :actual "(vec (keys (frequencies [:c :a :b :a])))"} + {:suite "maps / insertion order" :label "group-by first-occurrence order" :expected "[:c :a :b]" :actual "(vec (keys (group-by identity [:c :a :b :a])))"} {:suite "clojure.math" :label "sqrt" :expected "true" :actual "(< 1.4142 (clojure.math/sqrt 2) 1.4143)"} {:suite "clojure.math" :label "pow" :expected "1024" :actual "(long (clojure.math/pow 2 10))"} {:suite "clojure.math" :label "tan of 0" :expected "0" :actual "(long (clojure.math/tan 0))"}