From f7767706cf23231b03a3bfad2f3fecbb9e9a05fe Mon Sep 17 00:00:00 2001 From: Yogthos Date: Tue, 23 Jun 2026 02:06:24 -0400 Subject: [PATCH] Split 20-coll.clj into three collection-tier files The 1123-line collection tier is the largest source file. Cut it at two existing section banners into 20-coll (predicates, printing, hierarchies, pure-over-core leaves), 21-coll (rand/sort seams, the test runner, fn combinators), and 22-coll (canonical Clojure ports, transduce/into, JVM-shape stubs). No macros in this tier, so order is the only constraint; the emit-image manifest lists the three in sequence. Re-minted seed is identical apart from gensym label renumbering. --- host/chez/emit-image.ss | 2 +- host/chez/seed/prelude.ss | 458 ++++++++++---------- jolt-core/clojure/core/20-coll.clj | 668 ----------------------------- jolt-core/clojure/core/21-coll.clj | 362 ++++++++++++++++ jolt-core/clojure/core/22-coll.clj | 314 ++++++++++++++ 5 files changed, 906 insertions(+), 898 deletions(-) create mode 100644 jolt-core/clojure/core/21-coll.clj create mode 100644 jolt-core/clojure/core/22-coll.clj diff --git a/host/chez/emit-image.ss b/host/chez/emit-image.ss index 2e427dc..4ca6b83 100644 --- a/host/chez/emit-image.ss +++ b/host/chez/emit-image.ss @@ -103,7 +103,7 @@ (define ei-prelude-ns-files (append (map (lambda (tf) (cons "clojure.core" (string-append "jolt-core/clojure/core/" tf ".clj"))) - '("00-syntax" "00-kernel" "10-seq" "20-coll" "25-sorted" "30-macros" "40-lazy" "50-io")) + '("00-syntax" "00-kernel" "10-seq" "20-coll" "21-coll" "22-coll" "25-sorted" "30-macros" "40-lazy" "50-io")) (list (cons "clojure.string" "stdlib/clojure/string.clj") (cons "clojure.walk" "stdlib/clojure/walk.clj") (cons "clojure.template" "stdlib/clojure/template.clj") diff --git a/host/chez/seed/prelude.ss b/host/chez/seed/prelude.ss index fb3be3c..d4ab0ca 100644 --- a/host/chez/seed/prelude.ss +++ b/host/chez/seed/prelude.ss @@ -113,385 +113,385 @@ (guard (e (#t #f)) (def-var! "clojure.core" "update" (letrec ((update (lambda (m k f . args) (let fnrec2876 ((m m) (k k) (f f) (args (list->cseq args))) (jolt-assoc m k (jolt-apply f (jolt-get m k) args)))))) update))) (guard (e (#t #f)) - (def-var! "clojure.core" "vreset!" (letrec ((vreset! (lambda (vol newval) (let fnrec1677 ((vol vol) (newval newval)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") vol (keyword #f "val") newval) newval))))) vreset!))) + (def-var! "clojure.core" "vreset!" (letrec ((vreset! (lambda (vol newval) (let fnrec2046 ((vol vol) (newval newval)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") vol (keyword #f "val") newval) newval))))) vreset!))) (guard (e (#t #f)) - (def-var! "clojure.core" "vswap!" (letrec ((vswap! (lambda (vol f . args) (let fnrec1678 ((vol vol) (f f) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "vreset!") vol (jolt-apply f (jolt-get vol (keyword #f "val")) args)))))) vswap!))) + (def-var! "clojure.core" "vswap!" (letrec ((vswap! (lambda (vol f . args) (let fnrec2047 ((vol vol) (f f) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "vreset!") vol (jolt-apply f (jolt-get vol (keyword #f "val")) args)))))) vswap!))) (guard (e (#t #f)) - (def-var! "clojure.core" "ffirst" (letrec ((ffirst (lambda (coll) (let fnrec1679 ((coll coll)) (jolt-first (jolt-first coll)))))) ffirst))) + (def-var! "clojure.core" "ffirst" (letrec ((ffirst (lambda (coll) (let fnrec2048 ((coll coll)) (jolt-first (jolt-first coll)))))) ffirst))) (guard (e (#t #f)) - (def-var! "clojure.core" "nfirst" (letrec ((nfirst (lambda (coll) (let fnrec1680 ((coll coll)) (jolt-next (jolt-first coll)))))) nfirst))) + (def-var! "clojure.core" "nfirst" (letrec ((nfirst (lambda (coll) (let fnrec2049 ((coll coll)) (jolt-next (jolt-first coll)))))) nfirst))) (guard (e (#t #f)) - (def-var! "clojure.core" "fnext" (letrec ((fnext (lambda (coll) (let fnrec1681 ((coll coll)) (jolt-first (jolt-next coll)))))) fnext))) + (def-var! "clojure.core" "fnext" (letrec ((fnext (lambda (coll) (let fnrec2050 ((coll coll)) (jolt-first (jolt-next coll)))))) fnext))) (guard (e (#t #f)) - (def-var! "clojure.core" "nnext" (letrec ((nnext (lambda (coll) (let fnrec1682 ((coll coll)) (jolt-next (jolt-next coll)))))) nnext))) + (def-var! "clojure.core" "nnext" (letrec ((nnext (lambda (coll) (let fnrec2051 ((coll coll)) (jolt-next (jolt-next coll)))))) nnext))) (guard (e (#t #f)) - (def-var! "clojure.core" "last" (letrec ((last (lambda (s) (let fnrec1683 ((s s)) (if (jolt-truthy? (jolt-next s)) (fnrec1683 (jolt-next s)) (jolt-first s)))))) last))) + (def-var! "clojure.core" "last" (letrec ((last (lambda (s) (let fnrec2052 ((s s)) (if (jolt-truthy? (jolt-next s)) (fnrec2052 (jolt-next s)) (jolt-first s)))))) last))) (guard (e (#t #f)) - (def-var! "clojure.core" "butlast" (letrec ((butlast (lambda (s) (let fnrec1684 ((s s)) (let* ((ret (jolt-vector)) (s s)) (let loop1685 ((ret ret) (s s)) (if (jolt-truthy? (jolt-next s)) (let* ((_a$1686 (jolt-conj ret (jolt-first s))) (_a$1687 (jolt-next s))) (loop1685 _a$1686 _a$1687)) (jolt-seq ret)))))))) butlast))) + (def-var! "clojure.core" "butlast" (letrec ((butlast (lambda (s) (let fnrec2053 ((s s)) (let* ((ret (jolt-vector)) (s s)) (let loop2054 ((ret ret) (s s)) (if (jolt-truthy? (jolt-next s)) (let* ((_a$2055 (jolt-conj ret (jolt-first s))) (_a$2056 (jolt-next s))) (loop2054 _a$2055 _a$2056)) (jolt-seq ret)))))))) butlast))) (guard (e (#t #f)) - (def-var! "clojure.core" "partition-by" (letrec ((partition-by (case-lambda ((f) (let fnrec1688 ((f f)) (lambda (rf) (let fnrec1689 ((rf rf)) (let* ((buf (jolt-invoke (var-deref "clojure.core" "volatile!") (jolt-vector))) (pv (jolt-invoke (var-deref "clojure.core" "volatile!") jolt-nil)) (started (jolt-invoke (var-deref "clojure.core" "volatile!") #f))) (case-lambda (() (let fnrec1690 () (jolt-invoke rf))) ((result) (let fnrec1691 ((result result)) (let* ((b (jolt-invoke (var-deref "clojure.core" "deref") buf)) (result (if (jolt-zero? (jolt-count b)) result (begin (jolt-invoke (var-deref "clojure.core" "vreset!") buf (jolt-vector)) (jolt-invoke (var-deref "clojure.core" "unreduced") (jolt-invoke rf result b)))))) (jolt-invoke rf result)))) ((result input) (let fnrec1692 ((result result) (input input)) (let* ((val (jolt-invoke f input))) (if (jolt-truthy? (let* ((or__14__auto (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") started)))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= val (jolt-invoke (var-deref "clojure.core" "deref") pv))))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") started #t) (jolt-invoke (var-deref "clojure.core" "vreset!") pv val) (jolt-invoke (var-deref "clojure.core" "vswap!") buf jolt-conj input) result) (let* ((b (jolt-invoke (var-deref "clojure.core" "deref") buf))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") buf (jolt-vector)) (jolt-invoke (var-deref "clojure.core" "vreset!") pv val) (let* ((ret (jolt-invoke rf result b))) (begin (if (jolt-not (jolt-invoke (var-deref "clojure.core" "reduced?") ret)) (jolt-invoke (var-deref "clojure.core" "vswap!") buf jolt-conj input) jolt-nil) ret)))))))))))))) ((f coll) (let fnrec1693 ((f f) (coll coll)) (let* ((step (letrec ((step (lambda (s) (let fnrec1694 ((s s)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1695 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s (jolt-seq s))) (if (jolt-truthy? s) (let* ((fst (jolt-first s)) (fv (jolt-invoke f fst)) (run (jolt-cons fst (let* ((_a$1697 (var-deref "clojure.core" "take-while")) (_a$1698 (lambda (x) (let fnrec1696 ((x x)) (jolt= fv (jolt-invoke f x))))) (_a$1699 (jolt-rest s))) (jolt-invoke _a$1697 _a$1698 _a$1699))))) (jolt-cons run (jolt-invoke step (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1700 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-drop (jolt-count run) s)))))))) jolt-nil)))))))))) step))) (jolt-invoke step coll))))))) partition-by))) + (def-var! "clojure.core" "partition-by" (letrec ((partition-by (case-lambda ((f) (let fnrec2057 ((f f)) (lambda (rf) (let fnrec2058 ((rf rf)) (let* ((buf (jolt-invoke (var-deref "clojure.core" "volatile!") (jolt-vector))) (pv (jolt-invoke (var-deref "clojure.core" "volatile!") jolt-nil)) (started (jolt-invoke (var-deref "clojure.core" "volatile!") #f))) (case-lambda (() (let fnrec2059 () (jolt-invoke rf))) ((result) (let fnrec2060 ((result result)) (let* ((b (jolt-invoke (var-deref "clojure.core" "deref") buf)) (result (if (jolt-zero? (jolt-count b)) result (begin (jolt-invoke (var-deref "clojure.core" "vreset!") buf (jolt-vector)) (jolt-invoke (var-deref "clojure.core" "unreduced") (jolt-invoke rf result b)))))) (jolt-invoke rf result)))) ((result input) (let fnrec2061 ((result result) (input input)) (let* ((val (jolt-invoke f input))) (if (jolt-truthy? (let* ((or__14__auto (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") started)))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= val (jolt-invoke (var-deref "clojure.core" "deref") pv))))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") started #t) (jolt-invoke (var-deref "clojure.core" "vreset!") pv val) (jolt-invoke (var-deref "clojure.core" "vswap!") buf jolt-conj input) result) (let* ((b (jolt-invoke (var-deref "clojure.core" "deref") buf))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") buf (jolt-vector)) (jolt-invoke (var-deref "clojure.core" "vreset!") pv val) (let* ((ret (jolt-invoke rf result b))) (begin (if (jolt-not (jolt-invoke (var-deref "clojure.core" "reduced?") ret)) (jolt-invoke (var-deref "clojure.core" "vswap!") buf jolt-conj input) jolt-nil) ret)))))))))))))) ((f coll) (let fnrec2062 ((f f) (coll coll)) (let* ((step (letrec ((step (lambda (s) (let fnrec2063 ((s s)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2064 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s (jolt-seq s))) (if (jolt-truthy? s) (let* ((fst (jolt-first s)) (fv (jolt-invoke f fst)) (run (jolt-cons fst (let* ((_a$2066 (var-deref "clojure.core" "take-while")) (_a$2067 (lambda (x) (let fnrec2065 ((x x)) (jolt= fv (jolt-invoke f x))))) (_a$2068 (jolt-rest s))) (jolt-invoke _a$2066 _a$2067 _a$2068))))) (jolt-cons run (jolt-invoke step (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2069 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-drop (jolt-count run) s)))))))) jolt-nil)))))))))) step))) (jolt-invoke step coll))))))) partition-by))) (guard (e (#t #f)) - (def-var! "clojure.core" "some?" (letrec ((some? (lambda (x) (let fnrec1701 ((x x)) (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") x)))))) some?))) + (def-var! "clojure.core" "some?" (letrec ((some? (lambda (x) (let fnrec2070 ((x x)) (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") x)))))) some?))) (guard (e (#t #f)) - (def-var! "clojure.core" "identity" (letrec ((identity (lambda (x) (let fnrec1702 ((x x)) x)))) identity))) + (def-var! "clojure.core" "identity" (letrec ((identity (lambda (x) (let fnrec2071 ((x x)) x)))) identity))) (guard (e (#t #f)) - (def-var! "clojure.core" "constantly" (letrec ((constantly (lambda (x) (let fnrec1703 ((x x)) (lambda args (let fnrec1704 ((args (list->cseq args))) x)))))) constantly))) + (def-var! "clojure.core" "constantly" (letrec ((constantly (lambda (x) (let fnrec2072 ((x x)) (lambda args (let fnrec2073 ((args (list->cseq args))) x)))))) constantly))) (guard (e (#t #f)) - (def-var! "clojure.core" "neg?" (letrec ((neg? (lambda (x) (let fnrec1705 ((x x)) (< x 0))))) neg?))) + (def-var! "clojure.core" "neg?" (letrec ((neg? (lambda (x) (let fnrec2074 ((x x)) (< x 0))))) neg?))) (guard (e (#t #f)) - (def-var! "clojure.core" "bit-and" (letrec ((bit-and (case-lambda ((x y) (let fnrec1706 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-and") x y))) ((x y . more) (let fnrec1707 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-and") (jolt-invoke (var-deref "clojure.core" "__bit-and") x y) more)))))) bit-and))) + (def-var! "clojure.core" "bit-and" (letrec ((bit-and (case-lambda ((x y) (let fnrec2075 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-and") x y))) ((x y . more) (let fnrec2076 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-and") (jolt-invoke (var-deref "clojure.core" "__bit-and") x y) more)))))) bit-and))) (guard (e (#t #f)) - (def-var! "clojure.core" "bit-or" (letrec ((bit-or (case-lambda ((x y) (let fnrec1708 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-or") x y))) ((x y . more) (let fnrec1709 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-or") (jolt-invoke (var-deref "clojure.core" "__bit-or") x y) more)))))) bit-or))) + (def-var! "clojure.core" "bit-or" (letrec ((bit-or (case-lambda ((x y) (let fnrec2077 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-or") x y))) ((x y . more) (let fnrec2078 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-or") (jolt-invoke (var-deref "clojure.core" "__bit-or") x y) more)))))) bit-or))) (guard (e (#t #f)) - (def-var! "clojure.core" "bit-xor" (letrec ((bit-xor (case-lambda ((x y) (let fnrec1710 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-xor") x y))) ((x y . more) (let fnrec1711 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-xor") (jolt-invoke (var-deref "clojure.core" "__bit-xor") x y) more)))))) bit-xor))) + (def-var! "clojure.core" "bit-xor" (letrec ((bit-xor (case-lambda ((x y) (let fnrec2079 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-xor") x y))) ((x y . more) (let fnrec2080 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-xor") (jolt-invoke (var-deref "clojure.core" "__bit-xor") x y) more)))))) bit-xor))) (guard (e (#t #f)) - (def-var! "clojure.core" "bit-and-not" (letrec ((bit-and-not (case-lambda ((x y) (let fnrec1712 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-and-not") x y))) ((x y . more) (let fnrec1713 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-and-not") (jolt-invoke (var-deref "clojure.core" "__bit-and-not") x y) more)))))) bit-and-not))) + (def-var! "clojure.core" "bit-and-not" (letrec ((bit-and-not (case-lambda ((x y) (let fnrec2081 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-and-not") x y))) ((x y . more) (let fnrec2082 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-and-not") (jolt-invoke (var-deref "clojure.core" "__bit-and-not") x y) more)))))) bit-and-not))) (guard (e (#t #f)) - (def-var! "clojure.core" "pr-str" (letrec ((pr-str (lambda xs (let fnrec1714 ((xs (list->cseq xs))) (let* ((out "") (s (jolt-seq xs)) (first? #t)) (let loop1715 ((out out) (s s) (first? first?)) (if (jolt-truthy? s) (let* ((_a$1720 (let* ((_a$1716 (var-deref "clojure.core" "str")) (_a$1717 out) (_a$1718 (if (jolt-truthy? first?) "" " ")) (_a$1719 (jolt-invoke (var-deref "clojure.core" "__pr-str1") (jolt-first s)))) (jolt-invoke _a$1716 _a$1717 _a$1718 _a$1719))) (_a$1721 (jolt-next s)) (_a$1722 #f)) (loop1715 _a$1720 _a$1721 _a$1722)) out))))))) pr-str))) + (def-var! "clojure.core" "pr-str" (letrec ((pr-str (lambda xs (let fnrec2083 ((xs (list->cseq xs))) (let* ((out "") (s (jolt-seq xs)) (first? #t)) (let loop2084 ((out out) (s s) (first? first?)) (if (jolt-truthy? s) (let* ((_a$2089 (let* ((_a$2085 (var-deref "clojure.core" "str")) (_a$2086 out) (_a$2087 (if (jolt-truthy? first?) "" " ")) (_a$2088 (jolt-invoke (var-deref "clojure.core" "__pr-str1") (jolt-first s)))) (jolt-invoke _a$2085 _a$2086 _a$2087 _a$2088))) (_a$2090 (jolt-next s)) (_a$2091 #f)) (loop2084 _a$2089 _a$2090 _a$2091)) out))))))) pr-str))) (guard (e (#t #f)) - (def-var! "clojure.core" "pr" (letrec ((pr (lambda xs (let fnrec1723 ((xs (list->cseq xs))) (begin (jolt-invoke (var-deref "clojure.core" "__write") (jolt-apply (var-deref "clojure.core" "pr-str") xs)) jolt-nil))))) pr))) + (def-var! "clojure.core" "pr" (letrec ((pr (lambda xs (let fnrec2092 ((xs (list->cseq xs))) (begin (jolt-invoke (var-deref "clojure.core" "__write") (jolt-apply (var-deref "clojure.core" "pr-str") xs)) jolt-nil))))) pr))) (guard (e (#t #f)) - (def-var! "clojure.core" "prn" (letrec ((prn (lambda xs (let fnrec1724 ((xs (list->cseq xs))) (begin (jolt-apply (var-deref "clojure.core" "pr") xs) (jolt-invoke (var-deref "clojure.core" "__write") "\n") jolt-nil))))) prn))) + (def-var! "clojure.core" "prn" (letrec ((prn (lambda xs (let fnrec2093 ((xs (list->cseq xs))) (begin (jolt-apply (var-deref "clojure.core" "pr") xs) (jolt-invoke (var-deref "clojure.core" "__write") "\n") jolt-nil))))) prn))) (guard (e (#t #f)) - (def-var! "clojure.core" "print" (letrec ((print (lambda xs (let fnrec1725 ((xs (list->cseq xs))) (begin (jolt-invoke (var-deref "clojure.core" "__write") (let* ((out "") (s (jolt-seq xs)) (first? #t)) (let loop1726 ((out out) (s s) (first? first?)) (if (jolt-truthy? s) (let* ((x (jolt-first s)) (r (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") x)) "nil" (jolt-invoke (var-deref "clojure.core" "str") x)))) (let* ((_a$1727 (jolt-invoke (var-deref "clojure.core" "str") out (if (jolt-truthy? first?) "" " ") r)) (_a$1728 (jolt-next s)) (_a$1729 #f)) (loop1726 _a$1727 _a$1728 _a$1729))) out)))) jolt-nil))))) print))) + (def-var! "clojure.core" "print" (letrec ((print (lambda xs (let fnrec2094 ((xs (list->cseq xs))) (begin (jolt-invoke (var-deref "clojure.core" "__write") (let* ((out "") (s (jolt-seq xs)) (first? #t)) (let loop2095 ((out out) (s s) (first? first?)) (if (jolt-truthy? s) (let* ((x (jolt-first s)) (r (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") x)) "nil" (jolt-invoke (var-deref "clojure.core" "str") x)))) (let* ((_a$2096 (jolt-invoke (var-deref "clojure.core" "str") out (if (jolt-truthy? first?) "" " ") r)) (_a$2097 (jolt-next s)) (_a$2098 #f)) (loop2095 _a$2096 _a$2097 _a$2098))) out)))) jolt-nil))))) print))) (guard (e (#t #f)) - (def-var! "clojure.core" "println" (letrec ((println (lambda xs (let fnrec1730 ((xs (list->cseq xs))) (begin (jolt-apply (var-deref "clojure.core" "print") xs) (jolt-invoke (var-deref "clojure.core" "__write") "\n") jolt-nil))))) println))) + (def-var! "clojure.core" "println" (letrec ((println (lambda xs (let fnrec2099 ((xs (list->cseq xs))) (begin (jolt-apply (var-deref "clojure.core" "print") xs) (jolt-invoke (var-deref "clojure.core" "__write") "\n") jolt-nil))))) println))) (guard (e (#t #f)) - (def-var! "clojure.core" "frequencies" (letrec ((frequencies (lambda (coll) (let fnrec1731 ((coll coll)) (jolt-invoke (var-deref "clojure.core" "persistent!") (let* ((_a$1733 (lambda (counts x) (let fnrec1732 ((counts counts) (x x)) (jolt-invoke (var-deref "clojure.core" "assoc!") counts x (jolt-inc (jolt-get counts x 0)))))) (_a$1734 (jolt-invoke (var-deref "clojure.core" "transient") (jolt-hash-map))) (_a$1735 coll)) (jolt-reduce _a$1733 _a$1734 _a$1735))))))) frequencies))) + (def-var! "clojure.core" "frequencies" (letrec ((frequencies (lambda (coll) (let fnrec2100 ((coll coll)) (jolt-invoke (var-deref "clojure.core" "persistent!") (let* ((_a$2102 (lambda (counts x) (let fnrec2101 ((counts counts) (x x)) (jolt-invoke (var-deref "clojure.core" "assoc!") counts x (jolt-inc (jolt-get counts x 0)))))) (_a$2103 (jolt-invoke (var-deref "clojure.core" "transient") (jolt-hash-map))) (_a$2104 coll)) (jolt-reduce _a$2102 _a$2103 _a$2104))))))) frequencies))) (guard (e (#t #f)) - (def-var! "clojure.core" "group-by" (letrec ((group-by (lambda (f coll) (let fnrec1736 ((f f) (coll coll)) (let* ((tm (jolt-invoke (var-deref "clojure.core" "transient") (jolt-hash-map))) (ks (let* ((_a$1738 (lambda (ks x) (let fnrec1737 ((ks ks) (x x)) (let* ((k (jolt-invoke f x)) (b (jolt-get tm k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) (begin (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-vector x)) (jolt-invoke (var-deref "clojure.core" "conj!") ks k)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") b)) (begin (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-invoke (var-deref "clojure.core" "conj!") (jolt-invoke (var-deref "clojure.core" "transient") b) x)) ks) (begin (jolt-invoke (var-deref "clojure.core" "conj!") b x) ks))))))) (_a$1739 (jolt-invoke (var-deref "clojure.core" "transient") (jolt-vector))) (_a$1740 coll)) (jolt-reduce _a$1738 _a$1739 _a$1740)))) (begin (let* ((_a$1742 (lambda (_ k) (let fnrec1741 ((_ _) (k k)) (let* ((b (jolt-get tm k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") b)) jolt-nil (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-invoke (var-deref "clojure.core" "persistent!") b))))))) (_a$1743 jolt-nil) (_a$1744 (jolt-invoke (var-deref "clojure.core" "persistent!") ks))) (jolt-reduce _a$1742 _a$1743 _a$1744)) (jolt-invoke (var-deref "clojure.core" "persistent!") tm))))))) group-by))) + (def-var! "clojure.core" "group-by" (letrec ((group-by (lambda (f coll) (let fnrec2105 ((f f) (coll coll)) (let* ((tm (jolt-invoke (var-deref "clojure.core" "transient") (jolt-hash-map))) (ks (let* ((_a$2107 (lambda (ks x) (let fnrec2106 ((ks ks) (x x)) (let* ((k (jolt-invoke f x)) (b (jolt-get tm k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) (begin (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-vector x)) (jolt-invoke (var-deref "clojure.core" "conj!") ks k)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") b)) (begin (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-invoke (var-deref "clojure.core" "conj!") (jolt-invoke (var-deref "clojure.core" "transient") b) x)) ks) (begin (jolt-invoke (var-deref "clojure.core" "conj!") b x) ks))))))) (_a$2108 (jolt-invoke (var-deref "clojure.core" "transient") (jolt-vector))) (_a$2109 coll)) (jolt-reduce _a$2107 _a$2108 _a$2109)))) (begin (let* ((_a$2111 (lambda (_ k) (let fnrec2110 ((_ _) (k k)) (let* ((b (jolt-get tm k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") b)) jolt-nil (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-invoke (var-deref "clojure.core" "persistent!") b))))))) (_a$2112 jolt-nil) (_a$2113 (jolt-invoke (var-deref "clojure.core" "persistent!") ks))) (jolt-reduce _a$2111 _a$2112 _a$2113)) (jolt-invoke (var-deref "clojure.core" "persistent!") tm))))))) group-by))) (guard (e (#t #f)) - (def-var! "clojure.core" "not-empty" (letrec ((not-empty (lambda (coll) (let fnrec1745 ((coll coll)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") coll))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-zero? (jolt-count coll))))) jolt-nil coll))))) not-empty))) + (def-var! "clojure.core" "not-empty" (letrec ((not-empty (lambda (coll) (let fnrec2114 ((coll coll)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") coll))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-zero? (jolt-count coll))))) jolt-nil coll))))) not-empty))) (guard (e (#t #f)) - (def-var! "clojure.core" "filterv" (letrec ((filterv (lambda (pred coll) (let fnrec1746 ((pred pred) (coll coll)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-filter pred coll)))))) filterv))) + (def-var! "clojure.core" "filterv" (letrec ((filterv (lambda (pred coll) (let fnrec2115 ((pred pred) (coll coll)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-filter pred coll)))))) filterv))) (guard (e (#t #f)) - (def-var! "clojure.core" "max-key" (letrec ((max-key (case-lambda ((k x) (let fnrec1747 ((k k) (x x)) x)) ((k x y) (let fnrec1748 ((k k) (x x) (y y)) (if (let* ((_a$1749 (jolt-invoke k x)) (_a$1750 (jolt-invoke k y))) (> _a$1749 _a$1750)) x y))) ((k x y . more) (let fnrec1751 ((k k) (x x) (y y) (more (list->cseq more))) (let* ((kx (jolt-invoke k x)) (ky (jolt-invoke k y)) (v (if (> kx ky) x y)) (kv (if (> kx ky) kx ky))) (let* ((v v) (kv kv) (more more)) (let loop1752 ((v v) (kv kv) (more more)) (if (jolt-truthy? (jolt-seq more)) (let* ((w (jolt-first more)) (kw (jolt-invoke k w))) (if (>= kw kv) (loop1752 w kw (jolt-next more)) (loop1752 v kv (jolt-next more)))) v))))))))) max-key))) + (def-var! "clojure.core" "max-key" (letrec ((max-key (case-lambda ((k x) (let fnrec2116 ((k k) (x x)) x)) ((k x y) (let fnrec2117 ((k k) (x x) (y y)) (if (let* ((_a$2118 (jolt-invoke k x)) (_a$2119 (jolt-invoke k y))) (> _a$2118 _a$2119)) x y))) ((k x y . more) (let fnrec2120 ((k k) (x x) (y y) (more (list->cseq more))) (let* ((kx (jolt-invoke k x)) (ky (jolt-invoke k y)) (v (if (> kx ky) x y)) (kv (if (> kx ky) kx ky))) (let* ((v v) (kv kv) (more more)) (let loop2121 ((v v) (kv kv) (more more)) (if (jolt-truthy? (jolt-seq more)) (let* ((w (jolt-first more)) (kw (jolt-invoke k w))) (if (>= kw kv) (loop2121 w kw (jolt-next more)) (loop2121 v kv (jolt-next more)))) v))))))))) max-key))) (guard (e (#t #f)) - (def-var! "clojure.core" "min-key" (letrec ((min-key (case-lambda ((k x) (let fnrec1753 ((k k) (x x)) x)) ((k x y) (let fnrec1754 ((k k) (x x) (y y)) (if (let* ((_a$1755 (jolt-invoke k x)) (_a$1756 (jolt-invoke k y))) (< _a$1755 _a$1756)) x y))) ((k x y . more) (let fnrec1757 ((k k) (x x) (y y) (more (list->cseq more))) (let* ((kx (jolt-invoke k x)) (ky (jolt-invoke k y)) (v (if (< kx ky) x y)) (kv (if (< kx ky) kx ky))) (let* ((v v) (kv kv) (more more)) (let loop1758 ((v v) (kv kv) (more more)) (if (jolt-truthy? (jolt-seq more)) (let* ((w (jolt-first more)) (kw (jolt-invoke k w))) (if (<= kw kv) (loop1758 w kw (jolt-next more)) (loop1758 v kv (jolt-next more)))) v))))))))) min-key))) + (def-var! "clojure.core" "min-key" (letrec ((min-key (case-lambda ((k x) (let fnrec2122 ((k k) (x x)) x)) ((k x y) (let fnrec2123 ((k k) (x x) (y y)) (if (let* ((_a$2124 (jolt-invoke k x)) (_a$2125 (jolt-invoke k y))) (< _a$2124 _a$2125)) x y))) ((k x y . more) (let fnrec2126 ((k k) (x x) (y y) (more (list->cseq more))) (let* ((kx (jolt-invoke k x)) (ky (jolt-invoke k y)) (v (if (< kx ky) x y)) (kv (if (< kx ky) kx ky))) (let* ((v v) (kv kv) (more more)) (let loop2127 ((v v) (kv kv) (more more)) (if (jolt-truthy? (jolt-seq more)) (let* ((w (jolt-first more)) (kw (jolt-invoke k w))) (if (<= kw kv) (loop2127 w kw (jolt-next more)) (loop2127 v kv (jolt-next more)))) v))))))))) min-key))) (guard (e (#t #f)) - (def-var! "clojure.core" "juxt" (letrec ((juxt (lambda fs (let fnrec1759 ((fs (list->cseq fs))) (lambda args (let fnrec1760 ((args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (f) (let fnrec1761 ((f f)) (jolt-apply f args))) fs))))))) juxt))) + (def-var! "clojure.core" "juxt" (letrec ((juxt (lambda fs (let fnrec2128 ((fs (list->cseq fs))) (lambda args (let fnrec2129 ((args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (f) (let fnrec2130 ((f f)) (jolt-apply f args))) fs))))))) juxt))) (guard (e (#t #f)) - (def-var! "clojure.core" "every-pred" (letrec ((every-pred (lambda preds (let fnrec1762 ((preds (list->cseq preds))) (lambda xs (let fnrec1763 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (p) (let fnrec1764 ((p p)) (jolt-invoke (var-deref "clojure.core" "every?") p xs))) preds))))))) every-pred))) + (def-var! "clojure.core" "every-pred" (letrec ((every-pred (lambda preds (let fnrec2131 ((preds (list->cseq preds))) (lambda xs (let fnrec2132 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (p) (let fnrec2133 ((p p)) (jolt-invoke (var-deref "clojure.core" "every?") p xs))) preds))))))) every-pred))) (guard (e (#t #f)) - (def-var! "clojure.core" "some" (letrec ((some (lambda (pred coll) (let fnrec1765 ((pred pred) (coll coll)) (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((or__14__auto (jolt-invoke pred (jolt-first s)))) (if (jolt-truthy? or__14__auto) or__14__auto (fnrec1765 pred (jolt-next s))))) jolt-nil)))))) some))) + (def-var! "clojure.core" "some" (letrec ((some (lambda (pred coll) (let fnrec2134 ((pred pred) (coll coll)) (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((or__14__auto (jolt-invoke pred (jolt-first s)))) (if (jolt-truthy? or__14__auto) or__14__auto (fnrec2134 pred (jolt-next s))))) jolt-nil)))))) some))) (guard (e (#t #f)) - (def-var! "clojure.core" "some-fn" (letrec ((some-fn (lambda preds (let fnrec1766 ((preds (list->cseq preds))) (lambda xs (let fnrec1767 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "some") (lambda (p) (let fnrec1768 ((p p)) (jolt-invoke (var-deref "clojure.core" "some") p xs))) preds))))))) some-fn))) + (def-var! "clojure.core" "some-fn" (letrec ((some-fn (lambda preds (let fnrec2135 ((preds (list->cseq preds))) (lambda xs (let fnrec2136 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "some") (lambda (p) (let fnrec2137 ((p p)) (jolt-invoke (var-deref "clojure.core" "some") p xs))) preds))))))) some-fn))) (guard (e (#t #f)) - (def-var! "clojure.core" "not-any?" (letrec ((not-any? (lambda (pred coll) (let fnrec1769 ((pred pred) (coll coll)) (jolt-not (jolt-invoke (var-deref "clojure.core" "some") pred coll)))))) not-any?))) + (def-var! "clojure.core" "not-any?" (letrec ((not-any? (lambda (pred coll) (let fnrec2138 ((pred pred) (coll coll)) (jolt-not (jolt-invoke (var-deref "clojure.core" "some") pred coll)))))) not-any?))) (guard (e (#t #f)) - (def-var! "clojure.core" "not-every?" (letrec ((not-every? (lambda (pred coll) (let fnrec1770 ((pred pred) (coll coll)) (jolt-not (jolt-invoke (var-deref "clojure.core" "every?") pred coll)))))) not-every?))) + (def-var! "clojure.core" "not-every?" (letrec ((not-every? (lambda (pred coll) (let fnrec2139 ((pred pred) (coll coll)) (jolt-not (jolt-invoke (var-deref "clojure.core" "every?") pred coll)))))) not-every?))) (guard (e (#t #f)) - (def-var! "clojure.core" "split-at" (letrec ((split-at (lambda (n coll) (let fnrec1771 ((n n) (coll coll)) (let* ((_o$1772 (jolt-take n coll)) (_o$1773 (jolt-drop n coll))) (jolt-vector _o$1772 _o$1773)))))) split-at))) + (def-var! "clojure.core" "split-at" (letrec ((split-at (lambda (n coll) (let fnrec2140 ((n n) (coll coll)) (let* ((_o$2141 (jolt-take n coll)) (_o$2142 (jolt-drop n coll))) (jolt-vector _o$2141 _o$2142)))))) split-at))) (guard (e (#t #f)) - (def-var! "clojure.core" "split-with" (letrec ((split-with (lambda (pred coll) (let fnrec1774 ((pred pred) (coll coll)) (let* ((_o$1775 (jolt-invoke (var-deref "clojure.core" "take-while") pred coll)) (_o$1776 (jolt-invoke (var-deref "clojure.core" "drop-while") pred coll))) (jolt-vector _o$1775 _o$1776)))))) split-with))) + (def-var! "clojure.core" "split-with" (letrec ((split-with (lambda (pred coll) (let fnrec2143 ((pred pred) (coll coll)) (let* ((_o$2144 (jolt-invoke (var-deref "clojure.core" "take-while") pred coll)) (_o$2145 (jolt-invoke (var-deref "clojure.core" "drop-while") pred coll))) (jolt-vector _o$2144 _o$2145)))))) split-with))) (guard (e (#t #f)) - (def-var! "clojure.core" "qualified-keyword?" (letrec ((qualified-keyword? (lambda (x) (let fnrec1777 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) qualified-keyword?))) + (def-var! "clojure.core" "qualified-keyword?" (letrec ((qualified-keyword? (lambda (x) (let fnrec2146 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) qualified-keyword?))) (guard (e (#t #f)) - (def-var! "clojure.core" "simple-keyword?" (letrec ((simple-keyword? (lambda (x) (let fnrec1778 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) simple-keyword?))) + (def-var! "clojure.core" "simple-keyword?" (letrec ((simple-keyword? (lambda (x) (let fnrec2147 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) simple-keyword?))) (guard (e (#t #f)) - (def-var! "clojure.core" "qualified-symbol?" (letrec ((qualified-symbol? (lambda (x) (let fnrec1779 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) qualified-symbol?))) + (def-var! "clojure.core" "qualified-symbol?" (letrec ((qualified-symbol? (lambda (x) (let fnrec2148 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) qualified-symbol?))) (guard (e (#t #f)) - (def-var! "clojure.core" "simple-symbol?" (letrec ((simple-symbol? (lambda (x) (let fnrec1780 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) simple-symbol?))) + (def-var! "clojure.core" "simple-symbol?" (letrec ((simple-symbol? (lambda (x) (let fnrec2149 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) simple-symbol?))) (guard (e (#t #f)) - (def-var! "clojure.core" "ident?" (letrec ((ident? (lambda (x) (let fnrec1781 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))))))) ident?))) + (def-var! "clojure.core" "ident?" (letrec ((ident? (lambda (x) (let fnrec2150 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))))))) ident?))) (guard (e (#t #f)) - (def-var! "clojure.core" "qualified-ident?" (letrec ((qualified-ident? (lambda (x) (let fnrec1782 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "qualified-symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "qualified-keyword?") x))))))) qualified-ident?))) + (def-var! "clojure.core" "qualified-ident?" (letrec ((qualified-ident? (lambda (x) (let fnrec2151 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "qualified-symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "qualified-keyword?") x))))))) qualified-ident?))) (guard (e (#t #f)) - (def-var! "clojure.core" "simple-ident?" (letrec ((simple-ident? (lambda (x) (let fnrec1783 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "simple-symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "simple-keyword?") x))))))) simple-ident?))) + (def-var! "clojure.core" "simple-ident?" (letrec ((simple-ident? (lambda (x) (let fnrec2152 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "simple-symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "simple-keyword?") x))))))) simple-ident?))) (guard (e (#t #f)) - (def-var! "clojure.core" "ratio?" (letrec ((ratio? (lambda (x) (let fnrec1784 ((x x)) #f)))) ratio?))) + (def-var! "clojure.core" "ratio?" (letrec ((ratio? (lambda (x) (let fnrec2153 ((x x)) #f)))) ratio?))) (guard (e (#t #f)) - (def-var! "clojure.core" "decimal?" (letrec ((decimal? (lambda (x) (let fnrec1785 ((x x)) #f)))) decimal?))) + (def-var! "clojure.core" "decimal?" (letrec ((decimal? (lambda (x) (let fnrec2154 ((x x)) #f)))) decimal?))) (guard (e (#t #f)) - (def-var! "clojure.core" "class?" (letrec ((class? (lambda (x) (let fnrec1786 ((x x)) #f)))) class?))) + (def-var! "clojure.core" "class?" (letrec ((class? (lambda (x) (let fnrec2155 ((x x)) #f)))) class?))) (guard (e (#t #f)) - (def-var! "clojure.core" "rational?" (letrec ((rational? (lambda (x) (let fnrec1787 ((x x)) (jolt-invoke (var-deref "clojure.core" "int?") x))))) rational?))) + (def-var! "clojure.core" "rational?" (letrec ((rational? (lambda (x) (let fnrec2156 ((x x)) (jolt-invoke (var-deref "clojure.core" "int?") x))))) rational?))) (guard (e (#t #f)) - (def-var! "clojure.core" "nat-int?" (letrec ((nat-int? (lambda (x) (let fnrec1788 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (>= x 0) and__13__auto)))))) nat-int?))) + (def-var! "clojure.core" "nat-int?" (letrec ((nat-int? (lambda (x) (let fnrec2157 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (>= x 0) and__13__auto)))))) nat-int?))) (guard (e (#t #f)) - (def-var! "clojure.core" "neg-int?" (letrec ((neg-int? (lambda (x) (let fnrec1789 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (jolt-neg? x) and__13__auto)))))) neg-int?))) + (def-var! "clojure.core" "neg-int?" (letrec ((neg-int? (lambda (x) (let fnrec2158 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (jolt-neg? x) and__13__auto)))))) neg-int?))) (guard (e (#t #f)) - (def-var! "clojure.core" "pos-int?" (letrec ((pos-int? (lambda (x) (let fnrec1790 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (jolt-pos? x) and__13__auto)))))) pos-int?))) + (def-var! "clojure.core" "pos-int?" (letrec ((pos-int? (lambda (x) (let fnrec2159 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (jolt-pos? x) and__13__auto)))))) pos-int?))) (guard (e (#t #f)) - (def-var! "clojure.core" "replicate" (letrec ((replicate (lambda (n x) (let fnrec1791 ((n n) (x x)) (let* ((_a$1793 (lambda (_) (let fnrec1792 ((_ _)) x))) (_a$1794 (jolt-range n))) (jolt-map _a$1793 _a$1794)))))) replicate))) + (def-var! "clojure.core" "replicate" (letrec ((replicate (lambda (n x) (let fnrec2160 ((n n) (x x)) (let* ((_a$2162 (lambda (_) (let fnrec2161 ((_ _)) x))) (_a$2163 (jolt-range n))) (jolt-map _a$2162 _a$2163)))))) replicate))) (guard (e (#t #f)) - (def-var! "clojure.core" "take-last" (letrec ((take-last (lambda (n coll) (let fnrec1795 ((n n) (coll coll)) (let* ((c (jolt-invoke (var-deref "clojure.core" "vec") coll)) (len (jolt-count c))) (if (jolt-pos? len) (jolt-seq (jolt-invoke (var-deref "clojure.core" "subvec") c (max 0 (- len n)))) jolt-nil)))))) take-last))) + (def-var! "clojure.core" "take-last" (letrec ((take-last (lambda (n coll) (let fnrec2164 ((n n) (coll coll)) (let* ((c (jolt-invoke (var-deref "clojure.core" "vec") coll)) (len (jolt-count c))) (if (jolt-pos? len) (jolt-seq (jolt-invoke (var-deref "clojure.core" "subvec") c (max 0 (- len n)))) jolt-nil)))))) take-last))) (guard (e (#t #f)) - (def-var! "clojure.core" "drop-last" (letrec ((drop-last (case-lambda ((coll) (let fnrec1796 ((coll coll)) (jolt-invoke drop-last 1 coll))) ((n coll) (let fnrec1797 ((n n) (coll coll)) (let* ((_a$1799 (lambda (x _) (let fnrec1798 ((x x) (_ _)) x))) (_a$1800 coll) (_a$1801 (jolt-drop n coll))) (jolt-map _a$1799 _a$1800 _a$1801))))))) drop-last))) + (def-var! "clojure.core" "drop-last" (letrec ((drop-last (case-lambda ((coll) (let fnrec2165 ((coll coll)) (jolt-invoke drop-last 1 coll))) ((n coll) (let fnrec2166 ((n n) (coll coll)) (let* ((_a$2168 (lambda (x _) (let fnrec2167 ((x x) (_ _)) x))) (_a$2169 coll) (_a$2170 (jolt-drop n coll))) (jolt-map _a$2168 _a$2169 _a$2170))))))) drop-last))) (guard (e (#t #f)) - (def-var! "clojure.core" "distinct?" (letrec ((distinct? (case-lambda ((x) (let fnrec1802 ((x x)) #t)) ((x y) (let fnrec1803 ((x x) (y y)) (jolt-not (jolt= x y)))) ((x y . more) (let fnrec1804 ((x x) (y y) (more (list->cseq more))) (if (jolt-not (jolt= x y)) (let* ((s (let* ((_o$1806 x) (_o$1807 y)) (jolt-hash-set _o$1806 _o$1807))) (xs more)) (let loop1805 ((s s) (xs xs)) (if (jolt-truthy? xs) (let* ((x (jolt-first xs))) (if (jolt-contains? s x) #f (let* ((_a$1808 (jolt-conj s x)) (_a$1809 (jolt-next xs))) (loop1805 _a$1808 _a$1809)))) #t))) #f)))))) distinct?))) + (def-var! "clojure.core" "distinct?" (letrec ((distinct? (case-lambda ((x) (let fnrec2171 ((x x)) #t)) ((x y) (let fnrec2172 ((x x) (y y)) (jolt-not (jolt= x y)))) ((x y . more) (let fnrec2173 ((x x) (y y) (more (list->cseq more))) (if (jolt-not (jolt= x y)) (let* ((s (let* ((_o$2175 x) (_o$2176 y)) (jolt-hash-set _o$2175 _o$2176))) (xs more)) (let loop2174 ((s s) (xs xs)) (if (jolt-truthy? xs) (let* ((x (jolt-first xs))) (if (jolt-contains? s x) #f (let* ((_a$2177 (jolt-conj s x)) (_a$2178 (jolt-next xs))) (loop2174 _a$2177 _a$2178)))) #t))) #f)))))) distinct?))) (guard (e (#t #f)) - (def-var! "clojure.core" "replace" (letrec ((replace (lambda (smap coll) (let fnrec1810 ((smap smap) (coll coll)) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (x) (let fnrec1811 ((x x)) (jolt-get smap x x))) coll))))) replace))) + (def-var! "clojure.core" "replace" (letrec ((replace (lambda (smap coll) (let fnrec2179 ((smap smap) (coll coll)) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (x) (let fnrec2180 ((x x)) (jolt-get smap x x))) coll))))) replace))) (guard (e (#t #f)) - (def-var! "clojure.core" "nthnext" (letrec ((nthnext (lambda (coll n) (let fnrec1812 ((coll coll) (n n)) (let* ((n n) (xs (jolt-seq coll))) (let loop1813 ((n n) (xs xs)) (if (jolt-truthy? (let* ((and__13__auto xs)) (if (jolt-truthy? and__13__auto) (jolt-pos? n) and__13__auto))) (let* ((_a$1814 (jolt-dec n)) (_a$1815 (jolt-next xs))) (loop1813 _a$1814 _a$1815)) xs))))))) nthnext))) + (def-var! "clojure.core" "nthnext" (letrec ((nthnext (lambda (coll n) (let fnrec2181 ((coll coll) (n n)) (let* ((n n) (xs (jolt-seq coll))) (let loop2182 ((n n) (xs xs)) (if (jolt-truthy? (let* ((and__13__auto xs)) (if (jolt-truthy? and__13__auto) (jolt-pos? n) and__13__auto))) (let* ((_a$2183 (jolt-dec n)) (_a$2184 (jolt-next xs))) (loop2182 _a$2183 _a$2184)) xs))))))) nthnext))) (guard (e (#t #f)) - (def-var! "clojure.core" "bounded-count" (letrec ((bounded-count (lambda (n coll) (let fnrec1816 ((n n) (coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "counted?") coll)) (jolt-count coll) (let* ((i 0) (s (jolt-seq coll))) (let loop1817 ((i i) (s s)) (if (jolt-truthy? (let* ((and__13__auto s)) (if (jolt-truthy? and__13__auto) (< i n) and__13__auto))) (let* ((_a$1818 (jolt-inc i)) (_a$1819 (jolt-next s))) (loop1817 _a$1818 _a$1819)) i)))))))) bounded-count))) + (def-var! "clojure.core" "bounded-count" (letrec ((bounded-count (lambda (n coll) (let fnrec2185 ((n n) (coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "counted?") coll)) (jolt-count coll) (let* ((i 0) (s (jolt-seq coll))) (let loop2186 ((i i) (s s)) (if (jolt-truthy? (let* ((and__13__auto s)) (if (jolt-truthy? and__13__auto) (< i n) and__13__auto))) (let* ((_a$2187 (jolt-inc i)) (_a$2188 (jolt-next s))) (loop2186 _a$2187 _a$2188)) i)))))))) bounded-count))) (guard (e (#t #f)) - (def-var! "clojure.core" "run!" (letrec ((run! (lambda (proc coll) (let fnrec1820 ((proc proc) (coll coll)) (begin (jolt-reduce (lambda (_ x) (let fnrec1821 ((_ _) (x x)) (begin (jolt-invoke proc x) jolt-nil))) jolt-nil coll) jolt-nil))))) run!))) + (def-var! "clojure.core" "run!" (letrec ((run! (lambda (proc coll) (let fnrec2189 ((proc proc) (coll coll)) (begin (jolt-reduce (lambda (_ x) (let fnrec2190 ((_ _) (x x)) (begin (jolt-invoke proc x) jolt-nil))) jolt-nil coll) jolt-nil))))) run!))) (guard (e (#t #f)) - (def-var! "clojure.core" "completing" (letrec ((completing (case-lambda ((f) (let fnrec1822 ((f f)) (jolt-invoke completing f jolt-identity))) ((f cf) (let fnrec1823 ((f f) (cf cf)) (case-lambda (() (let fnrec1824 () (jolt-invoke f))) ((x) (let fnrec1825 ((x x)) (jolt-invoke cf x))) ((x y) (let fnrec1826 ((x x) (y y)) (jolt-invoke f x y))))))))) completing))) + (def-var! "clojure.core" "completing" (letrec ((completing (case-lambda ((f) (let fnrec2191 ((f f)) (jolt-invoke completing f jolt-identity))) ((f cf) (let fnrec2192 ((f f) (cf cf)) (case-lambda (() (let fnrec2193 () (jolt-invoke f))) ((x) (let fnrec2194 ((x x)) (jolt-invoke cf x))) ((x y) (let fnrec2195 ((x x) (y y)) (jolt-invoke f x y))))))))) completing))) (guard (e (#t #f)) - (def-var! "clojure.core" "nthrest" (letrec ((nthrest (lambda (coll n) (let fnrec1827 ((coll coll) (n n)) (if (jolt-pos? n) (let* ((or__14__auto (let* ((n n) (xs coll)) (let loop1828 ((n n) (xs xs)) (let* ((s (let* ((and__13__auto (jolt-pos? n))) (if (jolt-truthy? and__13__auto) (jolt-seq xs) and__13__auto)))) (if (jolt-truthy? s) (let* ((_a$1829 (jolt-dec n)) (_a$1830 (jolt-rest s))) (loop1828 _a$1829 _a$1830)) (jolt-seq xs))))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-list ))) coll))))) nthrest))) + (def-var! "clojure.core" "nthrest" (letrec ((nthrest (lambda (coll n) (let fnrec2196 ((coll coll) (n n)) (if (jolt-pos? n) (let* ((or__14__auto (let* ((n n) (xs coll)) (let loop2197 ((n n) (xs xs)) (let* ((s (let* ((and__13__auto (jolt-pos? n))) (if (jolt-truthy? and__13__auto) (jolt-seq xs) and__13__auto)))) (if (jolt-truthy? s) (let* ((_a$2198 (jolt-dec n)) (_a$2199 (jolt-rest s))) (loop2197 _a$2198 _a$2199)) (jolt-seq xs))))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-list ))) coll))))) nthrest))) (guard (e (#t #f)) - (def-var! "clojure.core" "abs" (letrec ((abs (lambda (x) (let fnrec1831 ((x x)) (if (jolt-neg? x) (- 0 x) x))))) abs))) + (def-var! "clojure.core" "abs" (letrec ((abs (lambda (x) (let fnrec2200 ((x x)) (if (jolt-neg? x) (- 0 x) x))))) abs))) (guard (e (#t #f)) - (def-var! "clojure.core" "NaN?" (letrec ((NaN? (lambda (x) (let fnrec1832 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) (jolt-not (jolt= x x)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "NaN? requires a number"))))))) NaN?))) + (def-var! "clojure.core" "NaN?" (letrec ((NaN? (lambda (x) (let fnrec2201 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) (jolt-not (jolt= x x)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "NaN? requires a number"))))))) NaN?))) (guard (e (#t #f)) - (def-var! "clojure.core" "object?" (letrec ((object? (lambda (x) (let fnrec1833 ((x x)) #f)))) object?))) + (def-var! "clojure.core" "object?" (letrec ((object? (lambda (x) (let fnrec2202 ((x x)) #f)))) object?))) (guard (e (#t #f)) - (def-var! "clojure.core" "undefined?" (letrec ((undefined? (lambda (x) (let fnrec1834 ((x x)) #f)))) undefined?))) + (def-var! "clojure.core" "undefined?" (letrec ((undefined? (lambda (x) (let fnrec2203 ((x x)) #f)))) undefined?))) (guard (e (#t #f)) - (def-var! "clojure.core" "keyword-identical?" (letrec ((keyword-identical? (lambda (a b) (let fnrec1835 ((a a) (b b)) (jolt= a b))))) keyword-identical?))) + (def-var! "clojure.core" "keyword-identical?" (letrec ((keyword-identical? (lambda (a b) (let fnrec2204 ((a a) (b b)) (jolt= a b))))) keyword-identical?))) (guard (e (#t #f)) - (def-var! "clojure.core" "any?" (letrec ((any? (lambda (x) (let fnrec1836 ((x x)) #t)))) any?))) + (def-var! "clojure.core" "any?" (letrec ((any? (lambda (x) (let fnrec2205 ((x x)) #t)))) any?))) (guard (e (#t #f)) - (def-var! "clojure.core" "printf" (letrec ((printf (lambda (fmt . args) (let fnrec1837 ((fmt fmt) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "print") (jolt-apply (var-deref "clojure.core" "format") fmt args)))))) printf))) + (def-var! "clojure.core" "printf" (letrec ((printf (lambda (fmt . args) (let fnrec2206 ((fmt fmt) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "print") (jolt-apply (var-deref "clojure.core" "format") fmt args)))))) printf))) (guard (e (#t #f)) - (def-var! "clojure.core" "bound?" (letrec ((bound? (lambda vars (let fnrec1838 ((vars (list->cseq vars))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (v) (let fnrec1839 ((v v)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get v (keyword #f "root"))))) vars))))) bound?))) + (def-var! "clojure.core" "bound?" (letrec ((bound? (lambda vars (let fnrec2207 ((vars (list->cseq vars))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (v) (let fnrec2208 ((v v)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get v (keyword #f "root"))))) vars))))) bound?))) (guard (e (#t #f)) - (def-var! "clojure.core" "with-bindings*" (letrec ((with-bindings* (lambda (binding-map f . args) (let fnrec1840 ((binding-map binding-map) (f f) (args (list->cseq args))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") binding-map) (dynamic-wind (lambda () #f) (lambda () (jolt-apply f args)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))))) with-bindings*))) + (def-var! "clojure.core" "with-bindings*" (letrec ((with-bindings* (lambda (binding-map f . args) (let fnrec2209 ((binding-map binding-map) (f f) (args (list->cseq args))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") binding-map) (dynamic-wind (lambda () #f) (lambda () (jolt-apply f args)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))))) with-bindings*))) (guard (e (#t #f)) - (def-var! "clojure.core" "bound-fn*" (letrec ((bound-fn* (lambda (f) (let fnrec1841 ((f f)) (let* ((bs (jolt-invoke (var-deref "clojure.core" "get-thread-bindings")))) (lambda args (let fnrec1842 ((args (list->cseq args))) (jolt-apply (var-deref "clojure.core" "with-bindings*") bs f args)))))))) bound-fn*))) + (def-var! "clojure.core" "bound-fn*" (letrec ((bound-fn* (lambda (f) (let fnrec2210 ((f f)) (let* ((bs (jolt-invoke (var-deref "clojure.core" "get-thread-bindings")))) (lambda args (let fnrec2211 ((args (list->cseq args))) (jolt-apply (var-deref "clojure.core" "with-bindings*") bs f args)))))))) bound-fn*))) (guard (e (#t #f)) - (def-var! "clojure.core" "thread-bound?" (letrec ((thread-bound? (lambda vars (let fnrec1843 ((vars (list->cseq vars))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (v) (let fnrec1844 ((v v)) (jolt-invoke (var-deref "clojure.core" "__thread-bound?") v))) vars))))) thread-bound?))) + (def-var! "clojure.core" "thread-bound?" (letrec ((thread-bound? (lambda vars (let fnrec2212 ((vars (list->cseq vars))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (v) (let fnrec2213 ((v v)) (jolt-invoke (var-deref "clojure.core" "__thread-bound?") v))) vars))))) thread-bound?))) (guard (e (#t #f)) - (def-var! "clojure.core" "key" (letrec ((key (lambda (e) (let fnrec1845 ((e e)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map-entry?") e)) (jolt-nth e 0) (jolt-throw (jolt-ex-info "key requires a map entry" (jolt-hash-map)))))))) key))) + (def-var! "clojure.core" "key" (letrec ((key (lambda (e) (let fnrec2214 ((e e)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map-entry?") e)) (jolt-nth e 0) (jolt-throw (jolt-ex-info "key requires a map entry" (jolt-hash-map)))))))) key))) (guard (e (#t #f)) - (def-var! "clojure.core" "val" (letrec ((val (lambda (e) (let fnrec1846 ((e e)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map-entry?") e)) (jolt-nth e 1) (jolt-throw (jolt-ex-info "val requires a map entry" (jolt-hash-map)))))))) val))) + (def-var! "clojure.core" "val" (letrec ((val (lambda (e) (let fnrec2215 ((e e)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map-entry?") e)) (jolt-nth e 1) (jolt-throw (jolt-ex-info "val requires a map entry" (jolt-hash-map)))))))) val))) (guard (e (#t #f)) - (def-var! "clojure.core" "make-hierarchy" (letrec ((make-hierarchy (lambda () (let fnrec1847 () (let* ((_o$1848 (keyword #f "parents")) (_o$1849 (jolt-hash-map)) (_o$1850 (keyword #f "descendants")) (_o$1851 (jolt-hash-map)) (_o$1852 (keyword #f "ancestors")) (_o$1853 (jolt-hash-map))) (jolt-hash-map _o$1848 _o$1849 _o$1850 _o$1851 _o$1852 _o$1853)))))) make-hierarchy))) + (def-var! "clojure.core" "make-hierarchy" (letrec ((make-hierarchy (lambda () (let fnrec2216 () (let* ((_o$2217 (keyword #f "parents")) (_o$2218 (jolt-hash-map)) (_o$2219 (keyword #f "descendants")) (_o$2220 (jolt-hash-map)) (_o$2221 (keyword #f "ancestors")) (_o$2222 (jolt-hash-map))) (jolt-hash-map _o$2217 _o$2218 _o$2219 _o$2220 _o$2221 _o$2222)))))) make-hierarchy))) (guard (e (#t #f)) (def-var-with-meta! "clojure.core" "global-hierarchy" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-invoke (var-deref "clojure.core" "make-hierarchy"))) (jolt-hash-map (keyword #f "private") #t))) (guard (e (#t #f)) - (def-var! "clojure.core" "isa?" (letrec ((isa? (case-lambda ((child parent) (let fnrec1854 ((child child) (parent parent)) (jolt-invoke isa? (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) child parent))) ((h child parent) (let fnrec1855 ((h h) (child child) (parent parent)) (let* ((or__14__auto (jolt= child parent))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-contains? (let* ((_a$1856 (jolt-get h (keyword #f "ancestors"))) (_a$1857 child) (_a$1858 (jolt-hash-set))) (jolt-get _a$1856 _a$1857 _a$1858)) parent))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "vector?") parent))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "vector?") child))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (let* ((_a$1859 (jolt-count parent)) (_a$1860 (jolt-count child))) (jolt= _a$1859 _a$1860)))) (if (jolt-truthy? and__13__auto) (let* ((ret #t) (i 0)) (let loop1861 ((ret ret) (i i)) (if (jolt-truthy? (let* ((or__14__auto (jolt-not ret))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= i (jolt-count parent))))) ret (let* ((_a$1866 (let* ((_a$1862 isa?) (_a$1863 h) (_a$1864 (jolt-nth child i)) (_a$1865 (jolt-nth parent i))) (jolt-invoke _a$1862 _a$1863 _a$1864 _a$1865))) (_a$1867 (jolt-inc i))) (loop1861 _a$1866 _a$1867))))) and__13__auto)) and__13__auto)) and__13__auto))))))))))) isa?))) + (def-var! "clojure.core" "isa?" (letrec ((isa? (case-lambda ((child parent) (let fnrec2223 ((child child) (parent parent)) (jolt-invoke isa? (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) child parent))) ((h child parent) (let fnrec2224 ((h h) (child child) (parent parent)) (let* ((or__14__auto (jolt= child parent))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-contains? (let* ((_a$2225 (jolt-get h (keyword #f "ancestors"))) (_a$2226 child) (_a$2227 (jolt-hash-set))) (jolt-get _a$2225 _a$2226 _a$2227)) parent))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "vector?") parent))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "vector?") child))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (let* ((_a$2228 (jolt-count parent)) (_a$2229 (jolt-count child))) (jolt= _a$2228 _a$2229)))) (if (jolt-truthy? and__13__auto) (let* ((ret #t) (i 0)) (let loop2230 ((ret ret) (i i)) (if (jolt-truthy? (let* ((or__14__auto (jolt-not ret))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= i (jolt-count parent))))) ret (let* ((_a$2235 (let* ((_a$2231 isa?) (_a$2232 h) (_a$2233 (jolt-nth child i)) (_a$2234 (jolt-nth parent i))) (jolt-invoke _a$2231 _a$2232 _a$2233 _a$2234))) (_a$2236 (jolt-inc i))) (loop2230 _a$2235 _a$2236))))) and__13__auto)) and__13__auto)) and__13__auto))))))))))) isa?))) (guard (e (#t #f)) - (def-var! "clojure.core" "parents" (letrec ((parents (case-lambda ((tag) (let fnrec1868 ((tag tag)) (jolt-invoke parents (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec1869 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "parents")) tag))))))) parents))) + (def-var! "clojure.core" "parents" (letrec ((parents (case-lambda ((tag) (let fnrec2237 ((tag tag)) (jolt-invoke parents (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec2238 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "parents")) tag))))))) parents))) (guard (e (#t #f)) - (def-var! "clojure.core" "ancestors" (letrec ((ancestors (case-lambda ((tag) (let fnrec1870 ((tag tag)) (jolt-invoke ancestors (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec1871 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "ancestors")) tag))))))) ancestors))) + (def-var! "clojure.core" "ancestors" (letrec ((ancestors (case-lambda ((tag) (let fnrec2239 ((tag tag)) (jolt-invoke ancestors (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec2240 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "ancestors")) tag))))))) ancestors))) (guard (e (#t #f)) - (def-var! "clojure.core" "descendants" (letrec ((descendants (case-lambda ((tag) (let fnrec1872 ((tag tag)) (jolt-invoke descendants (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec1873 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "descendants")) tag))))))) descendants))) + (def-var! "clojure.core" "descendants" (letrec ((descendants (case-lambda ((tag) (let fnrec2241 ((tag tag)) (jolt-invoke descendants (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec2242 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "descendants")) tag))))))) descendants))) (guard (e (#t #f)) - (def-var! "clojure.core" "derive" (letrec ((derive (case-lambda ((tag parent) (let fnrec1874 ((tag tag) (parent parent)) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "global-hierarchy") derive tag parent) jolt-nil))) ((h tag parent) (let fnrec1875 ((h h) (tag tag) (parent parent)) (let* ((tp (jolt-get h (keyword #f "parents"))) (td (jolt-get h (keyword #f "descendants"))) (ta (jolt-get h (keyword #f "ancestors"))) (tf (lambda (m source sources target targets) (let fnrec1876 ((m m) (source source) (sources sources) (target target) (targets targets)) (let* ((_a$1881 (lambda (ret k) (let fnrec1877 ((ret ret) (k k)) (jolt-assoc ret k (let* ((_a$1878 jolt-conj) (_a$1879 (jolt-get targets k (jolt-hash-set))) (_a$1880 (jolt-cons target (jolt-get targets target)))) (jolt-reduce _a$1878 _a$1879 _a$1880)))))) (_a$1882 m) (_a$1883 (jolt-cons source (jolt-get sources source)))) (jolt-reduce _a$1881 _a$1882 _a$1883)))))) (let* ((or__14__auto (if (jolt-not (jolt-contains? (jolt-get tp tag (jolt-hash-set)) parent)) (begin (if (jolt-contains? (jolt-get ta tag (jolt-hash-set)) parent) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") tag " already has " parent " as ancestor")) jolt-nil) (if (jolt-contains? (jolt-get ta parent (jolt-hash-set)) tag) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Cyclic derivation: " parent " has " tag " as ancestor")) jolt-nil) (let* ((_o$1884 (keyword #f "parents")) (_o$1885 (jolt-assoc tp tag (jolt-conj (jolt-get tp tag (jolt-hash-set)) parent))) (_o$1886 (keyword #f "ancestors")) (_o$1887 (jolt-invoke tf ta tag td parent ta)) (_o$1888 (keyword #f "descendants")) (_o$1889 (jolt-invoke tf td parent ta tag td))) (jolt-hash-map _o$1884 _o$1885 _o$1886 _o$1887 _o$1888 _o$1889))) jolt-nil))) (if (jolt-truthy? or__14__auto) or__14__auto h)))))))) derive))) + (def-var! "clojure.core" "derive" (letrec ((derive (case-lambda ((tag parent) (let fnrec2243 ((tag tag) (parent parent)) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "global-hierarchy") derive tag parent) jolt-nil))) ((h tag parent) (let fnrec2244 ((h h) (tag tag) (parent parent)) (let* ((tp (jolt-get h (keyword #f "parents"))) (td (jolt-get h (keyword #f "descendants"))) (ta (jolt-get h (keyword #f "ancestors"))) (tf (lambda (m source sources target targets) (let fnrec2245 ((m m) (source source) (sources sources) (target target) (targets targets)) (let* ((_a$2250 (lambda (ret k) (let fnrec2246 ((ret ret) (k k)) (jolt-assoc ret k (let* ((_a$2247 jolt-conj) (_a$2248 (jolt-get targets k (jolt-hash-set))) (_a$2249 (jolt-cons target (jolt-get targets target)))) (jolt-reduce _a$2247 _a$2248 _a$2249)))))) (_a$2251 m) (_a$2252 (jolt-cons source (jolt-get sources source)))) (jolt-reduce _a$2250 _a$2251 _a$2252)))))) (let* ((or__14__auto (if (jolt-not (jolt-contains? (jolt-get tp tag (jolt-hash-set)) parent)) (begin (if (jolt-contains? (jolt-get ta tag (jolt-hash-set)) parent) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") tag " already has " parent " as ancestor")) jolt-nil) (if (jolt-contains? (jolt-get ta parent (jolt-hash-set)) tag) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Cyclic derivation: " parent " has " tag " as ancestor")) jolt-nil) (let* ((_o$2253 (keyword #f "parents")) (_o$2254 (jolt-assoc tp tag (jolt-conj (jolt-get tp tag (jolt-hash-set)) parent))) (_o$2255 (keyword #f "ancestors")) (_o$2256 (jolt-invoke tf ta tag td parent ta)) (_o$2257 (keyword #f "descendants")) (_o$2258 (jolt-invoke tf td parent ta tag td))) (jolt-hash-map _o$2253 _o$2254 _o$2255 _o$2256 _o$2257 _o$2258))) jolt-nil))) (if (jolt-truthy? or__14__auto) or__14__auto h)))))))) derive))) (guard (e (#t #f)) - (def-var! "clojure.core" "underive" (letrec ((underive (case-lambda ((tag parent) (let fnrec1890 ((tag tag) (parent parent)) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "global-hierarchy") underive tag parent) jolt-nil))) ((h tag parent) (let fnrec1891 ((h h) (tag tag) (parent parent)) (let* ((parent-map (jolt-get h (keyword #f "parents"))) (childs-parents (if (jolt-truthy? (jolt-get parent-map tag)) (jolt-invoke (var-deref "clojure.core" "disj") (jolt-get parent-map tag) parent) (jolt-hash-set))) (new-parents (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not-empty") childs-parents)) (jolt-assoc parent-map tag childs-parents) (jolt-dissoc parent-map tag))) (deriv-seq (let* ((_a$1898 (var-deref "clojure.core" "mapcat")) (_a$1899 (lambda (e) (let fnrec1892 ((e e)) (let* ((_a$1896 (jolt-invoke (var-deref "clojure.core" "key") e)) (_a$1897 (let* ((_a$1893 (var-deref "clojure.core" "interpose")) (_a$1894 (jolt-invoke (var-deref "clojure.core" "key") e)) (_a$1895 (jolt-invoke (var-deref "clojure.core" "val") e))) (jolt-invoke _a$1893 _a$1894 _a$1895)))) (jolt-cons _a$1896 _a$1897))))) (_a$1900 (jolt-seq new-parents))) (jolt-invoke _a$1898 _a$1899 _a$1900)))) (if (jolt-contains? (jolt-get parent-map tag (jolt-hash-set)) parent) (let* ((_a$1902 (lambda (p G__27) (let fnrec1901 ((p p) (G__27 G__27)) (let* ((G__28 G__27) (t (jolt-nth G__28 0 jolt-nil)) (pr (jolt-nth G__28 1 jolt-nil))) (jolt-invoke (var-deref "clojure.core" "derive") p t pr))))) (_a$1903 (jolt-invoke (var-deref "clojure.core" "make-hierarchy"))) (_a$1904 (jolt-invoke (var-deref "clojure.core" "partition") 2 deriv-seq))) (jolt-reduce _a$1902 _a$1903 _a$1904)) h))))))) underive))) + (def-var! "clojure.core" "underive" (letrec ((underive (case-lambda ((tag parent) (let fnrec2259 ((tag tag) (parent parent)) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "global-hierarchy") underive tag parent) jolt-nil))) ((h tag parent) (let fnrec2260 ((h h) (tag tag) (parent parent)) (let* ((parent-map (jolt-get h (keyword #f "parents"))) (childs-parents (if (jolt-truthy? (jolt-get parent-map tag)) (jolt-invoke (var-deref "clojure.core" "disj") (jolt-get parent-map tag) parent) (jolt-hash-set))) (new-parents (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not-empty") childs-parents)) (jolt-assoc parent-map tag childs-parents) (jolt-dissoc parent-map tag))) (deriv-seq (let* ((_a$2267 (var-deref "clojure.core" "mapcat")) (_a$2268 (lambda (e) (let fnrec2261 ((e e)) (let* ((_a$2265 (jolt-invoke (var-deref "clojure.core" "key") e)) (_a$2266 (let* ((_a$2262 (var-deref "clojure.core" "interpose")) (_a$2263 (jolt-invoke (var-deref "clojure.core" "key") e)) (_a$2264 (jolt-invoke (var-deref "clojure.core" "val") e))) (jolt-invoke _a$2262 _a$2263 _a$2264)))) (jolt-cons _a$2265 _a$2266))))) (_a$2269 (jolt-seq new-parents))) (jolt-invoke _a$2267 _a$2268 _a$2269)))) (if (jolt-contains? (jolt-get parent-map tag (jolt-hash-set)) parent) (let* ((_a$2271 (lambda (p G__31) (let fnrec2270 ((p p) (G__31 G__31)) (let* ((G__32 G__31) (t (jolt-nth G__32 0 jolt-nil)) (pr (jolt-nth G__32 1 jolt-nil))) (jolt-invoke (var-deref "clojure.core" "derive") p t pr))))) (_a$2272 (jolt-invoke (var-deref "clojure.core" "make-hierarchy"))) (_a$2273 (jolt-invoke (var-deref "clojure.core" "partition") 2 deriv-seq))) (jolt-reduce _a$2271 _a$2272 _a$2273)) h))))))) underive))) (guard (e (#t #f)) - (def-var! "clojure.core" "sequential?" (letrec ((sequential? (lambda (x) (let fnrec1905 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "seq?") x))))))) sequential?))) + (def-var! "clojure.core" "sequential?" (letrec ((sequential? (lambda (x) (let fnrec2274 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "seq?") x))))))) sequential?))) (guard (e (#t #f)) - (def-var! "clojure.core" "associative?" (letrec ((associative? (lambda (x) (let fnrec1906 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))))))) associative?))) + (def-var! "clojure.core" "associative?" (letrec ((associative? (lambda (x) (let fnrec2275 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))))))) associative?))) (guard (e (#t #f)) - (def-var! "clojure.core" "counted?" (letrec ((counted? (lambda (x) (let fnrec1907 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "set?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "list?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "string?") x))))))))))))) counted?))) + (def-var! "clojure.core" "counted?" (letrec ((counted? (lambda (x) (let fnrec2276 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "set?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "list?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "string?") x))))))))))))) counted?))) (guard (e (#t #f)) - (def-var! "clojure.core" "indexed?" (letrec ((indexed? (lambda (x) (let fnrec1908 ((x x)) (jolt-invoke (var-deref "clojure.core" "vector?") x))))) indexed?))) + (def-var! "clojure.core" "indexed?" (letrec ((indexed? (lambda (x) (let fnrec2277 ((x x)) (jolt-invoke (var-deref "clojure.core" "vector?") x))))) indexed?))) (guard (e (#t #f)) (declare-var! "clojure.core" "sorted?")) (guard (e (#t #f)) - (def-var! "clojure.core" "reversible?" (letrec ((reversible? (lambda (x) (let fnrec1909 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "sorted?") x))))))) reversible?))) + (def-var! "clojure.core" "reversible?" (letrec ((reversible? (lambda (x) (let fnrec2278 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "sorted?") x))))))) reversible?))) (guard (e (#t #f)) - (def-var! "clojure.core" "seqable?" (letrec ((seqable? (lambda (x) (let fnrec1910 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "coll?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "string?") x))))))))) seqable?))) + (def-var! "clojure.core" "seqable?" (letrec ((seqable? (lambda (x) (let fnrec2279 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "coll?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "string?") x))))))))) seqable?))) (guard (e (#t #f)) - (def-var! "clojure.core" "boolean?" (letrec ((boolean? (lambda (x) (let fnrec1911 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "true?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "false?") x))))))) boolean?))) + (def-var! "clojure.core" "boolean?" (letrec ((boolean? (lambda (x) (let fnrec2280 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "true?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "false?") x))))))) boolean?))) (guard (e (#t #f)) - (def-var! "clojure.core" "double?" (letrec ((double? (lambda (x) (let fnrec1912 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "integer?") x)) and__13__auto)))))) double?))) + (def-var! "clojure.core" "double?" (letrec ((double? (lambda (x) (let fnrec2281 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "integer?") x)) and__13__auto)))))) double?))) (guard (e (#t #f)) - (def-var! "clojure.core" "float?" (letrec ((float? (lambda (x) (let fnrec1913 ((x x)) (jolt-invoke (var-deref "clojure.core" "double?") x))))) float?))) + (def-var! "clojure.core" "float?" (letrec ((float? (lambda (x) (let fnrec2282 ((x x)) (jolt-invoke (var-deref "clojure.core" "double?") x))))) float?))) (guard (e (#t #f)) - (def-var! "clojure.core" "infinite?" (letrec ((infinite? (lambda (x) (let fnrec1914 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt= x +inf.0))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= x -inf.0))) and__13__auto)))))) infinite?))) + (def-var! "clojure.core" "infinite?" (letrec ((infinite? (lambda (x) (let fnrec2283 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt= x +inf.0))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= x -inf.0))) and__13__auto)))))) infinite?))) (guard (e (#t #f)) - (def-var! "clojure.core" "atom?" (letrec ((atom? (lambda (x) (let fnrec1915 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "atom")))))) atom?))) + (def-var! "clojure.core" "atom?" (letrec ((atom? (lambda (x) (let fnrec2284 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "atom")))))) atom?))) (guard (e (#t #f)) - (def-var! "clojure.core" "volatile?" (letrec ((volatile? (lambda (x) (let fnrec1916 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "volatile")))))) volatile?))) + (def-var! "clojure.core" "volatile?" (letrec ((volatile? (lambda (x) (let fnrec2285 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "volatile")))))) volatile?))) (guard (e (#t #f)) - (def-var! "clojure.core" "reader-conditional?" (letrec ((reader-conditional? (lambda (x) (let fnrec1917 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "reader-conditional")))))) reader-conditional?))) + (def-var! "clojure.core" "reader-conditional?" (letrec ((reader-conditional? (lambda (x) (let fnrec2286 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "reader-conditional")))))) reader-conditional?))) (guard (e (#t #f)) - (def-var! "clojure.core" "tagged-literal?" (letrec ((tagged-literal? (lambda (x) (let fnrec1918 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "tagged-literal")))))) tagged-literal?))) + (def-var! "clojure.core" "tagged-literal?" (letrec ((tagged-literal? (lambda (x) (let fnrec2287 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "tagged-literal")))))) tagged-literal?))) (guard (e (#t #f)) - (def-var! "clojure.core" "record?" (letrec ((record? (lambda (x) (let fnrec1919 ((x x)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get x (keyword "jolt" "deftype"))))))) record?))) + (def-var! "clojure.core" "record?" (letrec ((record? (lambda (x) (let fnrec2288 ((x x)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get x (keyword "jolt" "deftype"))))))) record?))) (guard (e (#t #f)) - (def-var! "clojure.core" "uuid?" (letrec ((uuid? (lambda (x) (let fnrec1920 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "uuid")))))) uuid?))) + (def-var! "clojure.core" "uuid?" (letrec ((uuid? (lambda (x) (let fnrec2289 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "uuid")))))) uuid?))) (guard (e (#t #f)) - (def-var! "clojure.core" "inst?" (letrec ((inst? (lambda (x) (let fnrec1921 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "inst")))))) inst?))) + (def-var! "clojure.core" "inst?" (letrec ((inst? (lambda (x) (let fnrec2290 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "inst")))))) inst?))) (guard (e (#t #f)) - (def-var! "clojure.core" "char?" (letrec ((char? (lambda (x) (let fnrec1922 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "char")))))) char?))) + (def-var! "clojure.core" "char?" (letrec ((char? (lambda (x) (let fnrec2291 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "char")))))) char?))) (guard (e (#t #f)) - (def-var! "clojure.core" "realized?" (letrec ((realized? (lambda (x) (let fnrec1923 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "delay?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "realized"))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "future?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cached"))) (if (jolt= (keyword "jolt" "lazy-seq") (jolt-get x (keyword "jolt" "type"))) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "realized"))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "atom?") x)) #t (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "realized? not supported on: " x)) jolt-nil))))))))) realized?))) + (def-var! "clojure.core" "realized?" (letrec ((realized? (lambda (x) (let fnrec2292 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "delay?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "realized"))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "future?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cached"))) (if (jolt= (keyword "jolt" "lazy-seq") (jolt-get x (keyword "jolt" "type"))) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "realized"))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "atom?") x)) #t (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "realized? not supported on: " x)) jolt-nil))))))))) realized?))) (guard (e (#t #f)) - (def-var! "clojure.core" "force" (letrec ((force (lambda (x) (let fnrec1924 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "delay?") x)) (jolt-invoke (var-deref "clojure.core" "deref") x) x))))) force))) + (def-var! "clojure.core" "force" (letrec ((force (lambda (x) (let fnrec2293 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "delay?") x)) (jolt-invoke (var-deref "clojure.core" "deref") x) x))))) force))) (guard (e (#t #f)) - (def-var! "clojure.core" "pop" (letrec ((pop (lambda (coll) (let fnrec1925 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (if (jolt-zero? (jolt-count coll)) (jolt-throw "Can't pop empty vector") (jolt-invoke (var-deref "clojure.core" "subvec") coll 0 (jolt-dec (jolt-count coll)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-seq coll))) (jolt-throw "Can't pop empty list") (jolt-rest coll)) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "pop not supported on: " coll)) jolt-nil)))))))) pop))) + (def-var! "clojure.core" "pop" (letrec ((pop (lambda (coll) (let fnrec2294 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (if (jolt-zero? (jolt-count coll)) (jolt-throw "Can't pop empty vector") (jolt-invoke (var-deref "clojure.core" "subvec") coll 0 (jolt-dec (jolt-count coll)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-seq coll))) (jolt-throw "Can't pop empty list") (jolt-rest coll)) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "pop not supported on: " coll)) jolt-nil)))))))) pop))) (guard (e (#t #f)) - (def-var! "clojure.core" "dorun" (letrec ((dorun (case-lambda ((coll) (let fnrec1926 ((coll coll)) (let* ((s (jolt-seq coll))) (let loop1927 ((s s)) (if (jolt-truthy? s) (loop1927 (jolt-next s)) jolt-nil))))) ((n coll) (let fnrec1928 ((n n) (coll coll)) (let* ((n n) (s (jolt-seq coll))) (let loop1929 ((n n) (s s)) (if (jolt-truthy? (let* ((and__13__auto s)) (if (jolt-truthy? and__13__auto) (jolt-pos? n) and__13__auto))) (let* ((_a$1930 (jolt-dec n)) (_a$1931 (jolt-next s))) (loop1929 _a$1930 _a$1931)) jolt-nil)))))))) dorun))) + (def-var! "clojure.core" "dorun" (letrec ((dorun (case-lambda ((coll) (let fnrec2295 ((coll coll)) (let* ((s (jolt-seq coll))) (let loop2296 ((s s)) (if (jolt-truthy? s) (loop2296 (jolt-next s)) jolt-nil))))) ((n coll) (let fnrec2297 ((n n) (coll coll)) (let* ((n n) (s (jolt-seq coll))) (let loop2298 ((n n) (s s)) (if (jolt-truthy? (let* ((and__13__auto s)) (if (jolt-truthy? and__13__auto) (jolt-pos? n) and__13__auto))) (let* ((_a$2299 (jolt-dec n)) (_a$2300 (jolt-next s))) (loop2298 _a$2299 _a$2300)) jolt-nil)))))))) dorun))) (guard (e (#t #f)) - (def-var! "clojure.core" "doall" (letrec ((doall (case-lambda ((coll) (let fnrec1932 ((coll coll)) (begin (jolt-invoke (var-deref "clojure.core" "dorun") coll) coll))) ((n coll) (let fnrec1933 ((n n) (coll coll)) (begin (jolt-invoke (var-deref "clojure.core" "dorun") n coll) coll)))))) doall))) + (def-var! "clojure.core" "doall" (letrec ((doall (case-lambda ((coll) (let fnrec2301 ((coll coll)) (begin (jolt-invoke (var-deref "clojure.core" "dorun") coll) coll))) ((n coll) (let fnrec2302 ((n n) (coll coll)) (begin (jolt-invoke (var-deref "clojure.core" "dorun") n coll) coll)))))) doall))) (guard (e (#t #f)) - (def-var! "clojure.core" "spread" (letrec ((spread (lambda (arglist) (let fnrec1934 ((arglist arglist)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") arglist)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-next arglist))) (jolt-seq (jolt-first arglist)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$1935 (jolt-first arglist)) (_a$1936 (jolt-invoke spread (jolt-next arglist)))) (jolt-cons _a$1935 _a$1936)) jolt-nil))))))) spread))) + (def-var! "clojure.core" "spread" (letrec ((spread (lambda (arglist) (let fnrec2303 ((arglist arglist)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") arglist)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-next arglist))) (jolt-seq (jolt-first arglist)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$2304 (jolt-first arglist)) (_a$2305 (jolt-invoke spread (jolt-next arglist)))) (jolt-cons _a$2304 _a$2305)) jolt-nil))))))) spread))) (guard (e (#t #f)) - (def-var! "clojure.core" "list*" (letrec ((list* (case-lambda ((args) (let fnrec1937 ((args args)) (jolt-seq args))) ((a args) (let fnrec1938 ((a a) (args args)) (jolt-cons a args))) ((a b args) (let fnrec1939 ((a a) (b b) (args args)) (jolt-cons a (jolt-cons b args)))) ((a b c args) (let fnrec1940 ((a a) (b b) (c c) (args args)) (jolt-cons a (jolt-cons b (jolt-cons c args))))) ((a b c d . more) (let fnrec1941 ((a a) (b b) (c c) (d d) (more (list->cseq more))) (jolt-cons a (jolt-cons b (jolt-cons c (jolt-cons d (jolt-invoke (var-deref "clojure.core" "spread") more)))))))))) list*))) + (def-var! "clojure.core" "list*" (letrec ((list* (case-lambda ((args) (let fnrec2306 ((args args)) (jolt-seq args))) ((a args) (let fnrec2307 ((a a) (args args)) (jolt-cons a args))) ((a b args) (let fnrec2308 ((a a) (b b) (args args)) (jolt-cons a (jolt-cons b args)))) ((a b c args) (let fnrec2309 ((a a) (b b) (c c) (args args)) (jolt-cons a (jolt-cons b (jolt-cons c args))))) ((a b c d . more) (let fnrec2310 ((a a) (b b) (c c) (d d) (more (list->cseq more))) (jolt-cons a (jolt-cons b (jolt-cons c (jolt-cons d (jolt-invoke (var-deref "clojure.core" "spread") more)))))))))) list*))) (guard (e (#t #f)) - (def-var! "clojure.core" "print-str" (letrec ((print-str (lambda xs (let fnrec1942 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec1943 () (jolt-apply (var-deref "clojure.core" "print") xs)))))))) print-str))) + (def-var! "clojure.core" "print-str" (letrec ((print-str (lambda xs (let fnrec2311 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec2312 () (jolt-apply (var-deref "clojure.core" "print") xs)))))))) print-str))) (guard (e (#t #f)) - (def-var! "clojure.core" "println-str" (letrec ((println-str (lambda xs (let fnrec1944 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec1945 () (jolt-apply (var-deref "clojure.core" "println") xs)))))))) println-str))) + (def-var! "clojure.core" "println-str" (letrec ((println-str (lambda xs (let fnrec2313 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec2314 () (jolt-apply (var-deref "clojure.core" "println") xs)))))))) println-str))) (guard (e (#t #f)) - (def-var! "clojure.core" "prn-str" (letrec ((prn-str (lambda xs (let fnrec1946 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec1947 () (jolt-apply (var-deref "clojure.core" "prn") xs)))))))) prn-str))) + (def-var! "clojure.core" "prn-str" (letrec ((prn-str (lambda xs (let fnrec2315 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec2316 () (jolt-apply (var-deref "clojure.core" "prn") xs)))))))) prn-str))) (guard (e (#t #f)) - (def-var! "clojure.core" "rand-int" (letrec ((rand-int (lambda (n) (let fnrec1948 ((n n)) (jolt-invoke (var-deref "clojure.core" "int") (jolt-invoke (var-deref "clojure.core" "rand") n)))))) rand-int))) + (def-var! "clojure.core" "rand-int" (letrec ((rand-int (lambda (n) (let fnrec1677 ((n n)) (jolt-invoke (var-deref "clojure.core" "int") (jolt-invoke (var-deref "clojure.core" "rand") n)))))) rand-int))) (guard (e (#t #f)) - (def-var! "clojure.core" "shuffle" (letrec ((shuffle (lambda (coll) (let fnrec1949 ((coll coll)) (begin (if (jolt-not (jolt-invoke (var-deref "clojure.core" "coll?") coll)) (jolt-throw (let* ((_a$1950 (jolt-invoke (var-deref "clojure.core" "str") "shuffle requires a collection, got: " coll)) (_a$1951 (jolt-hash-map))) (jolt-ex-info _a$1950 _a$1951))) jolt-nil) (let* ((v (jolt-invoke (var-deref "clojure.core" "vec") coll)) (i (jolt-dec (jolt-count v)))) (let loop1952 ((v v) (i i)) (if (jolt-pos? i) (let* ((j (jolt-invoke (var-deref "clojure.core" "rand-int") (jolt-inc i))) (t (jolt-nth v i))) (let* ((_a$1953 (jolt-assoc (jolt-assoc v i (jolt-nth v j)) j t)) (_a$1954 (jolt-dec i))) (loop1952 _a$1953 _a$1954))) v)))))))) shuffle))) + (def-var! "clojure.core" "shuffle" (letrec ((shuffle (lambda (coll) (let fnrec1678 ((coll coll)) (begin (if (jolt-not (jolt-invoke (var-deref "clojure.core" "coll?") coll)) (jolt-throw (let* ((_a$1679 (jolt-invoke (var-deref "clojure.core" "str") "shuffle requires a collection, got: " coll)) (_a$1680 (jolt-hash-map))) (jolt-ex-info _a$1679 _a$1680))) jolt-nil) (let* ((v (jolt-invoke (var-deref "clojure.core" "vec") coll)) (i (jolt-dec (jolt-count v)))) (let loop1681 ((v v) (i i)) (if (jolt-pos? i) (let* ((j (jolt-invoke (var-deref "clojure.core" "rand-int") (jolt-inc i))) (t (jolt-nth v i))) (let* ((_a$1682 (jolt-assoc (jolt-assoc v i (jolt-nth v j)) j t)) (_a$1683 (jolt-dec i))) (loop1681 _a$1682 _a$1683))) v)))))))) shuffle))) (guard (e (#t #f)) - (def-var! "clojure.core" "sort-by" (letrec ((sort-by (case-lambda ((keyfn coll) (let fnrec1955 ((keyfn keyfn) (coll coll)) (jolt-invoke sort-by keyfn (var-deref "clojure.core" "compare") coll))) ((keyfn comp coll) (let fnrec1956 ((keyfn keyfn) (comp comp) (coll coll)) (jolt-invoke (var-deref "clojure.core" "sort") (lambda (x y) (let fnrec1957 ((x x) (y y)) (let* ((_a$1958 comp) (_a$1959 (jolt-invoke keyfn x)) (_a$1960 (jolt-invoke keyfn y))) (jolt-invoke _a$1958 _a$1959 _a$1960)))) coll)))))) sort-by))) + (def-var! "clojure.core" "sort-by" (letrec ((sort-by (case-lambda ((keyfn coll) (let fnrec1684 ((keyfn keyfn) (coll coll)) (jolt-invoke sort-by keyfn (var-deref "clojure.core" "compare") coll))) ((keyfn comp coll) (let fnrec1685 ((keyfn keyfn) (comp comp) (coll coll)) (jolt-invoke (var-deref "clojure.core" "sort") (lambda (x y) (let fnrec1686 ((x x) (y y)) (let* ((_a$1687 comp) (_a$1688 (jolt-invoke keyfn x)) (_a$1689 (jolt-invoke keyfn y))) (jolt-invoke _a$1687 _a$1688 _a$1689)))) coll)))))) sort-by))) (guard (e (#t #f)) - (def-var! "clojure.core" "parse-uuid" (letrec ((parse-uuid (lambda (s) (let fnrec1961 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "re-matches") (jolt-regex "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}") s)) (jolt-invoke (var-deref "clojure.core" "__make-uuid") s) jolt-nil) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "parse-uuid requires a string, got: " s))))))) parse-uuid))) + (def-var! "clojure.core" "parse-uuid" (letrec ((parse-uuid (lambda (s) (let fnrec1690 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "re-matches") (jolt-regex "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}") s)) (jolt-invoke (var-deref "clojure.core" "__make-uuid") s) jolt-nil) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "parse-uuid requires a string, got: " s))))))) parse-uuid))) (guard (e (#t #f)) - (def-var! "clojure.core" "random-uuid" (letrec ((random-uuid (lambda () (let fnrec1962 () (let* ((hx4 (lambda () (let fnrec1963 () (jolt-invoke (var-deref "clojure.core" "format") "%04x" (jolt-invoke (var-deref "clojure.core" "rand-int") 65536))))) (hx3 (lambda () (let fnrec1964 () (jolt-invoke (var-deref "clojure.core" "format") "%03x" (jolt-invoke (var-deref "clojure.core" "rand-int") 4096)))))) (jolt-invoke (var-deref "clojure.core" "parse-uuid") (let* ((_a$1965 (var-deref "clojure.core" "str")) (_a$1966 (jolt-invoke hx4)) (_a$1967 (jolt-invoke hx4)) (_a$1968 "-") (_a$1969 (jolt-invoke hx4)) (_a$1970 "-4") (_a$1971 (jolt-invoke hx3)) (_a$1972 "-") (_a$1973 (jolt-invoke (var-deref "clojure.core" "format") "%x" (+ 8 (jolt-invoke (var-deref "clojure.core" "rand-int") 4)))) (_a$1974 (jolt-invoke hx3)) (_a$1975 "-") (_a$1976 (jolt-invoke hx4)) (_a$1977 (jolt-invoke hx4)) (_a$1978 (jolt-invoke hx4))) (jolt-invoke _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)))))))) random-uuid))) + (def-var! "clojure.core" "random-uuid" (letrec ((random-uuid (lambda () (let fnrec1691 () (let* ((hx4 (lambda () (let fnrec1692 () (jolt-invoke (var-deref "clojure.core" "format") "%04x" (jolt-invoke (var-deref "clojure.core" "rand-int") 65536))))) (hx3 (lambda () (let fnrec1693 () (jolt-invoke (var-deref "clojure.core" "format") "%03x" (jolt-invoke (var-deref "clojure.core" "rand-int") 4096)))))) (jolt-invoke (var-deref "clojure.core" "parse-uuid") (let* ((_a$1694 (var-deref "clojure.core" "str")) (_a$1695 (jolt-invoke hx4)) (_a$1696 (jolt-invoke hx4)) (_a$1697 "-") (_a$1698 (jolt-invoke hx4)) (_a$1699 "-4") (_a$1700 (jolt-invoke hx3)) (_a$1701 "-") (_a$1702 (jolt-invoke (var-deref "clojure.core" "format") "%x" (+ 8 (jolt-invoke (var-deref "clojure.core" "rand-int") 4)))) (_a$1703 (jolt-invoke hx3)) (_a$1704 "-") (_a$1705 (jolt-invoke hx4)) (_a$1706 (jolt-invoke hx4)) (_a$1707 (jolt-invoke hx4))) (jolt-invoke _a$1694 _a$1695 _a$1696 _a$1697 _a$1698 _a$1699 _a$1700 _a$1701 _a$1702 _a$1703 _a$1704 _a$1705 _a$1706 _a$1707)))))))) random-uuid))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.core" "char-escape-strings" (let* ((_o$1979 (integer->char 10)) (_o$1980 "\\n") (_o$1981 (integer->char 9)) (_o$1982 "\\t") (_o$1983 (integer->char 13)) (_o$1984 "\\r") (_o$1985 (integer->char 12)) (_o$1986 "\\f") (_o$1987 (integer->char 8)) (_o$1988 "\\b") (_o$1989 (integer->char 34)) (_o$1990 "\\\"") (_o$1991 (integer->char 92)) (_o$1992 "\\\\")) (jolt-hash-map _o$1979 _o$1980 _o$1981 _o$1982 _o$1983 _o$1984 _o$1985 _o$1986 _o$1987 _o$1988 _o$1989 _o$1990 _o$1991 _o$1992)) (jolt-hash-map (keyword #f "private") #t))) + (def-var-with-meta! "clojure.core" "char-escape-strings" (let* ((_o$1708 (integer->char 10)) (_o$1709 "\\n") (_o$1710 (integer->char 9)) (_o$1711 "\\t") (_o$1712 (integer->char 13)) (_o$1713 "\\r") (_o$1714 (integer->char 12)) (_o$1715 "\\f") (_o$1716 (integer->char 8)) (_o$1717 "\\b") (_o$1718 (integer->char 34)) (_o$1719 "\\\"") (_o$1720 (integer->char 92)) (_o$1721 "\\\\")) (jolt-hash-map _o$1708 _o$1709 _o$1710 _o$1711 _o$1712 _o$1713 _o$1714 _o$1715 _o$1716 _o$1717 _o$1718 _o$1719 _o$1720 _o$1721)) (jolt-hash-map (keyword #f "private") #t))) (guard (e (#t #f)) - (def-var! "clojure.core" "char-escape-string" (letrec ((char-escape-string (lambda (c) (let fnrec1993 ((c c)) (jolt-get (var-deref "clojure.core" "char-escape-strings") c))))) char-escape-string))) + (def-var! "clojure.core" "char-escape-string" (letrec ((char-escape-string (lambda (c) (let fnrec1722 ((c c)) (jolt-get (var-deref "clojure.core" "char-escape-strings") c))))) char-escape-string))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.core" "char-name-strings" (let* ((_o$1994 (integer->char 10)) (_o$1995 "newline") (_o$1996 (integer->char 9)) (_o$1997 "tab") (_o$1998 (integer->char 13)) (_o$1999 "return") (_o$2000 (integer->char 12)) (_o$2001 "formfeed") (_o$2002 (integer->char 8)) (_o$2003 "backspace") (_o$2004 (integer->char 32)) (_o$2005 "space")) (jolt-hash-map _o$1994 _o$1995 _o$1996 _o$1997 _o$1998 _o$1999 _o$2000 _o$2001 _o$2002 _o$2003 _o$2004 _o$2005)) (jolt-hash-map (keyword #f "private") #t))) + (def-var-with-meta! "clojure.core" "char-name-strings" (let* ((_o$1723 (integer->char 10)) (_o$1724 "newline") (_o$1725 (integer->char 9)) (_o$1726 "tab") (_o$1727 (integer->char 13)) (_o$1728 "return") (_o$1729 (integer->char 12)) (_o$1730 "formfeed") (_o$1731 (integer->char 8)) (_o$1732 "backspace") (_o$1733 (integer->char 32)) (_o$1734 "space")) (jolt-hash-map _o$1723 _o$1724 _o$1725 _o$1726 _o$1727 _o$1728 _o$1729 _o$1730 _o$1731 _o$1732 _o$1733 _o$1734)) (jolt-hash-map (keyword #f "private") #t))) (guard (e (#t #f)) - (def-var! "clojure.core" "char-name-string" (letrec ((char-name-string (lambda (c) (let fnrec2006 ((c c)) (jolt-get (var-deref "clojure.core" "char-name-strings") c))))) char-name-string))) + (def-var! "clojure.core" "char-name-string" (letrec ((char-name-string (lambda (c) (let fnrec1735 ((c c)) (jolt-get (var-deref "clojure.core" "char-name-strings") c))))) char-name-string))) (guard (e (#t #f)) - (def-var! "clojure.core" "rand-nth" (letrec ((rand-nth (lambda (coll) (let fnrec2007 ((coll coll)) (let* ((v (jolt-invoke (var-deref "clojure.core" "vec") coll))) (jolt-nth v (jolt-invoke (var-deref "clojure.core" "rand-int") (jolt-count v)))))))) rand-nth))) + (def-var! "clojure.core" "rand-nth" (letrec ((rand-nth (lambda (coll) (let fnrec1736 ((coll coll)) (let* ((v (jolt-invoke (var-deref "clojure.core" "vec") coll))) (jolt-nth v (jolt-invoke (var-deref "clojure.core" "rand-int") (jolt-count v)))))))) rand-nth))) (guard (e (#t #f)) - (def-var! "clojure.core" "random-sample" (letrec ((random-sample (case-lambda ((prob) (let fnrec2008 ((prob prob)) (jolt-invoke jolt-filter (lambda (_) (let fnrec2009 ((_ _)) (< (jolt-invoke (var-deref "clojure.core" "rand")) prob)))))) ((prob coll) (let fnrec2010 ((prob prob) (coll coll)) (jolt-filter (lambda (_) (let fnrec2011 ((_ _)) (< (jolt-invoke (var-deref "clojure.core" "rand")) prob))) coll)))))) random-sample))) + (def-var! "clojure.core" "random-sample" (letrec ((random-sample (case-lambda ((prob) (let fnrec1737 ((prob prob)) (jolt-invoke jolt-filter (lambda (_) (let fnrec1738 ((_ _)) (< (jolt-invoke (var-deref "clojure.core" "rand")) prob)))))) ((prob coll) (let fnrec1739 ((prob prob) (coll coll)) (jolt-filter (lambda (_) (let fnrec1740 ((_ _)) (< (jolt-invoke (var-deref "clojure.core" "rand")) prob))) coll)))))) random-sample))) (guard (e (#t #f)) - (def-var! "clojure.core" "comparator" (letrec ((comparator (lambda (pred) (let fnrec2012 ((pred pred)) (lambda (a b) (let fnrec2013 ((a a) (b b)) (if (jolt-truthy? (jolt-invoke pred a b)) -1 (if (jolt-truthy? (jolt-invoke pred b a)) 1 (if (jolt-truthy? (keyword #f "else")) 0 jolt-nil))))))))) comparator))) + (def-var! "clojure.core" "comparator" (letrec ((comparator (lambda (pred) (let fnrec1741 ((pred pred)) (lambda (a b) (let fnrec1742 ((a a) (b b)) (if (jolt-truthy? (jolt-invoke pred a b)) -1 (if (jolt-truthy? (jolt-invoke pred b a)) 1 (if (jolt-truthy? (keyword #f "else")) 0 jolt-nil))))))))) comparator))) (guard (e (#t #f)) - (def-var! "clojure.core" "reductions" (letrec ((reductions (case-lambda ((f coll) (let fnrec2014 ((f f) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2015 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s (jolt-seq coll))) (if (jolt-truthy? s) (let* ((_a$2016 reductions) (_a$2017 f) (_a$2018 (jolt-first s)) (_a$2019 (jolt-rest s))) (jolt-invoke _a$2016 _a$2017 _a$2018 _a$2019)) (jolt-list (jolt-invoke f)))))))))) ((f init coll) (let fnrec2020 ((f f) (init init) (coll coll)) (jolt-cons init (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2021 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((_a$2022 reductions) (_a$2023 f) (_a$2024 (jolt-invoke f init (jolt-first s))) (_a$2025 (jolt-rest s))) (jolt-invoke _a$2022 _a$2023 _a$2024 _a$2025))) jolt-nil)))))))))))) reductions))) + (def-var! "clojure.core" "reductions" (letrec ((reductions (case-lambda ((f coll) (let fnrec1743 ((f f) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1744 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s (jolt-seq coll))) (if (jolt-truthy? s) (let* ((_a$1745 reductions) (_a$1746 f) (_a$1747 (jolt-first s)) (_a$1748 (jolt-rest s))) (jolt-invoke _a$1745 _a$1746 _a$1747 _a$1748)) (jolt-list (jolt-invoke f)))))))))) ((f init coll) (let fnrec1749 ((f f) (init init) (coll coll)) (jolt-cons init (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1750 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((_a$1751 reductions) (_a$1752 f) (_a$1753 (jolt-invoke f init (jolt-first s))) (_a$1754 (jolt-rest s))) (jolt-invoke _a$1751 _a$1752 _a$1753 _a$1754))) jolt-nil)))))))))))) reductions))) (guard (e (#t #f)) - (def-var! "clojure.core" "tree-seq" (letrec ((tree-seq (lambda (branch? children root) (let fnrec2026 ((branch? branch?) (children children) (root root)) (let* ((walk (letrec ((walk (lambda (node) (let fnrec2027 ((node node)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2028 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons node (if (jolt-truthy? (jolt-invoke branch? node)) (jolt-invoke (var-deref "clojure.core" "mapcat") walk (jolt-invoke children node)) jolt-nil)))))))))) walk))) (jolt-invoke walk root)))))) tree-seq))) + (def-var! "clojure.core" "tree-seq" (letrec ((tree-seq (lambda (branch? children root) (let fnrec1755 ((branch? branch?) (children children) (root root)) (let* ((walk (letrec ((walk (lambda (node) (let fnrec1756 ((node node)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1757 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons node (if (jolt-truthy? (jolt-invoke branch? node)) (jolt-invoke (var-deref "clojure.core" "mapcat") walk (jolt-invoke children node)) jolt-nil)))))))))) walk))) (jolt-invoke walk root)))))) tree-seq))) (guard (e (#t #f)) - (def-var! "clojure.core" "file-seq" (letrec ((file-seq (lambda (root) (let fnrec2029 ((root root)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "__file?") root)) (let* ((_a$2032 (var-deref "clojure.core" "tree-seq")) (_a$2033 (lambda (f) (let fnrec2030 ((f f)) (jolt-host-call "isDirectory" f)))) (_a$2034 (lambda (f) (let fnrec2031 ((f f)) (jolt-seq (jolt-host-call "listFiles" f))))) (_a$2035 root)) (jolt-invoke _a$2032 _a$2033 _a$2034 _a$2035)) (jolt-invoke (var-deref "clojure.core" "tree-seq") (var-deref "clojure.core" "__dir?") (var-deref "clojure.core" "__list-dir") root)))))) file-seq))) + (def-var! "clojure.core" "file-seq" (letrec ((file-seq (lambda (root) (let fnrec1758 ((root root)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "__file?") root)) (let* ((_a$1761 (var-deref "clojure.core" "tree-seq")) (_a$1762 (lambda (f) (let fnrec1759 ((f f)) (jolt-host-call "isDirectory" f)))) (_a$1763 (lambda (f) (let fnrec1760 ((f f)) (jolt-seq (jolt-host-call "listFiles" f))))) (_a$1764 root)) (jolt-invoke _a$1761 _a$1762 _a$1763 _a$1764)) (jolt-invoke (var-deref "clojure.core" "tree-seq") (var-deref "clojure.core" "__dir?") (var-deref "clojure.core" "__list-dir") root)))))) file-seq))) (guard (e (#t #f)) - (def-var! "clojure.core" "flatten" (letrec ((flatten (lambda (coll) (let fnrec2036 ((coll coll)) (let* ((_a$2037 (jolt-invoke (var-deref "clojure.core" "complement") (var-deref "clojure.core" "sequential?"))) (_a$2038 (jolt-rest (jolt-invoke (var-deref "clojure.core" "tree-seq") (var-deref "clojure.core" "sequential?") jolt-seq coll)))) (jolt-filter _a$2037 _a$2038)))))) flatten))) + (def-var! "clojure.core" "flatten" (letrec ((flatten (lambda (coll) (let fnrec1765 ((coll coll)) (let* ((_a$1766 (jolt-invoke (var-deref "clojure.core" "complement") (var-deref "clojure.core" "sequential?"))) (_a$1767 (jolt-rest (jolt-invoke (var-deref "clojure.core" "tree-seq") (var-deref "clojure.core" "sequential?") jolt-seq coll)))) (jolt-filter _a$1766 _a$1767)))))) flatten))) (guard (e (#t #f)) - (def-var! "clojure.core" "xml-seq" (letrec ((xml-seq (lambda (root) (let fnrec2039 ((root root)) (let* ((_a$2040 (var-deref "clojure.core" "tree-seq")) (_a$2041 (jolt-invoke (var-deref "clojure.core" "complement") (var-deref "clojure.core" "string?"))) (_a$2042 (jolt-invoke (var-deref "clojure.core" "comp") jolt-seq (keyword #f "content"))) (_a$2043 root)) (jolt-invoke _a$2040 _a$2041 _a$2042 _a$2043)))))) xml-seq))) + (def-var! "clojure.core" "xml-seq" (letrec ((xml-seq (lambda (root) (let fnrec1768 ((root root)) (let* ((_a$1769 (var-deref "clojure.core" "tree-seq")) (_a$1770 (jolt-invoke (var-deref "clojure.core" "complement") (var-deref "clojure.core" "string?"))) (_a$1771 (jolt-invoke (var-deref "clojure.core" "comp") jolt-seq (keyword #f "content"))) (_a$1772 root)) (jolt-invoke _a$1769 _a$1770 _a$1771 _a$1772)))))) xml-seq))) (guard (e (#t #f)) - (def-var! "clojure.core" "interleave" (letrec ((interleave (case-lambda (() (let fnrec2044 () (jolt-list ))) ((c1) (let fnrec2045 ((c1 c1)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2046 () (jolt-invoke (var-deref "clojure.core" "coll->cells") c1)))))) ((c1 c2) (let fnrec2047 ((c1 c1) (c2 c2)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2048 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s1 (jolt-seq c1)) (s2 (jolt-seq c2))) (if (jolt-truthy? (let* ((and__13__auto s1)) (if (jolt-truthy? and__13__auto) s2 and__13__auto))) (let* ((_a$2054 (jolt-first s1)) (_a$2055 (let* ((_a$2052 (jolt-first s2)) (_a$2053 (let* ((_a$2049 interleave) (_a$2050 (jolt-rest s1)) (_a$2051 (jolt-rest s2))) (jolt-invoke _a$2049 _a$2050 _a$2051)))) (jolt-cons _a$2052 _a$2053)))) (jolt-cons _a$2054 _a$2055)) jolt-nil)))))))) ((c1 c2 . cs) (let fnrec2056 ((c1 c1) (c2 c2) (cs (list->cseq cs))) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2057 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((ss (jolt-map jolt-seq (jolt-invoke (var-deref "clojure.core" "list*") c1 c2 cs)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "every?") jolt-identity ss)) (let* ((_a$2058 (jolt-map jolt-first ss)) (_a$2059 (jolt-apply interleave (jolt-map jolt-rest ss)))) (jolt-concat _a$2058 _a$2059)) jolt-nil))))))))))) interleave))) + (def-var! "clojure.core" "interleave" (letrec ((interleave (case-lambda (() (let fnrec1773 () (jolt-list ))) ((c1) (let fnrec1774 ((c1 c1)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1775 () (jolt-invoke (var-deref "clojure.core" "coll->cells") c1)))))) ((c1 c2) (let fnrec1776 ((c1 c1) (c2 c2)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1777 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s1 (jolt-seq c1)) (s2 (jolt-seq c2))) (if (jolt-truthy? (let* ((and__13__auto s1)) (if (jolt-truthy? and__13__auto) s2 and__13__auto))) (let* ((_a$1783 (jolt-first s1)) (_a$1784 (let* ((_a$1781 (jolt-first s2)) (_a$1782 (let* ((_a$1778 interleave) (_a$1779 (jolt-rest s1)) (_a$1780 (jolt-rest s2))) (jolt-invoke _a$1778 _a$1779 _a$1780)))) (jolt-cons _a$1781 _a$1782)))) (jolt-cons _a$1783 _a$1784)) jolt-nil)))))))) ((c1 c2 . cs) (let fnrec1785 ((c1 c1) (c2 c2) (cs (list->cseq cs))) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1786 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((ss (jolt-map jolt-seq (jolt-invoke (var-deref "clojure.core" "list*") c1 c2 cs)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "every?") jolt-identity ss)) (let* ((_a$1787 (jolt-map jolt-first ss)) (_a$1788 (jolt-apply interleave (jolt-map jolt-rest ss)))) (jolt-concat _a$1787 _a$1788)) jolt-nil))))))))))) interleave))) (guard (e (#t #f)) - (def-var! "clojure.core" "rationalize" (letrec ((rationalize (lambda (x) (let fnrec2060 ((x x)) x)))) rationalize))) + (def-var! "clojure.core" "rationalize" (letrec ((rationalize (lambda (x) (let fnrec1789 ((x x)) x)))) rationalize))) (guard (e (#t #f)) - (def-var! "clojure.core" "dedupe" (letrec ((dedupe (case-lambda (() (let fnrec2061 () (lambda (rf) (let fnrec2062 ((rf rf)) (let* ((pv (jolt-invoke (var-deref "clojure.core" "volatile!") (let* ((_o$2063 #f) (_o$2064 jolt-nil)) (jolt-vector _o$2063 _o$2064))))) (case-lambda (() (let fnrec2065 () (jolt-invoke rf))) ((result) (let fnrec2066 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec2067 ((result result) (input input)) (let* ((G__29 (jolt-invoke (var-deref "clojure.core" "deref") pv)) (seen (jolt-nth G__29 0 jolt-nil)) (prior (jolt-nth G__29 1 jolt-nil))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") pv (let* ((_o$2068 #t) (_o$2069 input)) (jolt-vector _o$2068 _o$2069))) (if (jolt-truthy? (let* ((and__13__auto seen)) (if (jolt-truthy? and__13__auto) (jolt= prior input) and__13__auto))) result (jolt-invoke rf result input)))))))))))) ((coll) (let fnrec2070 ((coll coll)) (let* ((step (letrec ((step (lambda (s prev) (let fnrec2071 ((s s) (prev prev)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2072 () (let* ((s (jolt-seq s))) (if (jolt-truthy? s) (let* ((x (jolt-first s))) (if (jolt= x prev) (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-invoke step (jolt-rest s) prev)) (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons x (jolt-invoke step (jolt-rest s) x))))) jolt-nil))))))))) step))) (let* ((s (jolt-seq coll))) (if (jolt-truthy? s) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2073 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((_a$2077 (jolt-first s)) (_a$2078 (let* ((_a$2074 step) (_a$2075 (jolt-rest s)) (_a$2076 (jolt-first s))) (jolt-invoke _a$2074 _a$2075 _a$2076)))) (jolt-cons _a$2077 _a$2078)))))) (jolt-list ))))))))) dedupe))) + (def-var! "clojure.core" "dedupe" (letrec ((dedupe (case-lambda (() (let fnrec1790 () (lambda (rf) (let fnrec1791 ((rf rf)) (let* ((pv (jolt-invoke (var-deref "clojure.core" "volatile!") (let* ((_o$1792 #f) (_o$1793 jolt-nil)) (jolt-vector _o$1792 _o$1793))))) (case-lambda (() (let fnrec1794 () (jolt-invoke rf))) ((result) (let fnrec1795 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec1796 ((result result) (input input)) (let* ((G__27 (jolt-invoke (var-deref "clojure.core" "deref") pv)) (seen (jolt-nth G__27 0 jolt-nil)) (prior (jolt-nth G__27 1 jolt-nil))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") pv (let* ((_o$1797 #t) (_o$1798 input)) (jolt-vector _o$1797 _o$1798))) (if (jolt-truthy? (let* ((and__13__auto seen)) (if (jolt-truthy? and__13__auto) (jolt= prior input) and__13__auto))) result (jolt-invoke rf result input)))))))))))) ((coll) (let fnrec1799 ((coll coll)) (let* ((step (letrec ((step (lambda (s prev) (let fnrec1800 ((s s) (prev prev)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1801 () (let* ((s (jolt-seq s))) (if (jolt-truthy? s) (let* ((x (jolt-first s))) (if (jolt= x prev) (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-invoke step (jolt-rest s) prev)) (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons x (jolt-invoke step (jolt-rest s) x))))) jolt-nil))))))))) step))) (let* ((s (jolt-seq coll))) (if (jolt-truthy? s) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1802 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((_a$1806 (jolt-first s)) (_a$1807 (let* ((_a$1803 step) (_a$1804 (jolt-rest s)) (_a$1805 (jolt-first s))) (jolt-invoke _a$1803 _a$1804 _a$1805)))) (jolt-cons _a$1806 _a$1807)))))) (jolt-list ))))))))) dedupe))) (guard (e (#t #f)) - (def-var! "clojure.core" "seq-to-map-for-destructuring" (letrec ((seq-to-map-for-destructuring (lambda (s) (let fnrec2079 ((s s)) (if (jolt-truthy? (jolt-next s)) (let* ((m (jolt-hash-map)) (xs (jolt-seq s))) (let loop2080 ((m m) (xs xs)) (if (jolt-truthy? xs) (if (jolt-truthy? (jolt-next xs)) (let* ((_a$2084 (let* ((_a$2081 m) (_a$2082 (jolt-first xs)) (_a$2083 (jolt-invoke (var-deref "clojure.core" "second") xs))) (jolt-assoc _a$2081 _a$2082 _a$2083))) (_a$2085 (jolt-invoke (var-deref "clojure.core" "nnext") xs))) (loop2080 _a$2084 _a$2085)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "No value supplied for key: " (jolt-first xs)))) m))) (if (jolt-truthy? (jolt-seq s)) (jolt-first s) (jolt-hash-map))))))) seq-to-map-for-destructuring))) + (def-var! "clojure.core" "seq-to-map-for-destructuring" (letrec ((seq-to-map-for-destructuring (lambda (s) (let fnrec1808 ((s s)) (if (jolt-truthy? (jolt-next s)) (let* ((m (jolt-hash-map)) (xs (jolt-seq s))) (let loop1809 ((m m) (xs xs)) (if (jolt-truthy? xs) (if (jolt-truthy? (jolt-next xs)) (let* ((_a$1813 (let* ((_a$1810 m) (_a$1811 (jolt-first xs)) (_a$1812 (jolt-invoke (var-deref "clojure.core" "second") xs))) (jolt-assoc _a$1810 _a$1811 _a$1812))) (_a$1814 (jolt-invoke (var-deref "clojure.core" "nnext") xs))) (loop1809 _a$1813 _a$1814)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "No value supplied for key: " (jolt-first xs)))) m))) (if (jolt-truthy? (jolt-seq s)) (jolt-first s) (jolt-hash-map))))))) seq-to-map-for-destructuring))) (guard (e (#t #f)) - (def-var! "clojure.core" "vary-meta" (letrec ((vary-meta (lambda (obj f . args) (let fnrec2086 ((obj obj) (f f) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "with-meta") obj (jolt-apply f (jolt-invoke (var-deref "clojure.core" "meta") obj) args)))))) vary-meta))) + (def-var! "clojure.core" "vary-meta" (letrec ((vary-meta (lambda (obj f . args) (let fnrec1815 ((obj obj) (f f) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "with-meta") obj (jolt-apply f (jolt-invoke (var-deref "clojure.core" "meta") obj) args)))))) vary-meta))) (guard (e (#t #f)) - (def-var! "clojure.core" "namespace-munge" (letrec ((namespace-munge (lambda (s) (let fnrec2087 ((s s)) (jolt-apply (var-deref "clojure.core" "str") (let* ((_a$2089 (lambda (c) (let fnrec2088 ((c c)) (if (jolt= c (integer->char 45)) (integer->char 95) c)))) (_a$2090 (jolt-seq (jolt-invoke (var-deref "clojure.core" "str") s)))) (jolt-map _a$2089 _a$2090))))))) namespace-munge))) + (def-var! "clojure.core" "namespace-munge" (letrec ((namespace-munge (lambda (s) (let fnrec1816 ((s s)) (jolt-apply (var-deref "clojure.core" "str") (let* ((_a$1818 (lambda (c) (let fnrec1817 ((c c)) (if (jolt= c (integer->char 45)) (integer->char 95) c)))) (_a$1819 (jolt-seq (jolt-invoke (var-deref "clojure.core" "str") s)))) (jolt-map _a$1818 _a$1819))))))) namespace-munge))) (guard (e (#t #f)) - (def-var! "clojure.core" "reduce-kv" (letrec ((reduce-kv (lambda (f init coll) (let fnrec2091 ((f f) (init init) (coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (let* ((_a$2093 (lambda (acc i) (let fnrec2092 ((acc acc) (i i)) (jolt-invoke f acc i (jolt-nth coll i))))) (_a$2094 init) (_a$2095 (jolt-range (jolt-count coll)))) (jolt-reduce _a$2093 _a$2094 _a$2095)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") coll)) (let* ((_a$2097 (lambda (acc k) (let fnrec2096 ((acc acc) (k k)) (jolt-invoke f acc k (jolt-get coll k))))) (_a$2098 init) (_a$2099 (jolt-keys coll))) (jolt-reduce _a$2097 _a$2098 _a$2099)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) init (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "reduce-kv not supported on: " coll)) jolt-nil)))))))) reduce-kv))) + (def-var! "clojure.core" "reduce-kv" (letrec ((reduce-kv (lambda (f init coll) (let fnrec1820 ((f f) (init init) (coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (let* ((_a$1822 (lambda (acc i) (let fnrec1821 ((acc acc) (i i)) (jolt-invoke f acc i (jolt-nth coll i))))) (_a$1823 init) (_a$1824 (jolt-range (jolt-count coll)))) (jolt-reduce _a$1822 _a$1823 _a$1824)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") coll)) (let* ((_a$1826 (lambda (acc k) (let fnrec1825 ((acc acc) (k k)) (jolt-invoke f acc k (jolt-get coll k))))) (_a$1827 init) (_a$1828 (jolt-keys coll))) (jolt-reduce _a$1826 _a$1827 _a$1828)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) init (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "reduce-kv not supported on: " coll)) jolt-nil)))))))) reduce-kv))) (guard (e (#t #f)) - (def-var! "clojure.core" "ex-info-val?" (letrec ((ex-info-val? (lambda (x) (let fnrec2100 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "ex-info")))))) ex-info-val?))) + (def-var! "clojure.core" "ex-info-val?" (letrec ((ex-info-val? (lambda (x) (let fnrec1829 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "ex-info")))))) ex-info-val?))) (guard (e (#t #f)) - (def-var! "clojure.core" "ex-unwrap" (letrec ((ex-unwrap (lambda (e) (let fnrec2101 ((e e)) (if (jolt= (jolt-get e (keyword "jolt" "type")) (keyword "jolt" "exception")) (jolt-get e (keyword #f "value")) e))))) ex-unwrap))) + (def-var! "clojure.core" "ex-unwrap" (letrec ((ex-unwrap (lambda (e) (let fnrec1830 ((e e)) (if (jolt= (jolt-get e (keyword "jolt" "type")) (keyword "jolt" "exception")) (jolt-get e (keyword #f "value")) e))))) ex-unwrap))) (guard (e (#t #f)) - (def-var! "clojure.core" "ex-data" (letrec ((ex-data (lambda (e) (let fnrec2102 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "data")) jolt-nil)))))) ex-data))) + (def-var! "clojure.core" "ex-data" (letrec ((ex-data (lambda (e) (let fnrec1831 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "data")) jolt-nil)))))) ex-data))) (guard (e (#t #f)) - (def-var! "clojure.core" "ex-message" (letrec ((ex-message (lambda (e) (let fnrec2103 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "message")) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) ex-message))) + (def-var! "clojure.core" "ex-message" (letrec ((ex-message (lambda (e) (let fnrec1832 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "message")) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) ex-message))) (guard (e (#t #f)) - (def-var! "clojure.core" "ex-cause" (letrec ((ex-cause (lambda (e) (let fnrec2104 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "cause")) jolt-nil)))))) ex-cause))) + (def-var! "clojure.core" "ex-cause" (letrec ((ex-cause (lambda (e) (let fnrec1833 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "cause")) jolt-nil)))))) ex-cause))) (guard (e (#t #f)) - (def-var! "clojure.core" "inst-ms" (letrec ((inst-ms (lambda (x) (let fnrec2105 ((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))) + (def-var! "clojure.core" "inst-ms" (letrec ((inst-ms (lambda (x) (let fnrec1834 ((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 fnrec2106 ((m m) (f f)) (let* ((_a$2108 (var-deref "clojure.core" "reduce-kv")) (_a$2109 (lambda (acc k v) (let fnrec2107 ((acc acc) (k k) (v v)) (jolt-assoc acc (jolt-invoke f k) v)))) (_a$2110 (jolt-hash-map )) (_a$2111 m)) (jolt-invoke _a$2108 _a$2109 _a$2110 _a$2111)))))) update-keys))) + (def-var! "clojure.core" "update-keys" (letrec ((update-keys (lambda (m f) (let fnrec1835 ((m m) (f f)) (let* ((_a$1837 (var-deref "clojure.core" "reduce-kv")) (_a$1838 (lambda (acc k v) (let fnrec1836 ((acc acc) (k k) (v v)) (jolt-assoc acc (jolt-invoke f k) v)))) (_a$1839 (jolt-hash-map )) (_a$1840 m)) (jolt-invoke _a$1837 _a$1838 _a$1839 _a$1840)))))) update-keys))) (guard (e (#t #f)) - (def-var! "clojure.core" "update-vals" (letrec ((update-vals (lambda (m f) (let fnrec2112 ((m m) (f f)) (let* ((_a$2114 (var-deref "clojure.core" "reduce-kv")) (_a$2115 (lambda (acc k v) (let fnrec2113 ((acc acc) (k k) (v v)) (jolt-assoc acc k (jolt-invoke f v))))) (_a$2116 (jolt-hash-map )) (_a$2117 m)) (jolt-invoke _a$2114 _a$2115 _a$2116 _a$2117)))))) update-vals))) + (def-var! "clojure.core" "update-vals" (letrec ((update-vals (lambda (m f) (let fnrec1841 ((m m) (f f)) (let* ((_a$1843 (var-deref "clojure.core" "reduce-kv")) (_a$1844 (lambda (acc k v) (let fnrec1842 ((acc acc) (k k) (v v)) (jolt-assoc acc k (jolt-invoke f v))))) (_a$1845 (jolt-hash-map )) (_a$1846 m)) (jolt-invoke _a$1843 _a$1844 _a$1845 _a$1846)))))) update-vals))) (guard (e (#t #f)) - (def-var! "clojure.core" "partitionv" (letrec ((partitionv (case-lambda ((n coll) (let fnrec2118 ((n n) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition") n coll)))) ((n step coll) (let fnrec2119 ((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 fnrec2120 ((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))) + (def-var! "clojure.core" "partitionv" (letrec ((partitionv (case-lambda ((n coll) (let fnrec1847 ((n n) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition") n coll)))) ((n step coll) (let fnrec1848 ((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 fnrec1849 ((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)) (declare-var! "clojure.core" "partition-all")) (guard (e (#t #f)) - (def-var! "clojure.core" "partitionv-all" (letrec ((partitionv-all (case-lambda ((n coll) (let fnrec2121 ((n n) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition-all") n coll)))) ((n step coll) (let fnrec2122 ((n n) (step step) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition-all") n step coll))))))) partitionv-all))) + (def-var! "clojure.core" "partitionv-all" (letrec ((partitionv-all (case-lambda ((n coll) (let fnrec1850 ((n n) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition-all") n coll)))) ((n step coll) (let fnrec1851 ((n n) (step step) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition-all") n step coll))))))) partitionv-all))) (guard (e (#t #f)) - (def-var! "clojure.core" "splitv-at" (letrec ((splitv-at (lambda (n coll) (let fnrec2123 ((n n) (coll coll)) (let* ((_o$2124 (jolt-invoke (var-deref "clojure.core" "vec") (jolt-take n coll))) (_o$2125 (jolt-drop n coll))) (jolt-vector _o$2124 _o$2125)))))) splitv-at))) + (def-var! "clojure.core" "splitv-at" (letrec ((splitv-at (lambda (n coll) (let fnrec1852 ((n n) (coll coll)) (let* ((_o$1853 (jolt-invoke (var-deref "clojure.core" "vec") (jolt-take n coll))) (_o$1854 (jolt-drop n coll))) (jolt-vector _o$1853 _o$1854)))))) splitv-at))) (guard (e (#t #f)) - (def-var! "clojure.core" "with-redefs-fn" (letrec ((with-redefs-fn (lambda (binding-map func) (let fnrec2126 ((binding-map binding-map) (func func)) (let* ((vars (jolt-invoke (var-deref "clojure.core" "vec") (jolt-keys binding-map))) (saved (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "var-get") vars))) (begin (begin (jolt-count (jolt-map (lambda (v) (let fnrec2127 ((v v)) (begin (jolt-invoke (var-deref "clojure.core" "var-set") v (jolt-get binding-map v)) jolt-nil))) vars)) jolt-nil) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke func)) (lambda () (let* ((i 0)) (let loop2128 ((i i)) (if (< i (jolt-count vars)) (begin (let* ((_a$2129 (var-deref "clojure.core" "var-set")) (_a$2130 (jolt-nth vars i)) (_a$2131 (jolt-nth saved i))) (jolt-invoke _a$2129 _a$2130 _a$2131)) (loop2128 (jolt-inc i))) jolt-nil))))))))))) with-redefs-fn))) + (def-var! "clojure.core" "with-redefs-fn" (letrec ((with-redefs-fn (lambda (binding-map func) (let fnrec1855 ((binding-map binding-map) (func func)) (let* ((vars (jolt-invoke (var-deref "clojure.core" "vec") (jolt-keys binding-map))) (saved (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "var-get") vars))) (begin (begin (jolt-count (jolt-map (lambda (v) (let fnrec1856 ((v v)) (begin (jolt-invoke (var-deref "clojure.core" "var-set") v (jolt-get binding-map v)) jolt-nil))) vars)) jolt-nil) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke func)) (lambda () (let* ((i 0)) (let loop1857 ((i i)) (if (< i (jolt-count vars)) (begin (let* ((_a$1858 (var-deref "clojure.core" "var-set")) (_a$1859 (jolt-nth vars i)) (_a$1860 (jolt-nth saved i))) (jolt-invoke _a$1858 _a$1859 _a$1860)) (loop1857 (jolt-inc i))) jolt-nil))))))))))) with-redefs-fn))) (guard (e (#t #f)) - (def-var! "clojure.core" "chunked-seq?" (letrec ((chunked-seq? (lambda (x) (let fnrec2132 ((x x)) #f)))) chunked-seq?))) + (def-var! "clojure.core" "chunked-seq?" (letrec ((chunked-seq? (lambda (x) (let fnrec1861 ((x x)) #f)))) chunked-seq?))) (guard (e (#t #f)) - (def-var! "clojure.core" "swap-vals!" (letrec ((swap-vals! (lambda (a f . args) (let fnrec2133 ((a a) (f f) (args (list->cseq args))) (let* ((old (jolt-invoke (var-deref "clojure.core" "deref") a))) (let* ((_o$2134 old) (_o$2135 (jolt-apply (var-deref "clojure.core" "swap!") a f args))) (jolt-vector _o$2134 _o$2135))))))) swap-vals!))) + (def-var! "clojure.core" "swap-vals!" (letrec ((swap-vals! (lambda (a f . args) (let fnrec1862 ((a a) (f f) (args (list->cseq args))) (let* ((old (jolt-invoke (var-deref "clojure.core" "deref") a))) (let* ((_o$1863 old) (_o$1864 (jolt-apply (var-deref "clojure.core" "swap!") a f args))) (jolt-vector _o$1863 _o$1864))))))) swap-vals!))) (guard (e (#t #f)) - (def-var! "clojure.core" "reset-vals!" (letrec ((reset-vals! (lambda (a newval) (let fnrec2136 ((a a) (newval newval)) (let* ((old (jolt-invoke (var-deref "clojure.core" "deref") a))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") a newval) (let* ((_o$2137 old) (_o$2138 newval)) (jolt-vector _o$2137 _o$2138)))))))) reset-vals!))) + (def-var! "clojure.core" "reset-vals!" (letrec ((reset-vals! (lambda (a newval) (let fnrec1865 ((a a) (newval newval)) (let* ((old (jolt-invoke (var-deref "clojure.core" "deref") a))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") a newval) (let* ((_o$1866 old) (_o$1867 newval)) (jolt-vector _o$1866 _o$1867)))))))) reset-vals!))) (guard (e (#t #f)) - (def-var! "clojure.core" "compare-and-set!" (letrec ((compare-and-set! (lambda (a oldval newval) (let fnrec2139 ((a a) (oldval oldval) (newval newval)) (if (jolt= oldval (jolt-invoke (var-deref "clojure.core" "deref") a)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") a newval) #t) #f))))) compare-and-set!))) + (def-var! "clojure.core" "compare-and-set!" (letrec ((compare-and-set! (lambda (a oldval newval) (let fnrec1868 ((a a) (oldval oldval) (newval newval)) (if (jolt= oldval (jolt-invoke (var-deref "clojure.core" "deref") a)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") a newval) #t) #f))))) compare-and-set!))) (guard (e (#t #f)) - (def-var! "clojure.core" "get-validator" (letrec ((get-validator (lambda (a) (let fnrec2140 ((a a)) (jolt-get a (keyword #f "validator")))))) get-validator))) + (def-var! "clojure.core" "get-validator" (letrec ((get-validator (lambda (a) (let fnrec1869 ((a a)) (jolt-get a (keyword #f "validator")))))) get-validator))) (guard (e (#t #f)) - (def-var! "clojure.core" "add-watch" (letrec ((add-watch (lambda (a key f) (let fnrec2141 ((a a) (key key) (f f)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-get a (keyword #f "watches")) key f) a))))) add-watch))) + (def-var! "clojure.core" "add-watch" (letrec ((add-watch (lambda (a key f) (let fnrec1870 ((a a) (key key) (f f)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-get a (keyword #f "watches")) key f) a))))) add-watch))) (guard (e (#t #f)) - (def-var! "clojure.core" "remove-watch" (letrec ((remove-watch (lambda (a key) (let fnrec2142 ((a a) (key key)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-get a (keyword #f "watches")) key jolt-nil) a))))) remove-watch))) + (def-var! "clojure.core" "remove-watch" (letrec ((remove-watch (lambda (a key) (let fnrec1871 ((a a) (key key)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-get a (keyword #f "watches")) key jolt-nil) a))))) remove-watch))) (guard (e (#t #f)) - (def-var! "clojure.core" "set-validator!" (letrec ((set-validator! (lambda (a f) (let fnrec2143 ((a a) (f f)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") a (keyword #f "validator") f) jolt-nil))))) set-validator!))) + (def-var! "clojure.core" "set-validator!" (letrec ((set-validator! (lambda (a f) (let fnrec1872 ((a a) (f f)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") a (keyword #f "validator") f) jolt-nil))))) set-validator!))) (guard (e (#t #f)) - (def-var! "clojure.core" "future-done?" (letrec ((future-done? (lambda (x) (let fnrec2144 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "future?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cached"))) (jolt-throw "future-done? requires a future")))))) future-done?))) + (def-var! "clojure.core" "future-done?" (letrec ((future-done? (lambda (x) (let fnrec1873 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "future?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cached"))) (jolt-throw "future-done? requires a future")))))) future-done?))) (guard (e (#t #f)) - (def-var! "clojure.core" "future-cancelled?" (letrec ((future-cancelled? (lambda (x) (let fnrec2145 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "future?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cancelled"))) and__13__auto)))))) future-cancelled?))) + (def-var! "clojure.core" "future-cancelled?" (letrec ((future-cancelled? (lambda (x) (let fnrec1874 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "future?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cancelled"))) and__13__auto)))))) future-cancelled?))) (guard (e (#t #f)) - (def-var! "clojure.core" "ns-name" (letrec ((ns-name (lambda (ns) (let fnrec2146 ((ns ns)) (let* ((nm (jolt-get ns (keyword #f "name")))) (if (jolt-truthy? nm) (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") nm)) jolt-nil)))))) ns-name))) + (def-var! "clojure.core" "ns-name" (letrec ((ns-name (lambda (ns) (let fnrec1875 ((ns ns)) (let* ((nm (jolt-get ns (keyword #f "name")))) (if (jolt-truthy? nm) (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") nm)) jolt-nil)))))) ns-name))) (guard (e (#t #f)) - (def-var! "clojure.core" "aget" (letrec ((aget (lambda (arr . idxs) (let fnrec2147 ((arr arr) (idxs (list->cseq idxs))) (jolt-reduce (lambda (v i) (let fnrec2148 ((v v) (i i)) (jolt-nth v i))) arr idxs))))) aget))) + (def-var! "clojure.core" "aget" (letrec ((aget (lambda (arr . idxs) (let fnrec1876 ((arr arr) (idxs (list->cseq idxs))) (jolt-reduce (lambda (v i) (let fnrec1877 ((v v) (i i)) (jolt-nth v i))) arr idxs))))) aget))) (guard (e (#t #f)) - (def-var! "clojure.core" "alength" (letrec ((alength (lambda (arr) (let fnrec2149 ((arr arr)) (jolt-count arr))))) alength))) + (def-var! "clojure.core" "alength" (letrec ((alength (lambda (arr) (let fnrec1878 ((arr arr)) (jolt-count arr))))) alength))) (guard (e (#t #f)) - (def-var! "clojure.core" "aset" (letrec ((aset (lambda (arr . idxs+val) (let fnrec2150 ((arr arr) (idxs+val (list->cseq idxs+val))) (let* ((n (jolt-count idxs+val)) (val (jolt-nth idxs+val (jolt-dec n))) (target (let* ((_a$2152 (lambda (t k) (let fnrec2151 ((t t) (k k)) (jolt-nth t k)))) (_a$2153 arr) (_a$2154 (jolt-take (- n 2) idxs+val))) (jolt-reduce _a$2152 _a$2153 _a$2154)))) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") target (jolt-nth idxs+val (- n 2)) val) val)))))) aset))) + (def-var! "clojure.core" "aset" (letrec ((aset (lambda (arr . idxs+val) (let fnrec1879 ((arr arr) (idxs+val (list->cseq idxs+val))) (let* ((n (jolt-count idxs+val)) (val (jolt-nth idxs+val (jolt-dec n))) (target (let* ((_a$1881 (lambda (t k) (let fnrec1880 ((t t) (k k)) (jolt-nth t k)))) (_a$1882 arr) (_a$1883 (jolt-take (- n 2) idxs+val))) (jolt-reduce _a$1881 _a$1882 _a$1883)))) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") target (jolt-nth idxs+val (- n 2)) val) val)))))) aset))) (guard (e (#t #f)) - (def-var! "clojure.core" "complement" (letrec ((complement (lambda (f) (let fnrec2155 ((f f)) (lambda args (let fnrec2156 ((args (list->cseq args))) (jolt-not (jolt-apply f args)))))))) complement))) + (def-var! "clojure.core" "complement" (letrec ((complement (lambda (f) (let fnrec1884 ((f f)) (lambda args (let fnrec1885 ((args (list->cseq args))) (jolt-not (jolt-apply f args)))))))) complement))) (guard (e (#t #f)) - (def-var! "clojure.core" "fnil" (letrec ((fnil (case-lambda ((f x) (let fnrec2157 ((f f) (x x)) (lambda (a . args) (let fnrec2158 ((a a) (args (list->cseq args))) (jolt-apply f (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a) args))))) ((f x y) (let fnrec2159 ((f f) (x x) (y y)) (lambda (a b . args) (let fnrec2160 ((a a) (b b) (args (list->cseq args))) (let* ((_a$2161 f) (_a$2162 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a)) (_a$2163 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) y b)) (_a$2164 args)) (jolt-apply _a$2161 _a$2162 _a$2163 _a$2164)))))) ((f x y z) (let fnrec2165 ((f f) (x x) (y y) (z z)) (lambda (a b c . args) (let fnrec2166 ((a a) (b b) (c c) (args (list->cseq args))) (let* ((_a$2167 f) (_a$2168 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a)) (_a$2169 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) y b)) (_a$2170 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") c)) z c)) (_a$2171 args)) (jolt-apply _a$2167 _a$2168 _a$2169 _a$2170 _a$2171))))))))) fnil))) + (def-var! "clojure.core" "fnil" (letrec ((fnil (case-lambda ((f x) (let fnrec1886 ((f f) (x x)) (lambda (a . args) (let fnrec1887 ((a a) (args (list->cseq args))) (jolt-apply f (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a) args))))) ((f x y) (let fnrec1888 ((f f) (x x) (y y)) (lambda (a b . args) (let fnrec1889 ((a a) (b b) (args (list->cseq args))) (let* ((_a$1890 f) (_a$1891 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a)) (_a$1892 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) y b)) (_a$1893 args)) (jolt-apply _a$1890 _a$1891 _a$1892 _a$1893)))))) ((f x y z) (let fnrec1894 ((f f) (x x) (y y) (z z)) (lambda (a b c . args) (let fnrec1895 ((a a) (b b) (c c) (args (list->cseq args))) (let* ((_a$1896 f) (_a$1897 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a)) (_a$1898 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) y b)) (_a$1899 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") c)) z c)) (_a$1900 args)) (jolt-apply _a$1896 _a$1897 _a$1898 _a$1899 _a$1900))))))))) fnil))) (guard (e (#t #f)) - (def-var! "clojure.core" "clojure-version" (letrec ((clojure-version (lambda () (let fnrec2172 () "1.11.0-jolt")))) clojure-version))) + (def-var! "clojure.core" "clojure-version" (letrec ((clojure-version (lambda () (let fnrec1901 () "1.11.0-jolt")))) clojure-version))) (guard (e (#t #f)) - (def-var! "clojure.core" "numerator" (letrec ((numerator (lambda (x) (let fnrec2173 ((x x)) (jolt-throw (jolt-ex-info "numerator requires a ratio (Jolt has no ratios)" (jolt-hash-map))))))) numerator))) + (def-var! "clojure.core" "numerator" (letrec ((numerator (lambda (x) (let fnrec1902 ((x x)) (jolt-throw (jolt-ex-info "numerator requires a ratio (Jolt has no ratios)" (jolt-hash-map))))))) numerator))) (guard (e (#t #f)) - (def-var! "clojure.core" "denominator" (letrec ((denominator (lambda (x) (let fnrec2174 ((x x)) (jolt-throw (jolt-ex-info "denominator requires a ratio (Jolt has no ratios)" (jolt-hash-map))))))) denominator))) + (def-var! "clojure.core" "denominator" (letrec ((denominator (lambda (x) (let fnrec1903 ((x x)) (jolt-throw (jolt-ex-info "denominator requires a ratio (Jolt has no ratios)" (jolt-hash-map))))))) denominator))) (guard (e (#t #f)) - (def-var! "clojure.core" "supers" (letrec ((supers (lambda (x) (let fnrec2175 ((x x)) (jolt-hash-set))))) supers))) + (def-var! "clojure.core" "supers" (letrec ((supers (lambda (x) (let fnrec1904 ((x x)) (jolt-hash-set))))) supers))) (guard (e (#t #f)) - (def-var! "clojure.core" "munge" (letrec ((munge (lambda (s) (let fnrec2176 ((s s)) (let* ((m (jolt-invoke (var-deref "clojure.core" "str-replace-all") "-" "_" (jolt-invoke (var-deref "clojure.core" "str") s)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") s)) (jolt-invoke (var-deref "clojure.core" "symbol") m) m)))))) munge))) + (def-var! "clojure.core" "munge" (letrec ((munge (lambda (s) (let fnrec1905 ((s s)) (let* ((m (jolt-invoke (var-deref "clojure.core" "str-replace-all") "-" "_" (jolt-invoke (var-deref "clojure.core" "str") s)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") s)) (jolt-invoke (var-deref "clojure.core" "symbol") m) m)))))) munge))) (guard (e (#t #f)) - (def-var! "clojure.core" "test" (letrec ((test (lambda (v) (let fnrec2177 ((v v)) (let* ((t (jolt-get (jolt-invoke (var-deref "clojure.core" "meta") v) (keyword #f "test")))) (if (jolt-truthy? t) (begin (jolt-invoke t) (keyword #f "ok")) (keyword #f "no-test"))))))) test))) + (def-var! "clojure.core" "test" (letrec ((test (lambda (v) (let fnrec1906 ((v v)) (let* ((t (jolt-get (jolt-invoke (var-deref "clojure.core" "meta") v) (keyword #f "test")))) (if (jolt-truthy? t) (begin (jolt-invoke t) (keyword #f "ok")) (keyword #f "no-test"))))))) test))) (guard (e (#t #f)) - (def-var! "clojure.core" "find" (letrec ((find (lambda (m k) (let fnrec2178 ((m m) (k k)) (if (jolt-contains? m k) (jolt-first (let* ((_o$2179 k) (_o$2180 (jolt-get m k))) (jolt-hash-map _o$2179 _o$2180))) jolt-nil))))) find))) + (def-var! "clojure.core" "find" (letrec ((find (lambda (m k) (let fnrec1907 ((m m) (k k)) (if (jolt-contains? m k) (jolt-first (let* ((_o$1908 k) (_o$1909 (jolt-get m k))) (jolt-hash-map _o$1908 _o$1909))) jolt-nil))))) find))) (guard (e (#t #f)) - (def-var! "clojure.core" "true?" (letrec ((true? (lambda (x) (let fnrec2181 ((x x)) (jolt= #t x))))) true?))) + (def-var! "clojure.core" "true?" (letrec ((true? (lambda (x) (let fnrec1910 ((x x)) (jolt= #t x))))) true?))) (guard (e (#t #f)) - (def-var! "clojure.core" "false?" (letrec ((false? (lambda (x) (let fnrec2182 ((x x)) (jolt= #f x))))) false?))) + (def-var! "clojure.core" "false?" (letrec ((false? (lambda (x) (let fnrec1911 ((x x)) (jolt= #f x))))) false?))) (guard (e (#t #f)) - (def-var! "clojure.core" "select-keys" (letrec ((select-keys (lambda (map keyseq) (let fnrec2183 ((map map) (keyseq keyseq)) (let* ((_a$2185 (lambda (m k) (let fnrec2184 ((m m) (k k)) (if (jolt-contains? map k) (jolt-assoc m k (jolt-get map k)) m)))) (_a$2186 (jolt-hash-map )) (_a$2187 keyseq)) (jolt-reduce _a$2185 _a$2186 _a$2187)))))) select-keys))) + (def-var! "clojure.core" "select-keys" (letrec ((select-keys (lambda (map keyseq) (let fnrec1912 ((map map) (keyseq keyseq)) (let* ((_a$1914 (lambda (m k) (let fnrec1913 ((m m) (k k)) (if (jolt-contains? map k) (jolt-assoc m k (jolt-get map k)) m)))) (_a$1915 (jolt-hash-map )) (_a$1916 keyseq)) (jolt-reduce _a$1914 _a$1915 _a$1916)))))) select-keys))) (guard (e (#t #f)) - (def-var! "clojure.core" "zipmap" (letrec ((zipmap (lambda (keys vals) (let fnrec2188 ((keys keys) (vals vals)) (let* ((m (jolt-hash-map )) (ks (jolt-seq keys)) (vs (jolt-seq vals))) (let loop2189 ((m m) (ks ks) (vs vs)) (if (jolt-truthy? (let* ((and__13__auto ks)) (if (jolt-truthy? and__13__auto) vs and__13__auto))) (let* ((_a$2193 (let* ((_a$2190 m) (_a$2191 (jolt-first ks)) (_a$2192 (jolt-first vs))) (jolt-assoc _a$2190 _a$2191 _a$2192))) (_a$2194 (jolt-next ks)) (_a$2195 (jolt-next vs))) (loop2189 _a$2193 _a$2194 _a$2195)) m))))))) zipmap))) + (def-var! "clojure.core" "zipmap" (letrec ((zipmap (lambda (keys vals) (let fnrec1917 ((keys keys) (vals vals)) (let* ((m (jolt-hash-map )) (ks (jolt-seq keys)) (vs (jolt-seq vals))) (let loop1918 ((m m) (ks ks) (vs vs)) (if (jolt-truthy? (let* ((and__13__auto ks)) (if (jolt-truthy? and__13__auto) vs and__13__auto))) (let* ((_a$1922 (let* ((_a$1919 m) (_a$1920 (jolt-first ks)) (_a$1921 (jolt-first vs))) (jolt-assoc _a$1919 _a$1920 _a$1921))) (_a$1923 (jolt-next ks)) (_a$1924 (jolt-next vs))) (loop1918 _a$1922 _a$1923 _a$1924)) m))))))) zipmap))) (guard (e (#t #f)) - (def-var! "clojure.core" "merge" (letrec ((merge (lambda maps (let fnrec2196 ((maps (list->cseq maps))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "some") jolt-identity maps)) (jolt-reduce (lambda (acc m) (let fnrec2197 ((acc acc) (m m)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") m)) acc (jolt-conj (let* ((or__14__auto acc)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map ))) m)))) maps) jolt-nil))))) merge))) + (def-var! "clojure.core" "merge" (letrec ((merge (lambda maps (let fnrec1925 ((maps (list->cseq maps))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "some") jolt-identity maps)) (jolt-reduce (lambda (acc m) (let fnrec1926 ((acc acc) (m m)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") m)) acc (jolt-conj (let* ((or__14__auto acc)) (if (jolt-truthy? or__14__auto) or__14__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 fnrec2198 ((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 fnrec2199 ((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 fnrec2200 ((m1 m1) (m2 m2)) (let* ((_a$2201 merge-entry) (_a$2202 (let* ((or__14__auto m1)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map )))) (_a$2203 (jolt-seq m2))) (jolt-reduce _a$2201 _a$2202 _a$2203)))))) (jolt-reduce merge2 maps)) jolt-nil))))) merge-with))) + (def-var! "clojure.core" "merge-with" (letrec ((merge-with (lambda (f . maps) (let fnrec1927 ((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 fnrec1928 ((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 fnrec1929 ((m1 m1) (m2 m2)) (let* ((_a$1930 merge-entry) (_a$1931 (let* ((or__14__auto m1)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map )))) (_a$1932 (jolt-seq m2))) (jolt-reduce _a$1930 _a$1931 _a$1932)))))) (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 fnrec2204 ((m m) (ks ks)) (jolt-reduce jolt-get m ks))) ((m ks not-found) (let fnrec2205 ((m m) (ks ks) (not-found not-found)) (let* ((sentinel (jolt-hash-map ))) (let* ((m m) (ks (jolt-seq ks))) (let loop2206 ((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 (loop2206 nxt (jolt-next ks)))) m))))))))) get-in))) + (def-var! "clojure.core" "get-in" (letrec ((get-in (case-lambda ((m ks) (let fnrec1933 ((m m) (ks ks)) (jolt-reduce jolt-get m ks))) ((m ks not-found) (let fnrec1934 ((m m) (ks ks) (not-found not-found)) (let* ((sentinel (jolt-hash-map ))) (let* ((m m) (ks (jolt-seq ks))) (let loop1935 ((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 (loop1935 nxt (jolt-next ks)))) m))))))))) get-in))) (guard (e (#t #f)) - (def-var! "clojure.core" "memoize" (letrec ((memoize (lambda (f) (let fnrec2207 ((f f)) (let* ((mem (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map )))) (lambda args (let fnrec2208 ((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 fnrec1936 ((f f)) (let* ((mem (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map )))) (lambda args (let fnrec1937 ((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 fnrec2209 ((f f)) f)) ((f a) (let fnrec2210 ((f f) (a a)) (lambda args (let fnrec2211 ((args (list->cseq args))) (jolt-apply f a args))))) ((f a b) (let fnrec2212 ((f f) (a a) (b b)) (lambda args (let fnrec2213 ((args (list->cseq args))) (jolt-apply f a b args))))) ((f a b c) (let fnrec2214 ((f f) (a a) (b b) (c c)) (lambda args (let fnrec2215 ((args (list->cseq args))) (jolt-apply f a b c args))))) ((f a b c . more) (let fnrec2216 ((f f) (a a) (b b) (c c) (more (list->cseq more))) (lambda args (let fnrec2217 ((args (list->cseq args))) (jolt-apply f a b c (jolt-concat more args))))))))) partial))) + (def-var! "clojure.core" "partial" (letrec ((partial (case-lambda ((f) (let fnrec1938 ((f f)) f)) ((f a) (let fnrec1939 ((f f) (a a)) (lambda args (let fnrec1940 ((args (list->cseq args))) (jolt-apply f a args))))) ((f a b) (let fnrec1941 ((f f) (a a) (b b)) (lambda args (let fnrec1942 ((args (list->cseq args))) (jolt-apply f a b args))))) ((f a b c) (let fnrec1943 ((f f) (a a) (b b) (c c)) (lambda args (let fnrec1944 ((args (list->cseq args))) (jolt-apply f a b c args))))) ((f a b c . more) (let fnrec1945 ((f f) (a a) (b b) (c c) (more (list->cseq more))) (lambda args (let fnrec1946 ((args (list->cseq args))) (jolt-apply f a b c (jolt-concat more args))))))))) partial))) (guard (e (#t #f)) - (def-var! "clojure.core" "trampoline" (letrec ((trampoline (case-lambda ((f) (let fnrec2218 ((f f)) (let* ((ret (jolt-invoke f))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "fn?") ret)) (jolt-invoke trampoline ret) ret)))) ((f . args) (let fnrec2219 ((f f) (args (list->cseq args))) (jolt-invoke trampoline (lambda () (let fnrec2220 () (jolt-apply f args))))))))) trampoline))) + (def-var! "clojure.core" "trampoline" (letrec ((trampoline (case-lambda ((f) (let fnrec1947 ((f f)) (let* ((ret (jolt-invoke f))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "fn?") ret)) (jolt-invoke trampoline ret) ret)))) ((f . args) (let fnrec1948 ((f f) (args (list->cseq args))) (jolt-invoke trampoline (lambda () (let fnrec1949 () (jolt-apply f args))))))))) trampoline))) (guard (e (#t #f)) - (def-var! "clojure.core" "max" (letrec ((max (case-lambda ((x) (let fnrec2221 ((x x)) x)) ((x y) (let fnrec2222 ((x x) (y y)) (if (> x y) x y))) ((x y . more) (let fnrec2223 ((x x) (y y) (more (list->cseq more))) (jolt-reduce max (jolt-invoke max x y) more)))))) max))) + (def-var! "clojure.core" "max" (letrec ((max (case-lambda ((x) (let fnrec1950 ((x x)) x)) ((x y) (let fnrec1951 ((x x) (y y)) (if (> x y) x y))) ((x y . more) (let fnrec1952 ((x x) (y y) (more (list->cseq more))) (jolt-reduce max (jolt-invoke max x y) more)))))) max))) (guard (e (#t #f)) - (def-var! "clojure.core" "min" (letrec ((min (case-lambda ((x) (let fnrec2224 ((x x)) x)) ((x y) (let fnrec2225 ((x x) (y y)) (if (< x y) x y))) ((x y . more) (let fnrec2226 ((x x) (y y) (more (list->cseq more))) (jolt-reduce min (jolt-invoke min x y) more)))))) min))) + (def-var! "clojure.core" "min" (letrec ((min (case-lambda ((x) (let fnrec1953 ((x x)) x)) ((x y) (let fnrec1954 ((x x) (y y)) (if (< x y) x y))) ((x y . more) (let fnrec1955 ((x x) (y y) (more (list->cseq more))) (jolt-reduce min (jolt-invoke min x y) more)))))) min))) (guard (e (#t #f)) - (def-var! "clojure.core" "reverse" (letrec ((reverse (lambda (coll) (let fnrec2227 ((coll coll)) (jolt-reduce jolt-conj (jolt-list ) coll))))) reverse))) + (def-var! "clojure.core" "reverse" (letrec ((reverse (lambda (coll) (let fnrec1956 ((coll coll)) (jolt-reduce jolt-conj (jolt-list ) coll))))) reverse))) (guard (e (#t #f)) - (def-var! "clojure.core" "empty" (letrec ((empty (lambda (coll) (let fnrec2228 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "sorted?") coll)) (jolt-invoke (jolt-get (jolt-invoke (var-deref "jolt.host" "ref-get") coll (keyword #f "ops")) (keyword #f "empty")) coll) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") coll)) (jolt-hash-map) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") coll)) (jolt-hash-set) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (jolt-vector) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "coll?") coll)) (jolt-list ) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))))))) empty))) + (def-var! "clojure.core" "empty" (letrec ((empty (lambda (coll) (let fnrec1957 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "sorted?") coll)) (jolt-invoke (jolt-get (jolt-invoke (var-deref "jolt.host" "ref-get") coll (keyword #f "ops")) (keyword #f "empty")) coll) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") coll)) (jolt-hash-map) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") coll)) (jolt-hash-set) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (jolt-vector) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "coll?") coll)) (jolt-list ) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))))))) empty))) (guard (e (#t #f)) - (def-var! "clojure.core" "assoc-in" (letrec ((assoc-in (lambda (m G__30 v) (let fnrec2229 ((m m) (G__30 G__30) (v v)) (let* ((G__31 G__30) (k (jolt-nth G__31 0 jolt-nil)) (ks (jolt-invoke (var-deref "clojure.core" "nthnext") G__31 1))) (if (jolt-truthy? ks) (jolt-assoc m k (jolt-invoke assoc-in (jolt-get m k) ks v)) (jolt-assoc m k v))))))) assoc-in))) + (def-var! "clojure.core" "assoc-in" (letrec ((assoc-in (lambda (m G__28 v) (let fnrec1958 ((m m) (G__28 G__28) (v v)) (let* ((G__29 G__28) (k (jolt-nth G__29 0 jolt-nil)) (ks (jolt-invoke (var-deref "clojure.core" "nthnext") G__29 1))) (if (jolt-truthy? ks) (jolt-assoc m k (jolt-invoke assoc-in (jolt-get m k) ks v)) (jolt-assoc m k v))))))) assoc-in))) (guard (e (#t #f)) - (def-var! "clojure.core" "update-in" (letrec ((update-in (lambda (m ks f . args) (let fnrec2230 ((m m) (ks ks) (f f) (args (list->cseq args))) (let* ((up (letrec ((up (lambda (m ks f args) (let fnrec2231 ((m m) (ks ks) (f f) (args args)) (let* ((G__32 ks) (k (jolt-nth G__32 0 jolt-nil)) (ks (jolt-invoke (var-deref "clojure.core" "nthnext") G__32 1))) (if (jolt-truthy? ks) (jolt-assoc m k (jolt-invoke up (jolt-get m k) ks f args)) (jolt-assoc m k (jolt-apply f (jolt-get m k) args)))))))) up))) (jolt-invoke up m ks f args)))))) update-in))) + (def-var! "clojure.core" "update-in" (letrec ((update-in (lambda (m ks f . args) (let fnrec1959 ((m m) (ks ks) (f f) (args (list->cseq args))) (let* ((up (letrec ((up (lambda (m ks f args) (let fnrec1960 ((m m) (ks ks) (f f) (args args)) (let* ((G__30 ks) (k (jolt-nth G__30 0 jolt-nil)) (ks (jolt-invoke (var-deref "clojure.core" "nthnext") G__30 1))) (if (jolt-truthy? ks) (jolt-assoc m k (jolt-invoke up (jolt-get m k) ks f args)) (jolt-assoc m k (jolt-apply f (jolt-get m k) args)))))))) up))) (jolt-invoke up m ks f args)))))) update-in))) (guard (e (#t #f)) - (def-var! "clojure.core" "find-keyword" (letrec ((find-keyword (case-lambda ((nm) (let fnrec2232 ((nm nm)) (jolt-invoke (var-deref "clojure.core" "keyword") nm))) ((ns nm) (let fnrec2233 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "keyword") ns nm)))))) find-keyword))) + (def-var! "clojure.core" "find-keyword" (letrec ((find-keyword (case-lambda ((nm) (let fnrec1961 ((nm nm)) (jolt-invoke (var-deref "clojure.core" "keyword") nm))) ((ns nm) (let fnrec1962 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "keyword") ns nm)))))) find-keyword))) (guard (e (#t #f)) - (def-var! "clojure.core" "inst-ms*" (letrec ((inst-ms* (lambda (i) (let fnrec2234 ((i i)) (jolt-invoke (var-deref "clojure.core" "inst-ms") i))))) inst-ms*))) + (def-var! "clojure.core" "inst-ms*" (letrec ((inst-ms* (lambda (i) (let fnrec1963 ((i i)) (jolt-invoke (var-deref "clojure.core" "inst-ms") i))))) inst-ms*))) (guard (e (#t #f)) - (def-var! "clojure.core" "comp" (letrec ((comp (case-lambda (() (let fnrec2235 () jolt-identity)) ((f) (let fnrec2236 ((f f)) f)) ((f g) (let fnrec2237 ((f f) (g g)) (case-lambda (() (let fnrec2238 () (jolt-invoke f (jolt-invoke g)))) ((x) (let fnrec2239 ((x x)) (jolt-invoke f (jolt-invoke g x)))) ((x y) (let fnrec2240 ((x x) (y y)) (jolt-invoke f (jolt-invoke g x y)))) ((x y z) (let fnrec2241 ((x x) (y y) (z z)) (jolt-invoke f (jolt-invoke g x y z)))) ((x y z . args) (let fnrec2242 ((x x) (y y) (z z) (args (list->cseq args))) (jolt-invoke f (jolt-apply g x y z args))))))) ((f g . fs) (let fnrec2243 ((f f) (g g) (fs (list->cseq fs))) (jolt-reduce comp (jolt-invoke comp f g) fs)))))) comp))) + (def-var! "clojure.core" "comp" (letrec ((comp (case-lambda (() (let fnrec1964 () jolt-identity)) ((f) (let fnrec1965 ((f f)) f)) ((f g) (let fnrec1966 ((f f) (g g)) (case-lambda (() (let fnrec1967 () (jolt-invoke f (jolt-invoke g)))) ((x) (let fnrec1968 ((x x)) (jolt-invoke f (jolt-invoke g x)))) ((x y) (let fnrec1969 ((x x) (y y)) (jolt-invoke f (jolt-invoke g x y)))) ((x y z) (let fnrec1970 ((x x) (y y) (z z)) (jolt-invoke f (jolt-invoke g x y z)))) ((x y z . args) (let fnrec1971 ((x x) (y y) (z z) (args (list->cseq args))) (jolt-invoke f (jolt-apply g x y z args))))))) ((f g . fs) (let fnrec1972 ((f f) (g g) (fs (list->cseq fs))) (jolt-reduce comp (jolt-invoke comp f g) fs)))))) comp))) (guard (e (#t #f)) - (def-var! "clojure.core" "ifn?" (letrec ((ifn? (lambda (x) (let fnrec2244 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "fn?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "set?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "var?") x))))))))))))))))) ifn?))) + (def-var! "clojure.core" "ifn?" (letrec ((ifn? (lambda (x) (let fnrec1973 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "fn?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "set?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "var?") x))))))))))))))))) ifn?))) (guard (e (#t #f)) (def-var! "clojure.core" "+'" jolt-add)) (guard (e (#t #f)) @@ -503,17 +503,17 @@ (guard (e (#t #f)) (def-var! "clojure.core" "dec'" jolt-dec)) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-add" (letrec ((unchecked-add (lambda (x y) (let fnrec2245 ((x x) (y y)) (+ x y))))) unchecked-add))) + (def-var! "clojure.core" "unchecked-add" (letrec ((unchecked-add (lambda (x y) (let fnrec1974 ((x x) (y y)) (+ x y))))) unchecked-add))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-subtract" (letrec ((unchecked-subtract (lambda (x y) (let fnrec2246 ((x x) (y y)) (- x y))))) unchecked-subtract))) + (def-var! "clojure.core" "unchecked-subtract" (letrec ((unchecked-subtract (lambda (x y) (let fnrec1975 ((x x) (y y)) (- x y))))) unchecked-subtract))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-multiply" (letrec ((unchecked-multiply (lambda (x y) (let fnrec2247 ((x x) (y y)) (* x y))))) unchecked-multiply))) + (def-var! "clojure.core" "unchecked-multiply" (letrec ((unchecked-multiply (lambda (x y) (let fnrec1976 ((x x) (y y)) (* x y))))) unchecked-multiply))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-negate" (letrec ((unchecked-negate (lambda (x) (let fnrec2248 ((x x)) (- x))))) unchecked-negate))) + (def-var! "clojure.core" "unchecked-negate" (letrec ((unchecked-negate (lambda (x) (let fnrec1977 ((x x)) (- x))))) unchecked-negate))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-inc" (letrec ((unchecked-inc (lambda (x) (let fnrec2249 ((x x)) (+ x 1))))) unchecked-inc))) + (def-var! "clojure.core" "unchecked-inc" (letrec ((unchecked-inc (lambda (x) (let fnrec1978 ((x x)) (+ x 1))))) unchecked-inc))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-dec" (letrec ((unchecked-dec (lambda (x) (let fnrec2250 ((x x)) (- x 1))))) unchecked-dec))) + (def-var! "clojure.core" "unchecked-dec" (letrec ((unchecked-dec (lambda (x) (let fnrec1979 ((x x)) (- x 1))))) unchecked-dec))) (guard (e (#t #f)) (def-var! "clojure.core" "unchecked-add-int" (var-deref "clojure.core" "unchecked-add"))) (guard (e (#t #f)) @@ -527,79 +527,79 @@ (guard (e (#t #f)) (def-var! "clojure.core" "unchecked-dec-int" (var-deref "clojure.core" "unchecked-dec"))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-divide-int" (letrec ((unchecked-divide-int (lambda (x y) (let fnrec2251 ((x x) (y y)) (quotient x y))))) unchecked-divide-int))) + (def-var! "clojure.core" "unchecked-divide-int" (letrec ((unchecked-divide-int (lambda (x y) (let fnrec1980 ((x x) (y y)) (quotient x y))))) unchecked-divide-int))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-remainder-int" (letrec ((unchecked-remainder-int (lambda (x y) (let fnrec2252 ((x x) (y y)) (remainder x y))))) unchecked-remainder-int))) + (def-var! "clojure.core" "unchecked-remainder-int" (letrec ((unchecked-remainder-int (lambda (x y) (let fnrec1981 ((x x) (y y)) (remainder x y))))) unchecked-remainder-int))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-int" (letrec ((unchecked-int (lambda (x) (let fnrec2253 ((x x)) (jolt-invoke (var-deref "clojure.core" "int") x))))) unchecked-int))) + (def-var! "clojure.core" "unchecked-int" (letrec ((unchecked-int (lambda (x) (let fnrec1982 ((x x)) (jolt-invoke (var-deref "clojure.core" "int") x))))) unchecked-int))) (guard (e (#t #f)) (def-var! "clojure.core" "unchecked-long" (var-deref "clojure.core" "unchecked-int"))) (guard (e (#t #f)) - (def-var! "clojure.core" "int?" (letrec ((int? (lambda (x) (let fnrec2254 ((x x)) (jolt-invoke (var-deref "clojure.core" "integer?") x))))) int?))) + (def-var! "clojure.core" "int?" (letrec ((int? (lambda (x) (let fnrec1983 ((x x)) (jolt-invoke (var-deref "clojure.core" "integer?") x))))) int?))) (guard (e (#t #f)) - (def-var! "clojure.core" "num" (letrec ((num (lambda (x) (let fnrec2255 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) x (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "num requires a number, got: " x))))))) num))) + (def-var! "clojure.core" "num" (letrec ((num (lambda (x) (let fnrec1984 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) x (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "num requires a number, got: " x))))))) num))) (guard (e (#t #f)) - (def-var! "clojure.core" "==" (letrec ((== (case-lambda ((x) (let fnrec2256 ((x x)) #t)) ((x y) (let fnrec2257 ((x x) (y y)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "number?") y) and__13__auto))) (jolt= x y) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Cannot cast to number: " (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) y x)))))) ((x y . more) (let fnrec2258 ((x x) (y y) (more (list->cseq more))) (if (jolt-truthy? (jolt-invoke == x y)) (jolt-apply == y more) #f)))))) ==))) + (def-var! "clojure.core" "==" (letrec ((== (case-lambda ((x) (let fnrec1985 ((x x)) #t)) ((x y) (let fnrec1986 ((x x) (y y)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "number?") y) and__13__auto))) (jolt= x y) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Cannot cast to number: " (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) y x)))))) ((x y . more) (let fnrec1987 ((x x) (y y) (more (list->cseq more))) (if (jolt-truthy? (jolt-invoke == x y)) (jolt-apply == y more) #f)))))) ==))) (guard (e (#t #f)) - (def-var! "clojure.core" "ensure-reduced" (letrec ((ensure-reduced (lambda (x) (let fnrec2259 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "reduced?") x)) x (jolt-invoke (var-deref "clojure.core" "reduced") x)))))) ensure-reduced))) + (def-var! "clojure.core" "ensure-reduced" (letrec ((ensure-reduced (lambda (x) (let fnrec1988 ((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 fnrec2260 ((pred pred)) (jolt-invoke halt-when pred jolt-nil))) ((pred retf) (let fnrec2261 ((pred pred) (retf retf)) (lambda (rf) (let fnrec2262 ((rf rf)) (case-lambda (() (let fnrec2263 () (jolt-invoke rf))) ((result) (let fnrec2264 ((result result)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") result))) (if (jolt-truthy? and__13__auto) (jolt-contains? result (keyword #f "halt")) and__13__auto))) (jolt-get result (keyword #f "halt")) (jolt-invoke rf result)))) ((result input) (let fnrec2265 ((result result) (input input)) (if (jolt-truthy? (jolt-invoke pred input)) (jolt-invoke (var-deref "clojure.core" "reduced") (jolt-hash-map (keyword #f "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 fnrec1989 ((pred pred)) (jolt-invoke halt-when pred jolt-nil))) ((pred retf) (let fnrec1990 ((pred pred) (retf retf)) (lambda (rf) (let fnrec1991 ((rf rf)) (case-lambda (() (let fnrec1992 () (jolt-invoke rf))) ((result) (let fnrec1993 ((result result)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") result))) (if (jolt-truthy? and__13__auto) (jolt-contains? result (keyword #f "halt")) and__13__auto))) (jolt-get result (keyword #f "halt")) (jolt-invoke rf result)))) ((result input) (let fnrec1994 ((result result) (input input)) (if (jolt-truthy? (jolt-invoke pred input)) (jolt-invoke (var-deref "clojure.core" "reduced") (jolt-hash-map (keyword #f "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 fnrec2266 ((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))) + (def-var! "clojure.core" "parse-boolean" (letrec ((parse-boolean (lambda (s) (let fnrec1995 ((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)) - (def-var! "clojure.core" "newline" (letrec ((newline (lambda () (let fnrec2267 () (begin (jolt-invoke (var-deref "clojure.core" "print") "\n") jolt-nil))))) newline))) + (def-var! "clojure.core" "newline" (letrec ((newline (lambda () (let fnrec1996 () (begin (jolt-invoke (var-deref "clojure.core" "print") "\n") jolt-nil))))) newline))) (guard (e (#t #f)) - (def-var! "clojure.core" "seque" (letrec ((seque (case-lambda ((s) (let fnrec2268 ((s s)) s)) ((n-or-q s) (let fnrec2269 ((n-or-q n-or-q) (s s)) s))))) seque))) + (def-var! "clojure.core" "seque" (letrec ((seque (case-lambda ((s) (let fnrec1997 ((s s)) s)) ((n-or-q s) (let fnrec1998 ((n-or-q n-or-q) (s s)) s))))) seque))) (guard (e (#t #f)) - (def-var! "clojure.core" "array-seq" (letrec ((array-seq (lambda (arr . _) (let fnrec2270 ((arr arr) (_ (list->cseq _))) (jolt-seq arr))))) array-seq))) + (def-var! "clojure.core" "array-seq" (letrec ((array-seq (lambda (arr . _) (let fnrec1999 ((arr arr) (_ (list->cseq _))) (jolt-seq arr))))) array-seq))) (guard (e (#t #f)) - (def-var! "clojure.core" "to-array-2d" (letrec ((to-array-2d (lambda (coll) (let fnrec2271 ((coll coll)) (jolt-invoke (var-deref "clojure.core" "to-array") (jolt-map (var-deref "clojure.core" "to-array") coll)))))) to-array-2d))) + (def-var! "clojure.core" "to-array-2d" (letrec ((to-array-2d (lambda (coll) (let fnrec2000 ((coll coll)) (jolt-invoke (var-deref "clojure.core" "to-array") (jolt-map (var-deref "clojure.core" "to-array") coll)))))) to-array-2d))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-byte" (letrec ((unchecked-byte (lambda (x) (let fnrec2272 ((x x)) (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 255))))) unchecked-byte))) + (def-var! "clojure.core" "unchecked-byte" (letrec ((unchecked-byte (lambda (x) (let fnrec2001 ((x x)) (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 255))))) unchecked-byte))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-short" (letrec ((unchecked-short (lambda (x) (let fnrec2273 ((x x)) (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 65535))))) unchecked-short))) + (def-var! "clojure.core" "unchecked-short" (letrec ((unchecked-short (lambda (x) (let fnrec2002 ((x x)) (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 65535))))) unchecked-short))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-char" (letrec ((unchecked-char (lambda (x) (let fnrec2274 ((x x)) (jolt-invoke (var-deref "clojure.core" "char") (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 65535)))))) unchecked-char))) + (def-var! "clojure.core" "unchecked-char" (letrec ((unchecked-char (lambda (x) (let fnrec2003 ((x x)) (jolt-invoke (var-deref "clojure.core" "char") (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 65535)))))) unchecked-char))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-float" (letrec ((unchecked-float (lambda (x) (let fnrec2275 ((x x)) (jolt-invoke (var-deref "clojure.core" "double") x))))) unchecked-float))) + (def-var! "clojure.core" "unchecked-float" (letrec ((unchecked-float (lambda (x) (let fnrec2004 ((x x)) (jolt-invoke (var-deref "clojure.core" "double") x))))) unchecked-float))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-double" (letrec ((unchecked-double (lambda (x) (let fnrec2276 ((x x)) (jolt-invoke (var-deref "clojure.core" "double") x))))) unchecked-double))) + (def-var! "clojure.core" "unchecked-double" (letrec ((unchecked-double (lambda (x) (let fnrec2005 ((x x)) (jolt-invoke (var-deref "clojure.core" "double") x))))) unchecked-double))) (guard (e (#t #f)) - (def-var! "clojure.core" "transduce" (letrec ((transduce (case-lambda ((xform f coll) (let fnrec2277 ((xform xform) (f f) (coll coll)) (jolt-invoke transduce xform f (jolt-invoke f) coll))) ((xform f init coll) (let fnrec2278 ((xform xform) (f f) (init init) (coll coll)) (let* ((xf (jolt-invoke xform f))) (jolt-invoke xf (jolt-reduce xf init coll)))))))) transduce))) + (def-var! "clojure.core" "transduce" (letrec ((transduce (case-lambda ((xform f coll) (let fnrec2006 ((xform xform) (f f) (coll coll)) (jolt-invoke transduce xform f (jolt-invoke f) coll))) ((xform f init coll) (let fnrec2007 ((xform xform) (f f) (init init) (coll coll)) (let* ((xf (jolt-invoke xform f))) (jolt-invoke xf (jolt-reduce xf init coll)))))))) transduce))) (guard (e (#t #f)) - (def-var! "clojure.core" "eduction" (letrec ((eduction (lambda args (let fnrec2279 ((args (list->cseq args))) (let* ((coll (jolt-last args)) (xforms (jolt-invoke (var-deref "clojure.core" "butlast") args))) (if (jolt-truthy? xforms) (let* ((_a$2280 jolt-into) (_a$2281 (jolt-vector)) (_a$2282 (jolt-apply (var-deref "clojure.core" "comp") xforms)) (_a$2283 coll)) (jolt-invoke _a$2280 _a$2281 _a$2282 _a$2283)) (jolt-into (jolt-vector) coll))))))) eduction))) + (def-var! "clojure.core" "eduction" (letrec ((eduction (lambda args (let fnrec2008 ((args (list->cseq args))) (let* ((coll (jolt-last args)) (xforms (jolt-invoke (var-deref "clojure.core" "butlast") args))) (if (jolt-truthy? xforms) (let* ((_a$2009 jolt-into) (_a$2010 (jolt-vector)) (_a$2011 (jolt-apply (var-deref "clojure.core" "comp") xforms)) (_a$2012 coll)) (jolt-invoke _a$2009 _a$2010 _a$2011 _a$2012)) (jolt-into (jolt-vector) coll))))))) eduction))) (guard (e (#t #f)) - (def-var! "clojure.core" "->Eduction" (letrec ((->Eduction (lambda (xform coll) (let fnrec2284 ((xform xform) (coll coll)) (jolt-invoke jolt-into (jolt-vector) xform coll))))) ->Eduction))) + (def-var! "clojure.core" "->Eduction" (letrec ((->Eduction (lambda (xform coll) (let fnrec2013 ((xform xform) (coll coll)) (jolt-invoke jolt-into (jolt-vector) xform coll))))) ->Eduction))) (guard (e (#t #f)) - (def-var! "clojure.core" "enumeration-seq" (letrec ((enumeration-seq (lambda (e) (let fnrec2285 ((e e)) (jolt-seq e))))) enumeration-seq))) + (def-var! "clojure.core" "enumeration-seq" (letrec ((enumeration-seq (lambda (e) (let fnrec2014 ((e e)) (jolt-seq e))))) enumeration-seq))) (guard (e (#t #f)) - (def-var! "clojure.core" "iterator-seq" (letrec ((iterator-seq (lambda (i) (let fnrec2286 ((i i)) (jolt-seq i))))) iterator-seq))) + (def-var! "clojure.core" "iterator-seq" (letrec ((iterator-seq (lambda (i) (let fnrec2015 ((i i)) (jolt-seq i))))) iterator-seq))) (guard (e (#t #f)) - (def-var! "clojure.core" "promise" (letrec ((promise (lambda () (let fnrec2287 () (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))))) promise))) + (def-var! "clojure.core" "promise" (letrec ((promise (lambda () (let fnrec2016 () (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))))) promise))) (guard (e (#t #f)) - (def-var! "clojure.core" "deliver" (letrec ((deliver (lambda (p v) (let fnrec2288 ((p p) (v v)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") p v) p))))) deliver))) + (def-var! "clojure.core" "deliver" (letrec ((deliver (lambda (p v) (let fnrec2017 ((p p) (v v)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") p v) p))))) deliver))) (guard (e (#t #f)) - (def-var! "clojure.core" "bean" (letrec ((bean (lambda (x) (let fnrec2289 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) x (jolt-hash-map)))))) bean))) + (def-var! "clojure.core" "bean" (letrec ((bean (lambda (x) (let fnrec2018 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) x (jolt-hash-map)))))) bean))) (guard (e (#t #f)) - (def-var! "clojure.core" "uri?" (letrec ((uri? (lambda (x) (let fnrec2290 ((x x)) #f)))) uri?))) + (def-var! "clojure.core" "uri?" (letrec ((uri? (lambda (x) (let fnrec2019 ((x x)) #f)))) uri?))) (guard (e (#t #f)) - (def-var-with-meta! "clojure.core" "special-syms" (let* ((_o$2291 (jolt-symbol #f "if")) (_o$2292 (jolt-symbol #f "do")) (_o$2293 (jolt-symbol #f "let*")) (_o$2294 (jolt-symbol #f "fn*")) (_o$2295 (jolt-symbol #f "quote")) (_o$2296 (jolt-symbol #f "var")) (_o$2297 (jolt-symbol #f "def")) (_o$2298 (jolt-symbol #f "loop*")) (_o$2299 (jolt-symbol #f "recur")) (_o$2300 (jolt-symbol #f "throw")) (_o$2301 (jolt-symbol #f "try")) (_o$2302 (jolt-symbol #f "catch")) (_o$2303 (jolt-symbol #f "finally")) (_o$2304 (jolt-symbol #f "new")) (_o$2305 (jolt-symbol #f "set!")) (_o$2306 (jolt-symbol #f ".")) (_o$2307 (jolt-symbol #f "monitor-enter")) (_o$2308 (jolt-symbol #f "monitor-exit"))) (jolt-hash-set _o$2291 _o$2292 _o$2293 _o$2294 _o$2295 _o$2296 _o$2297 _o$2298 _o$2299 _o$2300 _o$2301 _o$2302 _o$2303 _o$2304 _o$2305 _o$2306 _o$2307 _o$2308)) (jolt-hash-map (keyword #f "private") #t))) + (def-var-with-meta! "clojure.core" "special-syms" (let* ((_o$2020 (jolt-symbol #f "if")) (_o$2021 (jolt-symbol #f "do")) (_o$2022 (jolt-symbol #f "let*")) (_o$2023 (jolt-symbol #f "fn*")) (_o$2024 (jolt-symbol #f "quote")) (_o$2025 (jolt-symbol #f "var")) (_o$2026 (jolt-symbol #f "def")) (_o$2027 (jolt-symbol #f "loop*")) (_o$2028 (jolt-symbol #f "recur")) (_o$2029 (jolt-symbol #f "throw")) (_o$2030 (jolt-symbol #f "try")) (_o$2031 (jolt-symbol #f "catch")) (_o$2032 (jolt-symbol #f "finally")) (_o$2033 (jolt-symbol #f "new")) (_o$2034 (jolt-symbol #f "set!")) (_o$2035 (jolt-symbol #f ".")) (_o$2036 (jolt-symbol #f "monitor-enter")) (_o$2037 (jolt-symbol #f "monitor-exit"))) (jolt-hash-set _o$2020 _o$2021 _o$2022 _o$2023 _o$2024 _o$2025 _o$2026 _o$2027 _o$2028 _o$2029 _o$2030 _o$2031 _o$2032 _o$2033 _o$2034 _o$2035 _o$2036 _o$2037)) (jolt-hash-map (keyword #f "private") #t))) (guard (e (#t #f)) - (def-var! "clojure.core" "special-symbol?" (letrec ((special-symbol? (lambda (s) (let fnrec2309 ((s s)) (jolt-contains? (var-deref "clojure.core" "special-syms") s))))) special-symbol?))) + (def-var! "clojure.core" "special-symbol?" (letrec ((special-symbol? (lambda (s) (let fnrec2038 ((s s)) (jolt-contains? (var-deref "clojure.core" "special-syms") s))))) special-symbol?))) (guard (e (#t #f)) - (def-var! "clojure.core" "proxy-mappings" (letrec ((proxy-mappings (lambda (p) (let fnrec2310 ((p p)) (jolt-hash-map))))) proxy-mappings))) + (def-var! "clojure.core" "proxy-mappings" (letrec ((proxy-mappings (lambda (p) (let fnrec2039 ((p p)) (jolt-hash-map))))) proxy-mappings))) (guard (e (#t #f)) - (def-var! "clojure.core" "proxy-call-with-super" (letrec ((proxy-call-with-super (lambda (f p meth) (let fnrec2311 ((f f) (p p) (meth meth)) (jolt-invoke f))))) proxy-call-with-super))) + (def-var! "clojure.core" "proxy-call-with-super" (letrec ((proxy-call-with-super (lambda (f p meth) (let fnrec2040 ((f f) (p p) (meth meth)) (jolt-invoke f))))) proxy-call-with-super))) (guard (e (#t #f)) - (def-var! "clojure.core" "init-proxy" (letrec ((init-proxy (lambda (p mappings) (let fnrec2312 ((p p) (mappings mappings)) p)))) init-proxy))) + (def-var! "clojure.core" "init-proxy" (letrec ((init-proxy (lambda (p mappings) (let fnrec2041 ((p p) (mappings mappings)) p)))) init-proxy))) (guard (e (#t #f)) - (def-var! "clojure.core" "update-proxy" (letrec ((update-proxy (lambda (p mappings) (let fnrec2313 ((p p) (mappings mappings)) p)))) update-proxy))) + (def-var! "clojure.core" "update-proxy" (letrec ((update-proxy (lambda (p mappings) (let fnrec2042 ((p p) (mappings mappings)) p)))) update-proxy))) (guard (e (#t #f)) - (def-var! "clojure.core" "proxy-super" (letrec ((proxy-super (lambda args (let fnrec2314 ((args (list->cseq args))) (jolt-throw "proxy-super: JVM proxies are not supported in Jolt"))))) proxy-super))) + (def-var! "clojure.core" "proxy-super" (letrec ((proxy-super (lambda args (let fnrec2043 ((args (list->cseq args))) (jolt-throw "proxy-super: JVM proxies are not supported in Jolt"))))) proxy-super))) (guard (e (#t #f)) - (def-var! "clojure.core" "construct-proxy" (letrec ((construct-proxy (lambda (c . args) (let fnrec2315 ((c c) (args (list->cseq args))) (jolt-throw "construct-proxy: not supported in Jolt"))))) construct-proxy))) + (def-var! "clojure.core" "construct-proxy" (letrec ((construct-proxy (lambda (c . args) (let fnrec2044 ((c c) (args (list->cseq args))) (jolt-throw "construct-proxy: not supported in Jolt"))))) construct-proxy))) (guard (e (#t #f)) - (def-var! "clojure.core" "get-proxy-class" (letrec ((get-proxy-class (lambda interfaces (let fnrec2316 ((interfaces (list->cseq interfaces))) (jolt-throw "get-proxy-class: not supported in Jolt"))))) get-proxy-class))) + (def-var! "clojure.core" "get-proxy-class" (letrec ((get-proxy-class (lambda interfaces (let fnrec2045 ((interfaces (list->cseq interfaces))) (jolt-throw "get-proxy-class: not supported in Jolt"))))) get-proxy-class))) (guard (e (#t #f)) (def-var! "clojure.core" "sfield" (letrec ((sfield (lambda (sc k) (let fnrec358 ((sc sc) (k k)) (jolt-invoke (var-deref "jolt.host" "ref-get") sc k))))) sfield))) (guard (e (#t #f)) diff --git a/jolt-core/clojure/core/20-coll.clj b/jolt-core/clojure/core/20-coll.clj index 9f55c23..f5f688b 100644 --- a/jolt-core/clojure/core/20-coll.clj +++ b/jolt-core/clojure/core/20-coll.clj @@ -455,671 +455,3 @@ (defn println-str [& xs] (__with-out-str (fn* [] (apply println xs)))) (defn prn-str [& xs] (__with-out-str (fn* [] (apply prn xs)))) -;; --- leaves over the rand / sort host seams ---------------------------------- - -;; Canonical truncation toward zero via int (the kernel fn floored, which is -;; wrong for a negative n). -(defn rand-int [n] (int (rand n))) - -;; Pure-functional Fisher-Yates over vector assoc; returns a vector, as in -;; Clojure. Collections only — a string is seqable but not shuffleable, as on -;; the JVM (Collections/shuffle wants a Collection). -(defn shuffle [coll] - (when-not (coll? coll) - (throw (ex-info (str "shuffle requires a collection, got: " coll) {}))) - (loop [v (vec coll) i (dec (count v))] - (if (pos? i) - (let [j (rand-int (inc i)) - t (nth v i)] - (recur (assoc (assoc v i (nth v j)) j t) (dec i))) - v))) - -;; Canonical sort-by: the default comparator is compare (so nil sorts first, -;; like Clojure — the kernel fn used host ordering, which put nil last); the -;; comparator compares KEYS and may be 3-way or a boolean predicate (the host -;; sort seam normalizes). -(defn sort-by - ([keyfn coll] (sort-by keyfn compare coll)) - ([keyfn comp coll] - (sort (fn [x y] (comp (keyfn x) (keyfn y))) coll))) - -;; parse-uuid: nil unless s is a canonical 8-4-4-4-12 hex UUID string; throws -;; on a non-string (Clojure 1.11). __make-uuid is the host constructor for the -;; tagged value (overlay source can't write :jolt/type map literals — the -;; reader treats them as tagged forms). -(defn parse-uuid [s] - (if (string? s) - (when (re-matches - #"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}" s) - (__make-uuid s)) - (throw (str "parse-uuid requires a string, got: " s)))) - -;; Version-4 UUID (RFC 4122): zero-padded hex groups 8-4-4-4-12, version -;; nibble 4, variant 8-b — built over rand-int and validated by parse-uuid. -(defn random-uuid [] - (let [hx4 (fn [] (format "%04x" (rand-int 0x10000))) - hx3 (fn [] (format "%03x" (rand-int 0x1000)))] - (parse-uuid (str (hx4) (hx4) "-" (hx4) "-4" (hx3) - "-" (format "%x" (+ 8 (rand-int 4))) (hx3) - "-" (hx4) (hx4) (hx4))))) - -;; The char escape/name tables, as char-keyed maps (Clojure's shape). -(def ^:private char-escape-strings - {\newline "\\n" \tab "\\t" \return "\\r" \formfeed "\\f" - \backspace "\\b" \" "\\\"" \\ "\\\\"}) -(defn char-escape-string [c] (get char-escape-strings c)) - -(def ^:private char-name-strings - {\newline "newline" \tab "tab" \return "return" \formfeed "formfeed" - \backspace "backspace" \space "space"}) -(defn char-name-string [c] (get char-name-strings c)) - -;; Random selection over the host rand primitives. -(defn rand-nth [coll] - (let [v (vec coll)] (nth v (rand-int (count v))))) - -(defn random-sample - ([prob] (filter (fn [_] (< (rand) prob)))) - ([prob coll] (filter (fn [_] (< (rand) prob)) coll))) - -(defn comparator [pred] - (fn [a b] (cond (pred a b) -1 (pred b a) 1 :else 0))) - -;; Lazy: the running accumulators, one at a time (matches Clojure). -(defn reductions - ([f coll] - (lazy-seq - (let [s (seq coll)] - (if s - (reductions f (first s) (rest s)) - (list (f)))))) - ([f init coll] - (cons init - (lazy-seq - (when-let [s (seq coll)] - (reductions f (f init (first s)) (rest s))))))) - -;; Lazy pre-order DFS (matches Clojure): node, then its children's walks spliced -;; via the (now lazy) mapcat. -(defn tree-seq [branch? children root] - (let [walk (fn walk [node] - (lazy-seq - (cons node - (when (branch? node) - (mapcat walk (children node))))))] - (walk root))) - -;; file-seq: the tree of paths under root (root included), directories walked -;; via the host dir primitives. Paths (strings), not File objects. (Lives below -;; tree-seq: forward references are analysis errors.) -(defn file-seq [root] - (if (__file? root) - ;; java.io.File tree: walk via the File method surface so leaves are File - ;; values callers can invoke .isFile/.getName/slurp on. - (tree-seq (fn [f] (.isDirectory f)) (fn [f] (seq (.listFiles f))) root) - (tree-seq __dir? __list-dir root))) - -;; Canonical flatten via tree-seq: the leaves (non-sequential nodes) in order. -;; Flattens lists too (sequential?), matching Clojure/CLJS. -(defn flatten [coll] - (filter (complement sequential?) (rest (tree-seq sequential? seq coll)))) - -;; xml-seq: tree-seq over XML element trees. Elements are maps with :content. -(defn xml-seq [root] - (tree-seq (complement string?) (comp seq :content) root)) - -;; Lazy interleave: round-robin one element from each coll until any exhausts. -(defn interleave - ([] ()) - ([c1] (lazy-seq c1)) - ([c1 c2] - (lazy-seq - (let [s1 (seq c1) s2 (seq c2)] - (when (and s1 s2) - (cons (first s1) - (cons (first s2) - (interleave (rest s1) (rest s2)))))))) - ([c1 c2 & cs] - (lazy-seq - (let [ss (map seq (list* c1 c2 cs))] - (when (every? identity ss) - (concat (map first ss) - (apply interleave (map rest ss)))))))) - -;; No ratio type on Jolt, so rationalize is identity. -(defn rationalize [x] x) - -;; 0-arg: a stateful transducer (tracks [seen? prev] in a volatile, so no sentinel -;; value is needed). 1-arg: eager dedupe of consecutive equal elements. -(defn dedupe - ([] - (fn [rf] - (let [pv (volatile! [false nil])] - (fn - ([] (rf)) - ([result] (rf result)) - ([result input] - (let [[seen prior] @pv] - (vreset! pv [true input]) - (if (and seen (= prior input)) result (rf result input)))))))) - ([coll] - (let [step (fn step [s prev] - (make-lazy-seq - (fn* [] - (let [s (seq s)] - (if s - (let [x (first s)] - (if (= x prev) - (coll->cells (step (rest s) prev)) - (coll->cells (cons x (step (rest s) x))))) - nil)))))] - (let [s (seq coll)] - (if s - (make-lazy-seq - (fn* [] (coll->cells (cons (first s) (step (rest s) (first s)))))) - ()))))) - -;; Internal helper for {:keys [...]} destructuring over a seq of k/v pairs — -;; canonical Clojure 1.11 shape (core.clj seq-to-map-for-destructuring): -;; even pairs build a map (later keys win, as createAsIfByAssoc), a SINGLE -;; element is returned as-is (the trailing-map calling convention), and an -;; unpaired key past pairs throws. -(defn seq-to-map-for-destructuring [s] - (if (next s) - (loop [m {} xs (seq s)] - (if xs - (if (next xs) - (recur (assoc m (first xs) (second xs)) (nnext xs)) - (throw (str "No value supplied for key: " (first xs)))) - m)) - (if (seq s) (first s) {}))) - -;; Host-coupled fns that are pure logic over existing core primitives, so they -;; need no new jolt.host surface. - -;; vary-meta: f applied to obj's metadata (+ extra args), reattached. meta and -;; with-meta are the irreducible host primitives; vary-meta is just their compose. -(defn vary-meta [obj f & args] - (with-meta obj (apply f (meta obj) args))) - -;; namespace-munge: Clojure namespace name -> legal Java package name (- -> _). -(defn namespace-munge [s] - (apply str (map (fn [c] (if (= c \-) \_ c)) (seq (str s))))) - -;; reduce-kv over a map (k v) or vector (index v). Both branches go through reduce, -;; so reduced short-circuits — and the vector path indexes correctly. nil folds -;; to init, matching Clojure. -(defn reduce-kv [f init coll] - (cond - (vector? coll) (reduce (fn [acc i] (f acc i (nth coll i))) init (range (count coll))) - (map? coll) (reduce (fn [acc k] (f acc k (get coll k))) init (keys coll)) - (nil? coll) init - :else (throw (str "reduce-kv not supported on: " coll)))) - -;; ex-info accessors. The constructor (ex-info) stays native — it builds the tagged -;; value and wires into throw — but the value exposes :jolt/type/:message/:data/ -;; :cause via get, so the accessors are pure over get. A thrown non-ex-info arrives -;; wrapped as {:jolt/type :jolt/exception :value v}; unwrap that first. -(defn- ex-info-val? [x] (= (get x :jolt/type) :jolt/ex-info)) -(defn- ex-unwrap [e] - (if (= (get e :jolt/type) :jolt/exception) (get e :value) e)) -(defn ex-data [e] - (let [e (ex-unwrap e)] (if (ex-info-val? e) (get e :data) nil))) -(defn ex-message [e] - (let [e (ex-unwrap e)] - (cond (ex-info-val? e) (get e :message) - :else nil))) -(defn ex-cause [e] - (let [e (ex-unwrap e)] (if (ex-info-val? e) (get e :cause) nil))) - -;; inst-ms: epoch milliseconds of an instant; throws on a non-inst (Clojure -;; protocol behavior). -(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). -(defn update-keys [m f] - (reduce-kv (fn [acc k v] (assoc acc (f k) v)) (hash-map) m)) - -(defn update-vals [m f] - (reduce-kv (fn [acc k v] (assoc acc k (f v))) (hash-map) m)) - -;; Vector-returning partition variants (1.11): lazy seqs OF vectors. -(defn partitionv - ([n coll] (map vec (partition n coll))) - ([n step coll] (map vec (partition n step coll))) - ([n step pad coll] (map vec (partition n step pad coll)))) - -;; partition-all is a lazy-tier fn (40-lazy) — declared so partitionv-all -;; compiles; bound by the time anything calls it. -(declare partition-all) - -(defn partitionv-all - ([n coll] (map vec (partition-all n coll))) - ([n step coll] (map vec (partition-all n step coll)))) - -;; First part a vector, rest a seq — matching the reference implementation. -(defn splitv-at [n coll] - [(vec (take n coll)) (drop n coll)]) - -;; with-redefs-fn: temporarily set each var's root to the mapped value, run -;; the thunk, restore the saved roots even on throw. The with-redefs macro -;; (30-macros) builds the {var val} map from names. -(defn with-redefs-fn [binding-map func] - (let [vars (vec (keys binding-map)) - saved (mapv var-get vars)] - (doseq [v vars] (var-set v (get binding-map v))) - (try - (func) - (finally - ;; loop/recur, not dotimes: dotimes is a 30-macros macro and this tier - ;; compiles before it exists (a forward ref would resolve to the macro - ;; fn at runtime and mis-apply it). - (loop [i 0] - (when (< i (count vars)) - (var-set (nth vars i) (nth saved i)) - (recur (inc i)))))))) -;; Jolt has no chunked seqs, so this is always false. -(defn chunked-seq? [x] false) - -;; Atom peripheral operations. atom/swap!/reset!/deref stay native — the compiler -;; depends on them and they're hot. swap-vals!/reset-vals!/compare-and-set! compose -;; the native ops (which already validate and notify watches); get-validator reads a -;; slot; add-watch/remove-watch/set-validator! mutate the atom (or its watches -;; sub-table) through the one host primitive jolt.host/ref-put! — the minimal -;; mutation kernel the overlay can't express over core fns (a nil value removes the -;; key). compare-and-set! compares by value. -(defn swap-vals! [a f & args] - (let [old (deref a)] [old (apply swap! a f args)])) -(defn reset-vals! [a newval] - (let [old (deref a)] (reset! a newval) [old newval])) -(defn compare-and-set! [a oldval newval] - (if (= oldval (deref a)) (do (reset! a newval) true) false)) -(defn get-validator [a] (get a :validator)) -(defn add-watch [a key f] - (jolt.host/ref-put! (get a :watches) key f) a) -(defn remove-watch [a key] - (jolt.host/ref-put! (get a :watches) key nil) a) -(defn set-validator! [a f] - (jolt.host/ref-put! a :validator f) nil) - -;; vreset!/vswap! live in the seq tier (10-seq.clj): its transducers use them. - -;; Future status predicates — pure reads of the future's :cached/:cancelled slots. -;; future? stays native (deref/future-cancel/realized? call it); future-call and -;; future-cancel stay native too (OS threads). -(defn future-done? [x] - (if (future? x) (boolean (get x :cached)) (throw "future-done? requires a future"))) -(defn future-cancelled? [x] - (and (future? x) (boolean (get x :cancelled)))) - -;; ns-name: a namespace object's :name as a symbol. Pure over get + symbol. -(defn ns-name [ns] - (let [nm (get ns :name)] (if nm (symbol (str nm)) nil))) - -;; Java-array element access. Jolt arrays are mutable backing arrays; aget/alength -;; read them (nth/count) and aset writes a slot through ref-put!. Both handle the -;; multi-dimensional form (aget a i j ... / aset a i j ... v) by walking. The array -;; constructors (object-array/make-array/to-array/...) stay native — they build the -;; mutable backing. -(defn aget [arr & idxs] - (reduce (fn [v i] (nth v i)) arr idxs)) -(defn alength [arr] (count arr)) -(defn aset [arr & idxs+val] - (let [n (count idxs+val) - val (nth idxs+val (dec n)) - target (reduce (fn [t k] (nth t k)) arr (take (- n 2) idxs+val))] - (jolt.host/ref-put! target (nth idxs+val (- n 2)) val) - val)) - -;; --- fn combinators + host-free stubs ---------------------------------------- - -(defn complement - "Takes a fn f and returns a fn that takes the same arguments as f, has the - same effects, if any, and returns the opposite truth value." - [f] - (fn [& args] (not (apply f args)))) - -;; Canonical Clojure fnil: patches only the FIRST 1-3 arguments. -(defn fnil - ([f x] - (fn [a & args] (apply f (if (nil? a) x a) args))) - ([f x y] - (fn [a b & args] (apply f (if (nil? a) x a) (if (nil? b) y b) args))) - ([f x y z] - (fn [a b c & args] - (apply f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c) args)))) - -(defn clojure-version [] "1.11.0-jolt") - -;; bigdec is a host fn (host/chez/bigdec.ss) — a real BigDecimal value type. -(defn numerator [x] (throw (ex-info "numerator requires a ratio (Jolt has no ratios)" {}))) -(defn denominator [x] (throw (ex-info "denominator requires a ratio (Jolt has no ratios)" {}))) - -;; No class hierarchy on this host. -(defn supers [x] #{}) - -;; Like Clojure's munge: rewrite dashes to underscores, preserving the argument's -;; type — a symbol munges to a symbol, anything else to a string. (jolt only -;; rewrites dashes, not the full Compiler CHAR_MAP.) -(defn munge [s] - (let [m (str-replace-all "-" "_" (str s))] - (if (symbol? s) (symbol m) m))) - -(defn test - "Calls the :test fn from v's metadata; :ok if it runs, :no-test if absent." - [v] - (let [t (:test (meta v))] - (if t (do (t) :ok) :no-test))) - -;; --- canonical Clojure ports ------------------------------------------------- -;; key/val/find first — merge-with and memoize below use them. - -;; Strict, as in Clojure: an entry is what (seq m) yields (a host tuple), NOT -;; a plain vector — (key [1 2]) throws. -;; key/val moved above the hierarchies section (underive uses them). - -;; find was previously missing from jolt entirely. Presence (contains?), not -;; value, decides — so (find {:a nil} :a) is [:a nil]. Works on vectors by -;; index. The result must be a REAL entry (key/val are strict), so it is -;; minted as the first entry of a one-entry map — nil values survive (the -;; map builder switches to a phm when nil is involved). -(defn find [m k] - (when (contains? m k) (first {k (get m k)}))) - -;; some? lives in the top leaf block now (forward refs are errors). -(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). -(defn select-keys [map keyseq] - (reduce (fn [m k] (if (contains? map k) (assoc m k (get map k)) m)) - (hash-map) keyseq)) - -(defn zipmap [keys vals] - (loop [m (hash-map) ks (seq keys) vs (seq vals)] - (if (and ks vs) - (recur (assoc m (first ks) (first vs)) (next ks) (next vs)) - m))) - -;; conj semantics per entry arg (a map merges, a [k v] pair adds); nil args are -;; 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))) - maps))) - -(defn merge-with [f & maps] - (when (some identity maps) - (let [merge-entry (fn [m e] - (let [k (key e) v (val e)] - ;; presence — not nil-of-value — decides combination - (if (contains? m k) - (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 merge2 maps)))) - -(defn get-in - ([m ks] (reduce get m ks)) - ([m ks not-found] - ;; a fresh table is its own identity — a present-but-nil step is - ;; distinguished from a missing one - (let [sentinel (hash-map)] - (loop [m m ks (seq ks)] - (if ks - (let [nxt (get m (first ks) sentinel)] - (if (identical? sentinel nxt) - not-found - (recur nxt (next ks)))) - m))))) - -;; find-based, so nil RESULTS are cached too; args canonicalize as a collection key. -(defn memoize [f] - (let [mem (atom (hash-map))] - (fn [& args] - ;; plain let/if, not if-let: this tier loads before 30-macros defines it - (let [e (find (deref mem) args)] - (if e - (val e) - (let [ret (apply f args)] - (swap! mem assoc args ret) - ret)))))) - -(defn partial - ([f] f) - ([f a] (fn [& args] (apply f a args))) - ([f a b] (fn [& args] (apply f a b args))) - ([f a b c] (fn [& args] (apply f a b c args))) - ([f a b c & more] (fn [& args] (apply f a b c (concat more args))))) - -(defn trampoline - ([f] (let [ret (f)] (if (fn? ret) (trampoline ret) ret))) - ([f & args] (trampoline (fn [] (apply f args))))) - -;; Canonical pairwise max/min: > / < throw on non-numbers, and the NaN -;; behavior is Clojure's by construction. -(defn max - ([x] x) - ([x y] (if (> x y) x y)) - ([x y & more] (reduce max (max x y) more))) - -(defn min - ([x] x) - ([x y] (if (< x y) x y)) - ([x y & more] (reduce min (min x y) more))) - -(defn reverse [coll] (reduce conj (list) coll)) - -;; An empty coll of the same category; sorted colls keep their comparator (the -;; value's own :empty op). Strings and scalars are nil, as in Clojure; a lazy -;; seq empties to (). -(defn empty [coll] - (cond - (nil? coll) nil - (sorted? coll) ((get (jolt.host/ref-get coll :ops) :empty) coll) - (map? coll) {} - (set? coll) #{} - (vector? coll) [] - (coll? coll) () - :else nil)) - -(defn assoc-in [m [k & ks] v] - (if ks - (assoc m k (assoc-in (get m k) ks v)) - (assoc m k v))) - -(defn update-in [m ks f & args] - (let [up (fn up [m ks f args] - (let [[k & ks] ks] - (if ks - (assoc m k (up (get m k) ks f args)) - (assoc m k (apply f (get m k) args)))))] - (up m ks f args))) - -;; jolt keywords have no intern table (any keyword "exists"), so find-keyword -;; always finds — babashka makes the same call. -(defn find-keyword - ([nm] (keyword nm)) - ([ns nm] (keyword ns nm))) - -;; The raw Inst protocol method; jolt insts have one representation, so it is -;; inst-ms itself. -(defn inst-ms* [i] (inst-ms i)) - -;; Canonical comp — here rather than a host primitive so each stage is invoked with -;; jolt call semantics: (comp seq :content) works because the keyword stage -;; goes through IFn dispatch. -(defn comp - ([] identity) - ([f] f) - ([f g] - ;; fixed arities first (Clojure's own shape): the 1-arg path — every - ;; map/filter stage — is two direct calls, no rest-seq, no apply. - (fn - ([] (f (g))) - ([x] (f (g x))) - ([x y] (f (g x y))) - ([x y z] (f (g x y z))) - ([x y z & args] (f (apply g x y z args))))) - ([f g & fs] (reduce comp (comp f g) fs))) - -;; Canonical IFn set: fns, keywords, symbols, maps (sorted incl.), -;; sets, vectors, and vars — NOT lists ((ifn? '(1 2)) is false in Clojure). -(defn ifn? [x] - (or (fn? x) (keyword? x) (symbol? x) (map? x) (set? x) (vector? x) (var? x))) - -;; Auto-promoting (') and unchecked arithmetic. Jolt numbers don't overflow, -;; so all of these are the checked ops; fixed arities mirror Clojure's -;; signatures. unchecked-divide-int goes through quot, so dividing by zero -;; throws as on the JVM. -(def +' +) -(def -' -) -(def *' *) -(def inc' inc) -(def dec' dec) -(defn unchecked-add [x y] (+ x y)) -(defn unchecked-subtract [x y] (- x y)) -(defn unchecked-multiply [x y] (* x y)) -(defn unchecked-negate [x] (- x)) -(defn unchecked-inc [x] (+ x 1)) -(defn unchecked-dec [x] (- x 1)) -(def unchecked-add-int unchecked-add) -(def unchecked-subtract-int unchecked-subtract) -(def unchecked-multiply-int unchecked-multiply) -(def unchecked-negate-int unchecked-negate) -(def unchecked-inc-int unchecked-inc) -(def unchecked-dec-int unchecked-dec) -(defn unchecked-divide-int [x y] (quot x y)) -(defn unchecked-remainder-int [x y] (rem x y)) -(defn unchecked-int [x] (int x)) -(def unchecked-long unchecked-int) - -;; int? is integer? on jolt: one number type, so fixed-precision and -;; arbitrary-precision integers coincide. -(defn int? [x] (integer? x)) - -;; num: Clojure coerces to java.lang.Number; jolt just checks. -(defn num [x] - (if (number? x) x (throw (str "num requires a number, got: " x)))) - -;; == numeric equality: 1-arity is trivially true without inspecting the value -;; (Clojure's shape); 2+ args must be numbers, as Numbers.equiv throws. -(defn == - ([x] true) - ([x y] - (if (and (number? x) (number? y)) - (= x y) - (throw (str "Cannot cast to number: " (if (number? x) y x))))) - ([x y & more] - (if (== x y) - (apply == y more) - false))) - -;; ensure-reduced / halt-when: canonical Clojure. halt-when smuggles the halt -;; value through reduce in a ::halt-keyed map and unwraps it in the completion -;; arity, so the halt REPLACES the whole reduction result. -(defn ensure-reduced [x] (if (reduced? x) x (reduced x))) - -(defn halt-when - ([pred] (halt-when pred nil)) - ([pred retf] - (fn [rf] - (fn - ([] (rf)) - ([result] - (if (and (map? result) (contains? result ::halt)) - (get result ::halt) - (rf result))) - ([result input] - (if (pred input) - (reduced (hash-map ::halt (if retf (retf (rf result) input) input))) - (rf result input))))))) - -;; parse-boolean: exact "true"/"false" only; nil on anything else, throw on a -;; non-string (Clojure 1.11). -(defn parse-boolean [s] - (if (string? s) - (cond (= s "true") true (= s "false") false :else nil) - (throw (str "parse-boolean requires a string, got: " s)))) - -(defn newline [] (print "\n") nil) - -;; seque: jolt is single-threaded eager here — the queue is a no-op and the -;; coll passes through. -(defn seque - ([s] s) - ([n-or-q s] s)) - -(defn array-seq [arr & _] (seq arr)) - -(defn to-array-2d [coll] (to-array (map to-array coll))) - -;; Masking integer coercions (not aliases): byte/short wrap to their width. -;; unchecked-byte/short truncate to a number; unchecked-char returns a char (as on -;; the JVM). int handles chars, so (unchecked-byte \a) works. -(defn unchecked-byte [x] (bit-and (int x) 0xff)) -(defn unchecked-short [x] (bit-and (int x) 0xffff)) -(defn unchecked-char [x] (char (bit-and (int x) 0xffff))) -(defn unchecked-float [x] (double x)) -(defn unchecked-double [x] (double x)) - -;; --- transduce / into / eduction --------------------------------------------- -;; Canonical transduce: build the stacked rf once, reduce (which honors -;; `reduced` and steps lazy seqs incrementally), then run the completion arity. -(defn transduce - ([xform f coll] (transduce xform f (f) coll)) - ([xform f init coll] - (let [xf (xform f)] - (xf (reduce xf init coll))))) - -;; into stays a host primitive: it's perf-wall hot (the into-vec bench pays ~11% -;; through the overlay call layers — same lesson as even?/odd?). - -;; eduction is EAGER on jolt (documented divergence): the composed -;; xforms applied to coll, realized into a vector. -(defn eduction [& args] - (let [coll (last args) - xforms (butlast args)] - (if xforms - (into [] (apply comp xforms) coll) - (into [] coll)))) - -(defn ->Eduction [xform coll] (into [] xform coll)) - -;; --- JVM-shape stubs and trivial shells -------------------------------------- -;; Pure compositions or documented jolt stubs; the host keeps nothing. -(defn enumeration-seq [e] (seq e)) -(defn iterator-seq [i] (seq i)) - -;; jolt is single-threaded: a promise is an atom, deref never blocks -;; ((deref undelivered) is nil rather than a hang). -(defn promise [] (atom nil)) -(defn deliver [p v] (reset! p v) p) - -(defn bean [x] (if (map? x) x {})) - -(defn uri? [x] false) - -;; An EVALUATED set of quoted symbols — a quoted set literal ('#{if ...}) -;; stays an unevaluated reader form on jolt and contains? can't see into it. -(def ^:private special-syms - #{'if 'do 'let* 'fn* 'quote 'var 'def 'loop* 'recur 'throw 'try 'catch - 'finally 'new 'set! '. 'monitor-enter 'monitor-exit}) - -(defn special-symbol? [s] (contains? special-syms s)) - -;; print-method / print-dup are real multimethods in the io tier (50-io.clj). - -;; JVM proxies don't exist on this host: the read-only surface is inert, -;; the constructive surface throws. -(defn proxy-mappings [p] {}) -(defn proxy-call-with-super [f p meth] (f)) -(defn init-proxy [p mappings] p) -(defn update-proxy [p mappings] p) -(defn proxy-super [& args] (throw "proxy-super: JVM proxies are not supported in Jolt")) -(defn construct-proxy [c & args] (throw "construct-proxy: not supported in Jolt")) -(defn get-proxy-class [& interfaces] (throw "get-proxy-class: not supported in Jolt")) diff --git a/jolt-core/clojure/core/21-coll.clj b/jolt-core/clojure/core/21-coll.clj new file mode 100644 index 0000000..f4af5af --- /dev/null +++ b/jolt-core/clojure/core/21-coll.clj @@ -0,0 +1,362 @@ +;; clojure.core — collection tier, part 2 (rand/sort host seams, the +;; clojure.test runner, fn combinators). Continues 20-coll.clj; same constraints +;; (pure, eager, no macros), loaded in the 20 slot before 25-sorted. + +;; --- leaves over the rand / sort host seams ---------------------------------- + +;; Canonical truncation toward zero via int (the kernel fn floored, which is +;; wrong for a negative n). +(defn rand-int [n] (int (rand n))) + +;; Pure-functional Fisher-Yates over vector assoc; returns a vector, as in +;; Clojure. Collections only — a string is seqable but not shuffleable, as on +;; the JVM (Collections/shuffle wants a Collection). +(defn shuffle [coll] + (when-not (coll? coll) + (throw (ex-info (str "shuffle requires a collection, got: " coll) {}))) + (loop [v (vec coll) i (dec (count v))] + (if (pos? i) + (let [j (rand-int (inc i)) + t (nth v i)] + (recur (assoc (assoc v i (nth v j)) j t) (dec i))) + v))) + +;; Canonical sort-by: the default comparator is compare (so nil sorts first, +;; like Clojure — the kernel fn used host ordering, which put nil last); the +;; comparator compares KEYS and may be 3-way or a boolean predicate (the host +;; sort seam normalizes). +(defn sort-by + ([keyfn coll] (sort-by keyfn compare coll)) + ([keyfn comp coll] + (sort (fn [x y] (comp (keyfn x) (keyfn y))) coll))) + +;; parse-uuid: nil unless s is a canonical 8-4-4-4-12 hex UUID string; throws +;; on a non-string (Clojure 1.11). __make-uuid is the host constructor for the +;; tagged value (overlay source can't write :jolt/type map literals — the +;; reader treats them as tagged forms). +(defn parse-uuid [s] + (if (string? s) + (when (re-matches + #"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}" s) + (__make-uuid s)) + (throw (str "parse-uuid requires a string, got: " s)))) + +;; Version-4 UUID (RFC 4122): zero-padded hex groups 8-4-4-4-12, version +;; nibble 4, variant 8-b — built over rand-int and validated by parse-uuid. +(defn random-uuid [] + (let [hx4 (fn [] (format "%04x" (rand-int 0x10000))) + hx3 (fn [] (format "%03x" (rand-int 0x1000)))] + (parse-uuid (str (hx4) (hx4) "-" (hx4) "-4" (hx3) + "-" (format "%x" (+ 8 (rand-int 4))) (hx3) + "-" (hx4) (hx4) (hx4))))) + +;; The char escape/name tables, as char-keyed maps (Clojure's shape). +(def ^:private char-escape-strings + {\newline "\\n" \tab "\\t" \return "\\r" \formfeed "\\f" + \backspace "\\b" \" "\\\"" \\ "\\\\"}) +(defn char-escape-string [c] (get char-escape-strings c)) + +(def ^:private char-name-strings + {\newline "newline" \tab "tab" \return "return" \formfeed "formfeed" + \backspace "backspace" \space "space"}) +(defn char-name-string [c] (get char-name-strings c)) + +;; Random selection over the host rand primitives. +(defn rand-nth [coll] + (let [v (vec coll)] (nth v (rand-int (count v))))) + +(defn random-sample + ([prob] (filter (fn [_] (< (rand) prob)))) + ([prob coll] (filter (fn [_] (< (rand) prob)) coll))) + +(defn comparator [pred] + (fn [a b] (cond (pred a b) -1 (pred b a) 1 :else 0))) + +;; Lazy: the running accumulators, one at a time (matches Clojure). +(defn reductions + ([f coll] + (lazy-seq + (let [s (seq coll)] + (if s + (reductions f (first s) (rest s)) + (list (f)))))) + ([f init coll] + (cons init + (lazy-seq + (when-let [s (seq coll)] + (reductions f (f init (first s)) (rest s))))))) + +;; Lazy pre-order DFS (matches Clojure): node, then its children's walks spliced +;; via the (now lazy) mapcat. +(defn tree-seq [branch? children root] + (let [walk (fn walk [node] + (lazy-seq + (cons node + (when (branch? node) + (mapcat walk (children node))))))] + (walk root))) + +;; file-seq: the tree of paths under root (root included), directories walked +;; via the host dir primitives. Paths (strings), not File objects. (Lives below +;; tree-seq: forward references are analysis errors.) +(defn file-seq [root] + (if (__file? root) + ;; java.io.File tree: walk via the File method surface so leaves are File + ;; values callers can invoke .isFile/.getName/slurp on. + (tree-seq (fn [f] (.isDirectory f)) (fn [f] (seq (.listFiles f))) root) + (tree-seq __dir? __list-dir root))) + +;; Canonical flatten via tree-seq: the leaves (non-sequential nodes) in order. +;; Flattens lists too (sequential?), matching Clojure/CLJS. +(defn flatten [coll] + (filter (complement sequential?) (rest (tree-seq sequential? seq coll)))) + +;; xml-seq: tree-seq over XML element trees. Elements are maps with :content. +(defn xml-seq [root] + (tree-seq (complement string?) (comp seq :content) root)) + +;; Lazy interleave: round-robin one element from each coll until any exhausts. +(defn interleave + ([] ()) + ([c1] (lazy-seq c1)) + ([c1 c2] + (lazy-seq + (let [s1 (seq c1) s2 (seq c2)] + (when (and s1 s2) + (cons (first s1) + (cons (first s2) + (interleave (rest s1) (rest s2)))))))) + ([c1 c2 & cs] + (lazy-seq + (let [ss (map seq (list* c1 c2 cs))] + (when (every? identity ss) + (concat (map first ss) + (apply interleave (map rest ss)))))))) + +;; No ratio type on Jolt, so rationalize is identity. +(defn rationalize [x] x) + +;; 0-arg: a stateful transducer (tracks [seen? prev] in a volatile, so no sentinel +;; value is needed). 1-arg: eager dedupe of consecutive equal elements. +(defn dedupe + ([] + (fn [rf] + (let [pv (volatile! [false nil])] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (let [[seen prior] @pv] + (vreset! pv [true input]) + (if (and seen (= prior input)) result (rf result input)))))))) + ([coll] + (let [step (fn step [s prev] + (make-lazy-seq + (fn* [] + (let [s (seq s)] + (if s + (let [x (first s)] + (if (= x prev) + (coll->cells (step (rest s) prev)) + (coll->cells (cons x (step (rest s) x))))) + nil)))))] + (let [s (seq coll)] + (if s + (make-lazy-seq + (fn* [] (coll->cells (cons (first s) (step (rest s) (first s)))))) + ()))))) + +;; Internal helper for {:keys [...]} destructuring over a seq of k/v pairs — +;; canonical Clojure 1.11 shape (core.clj seq-to-map-for-destructuring): +;; even pairs build a map (later keys win, as createAsIfByAssoc), a SINGLE +;; element is returned as-is (the trailing-map calling convention), and an +;; unpaired key past pairs throws. +(defn seq-to-map-for-destructuring [s] + (if (next s) + (loop [m {} xs (seq s)] + (if xs + (if (next xs) + (recur (assoc m (first xs) (second xs)) (nnext xs)) + (throw (str "No value supplied for key: " (first xs)))) + m)) + (if (seq s) (first s) {}))) + +;; Host-coupled fns that are pure logic over existing core primitives, so they +;; need no new jolt.host surface. + +;; vary-meta: f applied to obj's metadata (+ extra args), reattached. meta and +;; with-meta are the irreducible host primitives; vary-meta is just their compose. +(defn vary-meta [obj f & args] + (with-meta obj (apply f (meta obj) args))) + +;; namespace-munge: Clojure namespace name -> legal Java package name (- -> _). +(defn namespace-munge [s] + (apply str (map (fn [c] (if (= c \-) \_ c)) (seq (str s))))) + +;; reduce-kv over a map (k v) or vector (index v). Both branches go through reduce, +;; so reduced short-circuits — and the vector path indexes correctly. nil folds +;; to init, matching Clojure. +(defn reduce-kv [f init coll] + (cond + (vector? coll) (reduce (fn [acc i] (f acc i (nth coll i))) init (range (count coll))) + (map? coll) (reduce (fn [acc k] (f acc k (get coll k))) init (keys coll)) + (nil? coll) init + :else (throw (str "reduce-kv not supported on: " coll)))) + +;; ex-info accessors. The constructor (ex-info) stays native — it builds the tagged +;; value and wires into throw — but the value exposes :jolt/type/:message/:data/ +;; :cause via get, so the accessors are pure over get. A thrown non-ex-info arrives +;; wrapped as {:jolt/type :jolt/exception :value v}; unwrap that first. +(defn- ex-info-val? [x] (= (get x :jolt/type) :jolt/ex-info)) +(defn- ex-unwrap [e] + (if (= (get e :jolt/type) :jolt/exception) (get e :value) e)) +(defn ex-data [e] + (let [e (ex-unwrap e)] (if (ex-info-val? e) (get e :data) nil))) +(defn ex-message [e] + (let [e (ex-unwrap e)] + (cond (ex-info-val? e) (get e :message) + :else nil))) +(defn ex-cause [e] + (let [e (ex-unwrap e)] (if (ex-info-val? e) (get e :cause) nil))) + +;; inst-ms: epoch milliseconds of an instant; throws on a non-inst (Clojure +;; protocol behavior). +(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). +(defn update-keys [m f] + (reduce-kv (fn [acc k v] (assoc acc (f k) v)) (hash-map) m)) + +(defn update-vals [m f] + (reduce-kv (fn [acc k v] (assoc acc k (f v))) (hash-map) m)) + +;; Vector-returning partition variants (1.11): lazy seqs OF vectors. +(defn partitionv + ([n coll] (map vec (partition n coll))) + ([n step coll] (map vec (partition n step coll))) + ([n step pad coll] (map vec (partition n step pad coll)))) + +;; partition-all is a lazy-tier fn (40-lazy) — declared so partitionv-all +;; compiles; bound by the time anything calls it. +(declare partition-all) + +(defn partitionv-all + ([n coll] (map vec (partition-all n coll))) + ([n step coll] (map vec (partition-all n step coll)))) + +;; First part a vector, rest a seq — matching the reference implementation. +(defn splitv-at [n coll] + [(vec (take n coll)) (drop n coll)]) + +;; with-redefs-fn: temporarily set each var's root to the mapped value, run +;; the thunk, restore the saved roots even on throw. The with-redefs macro +;; (30-macros) builds the {var val} map from names. +(defn with-redefs-fn [binding-map func] + (let [vars (vec (keys binding-map)) + saved (mapv var-get vars)] + (doseq [v vars] (var-set v (get binding-map v))) + (try + (func) + (finally + ;; loop/recur, not dotimes: dotimes is a 30-macros macro and this tier + ;; compiles before it exists (a forward ref would resolve to the macro + ;; fn at runtime and mis-apply it). + (loop [i 0] + (when (< i (count vars)) + (var-set (nth vars i) (nth saved i)) + (recur (inc i)))))))) +;; Jolt has no chunked seqs, so this is always false. +(defn chunked-seq? [x] false) + +;; Atom peripheral operations. atom/swap!/reset!/deref stay native — the compiler +;; depends on them and they're hot. swap-vals!/reset-vals!/compare-and-set! compose +;; the native ops (which already validate and notify watches); get-validator reads a +;; slot; add-watch/remove-watch/set-validator! mutate the atom (or its watches +;; sub-table) through the one host primitive jolt.host/ref-put! — the minimal +;; mutation kernel the overlay can't express over core fns (a nil value removes the +;; key). compare-and-set! compares by value. +(defn swap-vals! [a f & args] + (let [old (deref a)] [old (apply swap! a f args)])) +(defn reset-vals! [a newval] + (let [old (deref a)] (reset! a newval) [old newval])) +(defn compare-and-set! [a oldval newval] + (if (= oldval (deref a)) (do (reset! a newval) true) false)) +(defn get-validator [a] (get a :validator)) +(defn add-watch [a key f] + (jolt.host/ref-put! (get a :watches) key f) a) +(defn remove-watch [a key] + (jolt.host/ref-put! (get a :watches) key nil) a) +(defn set-validator! [a f] + (jolt.host/ref-put! a :validator f) nil) + +;; vreset!/vswap! live in the seq tier (10-seq.clj): its transducers use them. + +;; Future status predicates — pure reads of the future's :cached/:cancelled slots. +;; future? stays native (deref/future-cancel/realized? call it); future-call and +;; future-cancel stay native too (OS threads). +(defn future-done? [x] + (if (future? x) (boolean (get x :cached)) (throw "future-done? requires a future"))) +(defn future-cancelled? [x] + (and (future? x) (boolean (get x :cancelled)))) + +;; ns-name: a namespace object's :name as a symbol. Pure over get + symbol. +(defn ns-name [ns] + (let [nm (get ns :name)] (if nm (symbol (str nm)) nil))) + +;; Java-array element access. Jolt arrays are mutable backing arrays; aget/alength +;; read them (nth/count) and aset writes a slot through ref-put!. Both handle the +;; multi-dimensional form (aget a i j ... / aset a i j ... v) by walking. The array +;; constructors (object-array/make-array/to-array/...) stay native — they build the +;; mutable backing. +(defn aget [arr & idxs] + (reduce (fn [v i] (nth v i)) arr idxs)) +(defn alength [arr] (count arr)) +(defn aset [arr & idxs+val] + (let [n (count idxs+val) + val (nth idxs+val (dec n)) + target (reduce (fn [t k] (nth t k)) arr (take (- n 2) idxs+val))] + (jolt.host/ref-put! target (nth idxs+val (- n 2)) val) + val)) + +;; --- fn combinators + host-free stubs ---------------------------------------- + +(defn complement + "Takes a fn f and returns a fn that takes the same arguments as f, has the + same effects, if any, and returns the opposite truth value." + [f] + (fn [& args] (not (apply f args)))) + +;; Canonical Clojure fnil: patches only the FIRST 1-3 arguments. +(defn fnil + ([f x] + (fn [a & args] (apply f (if (nil? a) x a) args))) + ([f x y] + (fn [a b & args] (apply f (if (nil? a) x a) (if (nil? b) y b) args))) + ([f x y z] + (fn [a b c & args] + (apply f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c) args)))) + +(defn clojure-version [] "1.11.0-jolt") + +;; bigdec is a host fn (host/chez/bigdec.ss) — a real BigDecimal value type. +(defn numerator [x] (throw (ex-info "numerator requires a ratio (Jolt has no ratios)" {}))) +(defn denominator [x] (throw (ex-info "denominator requires a ratio (Jolt has no ratios)" {}))) + +;; No class hierarchy on this host. +(defn supers [x] #{}) + +;; Like Clojure's munge: rewrite dashes to underscores, preserving the argument's +;; type — a symbol munges to a symbol, anything else to a string. (jolt only +;; rewrites dashes, not the full Compiler CHAR_MAP.) +(defn munge [s] + (let [m (str-replace-all "-" "_" (str s))] + (if (symbol? s) (symbol m) m))) + +(defn test + "Calls the :test fn from v's metadata; :ok if it runs, :no-test if absent." + [v] + (let [t (:test (meta v))] + (if t (do (t) :ok) :no-test))) + diff --git a/jolt-core/clojure/core/22-coll.clj b/jolt-core/clojure/core/22-coll.clj new file mode 100644 index 0000000..b8d0c64 --- /dev/null +++ b/jolt-core/clojure/core/22-coll.clj @@ -0,0 +1,314 @@ +;; clojure.core — collection tier, part 3 (canonical Clojure ports: key/val/find, +;; merge-with, memoize, group-by, frequencies, transduce/into/eduction, and the +;; JVM-shape stubs). Continues 21-coll.clj; same constraints. + +;; --- canonical Clojure ports ------------------------------------------------- +;; key/val/find first — merge-with and memoize below use them. + +;; Strict, as in Clojure: an entry is what (seq m) yields (a host tuple), NOT +;; a plain vector — (key [1 2]) throws. +;; key/val moved above the hierarchies section (underive uses them). + +;; find was previously missing from jolt entirely. Presence (contains?), not +;; value, decides — so (find {:a nil} :a) is [:a nil]. Works on vectors by +;; index. The result must be a REAL entry (key/val are strict), so it is +;; minted as the first entry of a one-entry map — nil values survive (the +;; map builder switches to a phm when nil is involved). +(defn find [m k] + (when (contains? m k) (first {k (get m k)}))) + +;; some? lives in the top leaf block now (forward refs are errors). +(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). +(defn select-keys [map keyseq] + (reduce (fn [m k] (if (contains? map k) (assoc m k (get map k)) m)) + (hash-map) keyseq)) + +(defn zipmap [keys vals] + (loop [m (hash-map) ks (seq keys) vs (seq vals)] + (if (and ks vs) + (recur (assoc m (first ks) (first vs)) (next ks) (next vs)) + m))) + +;; conj semantics per entry arg (a map merges, a [k v] pair adds); nil args are +;; 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))) + maps))) + +(defn merge-with [f & maps] + (when (some identity maps) + (let [merge-entry (fn [m e] + (let [k (key e) v (val e)] + ;; presence — not nil-of-value — decides combination + (if (contains? m k) + (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 merge2 maps)))) + +(defn get-in + ([m ks] (reduce get m ks)) + ([m ks not-found] + ;; a fresh table is its own identity — a present-but-nil step is + ;; distinguished from a missing one + (let [sentinel (hash-map)] + (loop [m m ks (seq ks)] + (if ks + (let [nxt (get m (first ks) sentinel)] + (if (identical? sentinel nxt) + not-found + (recur nxt (next ks)))) + m))))) + +;; find-based, so nil RESULTS are cached too; args canonicalize as a collection key. +(defn memoize [f] + (let [mem (atom (hash-map))] + (fn [& args] + ;; plain let/if, not if-let: this tier loads before 30-macros defines it + (let [e (find (deref mem) args)] + (if e + (val e) + (let [ret (apply f args)] + (swap! mem assoc args ret) + ret)))))) + +(defn partial + ([f] f) + ([f a] (fn [& args] (apply f a args))) + ([f a b] (fn [& args] (apply f a b args))) + ([f a b c] (fn [& args] (apply f a b c args))) + ([f a b c & more] (fn [& args] (apply f a b c (concat more args))))) + +(defn trampoline + ([f] (let [ret (f)] (if (fn? ret) (trampoline ret) ret))) + ([f & args] (trampoline (fn [] (apply f args))))) + +;; Canonical pairwise max/min: > / < throw on non-numbers, and the NaN +;; behavior is Clojure's by construction. +(defn max + ([x] x) + ([x y] (if (> x y) x y)) + ([x y & more] (reduce max (max x y) more))) + +(defn min + ([x] x) + ([x y] (if (< x y) x y)) + ([x y & more] (reduce min (min x y) more))) + +(defn reverse [coll] (reduce conj (list) coll)) + +;; An empty coll of the same category; sorted colls keep their comparator (the +;; value's own :empty op). Strings and scalars are nil, as in Clojure; a lazy +;; seq empties to (). +(defn empty [coll] + (cond + (nil? coll) nil + (sorted? coll) ((get (jolt.host/ref-get coll :ops) :empty) coll) + (map? coll) {} + (set? coll) #{} + (vector? coll) [] + (coll? coll) () + :else nil)) + +(defn assoc-in [m [k & ks] v] + (if ks + (assoc m k (assoc-in (get m k) ks v)) + (assoc m k v))) + +(defn update-in [m ks f & args] + (let [up (fn up [m ks f args] + (let [[k & ks] ks] + (if ks + (assoc m k (up (get m k) ks f args)) + (assoc m k (apply f (get m k) args)))))] + (up m ks f args))) + +;; jolt keywords have no intern table (any keyword "exists"), so find-keyword +;; always finds — babashka makes the same call. +(defn find-keyword + ([nm] (keyword nm)) + ([ns nm] (keyword ns nm))) + +;; The raw Inst protocol method; jolt insts have one representation, so it is +;; inst-ms itself. +(defn inst-ms* [i] (inst-ms i)) + +;; Canonical comp — here rather than a host primitive so each stage is invoked with +;; jolt call semantics: (comp seq :content) works because the keyword stage +;; goes through IFn dispatch. +(defn comp + ([] identity) + ([f] f) + ([f g] + ;; fixed arities first (Clojure's own shape): the 1-arg path — every + ;; map/filter stage — is two direct calls, no rest-seq, no apply. + (fn + ([] (f (g))) + ([x] (f (g x))) + ([x y] (f (g x y))) + ([x y z] (f (g x y z))) + ([x y z & args] (f (apply g x y z args))))) + ([f g & fs] (reduce comp (comp f g) fs))) + +;; Canonical IFn set: fns, keywords, symbols, maps (sorted incl.), +;; sets, vectors, and vars — NOT lists ((ifn? '(1 2)) is false in Clojure). +(defn ifn? [x] + (or (fn? x) (keyword? x) (symbol? x) (map? x) (set? x) (vector? x) (var? x))) + +;; Auto-promoting (') and unchecked arithmetic. Jolt numbers don't overflow, +;; so all of these are the checked ops; fixed arities mirror Clojure's +;; signatures. unchecked-divide-int goes through quot, so dividing by zero +;; throws as on the JVM. +(def +' +) +(def -' -) +(def *' *) +(def inc' inc) +(def dec' dec) +(defn unchecked-add [x y] (+ x y)) +(defn unchecked-subtract [x y] (- x y)) +(defn unchecked-multiply [x y] (* x y)) +(defn unchecked-negate [x] (- x)) +(defn unchecked-inc [x] (+ x 1)) +(defn unchecked-dec [x] (- x 1)) +(def unchecked-add-int unchecked-add) +(def unchecked-subtract-int unchecked-subtract) +(def unchecked-multiply-int unchecked-multiply) +(def unchecked-negate-int unchecked-negate) +(def unchecked-inc-int unchecked-inc) +(def unchecked-dec-int unchecked-dec) +(defn unchecked-divide-int [x y] (quot x y)) +(defn unchecked-remainder-int [x y] (rem x y)) +(defn unchecked-int [x] (int x)) +(def unchecked-long unchecked-int) + +;; int? is integer? on jolt: one number type, so fixed-precision and +;; arbitrary-precision integers coincide. +(defn int? [x] (integer? x)) + +;; num: Clojure coerces to java.lang.Number; jolt just checks. +(defn num [x] + (if (number? x) x (throw (str "num requires a number, got: " x)))) + +;; == numeric equality: 1-arity is trivially true without inspecting the value +;; (Clojure's shape); 2+ args must be numbers, as Numbers.equiv throws. +(defn == + ([x] true) + ([x y] + (if (and (number? x) (number? y)) + (= x y) + (throw (str "Cannot cast to number: " (if (number? x) y x))))) + ([x y & more] + (if (== x y) + (apply == y more) + false))) + +;; ensure-reduced / halt-when: canonical Clojure. halt-when smuggles the halt +;; value through reduce in a ::halt-keyed map and unwraps it in the completion +;; arity, so the halt REPLACES the whole reduction result. +(defn ensure-reduced [x] (if (reduced? x) x (reduced x))) + +(defn halt-when + ([pred] (halt-when pred nil)) + ([pred retf] + (fn [rf] + (fn + ([] (rf)) + ([result] + (if (and (map? result) (contains? result ::halt)) + (get result ::halt) + (rf result))) + ([result input] + (if (pred input) + (reduced (hash-map ::halt (if retf (retf (rf result) input) input))) + (rf result input))))))) + +;; parse-boolean: exact "true"/"false" only; nil on anything else, throw on a +;; non-string (Clojure 1.11). +(defn parse-boolean [s] + (if (string? s) + (cond (= s "true") true (= s "false") false :else nil) + (throw (str "parse-boolean requires a string, got: " s)))) + +(defn newline [] (print "\n") nil) + +;; seque: jolt is single-threaded eager here — the queue is a no-op and the +;; coll passes through. +(defn seque + ([s] s) + ([n-or-q s] s)) + +(defn array-seq [arr & _] (seq arr)) + +(defn to-array-2d [coll] (to-array (map to-array coll))) + +;; Masking integer coercions (not aliases): byte/short wrap to their width. +;; unchecked-byte/short truncate to a number; unchecked-char returns a char (as on +;; the JVM). int handles chars, so (unchecked-byte \a) works. +(defn unchecked-byte [x] (bit-and (int x) 0xff)) +(defn unchecked-short [x] (bit-and (int x) 0xffff)) +(defn unchecked-char [x] (char (bit-and (int x) 0xffff))) +(defn unchecked-float [x] (double x)) +(defn unchecked-double [x] (double x)) + +;; --- transduce / into / eduction --------------------------------------------- +;; Canonical transduce: build the stacked rf once, reduce (which honors +;; `reduced` and steps lazy seqs incrementally), then run the completion arity. +(defn transduce + ([xform f coll] (transduce xform f (f) coll)) + ([xform f init coll] + (let [xf (xform f)] + (xf (reduce xf init coll))))) + +;; into stays a host primitive: it's perf-wall hot (the into-vec bench pays ~11% +;; through the overlay call layers — same lesson as even?/odd?). + +;; eduction is EAGER on jolt (documented divergence): the composed +;; xforms applied to coll, realized into a vector. +(defn eduction [& args] + (let [coll (last args) + xforms (butlast args)] + (if xforms + (into [] (apply comp xforms) coll) + (into [] coll)))) + +(defn ->Eduction [xform coll] (into [] xform coll)) + +;; --- JVM-shape stubs and trivial shells -------------------------------------- +;; Pure compositions or documented jolt stubs; the host keeps nothing. +(defn enumeration-seq [e] (seq e)) +(defn iterator-seq [i] (seq i)) + +;; jolt is single-threaded: a promise is an atom, deref never blocks +;; ((deref undelivered) is nil rather than a hang). +(defn promise [] (atom nil)) +(defn deliver [p v] (reset! p v) p) + +(defn bean [x] (if (map? x) x {})) + +(defn uri? [x] false) + +;; An EVALUATED set of quoted symbols — a quoted set literal ('#{if ...}) +;; stays an unevaluated reader form on jolt and contains? can't see into it. +(def ^:private special-syms + #{'if 'do 'let* 'fn* 'quote 'var 'def 'loop* 'recur 'throw 'try 'catch + 'finally 'new 'set! '. 'monitor-enter 'monitor-exit}) + +(defn special-symbol? [s] (contains? special-syms s)) + +;; print-method / print-dup are real multimethods in the io tier (50-io.clj). + +;; JVM proxies don't exist on this host: the read-only surface is inert, +;; the constructive surface throws. +(defn proxy-mappings [p] {}) +(defn proxy-call-with-super [f p meth] (f)) +(defn init-proxy [p mappings] p) +(defn update-proxy [p mappings] p) +(defn proxy-super [& args] (throw "proxy-super: JVM proxies are not supported in Jolt")) +(defn construct-proxy [c & args] (throw "construct-proxy: not supported in Jolt")) +(defn get-proxy-class [& interfaces] (throw "get-proxy-class: not supported in Jolt"))