how do I use third-party dependencies in a single-file clojure execution

@michaellan202 How are you running the Clojure file?

(there’s a trick where you can turn a Clojure file into a shell script that can run on Linux/macOS and it can contain its dependencies and code to reinvoke itself via the Clojure CLI)

Here’s an example I posted the other day in #tools-deps showing how a Clojure “shell script” could have functions invoked via the CLI -X option:

(! 962)-> ./example.clj -X example/test :foo '"bar"'
WARNING: test already refers to: #'clojure.core/test in namespace: example, being replaced by: #'example/test
[+] test successful {:foo bar}
(! 963)-> cat example.clj 
#!/bin/sh
#_(
   #_DEPS is same format as deps.edn. Multiline is okay.
   DEPS='
   {:deps {} :paths ["."]}
   '
   #_You can put other options here
   OPTS='
   -J-Xms256m -J-Xmx256m -J-client
   '
exec clojure $OPTS -Sdeps "$DEPS" "$@"
) ;; code goes below here
(ns example)
(defn test [arg-map]
  (println "[+] test successful" arg-map))

And here’s another possibility:

(! 991)-> bin/time.sh 
Time is now 2021-03-25T00:38:56.623Z
Java version is 15
(! 992)-> cat bin/time.sh 
#!/usr/bin/env clojure -Sdeps {:deps,{clj-time/clj-time,{:mvn/version,"0.14.2"}}} -M
 
(require '[clj-time.core :as t])
(println (str "Time is now " (t/now)))
(println (str "Java version is " (System/getProperty "java.version")))

Wow thats interesting. the second looks a lot better. The command line options confuse me, like I don’t get how to execute the main method, or what -M or -X do exactly, and the docs I have found aren’t comprehensive

Wow. The first one is quite the trick but isn't the second one just posix #! (and an unregistered reader tag I guess).

i have this long-running process that starts two go-loops to manage state while it runs. it's supposed to be started on demand by any client. is there a point to somehow "closing" the go-loops when each process completes?

i honestly don't even know how one would "exit" a go-loop.

Just stop looping. You can also request it to stop via a channel.

slaps forehead so just (if finished? nil (recur))

lots of times people pass an input channel and a cancel channel to a go loop

(when-not finished? (recur))

if I signal is received on the cancel channel -> perform cleanup and exit

sometimes you arrange these processes in trees, so that a process can signal to subprocesses the need to clean up and exit

But if the OS process is exiting there is not much that actually needs cleaning up. Threads, memory, even file handles will be wiped out by the OS anyway.

It depends on the use-case, can't make a generalization

e.g. you grabbed a lock, need to relinquish

Some C++ programs take a looong time to exit because they are running a bajillion pointless destructors

it's not only destructors, sometimes it just matters to finish what you are doing cleanly

like draining some job queue or whatever

(when-not finished? (recur)) this pattern requires a message after the "quit" signil though right? It's probably better to alt or some other mechanism that looks for a quit message in addition to a normal message

exit-ch is a good candidate for a promise-chan + alts!

inside your loop just alts! over your input-ch + exit-ch and do the right thing from there

(when-not (<! quit-chan) ... (recur))

not that ^ because if your quit-chan doesn't signal anything you'll block

that would park over your quit-ch

(when-not was just a syntactic rewrite of the (if finished? nil ..) expression, not an answer as such to handling core.async loops)

hence the alts!

closing the input channel is another implicit signal to quit

true

when-some is probably better for most reading from channel cases btw

(poll! quit-chan)?

or closed output-ch 🙂, there many ways to skin a cat

assuming it will signal at some point

you can check the ret val of >! or <!

@restenb (alts! [input cancel])

(when-let [task (<! input-ch)] ... (recur))

"exit-ch" can be useful when you have to propagate that exit to other places, otherwise it's true than just checking ret vals of put/take can be enough

when-some as alex said

I wrote this small lib to deal exactly with stopping/restarting go-loops. Uses a combination of atoms, poll! , and a loop-in-a-loop; Been using it happily for UI stuff in ClojureScript/React. Should work on JVM Clojure as well. https://github.com/saberstack/loop Note: A ss.loop/go-loop always exits on the very next (recur ...) call. It does not "die" automagically in the middle of execution.

It is very nice for the REPL specifically, when you have some go-loops that you’re writing and once in a while you’ll get a “runaway” go-loop and you need to restart your process in order to stop it.