it should look something like

(fn [f] (fn [req] (update-in (f req) [:cookies] conj "whatever")))

(defn- wrap-jwt-payload
  [request]
  (let [jwt     (jwt/get-token request)
        payload (jwt/decode-token jwt)]
    (prn jwt)
    (-> (update-in request [:params] merge payload)
        (update-in [:cookies] merge (->> (jwt/create-token payload (jwt/token-lifetime))
                                         (jwt/jwt-cookie))))))

nope

The prn would print out the old jwt. But a new jwt cookie was never set, as in the old one was never overwritten by the new one

I am shocked that it printed anything

because that is just wrong, the middleware wrapping functions are all functions that return a function

they are functions from handlers to handlers, not functions from requests to responses

oh yea I see how thats confusing.. Its not an actual middleware function

Its returning a modified request which gets passed to a handler function

It's confusing to call it wrap-... then...

Yea thats true, ill probably change the name

Cookies needs to be set in the response, and that function does it's update in on the passed in request

So that is also potentially confusing

It would be better as middleware since it could decode the JWT on the way in, add the payload to the request, call the handler, then add an updated JWT to the response before returning that (updated response).

So thats the reason why I added it in the middleware but I need to figure out why its not working

@mario.cordova.862 Middleware should have this general pattern:

(defn wrap-something
  [handler]
  (fn [req]
    (let [resp (handler (enhance req))]
      (enhance resp))))

In your case, you'd want to decode the JWT in that let and enhance would include that update-in that merged in the payload to the request :params.

And then the enhance on the response would merge the updated JWT into the :cookies.

Does that make sense?

(And note that those are two different enhance functions)

@seancorfield yes it makes sense. @smith.adriane gave an example earlier which pretty much mirrors yours. And that’s what I did to get it working. Thank you guys, I appreciate the help :)

:jvm-opts not supported at the top level of deps.edn?

I am writing a workflow management system, something like GNU make. I have jobs in one of four states: done, running, ready, or not ready (i.e., dependencies missing). Each category has one set each, containing job ids. I guess each set should be in the same atomic map, to ensure atomic updates.

{:done #{1 2}
 :running #{3 6}
 :ready #{4 5 7}
:not-ready #{8 9 10}

Is there a function that gives me the position of regex matches? I need to split a string on regex matches and know which strings matched or not (I could use clojure.string/split, then re-run the regex on each item, but that seems inefficient?)

the documentation of clojure.spec.alpha/fdef says that :args and :ret are require for :fn. is that still true?

Note that :fn specs require the presence of :args and :ret specs to
conform values, and so :fn specs will be ignored if :args or :ret
are missing.

say I’m creating a dynamic macro and also want to pass it a dynamic macro symbol

`(defmacro foo []
   `(~~sym ~@args))

`(defmacro foo []
   `(~'~sym ~@args))

Also, does anyone have a better mental model for complex quoting and unquoting like ~'~ , I at first had tried '~~ thinking I wanted to first fully retrieve the symbol and then quote it, not too sure of how to think of former one.

the backtick ` operator will replace symbols with their fully qualified versions:

user> `foo
user/foo

if the symbol can’t be resolved, then it will just use the current namespace

the symbol I was passing was already backticked and resolved

ymmv, but in general, I probably would avoid writing macros that write macros directly

depending on the use case, there’s probably an easier way

also, ~foo gets expanded to (clojure.core/unquote foo) :

> (pr-str (read-string "~+"))
"(clojure.core/unquote +)"

hmm i don’t think there is, the use-case is making it easier to wrap entire react libraries i.e.

(intern-comps `react-native '[View Text Input])

doubling up syntax quote like that is likely not required, and can be confusing

if you already inside a syntax quote, you can usually use a plain quote instead of adding another layer of syntax quoting

ah interesting, so this?

`(defmacro foo []
   '('~sym ~@args))

user=> (eval ``(~@[1 2]))
(1 2)
user=> (eval `'(~@[1 2]))
(1 2)
user=>

thanks, that’s a great tip, the extra backticks get confusing

dunno, I haven't read that much of what you are doing, but with no context my guess would that isn't correct

I know doing macrology with cljs can sometimes require some dark magic, but I’m still not sure why a macro that makes a macro would be necessary. i’m generally curious since it’s not totally implausible and sounds interesting.

usually macros that write macros can be turned into macros that expand into calls to other macros

i can post a link in a bit

obviously, I understand it may be a complete waste of time for you to explain it to me

macros are not composable, so long term it is better to crack open a macro then to build on one. I don't write any cljs, but my general impression is it has a real problem with an abundance of macros

my reasoning for macros writing macros being unnecessary is that I can’t think of a reason why code produced via “macros -> macros -> code” couldnt’ be produced with simply “macros -> code”

cljs can complicate issues compared to clj since macros are only available at compile and manipulation of namepaces/vars programmatically is limited. if you’re trying to target bootstrapped cljs, then things get even more complicated

@smith.adriane yea it’s for cljs so I’m sure that complicates it. here’s the repo (still very much WIP): https://github.com/alidlo/rewrap if there’s a better way of getting to “macros -> code” I’d love to know

you are mixing compile time and runtime state pretty liberally

at compile time/macro expand time the `rr you pass into interop/intern-comps is just a symbol

yes, i do fear that since i’m still new with macros I might be doing that. but I’m not sure i understand the specific issue you mentioned

and you are adding extra quoting to it

in the code itself i resolve the symbol

do you have an example of how you use the interned variables?

you can't pass non-literal arguments to macros

I quote the symbol b/c linter gives “unresolved symbol errors”

so i manually remove quote inside macro, and resolve symbol

maybe bin the linter instead

i use vscode with clj-kondo 😅

so for a macro (and this is extra true for cljs) if have (def x 1) and (some-macro x) the macro never gets 1

when you say (def x <any-expression>) you are defining x to be the result of evaluating the expression

and the result of evaluating the expression doesn't exist until runtime

@smith.adriane yes but example isn’t public rn, I can add one to repo later. but basically you’d use them like regular react components

which in the case of clojurescript, compile time is on the jvm and runtime is on a js vm, so they don't really share anything (they are kind of mixed in clojure)

so the name is interned via createElement ?

yeah, sorry, so in this case I don’t resolve the symbol I just add code for retrieving its component object

but it doesn't exist at macro expand time

so `rr is wrapped in this

(defn js-module* "Macro helper for getting js module, throws error if module does not exist."
       [sym k]
       `(if (goog.object/get ~sym ~k)
          (goog.object/get ~sym ~k)
          (throw (ex-info "Interned component not found" {:sym ~sym :key ~k}))))

@alidcastano for clj-kondo you want to use some configuration for unknown macros. the relevant docs: - https://github.com/borkdude/clj-kondo/blob/master/doc/config.md#lint-a-custom-macro-like-a-built-in-macro - https://github.com/borkdude/clj-kondo/blob/master/doc/config.md#exclude-unresolved-symbols-from-being-reported

thanks @borkdude will take a look. though tbh I didn’t mind manually adding the ' to the symbol

but that was the wrong thing to do

you should not being adding quoting to symbols passed to macros

@alidcastano hiredman is right. if you quote the symbol, the macro will see (quote a) instead of a.

which is why I rather flippantly suggested binning the linter

My clojurescript atom has a vector of words ["one" "word" "two" "blurred"] and i'm wondering why str/join is not making them into one string like I want.

i.e. a list instead of a symbol

because you aren't derefing the atom

@borkdude @hiredman I see, yeah I was incorrectly working around that, i.e. (if (and (seq? x) (= (first x) 'quote)) (second x) x)) , rather than knowing I had to configure the linter. thanks for clarifying that

I have started using clj-kondo a little at work, and I haven't found it to be a radical departure from other linters in that it is 80% keeping stuff tidy and 20% complaining about things that are correct the way they are

and that 20% is rather maddening and causes people to do things like add quoting or just declare the names of locally bound symbols in anaphoric macros

that's why the config exists. all the clojure code bases I've been working on have a fairly minimal config to get that 20% down to 0%

thanks hiredman, I am derefing it with @ though. output: ["はくじょ" "が" "きく"] what i doin: (.log js/console (str/join @stale-stack-jp))

I just strongly suggest you never abandon your own judgment for the linters

yeah, agree. don't follow tools blindly

sova your atom contains an a vector of a vector of strings, not a vector of strings

Ah. Thanks. How can I ensure I'm not appending new vectors?

just don't do it

@alidcastano, going back to your question. I think you want something like:

(defmacro intern-comps [sym tags]
  `(do
     ~@(for [tag tags]
         `(defn ~tag [args#]
            (~'.apply  react/createElement  nil (~'clj->js (into [(~'js-module* ~sym ~tag)] args#)))))))

> (macroexpand-1 '(intern-comps  rn [View]))
(do
 (clojure.core/defn
  View
  [args__106650__auto__]
  (.apply
   react/createElement
   nil
   (clj->js
    (clojure.core/into
     [(js-module* rn View)]
     args__106650__auto__)))))

😅

I was using conj, moving to concat seems to have done the trick

Hello, I've done something stupid and I can't figure it out 🙂

What's the easiest way to convert something like [:S [:ga-jar hakujo] [:verb iku]] to a map with the same keys?

there are three top level forms in there. what would the output be in your mind?

good point, I would like to discard the :S and keep

{:ga-jar "hakujo :verb "iku"}

(into {} (rest c))

that only works with vectors though, not lists

Amazin'!

Hello everyone any easy way to get a random item from a hash-set ?

(first (random-sample 0.5 #{"a" "b" "c" "d" "e"}))

but there is a chance that this returns nothing at all ?

yes...

I would use (rand-nth (vec s)) *edit - changed from seq to vec because the time-complexity of rand-nth is tied to the time-complexity of the collection

I wonder if there's a cheaper way to get an ILookup sequential from a set...

hmmm

seems way way better than what i came up with

in spec, if you use a set as a generator, it will pick a random item, might be worth looking up what it does

(when-not (first (random-sample 0.5 #{"a" "b" "c" "d" "e"})) "c")

ohhh completely forgot the spec way of doing it

damn, thanks

oh yeah you could just use spec and gen directly if you already use those :D

i already used this in my project, but i forgot

I'd like to recursively smash something like [:ga-jar [:no-jar hakujo] [:no-jar gakkou] sensei] to become

[:ga-jar "sensei of the gakkou of the hakujo"] 

@sova a description of the rule might be more helpful than a single example

depending on the rules, you could use reduce on the vector, or (rseq v) to build the string

Cool! Yeah, basically I want to analyze a vector and if it has any collection of subvecs labeled :no-jar I want to read from the end and join them all with "of the" in reverse order.

(->> '[:ga-jar [:no-jar hakujo] [:no-jar gakkou] sensei]
     (rseq)
     (keep (fn [t]
             (when (and (coll? t)
                        (= (first t) :no-jar))
               (second t))))
     (reduce (fn [sb e]
           (.append sb " of the ")
           (.append sb e))
         (StringBuilder.))
     (str))

" of the gakkou of the hakujo" 

it's slightly easier to read if you use str instead of StringBuilder / .append

You're an amazing wizard

not really - the building blocks in clojure are powerful, it just takes some practice to learn them

and in well written code, the blocks and what they each do should be clear

It's really cool, I don't get how it works exactly. When the key is :no-jar, keep the val... and it appends them in reverse order?

rseq is the efficient way to reverse a vector

oh (rseq) does that I presume. Thread-thru..

keep is just like map, but it throws away nils

so it's like map + filter in one

Cool cool. Hmm. This is very good. I have other blocks that may or may not need this logic, I have to figure out how to work this into my rule set

and the reduce call uses the StringBuilder to construct the result as it sees the inputs

sometimes it helps to write them separately and then make the parts that look similar identical, until you find things that can just be merged / reused

@noisesmith Reading the Java docs, StringBuilder can be faster, but from a simplicity standpoint and if performance is not critical, maybe we can just concat strings instead? (str str-1 str-2) etc

@raspasov yeah, that's true, using str does lead to slightly simpler code in the reduce

that part becomes

(reduce (fn [s e]
          (str s " of the " e))
        "")

Yea, either way not a huge difference 🙂 just more of a “pure” Clojure approach

Still need to keep the very last element of the vector

yeah - I literally followed the behavior you described rather than guessing rules to construct your example result

makes sense to add a new conditional to (when ) ?

you might need some sort of polymorphism around the handling of elements - where you need different combining rules / different extraction rules for each one

so instead of using keep before reduce, you'd use a cond or multimethod inside the reducing function to handle each case

and you might also need to keep track of the previous rule / previous token for some rules...

Yeah...

I have some simple rules figured out, but a couple of them can be recursive and it's not clear how to do vector surgery quite yet, but what you have said so far helps quite a bit

one pattern if you always need to see the previous token: (partition 2 1 (cons ::empty coll))

where ::empty could be nil, or any other preferred indicator that there's no "previous" item for that input

neat pattern, not sure what it means

@sova I would say, if an algorithm is becoming too complex, it might be worth re-examining the shape of the data structure you’re dealing with and if there’s a way to structure your data to make your life easier in the first place

There was a quote by someone, not sure who, but basically it said something like “figure out your data structure and then the algorithm is trivial”

that's a good point, I can render it to a nested map structure, but I feel like it's more or less the same acrobatics. Maybe not.

Yea… nested map can probably help… when I start reaching for things like “previous/next” data via (partition … etc) or some sort of reduce, it’s a sign that there’s too much acrobatics 🙂

Hmm. I wonder if the output of instaparse can be flattened rather than nested. If it can be flattened with a rule it would save me a lot of brain.

Right on, yeah it's easier when the drawers are labeled

What does that output look like?

The current output is a nested vector, [:S [:ni-jar gakkou] [:verb iku]] the map output is quite verbose, but it has everything associated perfectly {:content ({:tag :ga-jar, :content (hakujo)} {:tag :wo-jar, :content (kasa)} {:tag :verb, :content (ageru)})} Not sure why it decided to put parens around all the terms...

(those are not identical datas)

parens is probably because it’s a sequence, not a vector

So it's passable to use the vectors for simple stuff, but then I wanted to handle some nested types, which just get smooshed with string concatenation really,

I'm going to politely disagree with @raspasov here. If you want to visit each element of a sequential input in order to build a result, reduce is precisely what you want. If the combining rule is effected by the previous item, you either want to use pairs to track each item's previous, or hold that as part of the accumulated state. Neither of these are signs of problems.

@noisesmith fair 🙂 I won’t disagree; it was more of a general observation; I don’t have a full grasp of the data shape/problem we’re dealing with here

Here's a concrete example

input: [:S [:ga-jar [:no-jar gakkou] [:no-jar sensei] hanashi] [:verb sabishii]] desired result: [:S [:ga-jar "hanashi of the sensei of the gakkou"] [:verb "sabishii"]]

@sova can you paste an example of where we won’t be doing the transformation? Or we always have the :no-jar tag?

no transform required: [:S [:ga-jar hakujo] [:ni-jar sensei] [:wo-jar question] [:verb kiku]]

;transform
[:S 
 [:ga-jar [:no-jar gakkou] [:no-jar sensei] hanashi]
 [:verb sabishii]]
;no transform
[:S 
 [:ga-jar hakujo] 
 [:ni-jar sensei] 
 [:wo-jar question] 
 [:verb kiku]]

Is that correct?

(split by line so it’s easier to look at)

yep exactly

Essentially any vector that has more than two elements [:key and val] needs to be smashed to have just key and val.

smash = reduce?

It's a fun puzzle. Recursive ish

And they can be arbitrarily nested ?

Or that’s the deepest they go?

that is actually the deepest they go.

Ok

there could be many [:no-jar vecs] but all that depth