I know about https://gist.github.com/gregsh/b7ef2e4ebbc4c4c11ee9 . It has not reached a level for 'practical' use for met yet. Has anyone here managed to script IntelliJ (or any other IDE) in Clojure like one scripts Emacs in Elisp ? [I'm basically looking for an IDE that I can dynamically reprogram in Clojure.]

Curious to know if there is a standard workflow to navigate Protocol implementations. Particularly jump from a protocol method call to it's implementation. Example

(ns dirigent.protocols)

(defprotocol Trippable
  (tripped? [this])
  (run-body [this body-fn])
  (reset-trip [this]))


(ns dirigent.records.counter)

(defrecord CounterCB
    [circuit-breaker-name counter-state failure-pred threshold timeout]
  tcp/Trippable
  (tripped? [this]
    true)
  (run-body [this body-fn]
    (ctl/info "Running the body and counting errorr if possible"))
  (reset-trip [this]
    (ctl/info "Resetting the trip")))


(ns dirigent.records.sliding-window)

(defrecord SlidingWindowCB
    [circuit-breaker-name counter-state failure-pred threshold timeout]
  tcp/Trippable
  (tripped? [this]
    true)
  (run-body [this body-fn]
    (ctl/info "Running the body and counting errorr if possible"))
  (reset-trip [this]
    (ctl/info "Resetting the trip")))


(ns dirigent.core
  (:require [dirigent.protocols :refer [run-body]]))

(defn run-main
  [cb-record]
  ;; cb-record can either be CounterCB or SlidingWindowCB
  (run-body cb-record))

Please tell me what is your favorite code formatting library? Maybe you just trust your IDE's formatting?

Emacs does the right job, but otherwise cljfmt is the only one I know

do you think it is Emacs by it self, or the job is done by Paredit ar Cider?

I think mostly Emacs + Clojure mode, cider might add a bit of extra smartness around macros

but paredit doesn't really affect formatting imho, it simply helps you working with sexpressions

So I'm thinking about throwing a repo together for this prototype predicate dispatch thing I put together here: https://stackoverflow.com/questions/53329709/dispatching-function-calls-on-different-formats-of-maps/53354967#53354967 Anybody got a good idea for a library name? poly? polypred? predicate-dispatch? And what should be the name of the main defmethod-like macro? Currently it's defpoly but defpd might be clear enough?

I just installed Java/Leiningen/InteliJ on my Mac. I am getting strange error messages when I include libraries. Is there some way to verify if the install went ok? The rep works, but I don't know why this error comes up. When I worked on Linux with the same code, all was fine... Many thanks!!

@davidpty looks related to https://github.com/amalloy/ordered/pull/37. Does it happen with say Java 8?

I would love love love to see a page that shows me how to dissect an atom like a surgeon with code examples

I have to constantly re-reference basic material with regards to atoms and data storage. it's a shocker

most of the things i want to do are very basic: add a map to an atom, search an atom for a map with a matching :username "value"...

An atom only holds a single value - usually that value is a hash-map, but that's not always the case.

an atom is a pointer to a value that can be be atomically compared and swapped for another value

pointer dereference and atomic cas are the only two operations that exist for it, anything else is some operation on a value pointed to by the atom, not an operation on atoms

you can also set or remove a validator or a watch function

my point is just, an atom has those two operations only, and anything else "adding" whatever, or "searching", or whatever, have nothing to do with atoms

right, fair

so if you find yourself not knowing how to do whatever with an atom, the atom is not the part that matters, in reality you just don't know how to do whatever (search for things in a map, add things to a map, etc), so should focus on basic data structure manipulation (update-in, conj, seq, contains?, assoc) and ignore/forget anything to do with atoms

I’m looking for some code which would take a randomly-generated code form (from a spec or some other grammar) and then randomly break it in various ways in order to write generative tests for code using the parsed form.

Before I start bashing out the code-walking code, which is often a bit of a mess of edge cases, I thought I’d check if such a thing existed.

Does anyone know of anything like this?

Actually, it looks like zippers would be the best way to do this.