SOLVED (apologies if this should be in #beginners ) Hello — Looks like a Clojure int is a java.lang.Long for positive numbers, but not quite for negative ones. The smallest java.lang.Long is 0x8000000000000000, according to https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/lang/Long.java#L79, suggesting ordinary 64-bit twos complement:

jdk.internal.ValueBased
public final class Long extends Number
        implements Comparable<Long>, Constable, ConstantDesc {
    /** ... */
    @Native public static final long MIN_VALUE = 0x8000000000000000L;
    /** ... */
    @Native public static final long MAX_VALUE = 0x7fffffffffffffffL;

(format "0x%X" -9223372036854775808)
;; => "0x8000000000000000"
(class -9223372036854775808)
;; => java.lang.Long
(class 0x8000000000000000)
;; => clojure.lang.BigInt

(class -1)
;; => java.lang.Long
;; (format "0x%X" -1)
;; => "0xFFFFFFFFFFFFFFFF"

(class 0xFFFFFFFFFFFFFFFF)
;; => clojure.lang.BigInt
(= -1 0xFFFFFFFFFFFFFFFF)
;; => false

0x4000000000000000
;; => 4611686018427387904
(format "0x%X" 4611686018427387904)
;; => "0x4000000000000000"
(class 0x4000000000000000)
;; => java.lang.Long

We encountered a surprising scenario recently: Delivered promises are affected by thread interrupts. I did search if that has already been discussed, but did not find anything. Apologies if I missed something. Here is some code to reproduce what I mean:

(def p (promise))
(def f (future
         (println "Future: Waiting for promise to be delivered.")
         (let [v @p]
           (println "Future: Got promise value:" v)
           ;; Something interrupts this thread; normally this would be another thread, maybe calling future-cancel.
           (.interrupt (Thread/currentThread))
           (println "Future: Interrupted.")
           (println "Future: Reading promise value again.")
           ;; This will not print, as @p will throw an InterruptedException.
           (println "Future: Promised value:" @p))))
(deliver p :hello)
@f ; => Execution error (InterruptedException) at java.util.concurrent.locks.AbstractQueuedSynchronizer/acquireSharedInterruptibly

I'm looking for a Clojure notebook (clerk, gorilla, etc.) that has good LaTex support. I think I saw that Gorilla supports it, but I also want to be up with the latest. The only notebooking I've done was with Jupyter with Clojure on the backend, but I want to be all in on Clojure apps if possible. Any recommendations?

If I have a clojure source file with a bunch of symbols that were :refered in the ns form, is there a tool that can take a source code file and a map of namespace->alias pairs and replace all the referred symbols with the aliased symbol? I know I could probably do this manually with tools analyzer and rewrite-clj, but wondering if this exists yet So I want to do

(use-aliases "path/to/my-file.clj" {'medley.core 'm})

I have a hazy memory that clojure.core.cache has a way to put a size limit on a cache? I can’t find any documentation why i think this but I thought i remembered core.cache having an example or some docs composing a ttl cache with a size bounded cache. does that ring any bells with anyone?