There is no limit to how many times a function can be required. Are you asking if there is a way for a editor function to add the require in some context?

Several tools, lsp and cljr refactor, can do that.

I was trying to move a function to another namespace and wanted to know if lsp or cljr-refactor could do it. It happens that there is no way to do that yet.

In a REPL, you can type (source remove)

You can also git clone , then look in the source file core.clj (or any other source file)

Cool thanks!

If using https://clojuredocs.org/ to search for clojure.core function documentation, there is also a source code link that takes you directly to the source code of that function definition on GitHub

FYI for next time - you can use ` on a line before and after a big block of text to quote it as a single block. It’s called a ‘code block’ - there’s also an icon in the editing toolbar for it on the far right.

the callback from put! takes a single argument

should be something like:

(defn putp [c val]
  (let [p (promise)]
    (put! c val (fn [_] (deliver p val) ))
    (println "realized?" (realized? p))
    @p
    (println "OK")  ))

when running your code, I saw:

Exception in thread "async-dispatch-1" clojure.lang.ArityException: Wrong number of args (1) passed to: example/putp/fn--15434

Thanks a lot, Adrian - I wrote some comments in #beginners

I'm using emacs+cider. I'm less familiar with your editor, but it should show an error if there was one

the presentation talk you reference is using an alpha version of core.async from 2013, so I'm not that surprised that there's a slight difference

Sure - I'm just happy to find a solution

async=> (def a1 (atom nil))
#'metabase.test.util.async/a1
async=> (def a2 (atom nil))
#'metabase.test.util.async/a2
async=> (def a3 (atom nil))
#'metabase.test.util.async/a3
async=> (defn putp [c val]
          (let [p (promise)]
            (put! c val (fn [_] (deliver p val) ))
            (println "realized?" (realized? p))
            @p
            (println "OK")  ))
#'metabase.test.util.async/putp
async=> (def c (chan))
#'metabase.test.util.async/c
async=> (future
          (reset! a1 "about to put and block until take")
          (putp c 10)
          (reset! a2 "put succeeded"))
realized? false
#object[clojure.core$future_call$reify__8477
        "0x14d69935"
        {:status :pending, :val nil}]
async=> (take! c (fn [v] (reset! a3 v)))
OK
nil
async=> (println "@a1:" @a1)
@a1: about to put and block until take
nil
async=> (println "@a2:" @a2)
@a2: put succeeded
nil
async=> (println "@a3:" @a3)
@a3: 10
nil

note that it cannot print “OK” until you take! from the channel c since you are using an unbuffered channel

also, i modified the function on the put! call to take a single (ignored) argument

and if i leave that function not taking an argument i can recreate your issue. But I see the following: > Exception in thread “async-dispatch-6” clojure.lang.ArityException: Wrong number of args (1) passed to: metabase.test.util.async/putp/fn--114165

The reason is probably that you are running the code as a "script" in one go, which terminates before the future ran. You can deref the future for that not to happen I think. As you can see @U11BV7MTK ran the code in a repl, step by step, in a process that keeps running.

When running as a main file i get the same behavior: it works when the callback function takes a parameter and errors when that argument is left out

Thanks dpsutton!