How can you map values of the dictionary/map

map key-value pairs then into {}

Specter can help in these cases

user> (use 'com.rpl.specter)
user> (transform [MAP-VALS MAP-VALS]
              inc
              {:a {:aa 1} :b {:ba -1 :bb 2}})
{:a {:aa 2}, :b {:ba 0, :bb 3}}

any function in order to return first that satisfies the predicate

like (first pos? [-1 -2 3])

@denisgrebennicov use some like this (some #(when (pos? %) %) [-1 2 -3])

Hey everyone. I'm doing some coding games right now, wondering if there any other/better way of writing this? https://www.pastery.net/tcyjda/

players attack each other until hp of either one reaches 0, then it returns the winner and the rounds it took

I was recently wondering, does anyone have any cool examples of Clojure Vs. Other Language, where the clojure code is much shorter/impressive due to its paradigms?

@coinedtalk I like this one: Java: https://github.com/stuarthalloway/programming-clojure/blob/master/data/snippets/isBlank.java Clojure: https://github.com/stuarthalloway/programming-clojure/blob/192e2f28d797fd70e50778aabd031b3ff55bd2b9/src/examples/introduction.clj#L4-L5

thanks 🙂

I'm having a really weird issue

(defn generate-monster [xmax ymax]
  (Zombie. (rand-int xmax) (rand-int xmax)))

(def monsters (atom [(generate-monster 10 10) (generate-monster 10 10) (generate-monster 10 10)]))

@coinedtalk (repeatedly 3 #(generate-monster 10 10)) fails?

IllegalArgumentException No implementation of method: :move of protocol: #'myapp.core/Monster

yep

ah,, (into [] (repeatedly 3

has to be a vector(?)

That’s news to me in that case. I don’t know why wrapping it in into should make any difference. If the inner form, (repeatedly…) fails, it should fail before into even gets its hands on it.

The :move thing sounds like it has something to do with the protocol implementation, rather. Seeing as generate-monster has randoms in it, maybe it has something to do with you randomly hitting OK ints?

OK ints, like True?

More like, is 0 an acceptable input?

I'm going to put up a sample soon of adding persistent cookies to javafx webview in clojure vs the equivalent in java, it's about a twentieth the size of sloc

Rosetta code is great for language to language samples, but it's hard to beat J in most listings

When I add a new dependency to project.clj what should I do for the REPL to pick it up? (proto-repl in this case)

i did lein deps but my project can't find cheshire

@gold88 usually you have to restart the REPL entirely to pick up a new dep

could also take a look at https://github.com/pallet/alembic, which claims to load new deps without killing the REPL

If you wanted to use emacs, https://github.com/clojure-emacs/clj-refactor.el can also hot-reload dependencies

I did a noobie mistake and had an invalid require in another file

that kind of led to proto-repl refusing to reload deps in my other file

works now

as params

whats the difference between [method path & [opts]] and [method path & opts]

i know that & means all following params are to be known as opts

i think the first example destructures something?

(def foo [method path & [opts]] opts)
(foo 1 2 3 4 5 6) => 3

(def foo [method path & opts] opts)
(foo 1 2 3 4 5 6) => [3 4 5 6]

The [...] decstructures the vector of additional arguments

for example, if you have parameters such as [[a]] and pass a vector to the function, then a == the first element of the vector

i feel stupid for not writing it out on my repl 😞 sorry @trailcapital

so this is basically making the third parameter optional and discarding any additional

makes sense because the third parameter is a map to configure the request

yep!

You'll also see things like multi-arity functions to make things optional.

(defn foo
  ([x]
   (foo x nil))
  ([x y]
   [x y]))

(foo 1) => [1 nil]
(foo 1 2) => [1 2]

I see, so calling it with one param results in another call so I have two function calls

yep!

are there big advantages between multi-arity functions compared to var-arg ones?

you can have as many multi-arity ones as you like but only one varargs

does that ever come up in practice? In Python/JS, I don’t think I’ve ever come across a case where a function def needed to be way different at 2 args vs 3 vs N

It could be useful in cases where you want the optional param to be in a non-last position. Imagine you're making a function that accepts a docstring in the same way defn does...

(defn foo
  ([a c]
   (foo a "default" c))
  ([a b c]
   (foo a b c)))

maybe you want a function that accepts only 2, 4, or 6 params - but not 1, 3, or 5

(defn foo
  ([a b]
   (foo a b nil nil nil nil))
  ([a b c d]
   (foo a b c d nil nil))
  ([a b c d e f]
   ...)))