Is there a widely-used, well-documented library for implementing role-based access control in Clojure? I imagine it's often pretty domain-specific and mostly just simple checks on maps/sets etc., but wanted to see if there was something nice out there.

I'm trying to attach some metadata to a defed fn inside of a macro, but nothing quite seems to stick:

(let [doc "docs"
        meta {:arglists '([test])}]
    `(def ^~meta foo ~doc (fn [x] 1)))
;; => error: Metadata must be Symbol,Keyword,String or Map

But when I check, it says it's a map:

(let [meta {:arglists '([test])}]
    `[~(type meta)])
;;=>  [clojure.lang.PersistentArrayMap]

Am I just barking up the wrong tree here?

try: ~(with-meta 'foo meta)

I think it's trying to apply the metadata '~ to the symbol meta in your example

> (defmacro test-fn-meta []
  `(def ~(with-meta 'foo {:a 1}) (fn [])))
> (test-fn-meta)
#'my.ns/foo
> (meta #'foo)
{:a 1,
 :line 929,
 :column 18,
 :file "*cider-repl examples/browser:localhost:49996(clj)*",
 :name foo,
}

ah, that makes perfect sense. I'm adding the meta to the var, I had tried wrapping the fn before but that obviously doesn't do what I'm aiming for

as an improvement, defn allows an optional map between the name and params that will be added to the metadata:

(defmacro test-fn-meta []
  `(defn ~'foo ~{:a 1} [x] 1))

I had tried that, but in my (brief) test I couldn't override the :arglists, it just used the ones from the actual arg vector

let me try with this method, though

ah, that works!

nice

ok, I got everything working the way I wanted in clj, but when I tried using it in cljs I found a weird behavior with arglists:

(defn bar {:b 2 :arglists '([damned lies])}
  [x] 1)
(meta #'bar)
;;=> {:ns user, :name bar, :file "user/main.cljs", :end-column 10, :source "bar", :column 1, :line 1, :b 2, :end-line 1, :arglists ([damned lies]), :doc nil, :test nil}
;; this is just like clj^

(defn foo {:a 1 :arglists '([lies])}
  ([x] 1)
  ([x y] 2))
(meta #'foo)
;;=> {:ns user, :name foo, :file "user/main.cljs", :end-column 10, :top-fn {:variadic? false, :fixed-arity 2, :max-fixed-arity 2, :method-params [[x] [x y]], :arglists ([x] [x y]), :arglists-meta (nil nil)}, :source "foo", :column 1, :line 1, :end-line 1, :arglists ([x] [x y]), :doc "docs", :test nil, :a 1}

It looks like multi-arity functions will override the :arglists supplied in the metadata with the ones it figures out on its own

I'm up way too late, so I'll check in later, but this seems weird to me

b-+

There's no function to quickly check if a collection has duplicates, is there?

frequencies?

(apply distinct? [1 2 3 4 2])
=> false
(apply distinct? [1 2 3 4])
=> true

How can I split a string by (char 1)

;;; works, is there a better way?
(vec (.split (str "asdf" (char 1) "asdf") (str (char 1))))

;;; these don't work
(str/split (str "asdf" (char 1) "asdf")
  #"\u00001"
  ;;#"[\\1]"
  ;;#"\\x01"
  )

(let [s "asdf"] (str/split s (re-pattern (str (char 1)))))

if i understand what you're after

I get the same result for these two subexpressions. You do not?

user=> (= (vec (.split s1 (str (char 1)))) (str/split s1 #"\u0001"))

And in fact, for your first and third options that you say didn't work for you:

user=> (require '[clojure.string :as str])
nil
user=> (def s1 (str "asdf" (char 1) "asdf"))
user=> (def a1 (vec (.split s1 (str (char 1)))))
#'user/a1
user=> (def a2 (str/split s1 #"\u0001"))
#'user/a2
user=> (def a3 (str/split s1 #"\x01"))
#'user/a3
user=> (= a1 a2 a3)
true

ohh I had an extra 0 in the \u0001 str, that one works for me

(Note that inside a Clojure string surrounded by "", you need to type \\ to get a single backslash. Inside of #"" you only need to type one backslash to get one backslash in the regex string -- the Clojure reader parses regex strings slightly differently than regular strings, as a convenience to avoid having to type so many double backslashes)

Oh yeah \x01 does work with the single backslash

but that can lead to more confusion if you weren't aware of it (and I just double-checked -- this fact is documented in official docs here if you search for regex: https://clojure.org/reference/reader)

if you have a function that will end up reifying a java.util.Comparator, do you ask the caller to supply a function satisfying the <0,0,>0 contract that a comparator expects and reify it inside the function or do you have the caller just pass you a java.util.Comparator and not worry about it since its clear at the call site that you have that contract?

i guess, do you make everyone go through the ceremony of reify'ing or take a function and do the reify in one spot for conveinece to the caller

functions are Comparators

user=> (instance? java.util.Comparator (fn []))
true
user=>

https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/AFunction.java#L50

oh get out of town. awesome

https://clojure.org/guides/comparators for 10x more detail

What Java version do folks recommend or are using for prod? We're looking to upgrade from Java 8 but aren't sure how high is safe to go. Obviously we'll test things out well before we ship, just looking for a recommendation on a target.

What's the simplest way to get edn/read-string to throw or some other way to validate if the EDN file contains a valid data-structure but atfer it has junk?

config.edn:

{:a 1
 :b 2}
 :c 3}