Fork me on GitHub

I have a vector of maps, each map has a key :id, i’d like for this vector to actually be a map from the :id to a map of the rest of the data in the map


is there a cool flatten trick here


extract, pick something


or do i create an empty map and loop through and assoc in? doesn’t feel very functional


maybe reduce.


(into {} (map (juxt :id identity)) your-coll)


most codebases end up with some utility function that's u/key-by that does this to some effect. up to you how you resolve if there's the same id in more than one of the maps. first wins, last wins, etc

🎯 3

this is really awesome, juxt combines the functions :id, which is a keyword but why do you need identity?


oh that’s the piece that puts the rest of the map in as the value


((juxt :id identity) {:id 1 :other :stuff}) #_ -> [1 {:id 1, :other :stuff}]


yeah. you make tuples of [k v] and then pour those (into {})


that’s awesome, thanks!


This is one of those things where you often hear people say "what use is a function that always just returns its argument?" and here's a great example.


yeah, I would have asked that question too! but that’s really useful 🙂


When should one use Exception. vs ex-info ?


when consumer of your function expects to see specific Throwable class such as Exception

👍 1

generally, when writing Clojure, I almost always use ex-info

☝️ 1
✔️ 2

Not sure what I'm doing wrong exactly but I can't seem to get this clojars library working with a minimal example I added [kahdemlia "0.1.0-SNAPSHOT"] to my project.clj and tried to run

(ns ds-test.core
  (:require [kahdemlia.core :refer [make-node!]]))


but i will get

2. Unhandled clojure.lang.Compiler$CompilerException
   Error compiling kahdemlia/core.cljc at (1:1)
   #:clojure.error{:phase :compile-syntax-check,
                   :line 1,
                   :column 1,
                   :source "kahdemlia/core.cljc"}
    7648  clojure.lang.Compiler/load
           381  clojure.lang.RT/loadResourceScript
           372  clojure.lang.RT/loadResourceScript
           459  clojure.lang.RT/load
           424  clojure.lang.RT/load
                  core.clj: 6126  clojure.core/load/fn
                  core.clj: 6125  clojure.core/load
                  core.clj: 6109  clojure.core/load
       408  clojure.lang.RestFn/invoke
                  core.clj: 5908  clojure.core/load-one
                  core.clj: 5903  clojure.core/load-one
                  core.clj: 5948  clojure.core/load-lib/fn
                  core.clj: 5947  clojure.core/load-lib
                  core.clj: 5928  clojure.core/load-lib
       142  clojure.lang.RestFn/applyTo
                  core.clj:  667  clojure.core/apply
                  core.clj: 5985  clojure.core/load-libs
                  core.clj: 5969  clojure.core/load-libs
       137  clojure.lang.RestFn/applyTo
                  core.clj:  667  clojure.core/apply
                  core.clj: 6007  clojure.core/require
                  core.clj: 6007  clojure.core/require
       408  clojure.lang.RestFn/invoke
                      REPL:    1  ds-test.core/eval19109/loading--auto--
                      REPL:    1  ds-test.core/eval19109
                      REPL:    1  ds-test.core/eval19109
    7177  clojure.lang.Compiler/eval
    7166  clojure.lang.Compiler/eval
    7132  clojure.lang.Compiler/eval
                  core.clj: 3214  clojure.core/eval
                  core.clj: 3210  clojure.core/eval
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn/fn
          152  clojure.lang.AFn/applyToHelper
          144  clojure.lang.AFn/applyTo
                  core.clj:  665  clojure.core/apply
                  core.clj: 1973  clojure.core/with-bindings*
                  core.clj: 1973  clojure.core/with-bindings*
       425  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn
                  main.clj:  437  clojure.main/repl/read-eval-print/fn
                  main.clj:  437  clojure.main/repl/read-eval-print
                  main.clj:  458  clojure.main/repl/fn
                  main.clj:  458  clojure.main/repl
                  main.clj:  368  clojure.main/repl
       137  clojure.lang.RestFn/applyTo
                  core.clj:  665  clojure.core/apply
                  core.clj:  660  clojure.core/apply
                regrow.clj:   20  refactor-nrepl.ns.slam.hound.regrow/wrap-clojure-repl/fn
      1523  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   84  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:   56  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:  152  nrepl.middleware.interruptible-eval/interruptible-eval/fn/fn
           22  clojure.lang.AFn/run
               session.clj:  202  nrepl.middleware.session/session-exec/main-loop/fn
               session.clj:  201  nrepl.middleware.session/session-exec/main-loop
           22  clojure.lang.AFn/run
       834  java.lang.Thread/run

1. Caused by
   Could not locate clojure/spec__init.class, clojure/spec.clj or
   clojure/spec.cljc on classpath.


It’s failing to compile the kahdemlia.core namespace because it requires clojure.spec , which is a namespace that doesn’t exist in later versions of Clojure. You can try explicitly adding [org.clojure/clojure "1.9.0-alpha15"] to your dependencies, and it should compile. But I wouldn’t suggest using this library for anything serious unless you fork it and update it to work with a newer Clojure version


I see I see hmmmm, I'll just clone the repo and explore the library directly instead 🙂


That also works for trying it out. The spec library is now under clojure.spec.alpha, it seems like clojure.spec only existed for that alpha release of Clojure. So should be possible to update the library to work with the latest Clojure


I have a dev/user namespace. Things are working well. I have added a few dev tools like user/dbg. What are some of the approaches for configuring the REPL so I can reference user/dbg as just dbg in other namespaces without having to run require or use in each namespace where I would like to access them?


I don't know of any way to automatically do that off the top of my head, but if you have an editor or IDE where you have a key sequence of your choice assigned to "evaluate the expression just before the cursor", so you don't have to type the same expression more than once, it can be good to have frequently used expressions like `(require 'user.dbg)` or `(use 'user.dbg)` in a file at the top level of your project, e.g. named something like `scratch.clj`, that you often keep open while working in that project.


Having your chosen editor/IDE set up so that a very convenient short key sequence can send expressions to your REPL for evaluation is HIGHLY RECOMMENDED


That’s a good point. Let me look into the tooling more. With atom/chlorine I normally use execute from whichever namespace i’m currently in. Thus, if i’m in when I execute commands they are from that namespace.


I have a function that combines (apply require clojure.main/repl-requires) with loading my utilities from user.clj into the current ns, that gives me the standard things like doc, pprint, source in any ns

👍 1

i’m using an atom to a map, atom of a map? how do you even say that. 🙂 I’m using an atom referencing a map as a database for a tiny app i’m working on. It holds data about baseball players. I have been writing some functions to do data access / updates.


(defn update-player
  [id key value]
  (swap! league
         (fn [current-state]
           (assoc-in current-state [id key] value))))


this seems to work great, but it prints the entire database in the repl everytime


maybe a success or fail would be good or silent success error on fail.. does swap! ever fail? or.. how would silence its output?


Regarding terminology, I think "an atom containing a map" is fairly common.


containing! nice.


"referencing" is clear, too


In a REPL, any time any function can return a value that is very large in being printed, you can do something like (def x1 (some-expression-returning-big value)) , and it will only show #'user/x1 instead of the big value. The big value will be stored in x1 for future reference/manipulation.


Unless the function you pass to swap! can throw an exception, I don't know of any reasons why swap! can fail


Even then, swap! should leave the current value contained in the atom there.


right that makes sense


it seems to be updating the atom AND returning the new value


Atomically swaps the value of atom to be:
(apply f current-value-of-atom args). Note that f may be called
multiple times, and thus should be free of side effects.  Returns
the value that was swapped in.


That is what the last sentence of the doc string printed by (doc swap!) says it should do.


ha ha nice, thanks for the pointer


See also swap-vals! for its different, and sometimes useful, return value


that’s cool, both the old and new


i wrapped the swap! call in a count call to return far less info, is that something people do like, maybe i could wrap it in do and return nil?


A Clojure function body is already implicitly wrapped in a do, without having to type (do ...), so you can make the last expression nil in the body if you always want to return nil


If you aren't worried about large values accidentally being printed at a REPL, in development it can often be nice when functions return a useful value, even if you do not always use it. But yes, I see people sometimes returning a value like nil when they explicitly want that.


oh that’s really useful thanks, i didn’t know about the implicit do


(defn update-player
  [id key value]
  (swap! league
         (fn [current-state]
           (assoc-in current-state [id key] value)))
  (str "updated " id))


this is kinda useful


but yeah who knows maybe having the whole value there is good


anyway, thanks!

👍 1