Hi! I have a question. Let us say that i have a macro that replaces all occurrences of 'transact' to '\', sth like this:

(defmacro transmuting-macro [& body]
  (let [transmuted-body (clojure.walk/postwalk 
                         #(if (and (list? %) (= 'transact (first %))) 
                            (-> % rest (conj `/)) %) body)]
    transmuted-body)) 

(defn generate-error []
  (transmuting-macro (let [x 1
               b (transact 1 3)]
           (transact 3 0))))

My first thought is that (-> % rest (conj ...) ...) is losing any metadata that was on the original form

@mll Did you try something like

(with-meta (-> % rest (conj `/)) (meta %))

(and you may need to capture the metadata from (first %) in that expression and add it to the / symbol)

the problem is that meta of the body is nil...

I thought about the same but cannot find the meta. Where is it?

It may be that postwalk itself doesn't preserve metadata?

but i have looked at the original body

Hmm, I'll have to go digging. I ran into similar issues when working on expectations.clojure.test. I seem to recall needing to read metadata from &form (which is where the source form for the macro originates) but I can't remember how I propagated the data.

Hmm, no, looks like I sidestepped all of that in the end. Sorry @mll I have no suggestions right now.

Thanks

I did some digging and it seems there is a certain pattern to metas inside the form but not outside of it

not form

body

(with-meta transmuted-body (meta &form)) would be my best guess at this point @mll for the body of your let instead of just transmuted-body

You're right that postwalk doesn't preserve meta

there is a bug filed for this

or at least I thought there was, not seeing it

seems like this came up recently, but I don't know where then, don't see it in ask or jira

actually I am seeing it preserved in postwalk?

isn't this just the old issue https://clojure.atlassian.net/browse/CLJ-865

https://github.com/ztellman/potemkin/blob/master/src/potemkin/walk.clj I've had to use this a couple times to fix problems. Maybe it was when I was using map & similar on the sequences though :).

@alexmiller there we are, lists & seqs lose their meta:

user=> (clojure.walk/postwalk identity (with-meta (list 1 2 (with-meta (list 3 4) {:bar true})) {:foo true}))
(1 2 (3 4))
user=> (clojure.walk/postwalk identity ^:foo (list 1 2 ^:bar [ 3 4]))
(1 2 ^{:bar true} [3 4])

ah, thx

well, afaik there is no ticket about this

I can log one in the am, it's bitten me a couple of times.

I thought I found a ticket, but hazy memory.

Big thanks for spelling it out. I will use the potemkin for now then.

(s/def ::generate-labels (s/keys :req-un [::label-template
                                          ::data]
                                 :opt-un [::api-version]))

It could be very helpful as a doc then

@kwladyka I don’t believe so, but you could write a custom generator with s/with-gen

this is not what I really want to 😉

even then I will have to write this for all main map specs

this will be nice feature

you could write an alternate spec where the optional things are required, then use its generator as the generator here

thanks for the suggestion. Probably the best is to write macro which will create this spec using real one.

How to unbind a macro in the repl?

I required the cljs deftest and tried unmapping it like so: (ns-unmap 'cljs.test 'deftest)

But when I try to require the clj deftest (require '[clojure.test :refer [deftest]])

deftest already refers to: #'cljs.test/deftest in namespace: user

isn't the problem that you have a user/deftest and you need to unmap that?

cljs.test/deftest is a fine mapping and you probably don't want to unmap that one

Okay so how do I require the clj deftest in user ns given that the cljs deftest is already defined in that namespace?

you have a user/deftest and you need to remove that right?

got it thanks

you can use (ns-unmap 'some.ns 'sym) or (def sym nil) from inside that ns

ns-unmap actually removes the var entirely, def just happens to remove all aspects of the var that are usually a problem (eg test or macro metadata)

Hello everyone,

I have general question, about consuming messages from Kafka topic, is it better to collect all messages into async channel and handle it by pure methods which take channel and process it and return new output channel and so on or what is the best approach to model that ?

can anyone ELI5 how I should use :volatile-mutable?

Don't 🙂

Volatile mutable is useful internally (which is why it makes fields private) when defining complicated deftypes

I want to build a custom ref type (similar to atom). my main use case is CLJS, but I think it would be cute to support CLJ as well

You might use volatile mutable for that, but it will depend on the specifics. You should be very careful implementing mutable stuff shared between cljs and clj, you can get away with a lot on js that is very unsafe with multiple threads

@lilactown so something like volatile?

I'm at the level right now of "googling what the java volatile keyword does again" because I really don't live too much in the JVM runtime

@lilactown yeah, to add to what @hiredman is saying, I see a continuum from single process js, to multi process jvm, to multi server distsys, where every concurrency semantic gets harder to implement, and more gotchas come into play

but ostensibly I want the same thread safety guarantees as a clojure atom

and why are you not using atom?

It is unlikely that you custom ref type will be safe to use based just on volatile(but possible), so you may was well just assume you need a lock or an atomic ref

I want some special behavior (reactivity) on deref/swap/etc. I suppose I could have my custom type contain an atom and pass some of the methods through

The way to get what an atom has is using an atom

or I could pass in a java.util.concurrent.atomic.AtomicReference in the constructor and copy the general pattern in clojure.lang.Atom

@lilactown reactivity other than what add-watch or set-validator gives you?

yeah

I have a hard time imagining reactive semantics that aren't covered by those, I'd be fascinated to hear what you mean

it's mainly API/syntax. my goal: play with building a reagent ratom-like data structure, outside of the reagent view lib, and cljc

so e.g.:

(def foo (r/atom 0))

(def bar (r/reaction (* @foo 2))

(add-watch bar :log (fn [_ _ _ v] (prn :bar v))

(swap! foo inc)

;; out:
;;  :bar 4

you may be interested in javelin/hoplon https://github.com/hoplon/javelin

there is also a version for the jvm in progress

yeah I want to write my own 😄

I guess the AtomicReference class is where I should start

Atomic reference isn't going to be safe for that

Because you need to change the value and do your reaction stuff atomically

is it the and do your reaction stuff part that will be difficult to do atomically using just an AtomicReference?

Yes

I mean, I guess you could build a spin lock using atomic reference, but at that point you can just use a Lock

Atomic ref only lets you compare and set a reference atomically

I guess I’ll have to think about if what I really want is an atom, or something more akin to a fancy agent

Atom uses an AtomicReference internally

I just noticed atomic reference seems to have grown a Java version of swap!

start at ^:volatile-mutable, end up at a UI framework 🙂

@hiredman yeah, there are a few helpers in there.

It might also be interesting to look at a rules engine like clara

when I think high level what I actually want in CLJS, I don’t know if I want to guarantee that changes are synchronously invoked

it could be useful for React apps to have external state that participates using the React scheduler

which AFAICT is basically how an agent works but you can’t block on deref in CLJS

hey lets say I have a namespaced keyword :dojo.domain.error/not-found I want to convert it to a string but (str ns-k) -> ":dojo.domain.error/not-found" and (name ns-k) -> "not-found" I could drop the first char of the string of course but I wonder if there a better way of doing this

Rules engines often have the idea of quiescence, meaning you introduce new information, rules fire for a while asserting and retracting, until a stable state is reached

interesting

which is kind of like a transaction (introduce novelty -> react to novelty in private -> expose new start of the world atomically) which might lead you to wanting something like more like refs then atoms

I'm trying to create a web front end for a clj repl process. I will send code strings from the cljs client to the backend. I believe I have a lot to learn and feel kinda lost. I think I can start a clojure.main/repl process on the server. Is it just a matter of wrapping that clojure.main/repl call a binding that binds *in* and *out* to things that can be "sent" input and "receive" output? Any pointers for how I can start to approach this?

don't forget *err*

you could use inputstream / outputstream pairs to interact with the repl, yeah

to talk to the repl, you have an outputstream that pipes to an inputstream that feeds *in*

and the reverse for *out* and *err*

also, a repl (read, eval, print, loop) is something you can just construct, it's not magic

read the data from client, call eval on that, print (prn) the result to the client

(though there is bookkeeping for things like current ns dynamic vars etc...)

Yeah that was my first approach but I was having issues evaluating ns forms so I figured I'd jump into the main repl stuff

Has anyone seen an example of a macro that merges the (cond-> behavior with (-> such that it threads the value from each expression into the next conditional?

Would like to reduce nesting so looking at that and potentially things like a maybe monad.

(and these are external service calls dependent on prior values)

@activeghost https://stackoverflow.com/questions/51993246/a-cond-threading-macro-alternative-that-refers-last-threaded-state-inside-pred https://github.com/Engelberg/better-cond

but I agree with @noisesmith and usually just jam together as->and cond->

I misunderstood the question and accidentally said something relevant

Thx. Yes, I could use those but given these are expensive I want short circuit vs (let ... (if () (let ... (if ... ()))). I kind of want a (cond-as->

"expensive"

oh, then you want some-> in there

they are external service calls, don't want to make them ahead of time. I also want control over the return value .. so (some-> would work with some munging (to allow a predicate to determine instead of nil)

I think what you want isn't a syntax rewrite, and all these threading operators can do is syntax

none of them have real semantics

you can use run! or reduce to call each function in a series, and then use an exception or reduced to force short circuiting

at least that has meaning at runtime beyond moving parens around

True, will try that route first. Hadn't thought of running them as a sequence in reduce.

(reduce (fn [state f] (f state)) init [f1 f2 ...])

if any of the fs return (reduced v) that will prevent further functions from running, and will be the return value of reduce

if you find it ugly, you could make a macro that takes each form in a body and puts it in a two-arg function

We'll see, I've done this for other things just not sequences of server calls. I can hand it a sequence of partially applied fns and avoid the macro as they all return the same shape. Thx!

also (defn rapply [state f] (f state)) might be nice to in that sort of idiom

a silly little dsl

(cmd)user=> (defn rapply [state f] (f state))
#'user/rapply
(ins)user=> (def pt (partial apply partial))
#'user/pt
(ins)user=> (defn states [init & fs] (reduce rapply init (map pt fs)))
#'user/states
(ins)user=> (states 0 [+ 1] [* 3] [/ 2.0] [reduced] [#(throw (ex-info {:oops %}))]])
0.6666666666666666
(ins)user=> 

is there a way to cleanly exit a swap operation if an exception is thrown during it?

namely,

> (def a (atom 1))
> (swap! a (fn [a] (throw Exception)))
> @a
1

i’m trying to see if it’s possible to do multiple swaps within a dosync (which is probably an abuse of dosync, if possible)

what's unclean about that?

swap! and dosync are unrelated

@gtzogana to be clear, what you have above already happens (except the exception goes all the way up, isn't caught by swap! itself)

ugh, i was making a dumb syntax error. my bad

is there any notion of transactional operation on more than one atom? or am i just using the wrong primitive

that's what refs are

I think you want ref

yeah, figured. ok, thanks!

Is it possible configure the clojure reader, so it would not ignore comment only lines?

(+ 6 6 ; add numbers )

; add numbers

(+ 6 6)

the comment in the first version is available in the read meta-data

but in the second version the comment is completely gone.

I am trying to get the second version to give me back comments only as well.

@hoertlehner I was not aware that the Clojure reader would give back comments, ever, in any form, metadata or otherwise. How did you get it to do so for the first string?

And depending on what your goal is, there are 3rd party libraries that might already do what you want.

The reader’s job is to turn strings into data. Retaining comments or other white space is outside its main job. As Andy said, there are parsers that retain this context that might be a better match for your needs.

just my humble opinion but I think you'd be better off extracting to a function and letting the function name be your comment or putting docs on the function. unless this is a you-dont-control-the-src situation