What's the idiomatic or preferred way of writing a defxxx macro without turning it into a global`def`? I'm considering either using swap! on a global registry atom, or rewriting into a multimethod dispatch

i'd just expand into a defn

doing that stuff manually sounds very dangerous

I want to have multiple 'types' of things that share the same name without colliding, eg.

(def-action foo 
   ...)
(def-transformation foo 
   ...)

I could of course intern a (symbol (str % "-action")) but that seems like an uglier hack

in that case i'd namespace them

actions/foo transform/foo

oh, even if there isn't an actual corresponding namespace?

just make a corresponding namespace

grouping functions like that is the purpose of namespaces

that makes sense, thanks!

I saw that Meander uses a system of global "registry" atoms for its macros, and was wondering if that was a normal thing to do

is there a way to improve REPL I get with lein repl because that one doesn't work with directional arrow keys

@roklenarcic have a look at rebel-readline

What library would y'all recommend to parse a sequence of same attributes maps in to csv

usually, "parse" means read but the rest of your sentence sounds like "write"

org.clojure/data.csv can do both

In general, most would be better off using def or defn.

Even really common ones like defroute from compojure are less than ideal. You often want to close over state (e.g. a db connection) before your final definition. So make a fn that accepts any variables and returns the final state.

I have Record name Event with several keys. How can I cast the Event record in to another Record with similar keys?

@contact904 something like this? https://gist.github.com/lukaszkorecki/7cf33665fb70e8357210af925834de4f

haven't checked, but maybe map->OtherRecord?

@vlaaad @lukaszkorecki yes! that is what I needed thank you

I've updated the gist - select-keys is not necessary actually

you can just pass the record to map->OtherRecord

I have an api library that allows a single stream of messages to be received and allows handlers to be attached to handle messages. I just realized that instead of managing my own handlers I could just have an atom which is always reset! to the newest message, and have users use add-watch to manage handlers. Is there a reason not to do that? Are there any examples of other libraries which use atoms in this way?

you could do that, but it appears to be shuffling stuff around, moving the handler business from the message connection to the atom, and it is not clear to me what the advantage would be

@jjttjj for serialized strictly ordered things that only take one action at a time, sometimes an agent is a better abstraction than an atom (with a wrapping function that knows what action to pass to the agent)

since an agent implicitly queues the functions sent to it, and only runs one at a time without retries

Just curious, which is better for a cloud-native clojure backend? AWS or Google?

Big question, I know, just wondered if anyone had any strong opinions. Or if one was better tool-supported than the other

Don't think either is better for clojure in particular

Aws generally has higher adoption, so support is generally higher. But not clojure specific.

Sure, I noticed Cognitect had AWS-native consulting. Wondered if that was for any particular reason other than general AWS adoption

Market share - Amazon was first so it capture the majority of the market. Both Microsoft and Google are catching up and do not have as many offerings in their cloud catalogue as Amazon does, though Microsoft is certainly catching up.

Hi, everyone. Which channel is recommended for technical questions (StackOverflow like)?

https://ask.clojure.org

anyone know offhand how to spec a s/coll-of of alternating integers and uuids?

don't use s/coll-of

(s/* (s/alt :i int? :u uuid?))

thanks @alexmiller!

I am not sure of the meaning of your English description, but perhaps you wanted this instead? (s/* (s/cat :i int? :u uuid?)) . Alex's version allows all integers, or all uuids, or arbitrary mixes of both in any order. The latter one only allows int1, uuid1, int2, uuid2, ...

I'm trying to figure out what the error here is

{:type clojure.lang.ExceptionInfo
   :message "error parsing spec form"
   :data {:k :marketplace.accounting.keys/funding-channel-id, :m (nilable (or :uuid uuid? :string string?))}
   :at [clojure.core$ex_info invokeStatic "core.clj" 4739]}
  {:type java.lang.Exception
   :message "Unable to resolve spec: :uuid"
   :at [clojure.spec.alpha$reg_resolve_BANG_ invokeStatic "alpha.clj" 69]}]

is that the wrong way to use s/or? I haven't touched spec stuff in a while, I'm trying to describe a field that can be nil, uuid, or string (for historical reasons all of these must be accepted)

are you sure you are using s/or?

here's the diff

+(s/def ::funding-channel-id
+  "The identifier for the funding / repayments channel for the loan this trade is for."
+  (s/nilable (s/or :uuid uuid?
+                   :string string?)))

user=> (s/valid? (s/nilable (or :uuid)) "foo")
Execution error at user/eval142 (REPL:1).
Unable to resolve spec: :uuid
user=> 

I thought the args to s/or were keys alternated with specs

they are, I am using clojure.core/or there and getting a similar error message to what you are getting

OK - nothing in my diff from master has or, only s/or, and only in the spec where I see that error

but this could be a misleading error because our lib does some funky things with spec merging

the string "error parsing spec form" doesn't seem to exist in the spec repo

(spec 1 I guess, haven't checked spec 2)

yeah, then this is internal to our lib, and I need to resolve this with internal resources, thanks