agreed, @noisesmith is one of the most helpful people here; we should start tipping him in micro bitcoins or something 🙂

Does anybody have any Emacs configs to expand upon this? http://fgiasson.com/blog/index.php/2016/06/14/my-optimal-gnu-emacs-settings-for-developing-clojure-revised/ I adopted this config when I started just under a year ago and I never thought about it since

@radomski you may take a look at my emacs config that I’ve been using for 5 years: https://github.com/igrishaev/dotfiles/blob/master/.emacs

How come coll-reduce isn't implemented for Iterator?

1. I'm not using datomic. 2. I need to inspect a large eav store (about 10,000 items). 3. Anyone knows of a good tool for analyzing this?

10000 items isn’t exactly large

I think you can just load that into memory and use Datascript

no no, I meant I'm currently dumping it via println

and manually inspecting it by hand when something goes wrong

(s/def ::delay (s/and (s/or :val pos? :val zero?) int?))

(s/valid? ::delay 0)

gives false

if I restructure the ::delay to (s/def ::delay (s/and int? (s/or :val pos? :val zero?)))

it then works

can anyone explain why

(s/def ::delay (s/and (s/or :val pos? :val zero?) int?)) (s/valid? ::delay 0) => false (s/def ::delay (s/and int? (s/or :val pos? :val zero?))) (s/valid? ::delay 0) => true

you can use s/explain in place of s/valid? to get more information

I tried it here and it seems like the first option passes [:val 0] to the int? pred

so this is probably what's causing it to fail

is it normal behavior?

i think it shouldn't

Seems that's the case as (spec/def ::delay (spec/and (spec/or :val pos? :val zero?) #(int? (second %)))) works

https://clojuredocs.org/clojure.spec/or "Returns a destructuring spec that returns a map entry containing the key of the first matching pred and the corresponding value."

and that I don't know enough to say

I thought that the above would only be true when conforming, didn't realize it would have this kind of implication

btw @h.elmougy you can use pos-int? as well

I think it makes sense. This way, you can check only specific keys in the following specs.

or https://clojuredocs.org/clojure.core/nat-int_q

@p-himik that is true

I have something like this (reduce + (map #(* (first %) (last %)) …) that runs at 1500msecs. Then I tried it in a loop and it drops to 20msecs. Why does Rich hickey hate me so ?

How did you do it in a loop?

(loop [acc 0 item items] (if (seq item) (recur (+ acc (….))) acc)

something like that

Still not clear. 🙂 It depends on what items is and how you recur on item.

In CLJS and items being a vector, reduce works about 8% faster than loop:

(def items (mapv #(vector % %) (range 10000)))

(simple-benchmark [] (reduce + (map #(* (first %) (last %)) items)) 1000)
[], (reduce + (map (fn* [p1__115369#] (* (first p1__115369#) (last p1__115369#))) items)), 1000 runs, 4812 msecs

(simple-benchmark [] (loop [acc 0, items items] (if (seq items) (recur (let [i (first items)] (+ acc (* (first i) (last i)))) (rest items)) acc)) 1000)
[], (loop [acc 0 items items] (if (seq items) (recur (let [i (first items)] (+ acc (* (first i) (last i)))) (rest items)) acc)), 1000 runs, 5219 msecs

Just a suggestion. Is it because map creates a new list, before reducing on it? I wonder how this would perform: (reduce #(+ (* (first %2) (last %2)) %1) 0 ....) Skipping the creation of the intermediate list.

There's no an intermediate list. map is lazy.

@p-himik Use destructing instead of first/last. Last isn't all that fast and will create another intermediate sequence actually.

@rauh I know, I was deliberately repeating what laujensen provided.

Oh I see! 🙂

By the way, first with peek is faster than destructuring by about 15%.

you can't destructure last

items are a two element vector so you can in this instance but certainly not in the general sense of last

@laujensen also make sure your first reduce isn't actually realizing the lazy seq vs your loop using the already realized one

there's just way too much you haven't said about this to make a guess, but there's absolutaly no way that a 1:1 translation from reduce to loop results in 2 factors of magnitude perf increase

in fact, often reduce is faster than manual looping over a seq view

Thanks for the input guys, I'll fiddle a bit

hello everyone, im coding a scheduler which receives a function as a parameter, if the function execution raises an exception, id like to log the function name is there a standart way of getting a function name in clojure?

no

(-> func meta :name) ?

that works if you pass a Var, not if you pass a function as a value

;; get name of the created class for foo
((fn [f]
   (-> f
       .getClass
       .getName)) clojure.string/replace) => clojure.string$replace

It's a bit hacky.

And expensive I believe, because you do a reflection.

not all "reflection" is slow, this is not the case. but it's still a bad idea :)

(-> func var meta :name)

that's not how var works

What do you use for data validation? Clojure spec looks great to generate and check data validation, but on the other hand it is totally not human readable. So using clojure spec i would have to validate twice, once with clojure spec and once for users with usability messages. It sound like something is wrong in this pattern. How do you do this? I would like to use clojure spec but something deep inside me saying i need complete solution to generate, validate, human readable information and spec doesn’t fit into this at that moment.

@kwladyka there are libraries for mapping from the spec errors to human readable messages, the intention for spec is to be easy to integrate with tooling for readability

@kwladyka We use just spec -- and then explain-data for failures, and we map the data structure to our own custom error messages.

has anyone written a let style macro that puts the bindings at the end? I do like the haskell where syntax whereby the local definitions can follow after usage

dpsutton, does that have some benefit im not understanding?

just for clarity of reading. For example you define a function and have a bunch of stuff in the let bindings and there's a lot of details immediately and then the implementation. The where style let's you put some clear logic and then define the local bindings after their usage. A macro could simple rewrite this into a traditional let but i do like the usage first

I did something like that in my raft implementation

https://github.com/hiredman/raft/blob/master/src/com/manigfeald/raft/rules.clj#L131-L145

ah thanks!

@laujensen and example is the following:

levelorder :: (Ord a) => Tree a -> [a]
levelorder t = step [t]
	where
		step [] = []
		step ts = concatMap elements ts ++ step (concatMap subtrees ts)
		elements Nil = []
		elements (Node left x right) = [x]
		subtrees Nil = []
		subtrees (Node left x right) = [left,right]

with good naming it can make the logic really clear and push the details down below but still close if you are interested

it has these things I called "rules" that have three parts, a true/false expression that determines if the body should be applied, a body that updates the passed in state, and then bindings (usually a big destructuring) that establish any bindings for the first two parts

in clojure, the let puts all of the stuff above. i can see both having their benefits but sometimes just want to see a nice clear logic

@dpsutton I think Ive done too much Clojure and too little Haskell to find that order help. Looks upside down to me 🙂

that's the point

one thing with the let ordering is that it's the same dependency order as defn/def ordering, so there's some consistency here. also with imperative language statement ordering

yeah i'm thinking some syntax like

(with-delayed-context
  (-> (sanitize-data data)
    (filter incomplete?)
    (map complete-names))
  (with-bindings [sanitize-data (fn [data] ...)
                  incomplete? (fn [item] (and ...))
                  complete-names (fn [item] (or ...))]))

put the high level logic at the top and the details below

but better names than with-delayed-context and with-bindings

(defn where [body bindings] `(let ~bindings ~body))

but you lose the implicit do i believe. that's why i was thinking a keyword to signal the end of the body

so keep taking forms as the body until you see the with-bindings or where and then invert

or just use do if you need one

(defmacro where
  [& body-and-bindings]
  `(let ~(last body-and-bindings)
     ~@(butlast body-and-bindings)))

user=> (where (+ x y) [y 1 x (inc y)])
3

ah, don't overcomplicate it. nice

could anyone shed some light on why this doesn't work?

(mapcat :id
  [[{:id 1} {:id 2}]
   [{:id 3} {:id 4}]])

this works fine

(map :id [{:id 1} {:id 2} {:id 3} {:id 4}])

@tmountain [{:a 0}] doesn’t have an :a key

it’s a vector containing an item with an :a key

mapcat unfolds after, not before, the input list

you could do (map :id (apply concat coll)) instead

or (into [] (comp cat (map :id)) coll)

awesome, thanks!