thanks!

This article says it's pretty safe to upgrade: https://aws.amazon.com/blogs/developer/aws-sdk-for-java-version-1-12/

(alter-var-root! #'v memoize)

sans potential syntax errors

or just (def f (memoize f))

as a side note, I have a personal rule to always write a comment describing why this particular memoized case will not have unbounded memory growth... just to be careful with it

@UK0810AQ2 Thanks. @U11SJ6Q0K The problem with doing def and returning a function is that it breaks statical analysis, e.g. in Cursive.

@U11SJ6Q0K And I do have a note, although that note is about using core.memoize instead, precisely to limit memory use. It is not relevant for now 🙂

Make that function a component, problem solved 🙂

Note that you can also memoize a function while defining it

Which is useful for recursion. The classic case being fibonacci:

(def fib (memoize (fn [n] (if (< n 2) 1 (+ (fib (dec n)) (fib (- n 2)))))))

Also… I almost never use memoize in production code due to memory use. I’m all about core.cache

I just referred to this because “one-liner” was mentioned 🙂

"in-liner"

@U051N6TTC Also breaks static analysis. The alter-var-root trick is the best if you want Cursive to know that it’s dealing with a function. Just a shame it doesn’t work in CLJS.

Sorry, I have no idea what static analysis does here, nor what it provides, as I’ve never used Cursive. I was responding to the one-liner part

Everything is in line 8,

When you also add %file, you will likely see that all messages seem to origin from the same clojure file (depending on how you log to Logback). I think Clojure does not support exposing line numbers to the logging framework.

How are you using Logback? Through clojure.tools.logging?

Yes.

Then you will not receive meaningful filenames or line numbers in your log.

@U031CHTGX1T How do you bypass this? With (:line (meta &form)) in a macro?

Not sure how this is transported, sorry

filterv, into with a filter transducer, cond-> with assoc or conj.

(cond-> [:a] true (conj :b))
(cond-> {:a 1} true (assoc :b 2))

what does "conditional vectors & hash-maps" mean?

When trying to conditionally insert data into them

Note that, unlike cond branching, cond-> threading does
not short circuit after the first true test expression.

then, as already mentioned here, there is a spectrum of conditional functions in clojure. like cond->

I've had a colleague argue for using splice-unquoting:

`[1 2 ~@(when foo [3])]

concat and merge

(except concat doesn’t return a vector)

(concat [:a] (when true [:b]))

(merge {:a 1} (when true {:b 2}))

(defn bar [foo]
  `[1 2 ~@(when foo [3])])

(defn bar' [foo]
  (cond-> [1 2]
    foo (conj 3)))

(time
 (dotimes [_ 10000]
   (bar true)))
;; => 23.4ms

(time
 (dotimes [_ 10000]
   (bar' true)))
;; => 1.5ms

I think the merge\concat approach is my favorite so far, I like the way it makes the intention really clear. Also like the splice approach, that's pretty concise!

cond-> works too, didn't consider that one but feels like too much given each pair would have a consistent operation so specifying it each time here is not ideal to me

You can easily write your own macro around cond-> , something like cond->conj or cond->assoc - it would be the most terse and, given a proper name, the most clear.

(concat []
           (if meeting-url
             [(b/text {:href meeting-url} "☎")]
             [(b/text {} ":no_mobile_phones:")])
           [(b/text "\t")
            (b/text
             (str (date/time time-zone start)
                  " - "
                  (date/time time-zone end)
                  " "
                  summary))])

But in this case, your whole block could be replaced with:

[(if meeting-url
   (b/text {:href meeting-url} "☎")
   (b/text {} ":no_mobile_phones:"))
 (b/text "\t")
 (b/text
   (str (date/time time-zone start)
        " - "
        (date/time time-zone end)
        " "
        summary))]

That's true, but still trying out the content formatting

I'm not talking about formatting here but rather about the lack of need for concat and that [], along with [] within if. You can make do with a single vector in this particular case.

Right, I understand

I'm just saying I'm not 100% on what I want this program to do so the flexibility is useful for now, if it doesn't change will probably optimize it

tangential note, into if you will :) https://stuartsierra.com/2015/04/26/clojure-donts-concat

the real lesson of that article is: don’t mix concat with recursion

He alludes to it later: “don’t mix lazy and eager evaluation.”

recursion is eager

I also take it as "distinguish between seq and coll fns" often people will use a seq fn whereas a coll one performs better and has no big difference

Yeah unfort there’s no eager version of concat. (varargs, nil punning)

(vec (concat …)) is sufficient tho

(defn concatv [& args]
  (reduce into [] args))

yeah, put it in core, and I’m down to use it 😄

til then, concat w/o recursion is the biz

(Honestly, I use merge nil-punning way more than concat anyways. It’s fairly uncommon to have conditional concating.)

(conj {} [:a 1]) ;;=> {:a 1} could help

A slightly different question, but the answers might be relevant: https://clojurians.slack.com/archives/C03S1KBA2/p1644497018889889

Alternatively, you can just walk the resulting data structure in any way you want and replace all map with sorted ones, and then pprint it - all via built-in means.

hm yeah, i'll have to check that out

walk is a little more annoying than i'd hoped would exist, but i'll figure something out

walk will be much less annoying than anything else that doesn't provide a one-line argument like :map-factory sorted-map. :)

hah right, which is what i was hoping for

(require '[clojure.walk :as walk])

(defn deep-order-maps [v]
  (walk/postwalk (fn [x]
                   (cond->> x
                     (map? x) (into (sorted-map))))
                 v))

found the solution for my purposes: (into (sorted-map) existing-map) will decode into a sorted json object using cheshire/generate-string

oh excellent, that's even better cuz it's recursive

Officially over-engineered https://replit.com/@eccentric-j/conversion-v2#main.clj now but it was fun and learned a bit more about the differenced between symbols and vars. If anyone also finds it kind of fun to solve these trivial problems I'd be interested to see what people come up with!

The first arg is for the recursive call. You can add another arity that would call the 2-arity with [] as the first argument.

it builds the path as it descends

There's also a bug in there where it loses k in the false branch. Here's a fixed and formatted version:

(defn f
  ([m]
   (f [] m))
  ([p m]
   (for [[k v] m
         i (if (map? v)
             (f (conj p k) v)
             [(conj p k v)])]
     i)))

the other option is to build the path on the way up, but building on the way down means all the paths start from the same immutable vector, which means they can share structure

Ohhh, okay. Sorry, folks :man-facepalming: Thanks a lot, amazing 💯