Is there a common idiom/macro to evaluate to the current value of an atom before a swap! other than the obvious

(let [current @a] (swap! a f) current)

I think Alex added something like that recently

there's swap-vals!

^^

Thanks. That's a lead-in to my real question: Is this an idiomatic way to make a "stateful" function. There is a surprising dearth of succinct answers from googling. Or I'm using the wrong terms.

(defn stepper []
  (let [s (atom (cycle [1 2 3]))]
    (fn []
      (let [n (first @s)] (swap! s rest) n))))

(def f (stepper))
(repeatedly 4 f)
;; (1 2 3 1)

I mean, is there another way to keep state other than using an atom? I can't seem to make this work with a closure over an immutable.

How much does clojure knowledge translate to lisp?

According to me, the macro thinking, the homoiconicity, code data equivalence and the REPL workflow. All of these can be equally applied back to any LISP. But Clojure spoiled me with the awesome data structure literals, proper persistent data sturctures and the JVM which I sorely miss in other LISPs.

@coinedtalk lisps are by design very small at their core. a handful of primitives + IO stuff. implementing one will give you an idea:

https://github.com/kanaka/mal

clojure builds on the philosophy of immutability (which makes history(!) cheap through structure sharing) and simplicity (very few data interfaces: seq, maps, ... and a lot of functions that work across them). This maximizes developer power IMHO.

has any one had success finding a "cursive-like" clojure debugger for vs code? something that could launch my ring web server application?

@mcferren Any reason why you can’t use cursive?

VS Code doesn’t get much attention from the Clojure dev community. It’s mostly Emacs, Vim, Cursive, and Sublime/Atom

@rmprescott Have you gotten an answer for the question you asked earlier yet? I think I have an idea of the function you’re trying to write but the approach seems to be a bit off

VS Code has gotten a lot of love recently. And I think Calva is reusing a lot of CIDER components so it should be quite feature-packed

thanks @admay. I have been using cursive over the past year. Reasons being (1) intellij is a heavy app and affects the performance of my laptop, (2) cursive seems to pass over the same breakpoint multiple times giving me an inconsistent perspective on the behavior of loops and recursion (3) i get the red x circle many times when trying to add break points to various lines in my code (4) I often get the java.lang.RuntimeException: Unable to resolve symbol: ... in this context, compiling:(NO_SOURCE_PATH:0:0) when trying to evaluate code in my breakpoint windows

thanks @dpsutton - I will checkout Calva

I don't know if the debugger from CIDER is used in it but the maintainer is quite active in #editors and #calva-dev

also, colin -- the developer of cursive-- is quite responsive and would probably love bug reports about those issues.

@mcferren Those are all really good reasons not to use Cursive haha That being said, I’d go with @dpsutton’s excellent suggestion in Calva. I will say though, Calva encourages a different kind of workflow. Rather than writing functions and debugging via breakpoints, Calva encourages interactive development via inline evaluation similar to Vim + Fireplace and Emacs + Cider

maybe i have an older version of cursive installed - i will try to update

hey everyone, quick question: if I have (def equals_zero (- 1 1)) and want to get '(- 1 1) out, what do I do?

Er, when? At run time?

I'd like to replace (+ 1 1) with (- 1 1) and then eval it

or other way around w/e

Like this?

user=> (def foo '(- 1 1))
#'user/foo
user=> (eval (cons '+ (rest foo)))
2

yeah, but def foo doesn't have ' in it

I'm still a bit confused. If you're in the repl, or at run time, then equals_zero doesn't have the value (- 1 1). It has the value 0, because the form (- 1 1) has been evaluated and the result assigned to the var equals_zero

You could probably do some horrible stuff with macros, but I think the question here is why. What's this trying to solve?

just want to show someone how you can manipulate functions in clojure

curiosity, doesn't solve anything unless you know any practical applications of this

I don't think you can. If you want to muck about like that before the function is exec'd then you'd expect the original definition to be '(- 1 1), which you could then load and alter before execing

Maybe what you’re wanting to demonstrate is how macros work?

The thing about functions is that once you evaluate them, they’re replaced by the result of evaluating

At runtime, in a limited sense, you can “modify” a function by composing it with another. For example you can invert a predicate with complement.

But yeah, all my function munging in the past has been with macros evaluated at compile-time. And I avoid it unless absolutely necessary, because writing macros hurts my brain 😉

@coinedtalk you want the source of foo, before it was evaled, right? Not possible, without writing an extra def-with-source macro of some sort

are leiningen questions out of scope for this channel?

Well there is a #leiningen channel. Did you not get a response there?

thanks @carr0t didn't know about those chans

will try them first

Is this the best for threadpool? https://github.com/TheClimateCorporation/claypoole

Any others?

Last update was 2 years ago, not sure if that is good, or is it?

are you familiar with java.util.concurrent.Executors?

Yeah, a little yeah

Not that much though

It uses that, doesnt?

I've never used claypoole, I use Executors lots

Directly you mean

yes

they come with the jvm and don't require any libraries to use, and are pretty good

I see, thanks, gonna check on that

A coworker did one to easier use, but something is off, its not as fast as it should 3 rmq consumers with pool for eachself, but terrible slow and the memory/cpu is not using that much

gonna check on that, thanks

even if im executing something, i use .submit, right?

if you are using rabbitmq, I believe there is a setting somewhere for how many messages a connection will claim without acking

I use langohr, not sure where to do that, there’s prefetch, and using a fixed threadpool

found it, he uses this

(defn execute*
  ([f]
   (execute* pools/main-pool f))
  ([p f]
   (.execute ^ExecutorService p f)))

does anyone know if any of the various helper libraries have a defn replacement that adds some kind of default argument syntax? the multiple arity technique is pretty tedious

oh nevermind. i just discovered fnil.

fnil, cool!

midje’s contains checker seems to get verbose quickly with nested maps. Is there a different checker that i should be using, or am i thinking about my checks in the wrong way?

Is LightTable still a thing? I found the concept very intersting. But I do not see that it is still talked about.

Development of light table is largely dead due to inactivity

Meaning that there currently is not much happening but that could change with the right people... I know I have very little time to work on it

I know there`s always a better way, what would you guys say about this thread

This, I mean

(defn execute [^ExecutorService pool func & args]
  (.execute pool (fn [] (apply func args))))

I might be inclined to do that as a macro so there's more flexibility about what you're executing. Maybe something like:

(defmacro with-pool [pool & body]
  `(.execute ^ExecutorService ~pool
    (fn [] (do ~@body))))

small point - fn already has an implicit do

so @noisesmith

(defmacro with-pool [pool & body]
  `(.execute ^ExecutorService ~pool
    (fn [] (~@body))))

Or without the ()?

I dont use macro much, I should use it more often

without ()

if you use macroexpand it's easier - one version turns (with-pool p (+ 1 1)) into ... (fn [] ((+ 1 1)))... which is obviously wrong

Thanks