Is there a way to "arrange" the order of a key in a hash-map? I'm building a service which returns JSON, and I want to have control on which field gets displayed first in the JSON (e.g. I don't want the "id" and "type" field to be hidden somewhere in the middle of a dense object).

Will creating a type/record do the trick?

The order of the key in JSON will likely depend on which library you are using to encode it from Clojure. You might get away with using a sorted-map

I'm using ring-json, which uses cheshire

You might be able to get away with something like this:

(into (array-map :id 17 :type "some-type")
      {:an "unordered" :map "to dump in"})

Well, I guess I'll stick to the randomness then. I'm not going to convolute my function with that. I appreciate your inputs though @noonian

@hawari.rahman17 if you use Jsonista (or something else that allows access to the underlying Jackson stuff), you can use Jackson to do this:

(ns foo
  (:require [jsonista.core :as json]
  (:import [com.fasterxml.jackson.core JsonGenerator]
           [com.fasterxml.jackson.databind SerializationFeature]

(def object-mapper
  (doto
    (json/object-mapper)
    (.configure SerializationFeature/ORDER_MAP_ENTRIES_BY_KEYS true)

(defn encode [event]
  (json/write-value-as-string event object-mapper))

although, I just realized that you want them sorted in a custom order, not alphabetically... my bad

CLJS related question

Can anyone tell me why this fails trying to call on null

(defn Get [url fun] (req/get url #((fun %2))))

while this just works fine ?

(defn Get [url fun] (req/get url fun))

Hi guys! How can I update a value inside a atom vector of maps? For example:

(def var (atom [{:a 1 :b 2} {:a 2 :b 2}]

u can use update-in or assoc-in

Is there a way to destructure varargs on type? This works but seems unreadable:

(defn myfun
 [x y & args]
 (let [tooltip (some #(when (string? %) %)
                     args)
       mykey   (or (some #(when (keyword? %) %)
                         args)
                   :default)]
   (do- stuff)))

@magra Hrm. If that last argument were instead a map, you could use map destructuring to pull out what you want. It seems tricker to algorithmically cope with a list of typed args...

I guess you could have a string or keyword anywhere in that list.

@mfikes Maybe I will just write a function like string? that returns the string instead of boolean.

like get-first-string.

It would not be destructuring but readable.

Yeah, you could then use juxt to destructure as in

(let [[tooltip mykey] ((juxt first-string first-keyword) args)]
   ...

But, to be honest, I would just let tooltip and mykey

(get-first seq string? :default)

Thanks!!!

Yeah, that looks better

Make a reusable little fn

Why does the first example here work and the second one not?

(defn sitemap
  [url]
  (def host (get (liburl/url url) :host))
  (def anchors (-> url
                   client/get :body
                   hickory/parse hickory/as-hickory
                   ((partial select/select (select/tag :a)))))
  (map :attrs anchors))

(defn sitemap
  [url]
  (def host (get (liburl/url url) :host))
  (def anchors (-> url
                   client/get :body
                   hickory/parse hickory/as-hickory
                   ((partial select/select (select/tag :a)))
                   (map :attrs)))
  anchors)

Generally, you should never use def inside a defn - those create global vars with scope beyond the function

use let instead

oops, that's good to know. Thanks!

on the second one not working, you’re using -> which is thread-first

so it will effectively do (map anchors :attrs)

ah

in this case if all the other functions are single arg, you can just switch to ->>

Supposing they weren't, how do I get around this? define a lambda that calls map with the args reversed or a partial function using map?

I probably just wouldn’t use a thread macro to combine those two sets of calls

you could use a thread-last at the end of the thread-first (-> url client/get ... (->> (map :attrs)))

I find mixing them is generally harder to read than not using them at all

though it’s not the most elegant approach

and as-> can be used in some cases

I think this function might be guilty of doing too much

-> works best on a series of functions that take and return collections (maps, vectors, etc) - functions like conj, merge, assoc, etc

->> works best on a series of functions that take and return sequences - functions like filter, map, reduce, etc

b/c all collection functions take the collection first and all sequence functions take the sequence last

I think the scope of your function is fine

just use let bindings to structure things rather than trying to force it all into a thread-first macro?

yeah

I find the ((partial select/select (select/tag :a))) hard to read too and maybe not worth including in that threaded expr

👋

Yeah I think pulling it apart some would help. Thanks for your time and expertise

can a defmethod be dispatched based on matching one of N values? i have a mutimethod that dispatches on a map key that represents a frequency of an event (:daily, :weekly, :monthly, :yearly [or :annual, :annually]). it is the "yearly or annually or annual" set of values that I would like to handle in a single defmethod handle.

you can’t define it directly in this way, but you can define multiple defmethods that invoke the same function - some people have macro’ed that up to avoid the duplication

or you can leverage multimethods ability to create arbitrary keyword hierarchies

then you’d have a “parent” keyword and just define one method on that

ah, ok, had not consider that. thank you.

https://clojure.org/reference/multimethods has an example

I like implementing a defmethods macro — but it’s simpler to leave the defmethod dispatch duplication while handling the logic duplication with a separate function

@bjr @alexmiller thank you both for the feedback. i had considered moving the logic duplication to a function defined outside the multimethod hierarchy, but was seeking for a way to avoid that. will try the keyword hierarchy after grokking it. thanks again.

are the clojure koans a good way to start?

@guilhermelionribeiro A lot of people like them as a starting point. Also check out Clojure for the Brave and True.

@seancorfield will do, thanks!!

Hi guys, why do the following return the same result:

(clojure.string/split "a_b" #"_")
(clojure.string/split "a_b_" #"_")

In the second case, I expect ["a" "b" ""] instead of ["a" "b"]

@ahmadnazir by default trailing empty strings are discarded

pass -1 as the limit to get them back:

=> (clojure.string/split "a_b_" #"_" -1)
["a" "b" ""]

Does anyone here have any Common Lisp experience? I'm trying to figure out an idiomatic way to map a basic snippet of code to Clojure

I've used common lisp ~6 years ago but ask away, I'm sure that if I can't somebody else will be able to answer

I'd like a function that maps over a few different ranges of numbers, and puts them all into a flat sequence of numbers, like this: https://github.com/HackerTheory/crawler2/blob/master/neighborhood.lisp#L216-L231

This is mutating the same lexical results list. I need a functional/clojure way to do the same within the same function

So given (range 0 5), (range 0 3), and (range -3 1), this theoretical function would return (0 1 2 3 4 0 1 2 -3 -2 -1 0)

(partial apply concat) returns a function that does that

The best I can think of is nested fors with flatten

=> (concat (range 0 5) (range 0 3) (range -3 1))
(0 1 2 3 4 0 1 2 -3 -2 -1 0)

oh yeah, that's just concat

Ok, well, that is the basic idea, although like the linked code, this function would be a HOF that calls a function on each number, and puts that in the returned sequence instead of the number.

Sorry I left that part out

also has a conditional to see if it even will call the function or just skip the number

mapcat

if you need to include some numbers and exclude others, combine it with filter

That's just map + concat right? I need to map several times

what do you mean "map several times"? I don't quite follow you there

(into [] (comp cat (map f)) [coll1 coll2 ... colln])

The idea is I'm collecting a list of neighbor cells of a 2D grid given an origin. If I were for example to collect a cross shape with an arbitrary size, I'd need to map from left to right, then from top to 1 above origin. and then 1 below origin to bottom, in order to skip processing the origin twice (because it already was with the left to right pass)

Hello all! 🙂 Extremely new here. Im wondering why I get the space between "John" and "!" in my output. => ((fn [name] (println "Hello, " name "!")) "John") Hello, John !

@gryclmn: println adds spaces between args

ha! How can I avoid this? I also apologize for not wrapping the code as "code", just saw that ability, new to Slack

@mfiano: sounds like what you need is two steps, generating x/y pairs, then doing something with each pair

@gryclmn: you can create a string with str then call println on that

=> (str "Hello, " "John" "!")
"Hello, John!"
=> (println (str "Hello, " "John" "!"))
Hello, John!
nil

@noisesmith Thank you very much!

@sundarj Thank you

(defn testfn []
  (map vector (range 0 5)))

should be ok either place. can you share the NPE output?

What's NPE?

NullPointerException

https://gist.github.com/mfiano/b4747471bc8ff415557b9407039880b5

looks like that error is coming out of slamhound, not your code

well, I guess not, that’s just in the middleware

odd. it's the same function defined in a package and the REPL. when called with the fully qualified package name it errors, but works fine with the REPL package

oh, it’s picking up mfiano.crawler.kernel/map not clojure.core/map

so map means something different in the namespace

Oh I might have some funky refers going on there. Thanks

yeah, be careful overlapping clojure.core fns :)