this feature does not exist, but writing a function with this behavior on top of reduce should not be hard

(def a 1)
(defn ret-a [] a)
(ret-a) ;; => 1
(def a 2)
(ret-a) ;; => 2

(def ^:const b 1)
(defn ret-b [] b)
(ret-b) ;; => 1
(def b 2)
(ret-b) ;; => 1

See https://clojure.org/reference/compilation for a description of direct linking

@UGSM2S2CS the problem with "behaving like they had ^:const set on them", AFAIK, is that ^:const only makes sense for primitives, and direct linking works for any compile time calculated value

thanks, im pretty sure i will forget soon! i am just still not sure still what direct linking does and i saw ^:const which made me think that direct linkng is pretty much the same as if everyting (non-dynamic, non-redef) would behave like const, but parameter to the compiler

pretty much the only good use of ^:const is to define vars holding long values that clojure can inline unboxed

(def a 1)
(decompiler/decompile a)
;; ...
;; public static void __init0() {
;;        const__0 = RT.var("user", "a");
;; }
;; ...

(def ^:const b 1)
(decompiler/decompile b)
;; ...
;; public static void __init0() {
;;        const__0 = 1L;
;; }
;; ...

no, direct linking is orthogonal

and it's about removing var indirection from function calls

^:const is about inlining the var value in the bytecode

thank you, got it eventually i think but for me the idea still feels similar — as far as i saw both ^:const on a function and direct-linking removes the var lookup @U051SS2EU • no ^:const, no direct linking:

(aot-compile '[(defn a [] nil) (defn b [] (a))] false)
=>
"
 // Decompiling class: learn_clojure/aot_compiler$b
 package learn_clojure;
 
 import clojure.lang.*;
 
 public final class aot_compiler$b extends AFunction
 {
     public static final Var const__0;
     
     public static Object invokeStatic() {
         return ((IFn)aot_compiler$b.const__0.getRawRoot()).invoke();
     }
     
     @Override
     public Object invoke() {
         return invokeStatic();
     }
     
     static {
         const__0 = RT.var(\"learn-clojure.aot-compiler\", \"a\");
     }
 }
 
 "

(aot-compile '[(defn a [] nil) (defn b [] (a))] true)
=>
"
 // Decompiling class: learn_clojure/aot_compiler$b
 package learn_clojure;
 
 import clojure.lang.*;
 
 public final class aot_compiler$b extends AFunction
 {
     public static Object invokeStatic() {
         return aot_compiler$a.invokeStatic();
     }
     
     @Override
     public Object invoke() {
         return invokeStatic();
     }
 }
 
 "

(aot-compile '[(defn a {:const true} [] nil) (defn b [] (a))] false)
=>
"
 // Decompiling class: learn_clojure/aot_compiler$b
 package learn_clojure;
 
 import clojure.lang.*;
 
 public final class aot_compiler$b extends AFunction
 {
     public static final AFn const__1;
     
     public static Object invokeStatic() {
         return aot_compiler$b.const__1.invoke();
     }
     
     @Override
     public Object invoke() {
         return invokeStatic();
     }
     
     static {
         const__1 = (AFn)RT.readString(\"#=(learn_clojure.aot_compiler$a. )\");
     }
 }
 
 "

you shouldn't use ^:const on a function

it's a very bad idea

it's not supposed to work, and it won't

got it, thanks. just hoped this helps me to understand the machinery a bit more

Or make the REPL input

(min [{:lat 1 :lng 3} {:lat 5 :lng 0}])

the ks vector that is passed to comparator-over-maps is supposed to match the possible keys in your input

yeah! I can run it. thanks. but I understand too hard

Try to follow process of substitution in your mind (or a scratch buffer :)):

(comparator-over-maps a-custom-fn [:a :b :c]) ;; returns a function

(fn [maps]
  (zipmap [:a :b :c]
          (map (fn [k] (apply a-custom-fn (map k maps)))
               [:a :b :c])))

(zipmap [:a :b :c]
        (map (fn [k] 
               (apply a-custom-fn
                      (map k [{:a 1} {:a 2 :b 3}])))
             [:a :b :c]))

@U025AG2H55F I think you are facing a very common hurdle we all face when we start to learn Clojure/Lisp. Try to think about all your code by doing substitutions like I showed above. That will help a lot. I teach a Clojure workshop that has https://github.com/adityaathalye/clojure-by-example/blob/master/src/clojure_by_example/ex01_fundamentally_functional.clj to become more familiar with how to read and mentally evaluate Clojure expressions.

thanks @U055NJ5CC @U051MHSEK. my english is poor. thanks brother! thank you very much!

thanks @UMPJRJU9E

Any time, Quan Xing. Happy to help :) > my english is poor No matter... May your Clojure be strong :spock-hand:

https://borkdude.github.io/re-find.web/

Thank you! I can't quite figure out what terms I need to Google to find this 😅

remember that it’s from borkdude (clj-kondo, babashka…) and that it resembles re-find which is a clojure core function for regex

I also find it quite cool but forgot several times where to find it!

printing 350,000 strings can take quite a while and if the repl is also sending stdout back over the repl, that can also be pretty slow. It's hard to tell if the root cause is because writing to stdout is getting backed up or just due to some computation. Do you get the same issue with:

(defn intense
  [x]
  (binding [*out* (proxy [java.io.Writer] []
                    (write [_ ])
                    (flush []))]
    (dotimes [n (reduce * (range 1 x))]
      (println "n is " n ", "))))

Hmm, I can’t get that code to run. Do i have to require another namespace in my file/set up another dependency?

clj or cljs?

oh, this is all cljs. not sure what the cljs equivalent is

maybe:

(defn intense
  [x]
  (binding [*out* (constantly nil)]
    (dotimes [n (reduce * (range 1 x))]
      (println "n is " n ", "))))

anyway, does your original problem print a ton of stuff to stdout?

because a version without printing, which doesn't do much, seems fine

(defn intense
  [x]
  (binding [cljs.core/*print-fn* (fn [x])]
    (dotimes [n (reduce * (range 1 x))]
      (println "n is " n ", "))))

I ran that version of intense two times. The first time I got these errors:

ERROR: XNIO001007: A channel event listener threw an exception
java.lang.AssertionError: Assert failed: No more than 1024 pending puts are allowed on a single channel. Consider using a windowed buffer.
(< (.size puts) impl/MAX-QUEUE-SIZE)

Exception in thread "async-dispatch-4" [2021-07-09 15:53:22.866 - WARNING] :shadow.remote.relay.local/client-not-keeping-up - {:client {:client-info {:connection-info {:remote true, :websocket true}, :since #inst "2021-07-09T19:53:06.816-00:00"}, :client-id 4, :last-ping 1625860386816, :last-pong 1625860386816}, :msg {:op :client-not-found, :client-id 3}}
java.io.IOException: UT002027: Could not send data, as the underlying web socket connection has been broken

that's weird. It doesn't seem like it's even doing much in that version

The original problem does not print that amount of stuff to stdout

As in the one in propeller

it looks like you are pushing code to run in a browser

browsers are single threaded environments

so if you are running some intense thing, nothing else can run

so any keep alives, heart beats, whatever will timeout

I see, I guess it’s too intensive to run in a browser then. Thanks @U0NCTKEV8 and @U7RJTCH6J

depending on whatever it is, you may be able to break it up in a such a way as to run it in chunks that periodically yield control of the main thread so other things can run

Since using web workers means some additional complexity, I would recommend first trying to make it yield control as @U0NCTKEV8 said. If it's a reduce you could do that fairly simply by making it write a value to a channel inside the fn that you're passing to reduce.

Then make another go-loop that takes values off of that channel (so the buffer does not fill up)

Perhaps there is an even simpler way, but that would work

I’ll try these things out, see what works in the original problem. Thanks @U8QBZBHGD and @UC681SR17

I'm curious about the motivation to do this work in the browser