do people use edn as a configuration format? How’s that working out? It seems like clojure-the-language really wants me to use namespaced keywords, but that seems very verbose when using EDN since it doesn’t seem to have ns aliases

@noisesmith yeah I guess. That seems iffier than writing the real transducer though 😕

kinda noob here, but I just typed in a function into the repl. How do I print the function back out as source code? I tried (clojure.repl/source myfun) but “Source not found”

the source function only works for code that came from a file

it's really too bad

We have source for REPL-entered defs working in Lumo, Planck, and Replete—it seems like a reasonable and useful thing to have.

@lvh, I've use EDN (without namespaced keywords) for config for years in various projects and it has worked well, I do recommend it.

Not sure if Clojure in general pushes for namespaced keywords, but clojure.spec does. I like the idea in principle, but haven't used it much in practice. My config-validation specs use (s/keys :req-un [...])…

for namespaced keywords, shouldn't having a namespace alias in effect apply it to an edn file you read?

hi guys, can cljfmt rewrite one line if to 3 lines:

(if true true false) to
(if true 
  true
  false)

@nxqd: no, because both are equally valid from cljfmt’s POV. zprint might be able to, though.

@weavejester thanks for the info. I will check zprint.

is there any best practice for noting something is an element of a collection? (map (fn [fluffy-cow] (fiddle fluffy-cow) fluffy-cows) or is just dropping the “s” the convention?

I was thinking perhaps (map (fn [a-fluffy-cow] (…)) fluffy-cows)

or (map (fn [single-fluffy-cow] (…)) fluffy-cows)

I think it should be obvious, at least in the map example

@tatut thanks

Still, I do tend to do the singular/plural thing when naming: (map (fn [row] ...) rows) and so on

Just found this gem: http://tonsky.me/blog/readable-clojure/

some of the advices there are quite questionable

;;  import static jcuda.jcudnn.JCudnn.cudnnConvolutionForward;
  ;;  import static jcuda.jcudnn.JCudnn.cudnnCreate;
  ;;  import static jcuda.jcudnn.JCudnn.cudnnCreateConvolutionDescriptor;
  ;;  import static jcuda.jcudnn.JCudnn.cudnnCreateFilterDescriptor;
  ;;  import static jcuda.jcudnn.JCudnn.cudnnCreateLRNDescriptor;
  ;;  import static jcuda.jcudnn.JCudnn.cudnnCreatePoolingDescriptor;

Is there a rule-of-thumb on "when to use qualified keywords in domain data structures?" E.g. datomic's tx-report has unqualified keys, like :db-before, even though tx-report is not a data structure internal to datomic – it is used all over the client apps.

e.g. (defn f [the-foo] (let [foo (munge the-foo)]...)) "the-" always tells me i'm dealing with an arg, not something letted or a global.

thank you all for being such a wonderful community ❤️

question about recur & co, I wrote the following algorithm to fill in an image with a certain colour (inspired loosely on https://en.wikipedia.org/wiki/Flood_fill )

(defn fill-coordinates
  "Recursive function that generates all the coordinates
  which need to be filled in with the new colour.
  It's inspired by the flood-fill algorithm, but had to be
  heavily modified since there is no mutation here."

  ([img coord old-colour new-colour coords]
   (if (or (= new-colour old-colour)
           ;; when outside of the range no need for the extra check
           (not (valid-coord? coord img)))
     coords
     (if (or
          (contains? coords coord)
          (not= (get-in img coord) old-colour))
       coords
       (letfn [(rec-call [direction filled-coords]
                 (fill-coordinates img (move direction coord) old-colour new-colour filled-coords))]

         (let [c-incl (union coords #{coord})
               c-north (rec-call :north c-incl)
               c-east (rec-call :east c-north)
               c-south (rec-call :south c-east)]

           (rec-call :west c-south))))))

  ([img coord new-colour]
   (let [old-colour (get-in img coord)]
     (fill-coordinates img coord old-colour new-colour #{}))))

now the problem is that on big images I get a stack overflow

but I don't think I can actually use recur in this case right?

I was trying to avoid in place mutation, and I also have a letfn there for convenience

recur doesn't like leftn as point to jump to, but more importantly I'm not sure this is tail recursive or could be written as such

wait, why can't you recur inside a letfn? - if you mean jumping from tail of one function to another function, check out trampoline

trampoline is another way to avoid growing stack

(without being limited to self calls)

I meant that if I just do a recur it will fail saying it's expecting 5 arguments instead of 2, so it's trying to call the outer function I guess

you can only recur into the same function - a recur to a letfn bound function must be done inside that function

and well these are all self calls in a way, even if there is a chain of them

(let [c-incl (union coords #{coord})
               c-north (rec-call :north c-incl)
               c-east (rec-call :east c-north)
               c-south (rec-call :south c-east)]

           (rec-call :west c-south)))))

and you can only recur to the same arity

ahh ok sorry I understood now

ok I can try

(defn map<-lst [f lst]
  (into {} (map (fn [e] [(f e) e]) lst)))

move a paren so it uses a transducer

(defn map<-lst [f lst]
  (into {} (map (fn [e] [(f e) e])) lst))

how would it look ?

lol

one paren moves from being after lst to being after the fn arg to map

I was expecting the (fn [e] [(f e) e]) which looks ugly, to be simplified

oh!

(juxt f identity) ?

not sure that's much prettier

(defn map<-lst [f lst]
  (into {} (map (juxt f identity)) lst))

hmm, I was hoping for #[(f %) %] but I can't do that

isn't that like a scanl

from haskell

like take 2 scanl

not really - there's no accumulated result over args

(not in the way scanl does that is - of course it's all accumulated into a hash-map)

there's always #(identity [(f %) %])

Or #(do [(f %) %]), which some might consider uglier

that's a lot worse than (juxt f identity)

huh

(defn v [& args] (into [] args)) #(v (f %) %) 🙂

I was surprised juxt returned a vector

v is a poor performing version of vector