(reduce #(or %1 %2) true bools)

just don't put true for the init value...

yeah I know I can make an anon fn, the question is if something like this already exists in core

not that I know of

(some true? ...) maybe? but unlike reduce it will give you nil in case of all false

Btw, there is (some-fn true?) that acts that way, but I find #(or %1 %2) better at communicating the intent, so I guess I’ll stick to that

Could also do either (some identity bools) or (some true? bools), it returns nil if all are false, but has the benefit of early termination.

my real context was (update acc :bool-field or another-bool) , so there was no coll of bools, that was an example…

$ clj
Clojure 1.11.1
user=> (def foo:bar 5)
#'user/foo:bar
user=> foo:bar
5
user=> (def baz::qux 10)
Syntax error reading source at (REPL:3:14).
Invalid token: baz::qux
10
Syntax error reading source at (REPL:3:18).
Unmatched delimiter: )
user=>

The error is pretty clear, no? From https://clojure.org/reference/reader#_symbols: > • Symbols beginning or ending with ':' are reserved by Clojure. A symbol can contain one or more non-repeating ':'s.

Context: I've been using single colons as a light-weight grouping prefix, e.g. widget:foo and widget:bar. In the context of debugging clojure-mode's failure to syntax-highlight this correctly (https://github.com/clojure-emacs/clojure-mode/issues/653), I ran into this.

@U2FRKM4TW the section you quote suggests that the syntax error is a bug, no?

D'oh

Misread

thanks

No need to remove the original message though. It just creates clutter since the thread is still there.

my bad

You can write a macro that rewrites the initial form.

For sure. Wondering if one like it already exists. :)

I just had to

(defmacro debug
  [body]
  (if (seq? body)
    `(list '~(first body) ~@(rest body))
    body))
#'user/debug
(debug (println (+ 1 2) (- 2 1)))
(println 3 1)

(defmacro dry-run
    [[f & b :as body] & _]
    `(log/infof "Would execute ‘%s’"
                (list (quote ~f) ~@b)))

@UAEH11THP Thanks! Yours looks more robust. :)

it's the same as yours haha (other than the consideration "what if body is a plain value") mine still breaks probably if it's used on a macro (like (debug (-> foo (bar 1) (baz 2))) )

Yeah. I imagine that something that would be truly robust here would actually be a bit difficult.

hmm if only macros then

(defmacro debug
  [body]
  (if (seq? body)
    `(if (not (:macro (meta (var ~(first body)))))
       (list '~(first body) ~@(rest body))
       ~body)
    body))

My feeling is whilst it's possible (after all, it's just k/v pairs on the response), the browser's behaviour might make it indeterminate

if you have Set-Cookie: foo=bar;foo=baz then it might be interesting to see if the browser accepts that and what happens when it sends it back to the server.

https://httpwg.org/specs/rfc6265.html#sane-set-cookie > If the user agent receives a new cookie with the same cookie-name, domain-value, and path-value as a cookie that it has already stored, the existing cookie is evicted and replaced with the new cookie.

You would be breaking the specs 'tho

> Although cookies are serialized linearly in the Cookie header, servers SHOULD NOT rely upon the serialization order. In particular, if the Cookie header contains two cookies with the same name (e.g., that were set with different Path or Domain attributes), servers SHOULD NOT rely upon the order in which these cookies appear in the header.

` Servers SHOULD NOT include more than one Set-Cookie header field in the same response with the same cookie-name. (See Section 5.2 for how user agents handle this case.)`

Interesting stuff

I know with a Set-Cookie header there is defined behavior, i'm thinking of the Cookie header

>> e.g., that were set with different Path or Domain attributes >

so it sounds like you can make a browser send 2 values for the same cookie?

https://github.com/clojure/data.json/blob/master/src/test/clojure/clojure/data/json_test.clj#L128-L141

not identity but something similar to (fn foo [k v] foo)

makes sense now, thanks. seems like a bit of a strange choice on implementation though.

this is the way to effectively remove some properties from output

it’s a clever way to indicate “omit this” without a sigil that could be a valid object in json

(if-not (= value-fn out-value)
  (assoc! result key out-value)
  result)

it’s an unambiguous object in memory available to both the value-fn definition and the calling code

kind of a hack but clever

Definitely too clever for my very smooth brain. I understand now with the examples provided, though, thanks @U11BV7MTK

wow, I didn't know it had that knob

it's actually a common pattern for "impossible" values

promise uses a CountDownLatch for coordination and an atom for the result, the atom's initial value is the CountDownLatch

verbs are good. noun may be implied by the arg name and/or namespace context so might not even be necessary. "correct" seems like it doesn't say much about what is being corrected or what a correction would be, so if there's something more specific, I'd try to use more specific words ("staging" seems like an important word here for example)

Zach Tellman's "Elements of Clojure" book has a lot of good advice on naming https://elementsofclojure.com/

And the community style guide has a big section on naming things https://guide.clojure.style/#naming

Awesome, thanks!