Clojurians Log v2

No, it’s something weirder than that:

(prn (first (errors-from (:new (second errors)))))
{:unexpected :except, :expected #{":only" ":rename" ":exclude" :eof}}
=> nil
(prn {:unexpected :except, :expected #{":only" ":rename" ":exclude" :eof}})
{:unexpected :except, :expected #{":only" ":rename" ":exclude" :eof}}
=> nil
(contains? common-errors (first (errors-from (:new (second errors)))))
=> false
(= {:unexpected :except, :expected #{":only" ":rename" ":exclude" :eof}} (first (errors-from (:new (second errors)))))
=> false

Arg, one of those keywords is an AST class which prints as the actual keyword:

(->> (tree-seq #(or (sequential? %) (map? %)) identity (first (errors-from (:new (second errors)))))
       (mapv #(vector % (class %))))
=>
[[{:unexpected :except, :expected #{":only" ":rename" ":exclude" :eof}} clojure.lang.PersistentArrayMap]
 [[:unexpected :except] clojure.lang.MapEntry]
 [:unexpected clojure.lang.Keyword]
 [:except cursive.psi.impl.ClEditorKeyword]
 [[:expected #{":only" ":rename" ":exclude" :eof}] clojure.lang.MapEntry]
 [:expected clojure.lang.Keyword]
 [#{":only" ":rename" ":exclude" :eof} clojure.lang.PersistentHashSet]]

That would do it 🙂

They don’t normally do that but I defined a print-method for them for some testing a while back.

it was tricky printing like I thought!

Indeed it was!

Are there any tools/libraries that help moving/renaming namespaces in bulk, including references? I found clojure.tools.namespace.move but I'm wondering if anything better has come along since, since it just does a naive regex replace

A little something about protocols: My first question is: is this the correct way to type-hint the return type of a fn in a protocol?:

(defprotocol Foo
  (^String foo [this]))

;; foo should be typehinted to return a String

(defprotocol Bar
  (^String bar
    [this]
    [this that]))

(gen-interface
    :name
    typehints.protocols.Foo
    :methods
    ([foo [] Object]))

I have to go but I may write more in a bit when I'm back, hope that helps at least

It does, thanks!

Hey folks, how can I use interleave such that lists of different lengths zip with nil? e.g. (partition 2 (interleave [1 2 3] [4 5])) => ((1 4) (2 5) (3 nil))

oops, fixed

Hello folks 😄 Does anyone happen to have worked with .HAR files in Clojure? is there any libraries ready to use? I haven't found any

I wrote my one version of interleave)

(defn exhaustive-interleave
  "Same as clojure.core/interleave but continue until any input is not empty"
  {:added "1.0"
   :static true}
  ([] ())
  ([c1] (lazy-seq c1))
  ([c1 c2]
   (lazy-seq
    (let [s1 (seq c1) s2 (seq c2)]
      (when (or s1 s2)
        (cons (first s1) (cons (first s2)
                               (exhaustive-interleave (rest s1) (rest s2))))))))
  ([c1 c2 & colls]
   (lazy-seq
    (let [ss (map seq (conj colls c2 c1))]
      (when (some identity ss)
        (concat (map first ss) (apply exhaustive-interleave (map rest ss))))))))

Do you mean this one? https://en.wikipedia.org/wiki/HAR_(file_format)

yes

technically it's just a JSON 😅 but i wonder if there's anything beyond only parsing it as JSON

When I read the spec correctly, it is json based. If that’s the case, you could process with e.g. cheshire

Ah, now I get you. What things beyond parsing do you have in mind?

🤘 thanks

here's a one-liner that does the zip: (defn zip [[a & as] [b & bs]] (lazy-seq (cons [a b] (when (some seq [as bs]) (zip as bs)))))

Honestly i don't know, but if anyone made anything i'd like to check it out before reinventing the wheel

maybe i'll find out while building my solution 😄

(concat shorter-end (repeat nil)) then interleave as normal

Do you miss Leiningen templates when using cli-tools?

If you do full-stack development do you make it one big project (backend+frontend) or separate them?

you can still use leiningen templates with the cli tools with clj-new

@gr.evocatus https://github.com/seancorfield/clj-new is what Alex is referring to. See a list of CLI tools here https://github.com/clojure/tools.deps.alpha/wiki/Tools

(cond-> {:foo "foo"}
        true (assoc :bar "bar")
        true (update :foo str "123")
        some-bool? (assoc :baz "baz"))

mix -> and cond->

(-> {:foo "foo"}
    (assoc :bar "bar")
    (update :foo str "123")
    (cond-> some-bool? (assoc :baz "baz"))

Does that play nicely with multiple conditions? e.g:

(cond-> {:foo "foo"}
        true (assoc :bar "bar")
        true (update :foo str "123")
        some-bool? (assoc :baz "baz")
        some-other-bool? (assoc :quux "quux"))

I guess I'd end up with:

(-> {:foo "foo"}
    (assoc :bar "bar")
    (update :foo str "123")
    (cond-> some-bool? (assoc :baz "baz")
            some-other-bool? (assoc :quux "quux")))

Looks good to me! Thanks @ghadi

np. @curlyfry a little of that can go a long way

Could also do this:

(cond-> {:foo "foo123" :bar "bar"}
        some-bool? (assoc :baz "baz"))

Without more context on how dynamic you need it to be, I’m not sure. But the general principle holds that anything in a static true section should be moveable into the initial map.

@curlyfry alternatively merge:

(merge {:foo "foo"}
       {:bar "bar"
        :foo "123"}
       (when some-bool?
         {:baz "baz"})
       (when some-other-bool?
         {:quux "quux"}))

Requires that you explicitly get update values, but it’s extremely straightforward:

(let [{foo :foo} mah-map]
  (merge {:bar "bar"
          :foo (str foo "123")}
         (when some-bool?
           {:baz "baz"})
         (when some-other-bool?
           {:quux "quux"})))