Hello, people. I have a thread running a loop/recur (it's a Kafka consumer). That thread is launched from a call to component/start, and I want to stop that thread (break the loop) whenener component/stop is called. What would be the best way to do this? A hack is to create an atom that is a boolean, and check it before calling recur . It works but I want to avoid global state. If the question is not clear, I can create a gist and share it. Thank you.

@yokoyama.km You can try calling future-cancel on it but the loop would need to be "well-behaved" and be able to be cancelled.

Using an atom like that is not a hack it is good practice

Be sure to wait on the future in your stop, so he future has actually exited by the time it returns

Yeah, that would be my recommendation too: provide some mutable state that can be leveraged to cause the thread to stop. At work we do something similar (but the other way around) -- we wait on a promise in our main thread and the background thread running the server delivers the promise when it shuts down.

Thank you, guys. I was thinking that could exist some way involving channels, but I didn't come up with a solution.

number_to_human(123)                                          # => "123"
number_to_human(1234)                                         # => "1.23 Thousand"
number_to_human(12345)                                        # => "12.3 Thousand"
number_to_human(1234567)                                      # => "1.23 Million"
number_to_human(1234567890)                                   # => "1.23 Billion"

hello @nfedyashev https://github.com/trhura/clojure-humanize seems to be what you are looking for

"intword" Perfect. Thank you very much @jmayaalv

Hi, are there any clj source code formatter that format something like

(let [foo "foo"
      barqux "barqux"]
  ....)

(let [foo    "foo"
      barqux "barqux"]
  ....)

Is this the correct way to define a spec to validate this?

user> (number? ##NaN)
;; => true

That's actually correct, do a google search for "Is NaN a number"

NaN is weird in so many ways, in multiple programming languages. This Github repo is not actually recommended, unless you are somewhat obsessive-compulsive about such things: https://github.com/jafingerhut/batman

Is there an opposite to destructuring? For example I often have to write {:a a :b b} and I guess a macro could save me from the repetition. Wondered if someone already wrote it?

Several libraries have something similar @neo2551 including one of ours...

https://github.com/worldsingles/commons/blob/master/src/ws/clojure/extensions.clj#L152-L174 for example

Thanks I will look for it then.

there are a few ways to do it - I have this for debugging:

(ins)user=> (defmacro locals [] (into {} (map (juxt keyword identity) (keys &env))))
#'user/locals
(ins)user=> (let [a 0] ((fn [x] (loop [q :a] (locals)))  42))
{:a 0, :x 42, :q :a}

(demonstrating it captures all varieties of local binding)

there's a version in the useful lib too

Thanks a lot!

https://github.com/clj-commons/useful/blob/master/src/flatland/useful/map.clj#L9

Why can I use clojure.string/capitalize without requireing it?

because somebody else required clojure.string first

best practice (outside a repl at least) is to always require and alias every ns you actually access

Hey team, is there a "best practices for setting up clojure with postgres" tutorial you'd recommend? (am looking for recommended libraries, potential ~orm-like stuff, discussion on tradeoffs between diff choices) If something like this exists would love to know!

@stopachka We don't use "ORM" stuff because we don't have objects. next.jdbc is going to be your first stop -- that's a general JDBC wrapper and lets you read/write hash maps from/to rows in the database.

Start here: https://cljdoc.org/d/seancorfield/next.jdbc/1.1.547/doc/getting-started -- read all the docs (seriously!)... there's some PostgreSQL-specific stuff in the Tips & Tricks page but the rest should all be generally applicable.

oo this looks great, on it -- thanks Sean!

I test against Embedded PostgreSQL 12.2.0 but you'll want the regular JDBC driver org.postgresql/postgresql {:mvn/version "42.2.14.jre7"}

There's a #sql channel if you have questions.

nice! one quick q, am guessing there may also be libraries that do stuff like: 1. something that handles migrations, etc 2. maybe a macro library, that given some sql structure, gives me a bunch of helper functions for querying 3. some higher-level sql library, so we don't need to write with strings perhaps 2 & 3 are a bit superfluous -- wonder how clj community handles these

I just noticed that you can't call pop on a LazySeq, even after calling doall. I have some code that operates on a list as if it were a stack, but there are times when I also must map down the "stack" (I know that is technically a violation of the stack API) and still be able to call pop on the resulting seq. Any suggestions? The only solution I have come up with is (pop (reverse (into '() (map identity '(1 2 3))))) but I don't like needing the reverse.

I suppose I could switch to using rest instead of pop and get the same result except it remains as a LazySeq. Is that good/bad? I would rather have an efficient way to create a list from a LazySeq that doesn't reverse the order.

@erp12 Use a vector instead? And mapv instead of map.

or vector and transduce

why do you need a list?

why is pop better than rest for your use case?

(agreed, for a stack, use a vector, if that's what you need)

if you're going to use stack verbs then I'd stick with stack api

I went with lists because of the note here: https://clojure.org/reference/data_structures#Lists

well that's fine until you do non-stack things

@erp12 cool - sounds like an actual list is what you want, see the list* function linked on that same node

it gives you a real list without reverse etc.

that sounds worse than using a vector to me

n/m it doesn't return a list

That makes sense. Stacks are stacks. No getting around it.

Thanks all! The only time I needed to map down the stack is to coerce the elements in the event stack is being passed from the outside. That might happen rare enough to accept the cost of a round trip through a seq, or maybe I will just check the stack with a spec and then throw if the caller screwed it up.

Hello clojurians, I was wondering if this is a correct way to use a repl a running ring webserver:

(defn -main
  "Blogo blog backend"
  []
  (future ;; Pretty cool, it unblocks me from using the repl!!
   (jetty/run-jetty app {:port 9091})))

Passing :join? false in that options hash map will do what you want for the REPL.

But if you do it in your -main, when you run the app outside the REPL, it will just exit immediately.

So I'd recommend writing a function to call specifically from the REPL, and then calling it from -main with a different argument:

(defn start [& [join?]] (jetty/run-jetty-app {:port 9091 :join? join?}))
;; call from REPL as (start)
(defn -main [& args ]
  (start true))

How can I repeat the last command in REPL (in shell it is arrow up or !!)?

Can someone please explain how I'd use spec in production code?

I understand it principally

And I've played about with it on the repl

But how is it actually used in the wild?

https://corfield.org/blog/2019/09/13/using-spec/ talks about how we use Spec at World Singles Networks. We've been heavy users since the 1.9 alpha days.

^ @frosku

Thanks @seancorfield