What do you guys think of this macro:

(defmacro until->
  [pred & [expr & forms]]
  (let [g (gensym)
        steps (map (fn [step]
                     `(if (or (~pred ~g) (instance? Throwable ~g))
                        ~g
                        (try
                          (-> ~g ~step)
                          (catch Throwable t#
                            t#))))
                   forms)]
    `(let [~g (try ~expr (catch Throwable t# t#))
           ~@(interleave (repeat g) (butlast steps))]
       ~(if (empty? steps)
          g
          (last steps)))))

It'll keep threading until pred is true, at which point it'll short-circuit and return the last value

I also made it so it captures thrown exceptions, and short-circuit on them and return them as a value instead

(defn might-error-or-throw [e]
  (case (rand-nth [:a :b :c])
    :a :error
    :b (throw (ex-info "Failed!" {e e}))
    :c e))

(until-> #{:error} (might-error-or-throw 10) inc might-error-or-throw inc)

Until you showed the usage I couldn't imagine how it worked... Hmm... I'm still thinking about it...

Haha, ya, I should always accompany a macro with a usage examples 😛

It's sort of take-while but complemented and threaded...?

Kind of, but not for sequences

More like a generic version of some->

Ah, right. Of course.

(defn might-be-nil [e]
  (case (rand-nth [:a :b])
    :a nil
    :b e))

(until-> nil? (might-be-nil 10) inc might-be-nil inc)

Maybe it be better to call it: shortcircuit-on-> but that looks a bit ugly 😛

a more generic way might be a threading macro that takes a predicate to decide when to short circuit?

I can't remember ever needing this sort of computation but it's interesting.

That's what my macro does! 😉

It short-circtuit when pred is true

Also short-circuit if something throws an exception

ohh right missed that arg

Thought it be a good way for people who like to treat error as values. They could easily build their own value representation of an error, make a pred for it, and then use until-> to guard for those

you might be able to similarly reduce across a list of functions

in that case you can just used a reduced as your "error" value

Are there any neat libraries for test coverage (preferably that are still actively maintained)? In my brief time with Eclipse and Java, I always appreciated being told which branches in code weren't being executed; of course it led to more robust code (or exceedingly painful headaches).

Hi folks! Is there any good remote pair programming tool that is neither Emacs nor terminal-based?

Hi everyone. I'm doing a quick spike today on using the Github API (which I gather is GraphQL) to find repos inside a particular organisation and with particular tags. Is there a good GraphQL client library for Clojure, or does anyone know of a project that does something similar already that I could study? A quick Google search is finding mostly ClojureScript, so maybe I should do that instead...

Hey folks, I have a overloaded function with different arity like

(defn overload 
  ([a]
   (println a))
   
   ([a b]
    (println a b))

    ([a b c]
      (println a b c)))

Feel I must be missing something, but here it goes: I wan't a lein/`clj` based docker image with all dependencies baked it. What would one RUNin the build expressing "Just download all deps lein/`clj`" ?

@deas build an uberjar and install it in the docker image

e.g. https://github.com/seancorfield/depstar can build the uberjar for you

@potetm Thought about using an uberjar. Wonder how come there is no "clean" way to say "Just download the deps clj." The functionality is all there already. :thinking_face: Same with lein.

It is not clear to me what you're asking for @deas

what does the intended docker image run when given no args, or when given args?

You can do that. I dunno what’s stopping you.

But a single binary is much more reliable in a lot of facets.

You can, e.g., run clj --eval '(println "downloaded!")' from the base directory in the project

that’ll download all deps before running the eval form

(But, again, I recommend against that. I see zero upside to doing that vs building a single binary.)

@ghadi @potetm I want a docker image that starts fast. Preferrably based on clojure:tools-deps and just using cljfor simplicity. ADD foo.clj RUN clj -S deps ... --eval '(println "bla")'and thats it.

Your app will start faster with an uberjar.

And you can build it using tools.deps using depstar.

Having a single, static artifact in prod is, in many ways, simpler.

Option 1: Ensure certain commands have been previously executed in an environment (i.e. temporal complection) Option 2: Ship the artifact (i.e. data).

running clj -Sdeps as the CMD portion of your container will probably never use cached classpath -> thus will not startup quickly

I wrote RUN but I meant CMD ^

@ghadi he said in a thread it’s for an example. He wants to remove steps for clarity.

(but inside a container build always use clojure not clj because no terminal input)

whoa @potetm nice job with this -> https://github.com/ring-clojure/ring/pull/359

I had been lamenting that for years

Are there any good libraries / guidelines for managing threads over a load balancer? e.g. if you wanted to split up work, had a redis connection between servers and wanted to split the thread load between nodes. e.g. like what the actor model does in erlang ?

@jdkealy from the client or server perspective?

On a server. Let’s say i had 30k stock symbols i wanted to watch and I had 300 servers. I want to have a thread per stock symbol and have on average 100 threads on each server and a monitor to make sure every thread is still alive.

How does one insert a newline char into a str concatenation?

; map destructuring
(defn my-location
  [{lat :lat lng :lng}]
  (str "The latitude is: " lat ", and "
       (newline)
       "the longitude is: " lng "."))

(my-location {:lat 22 :lng 81})

; Result I want:
; The latitude is: 22, and
; the longitude is: 81.
;
; Result I get:
; The latitude is: 22, and the longitude is: 81.

(newline) prints a newline, \newline is the newline character, and "\n" is a string with the newline character in it

(defn my-location
  [{lat :lat lng :lng}]
  (str "The latitude is: " lat ", and " 
       (newline)
       \newline
       "\n"
       "the longitude is: " lng "."))

(my-location {:lat 22 :lng 81})

Instead of a value of:

The latitude is: 22, and
the longitude is: 81.

It's correct as a value, if you want to see the linebreaks you need to println the result

@johnmi using both \newline and "\n" is an odd choice

I was just testing all three at the same time.

Two problems with using println. 1. println produces a side effect instead of a return value.

your complaint was about a behavior - what you saw

the string is correct

clojure doesn't expand newlines in string literals ever, it escapes them

unless you are using a display procedure for side effects

2. only the second println gets returned a a value.

what does that even mean?

So

(defn my-location
  [{lat :lat lng :lng}]
  (str (println "The latitude is: " lat ", and "
                "the longitude is: " lng ".")))

No, it returns a string if you skip the println

that returns the string nil

@johnmi perhaps newline doesn't do what you think it does? It prints out and doesn't add anything to your str (it returns null that is skipped by str)

I think this conversation belongs in #beginners and there's a misunderstanding of printing to *out* vs. returning values

yeah, absolutely

thanks, I will move it there, if i need to, after learning about “out” vs returning values.

so, Im writing a block of code that follows this patterns

(let [f' (f)
      x' (x f')
      ; lots of other function calls
      y' (y)]
  (do-stuff f'  
            x' 
            ; other stuff
            y'))

(let [...
      users (get-lots-of-users)
      _ (log/info "Found " (count users) " users ")
      ; expect lots of _ (log/...) inside the same let block
     ] ...)

(let [...
      users (let [users* (get-lots-of-users)]
              (log/info "Found " (count users*) "users ")
               users*)
           ; expect lots of those nested lets inside the same let block
     ] ...)

could (log/spy :info ....)` be helpful?

I'm a lot more likely to write the first version than the second, but usually only if I'm debugging. If it were code I wanted to keep, I'd probably move (log/info "Found " (count users) " users ") inside the get-lots-of-users fn itself.

I would usually do the former for expediency, or often try to move the calculation out into a function, which does the logging there

the latter is much more satisfying as a long-term solution

Aside: using clojure.tools.logging.readable will likely yield better output when logging a mix of literal text and programmatic values.

thanks everybody for the input, I think Ill move the logging to the inner functions called inside the let block 🙂

Has anyone come up with a poc/bare bones kubernetes operator one can borrow? Asking for a friend. 😉

(get {(Integer/parseInt "0") :found} (long 0)) is confusing me the more i think about it. But I think I'm really glad it works the way it does