Getting to lein repl on rPi Java 8 is 28s +/- 0.5s measuring error. Getting to clojure.main repl is about 5 seconds. lein's nREPL session is noticeably laggy

Getting latency metrics for nREPL's RPCs would be interesting.

Hey, Clojurians. Is anyone else using Walmart Labs' Lacinia GraphQL library? I'm using it but I'm having trouble understanding how the resolved-values third parameter of a resolver function signature is supposed to work. Can someone lend me a hand?

@ghadi What is breaking Boot on JDK 9 RC 1 right now?

for Boot https://github.com/boot-clj/boot-bin/pull/4 and then we'll need a release

(But I was talking about lein being broken earlier)

Yeah, you'd mentioned both were broken and I was curious whether Boot's issue was similar to Leiningen's...

Thanks!

lein needs to remove its reliance on the bootclasspath by default. It will be 1.9+ before https://dev.clojure.org/jira/browse/CLJ-2077 lands, if that will land at all (and I don't care if it does)

(I don't see us moving to Java 9 any time soon but I like to keep track of what's happening in Boot-land)

lein landed an option to stop mucking with the bootclasspath, but it still does it by default https://github.com/technomancy/leiningen/blob/master/bin/lein#L204-L206

Hello all, anyone worked with business hours calculation? I need to define something like business hour 09:00am -> 06:00pm, and local time 05:00 + 3 business hour returns 11:00pm next day. If next day is saturday or my business day (saturday can be business day for my business) return it

Hmm, I'm sure someone asked that exact question a week or so ago and there was a library suggested... unfortunately that's further back than the 10k message limit @fabrao

@seancorfield don´t clojurians#slack has old logs repo?

https://clojurians-log.clojureverse.org/ ?

do you remember it was here?

I searched those archives but couldn't find it...

me too, but the difficult is the key to find it

Just represent business hours in base 9, modulo 60b9 😛

hour 0 is monday at 9am, hour 10 (base 9) is tuesday 9am, hour 57 is friday 4pm

57 + 3 mod 60 = 01 = 10am monday

(don't actually do this)

https://github.com/mprokopov/business-time ?

Yeah, I think that was the library that was shared -- thanks @misha

It seems that the output from explain-data of spec is not a “real” map, but some object of type #:clojure.spec.alpha. Unfortunately, it makes cheshire go nuts. How do I cast it to a plain old map?

(type (s/explain-data ...))  ;;=> clojure.lang.PersistentArrayMap
*clojure-version*
=> {:major 1, :minor 9, :incremental 0, :qualifier "alpha16"}

What the…

Thanks

That's just notation for a map where all of the keys are qualified in the clojure.spec.alpha namespace.

#:foo{:a 1 :b 2} == {:foo/a 1 :foo/b 2}

(Introduced in Clojure 1.9)

Oh, right!

Cheers

Anyone ever played with Alia and needed to use PagingState to basically split a larger request into separate pages ? (I should say that I see that PagingState can be passed to alia's execute function, though grepping through the source, I can't see how I'm expected to get a com.datastax.driver.core.PagingState)

@pseud yes - it's easy, and you don't need to directly play with PagingState

https://github.com/mpenet/alia/blob/master/modules/alia-manifold/src/qbits/alia/manifold.clj#L67 and https://github.com/mpenet/alia/blob/master/modules/alia-async/src/qbits/alia/async.clj#L66

are the manifold and core.async implementations respectively which return a channel / stream of results and work with the PagingState in the background

actually, iirc they work with the ResultSetFuture/ResultSet which manage the PagingState for you

the :fetch-size option lets you control your page-size

@mccraigmccraig digesting.. thanks ! 🙂

yw @pseud - more questions welcome should you need

I have seen people use clojure.core/into to merge maps instead of clojure.core/merge. Beyond the fact that into can operate on many collection types, is there any reason to prefer one over the other when working exclusively with maps?

@hmaurer I personally think it's a bit clearer to use merge when dealing exclusively with maps. merge is also variadic, letting you merge multiple maps with one call.

@pseud @mccraigmccraig I am on holiday, but if i recall even alia/execute supports at least :fetch-size and is truly lazy by default (no chunking). But @mccraigmccraig is right the async or manifold interfaces are much better for this kind of things

@mpenet Yup - it returns a non-chunked lazy seq. That said, it still often seemed to cause timeouts when I issued a large query (I bound the result to a var so that the repl wouldn't try to print the response, thus realizing it). But yes, I tried :fetch-size and that seems to suffice for me. 🙂

Hey! Is this the right place to ask for assistance? I am new at Clojure and having some problems. I have a variable filenameswhich is a vector of filenames of .edn files.

(defn read-file-as-edn [filename]  
  (->> filename
    (slurp)
    (edn/read-string)))
 
 (let [filenames (list-files)]
  (->>      
      (map read-file-as-edn)
      (flatten)
      (into [])))

@kaspern you're missing the first element of the ->> form

(->> (list-files) (map read-file-as-edn) ...), and then you can get rid of the let

or else (->> filenames ...)

(->> (list-files)
    (map read-file-as-edn)
    (flatten)
    (into []))

@kaspern malformed edn in one of the files

That would explain many things. I would have liked an error indicating so 😞 But thanks!

Is there a way to get only the part of a map that matched a clojure spec? e.g. if I have (def spec (s/keys :req [:foo/bar])) and run (s/conform spec {:foo/bar 22 :abc 123}), the map does conform and so it will be fully returned

I would like to only get the part of the map that conformed, and get rid of the superfluous :abc key

in the more general case, I want to keep the parts of a data structure that the spec validated, and get rid of everything else

Obviously I could do a select-keys afterwards if I know the keys, but I’m wondering if there is a way to do this directly from the spec

I don't think it's possible, no. You could use form and match on the return value to get the keys directly from the spec and then run the select-keys on that.

(defn how-conform [aspec data]
  (let [
        c (s/conform aspec data)
        c (if (map? c) c (into {} [c]))
        r (map (fn [x] (get c x x)) (s/describe aspec))
      ]
     (map vec (partition 2 (rest r)))))

(how-conform (s/keys :req [::a ::b]) {::a 5 ::b 7 ::c 8})

like that ?

=> ([:req [:user/a :user/b]])

@the-kenny @octo221 thanks! that helps

it's not quite what you asked for but it's near

follow-up question: given that the return-value of s/describe is a form, e.g.

(keys
 :req
 [:identity/first-name :identity/last-name]
 :opt
 [:identity/address :identity/user-account])

e.g. given a form with named arguments, what is the cleanest way to convert it to a map where the keys are the arguments’ names, and the values are the arguments’ values?

hmaurer: well you could write a tuple spec for that & conform on it. Example incoming.

@hmaurer Ugh that got a bit more ugly than anticipated, but should work for any simple s/keys spec. I'm sure someone out there wrote a nicer version of this 🙂

(->> (s/describe (s/keys :req [::foo]
                                  :opt []))
              (s/conform (s/cat :keys-sym #{'keys}
                                :pairs (s/* (s/cat :kw keyword?
                                                   :keys (s/coll-of keyword?)))))
              :pairs
              (map (juxt :kw :keys))
              (into {}))

Why the last expression returns {:a :foo, :args [{:id :XX}], :id :XX} instead of: {:a :foo, :args [], :id :XX}

(require '[clojure.zip :as zip])

(defn my-zipper [tree]
  (zip/zipper
    (fn branch? [node]
      (:args node))
    (fn children [node]
      (:args node))
    (fn make-node [node children]
      (assoc node :args (vec children)))
    tree))

(def z (my-zipper {:a :foo :args []}))

(loop [loc z]
  (if (zip/end? loc)
    (zip/node loc)
    (recur
      (zip/next 
         (zip/edit loc #(assoc % :id :XX))))))

it looks it is associated with the fact that traversing with zip/next reveals there are 2 nodes :

(zip/node (zip/next z))                   ;  => nil
(zip/node (zip/next (zip/next z)))  ;  => {:a :foo :args []} 

why is that? There is a single node with empty children so there should be only one node, correct?

@lambder I’ve not used zippers before, but it looks like your test in branch? is slightly incorrect: that will consider a node with an :args of [] to be a branch, since it’s not nil. Changing branch? to this fixes it, by the looks of things: (fn branch? [node] (seq (:args node)))

Since seq returns falsey for empty collections.

(:args []) ;=> nil

should it be false?

oh cool

@chrisjd (seq nil) === nil

so what is the difference?

(seq []) is also nil; that’s the key difference. I guess you would consider a node with an :args of [] to be a leaf, so it makes sense like that.

the doc says branch? should return true for nodes with empty children as they potentially can have children

Ah, so this is where my lack of experience with zippers fails us. 🙂

for {:a :foo :args []} branch needs to be truthy

Oh, my mistake — that should be children that’s modified to use seq (I actually did that in my REPL test…)

the doc says children should return sequence of children

the vector is itself a sequence

(fn children [node]
      (:args node))

returns then [] which is empty sequence of children

where the extra nil node comes from?

Well, it specifically says that it should return a “seq” of its children. A [] can be viewed as a seq, but isn’t a seq by itself.

I havn’t said it is a seq

i said it is a sequence

(sequential? []) returns true

Right, but the docs say seq. There’s a difference between seq and a sequence (unfortunately)

so if i return () would that change anything?

ok, @chrisjd it looks like this works:

(defn my-zipper [tree]
  (zip/zipper
    (fn branch? [node]
      (:args node))
    (fn children [node]
      (seq (:args node)))
    (fn make-node [node children]
      (assoc node :args (vec children)))
    tree))

yeah

the doc is misleading tho

nil is not a sequence

the doc should say that if no children then return nil

The key point is the distinction between a seq and a sequence. They’re not the same thing.

instead of () or []

well

Yeah, I agree that would be clearer 🙂

how would you give me empty seq?

as a literal in clojure?

nil

really?

yeah, it’s strange, but without it things would be really awkward.

that would be proof that seq is not sequential (sequential? nil) ;=> false

which would be total fuckup

seq is not a seq

A seq doesn’t implement Sequential, that’s all.

Err, sorry, nil doesn’t implement Sequential

nil doesn't implement anything, it's not a sequence and it's not sequential, it just behaves as a seq and thus as a seqable

the empty seq is ()

seq is a logical abstraction, it doesn't dictate a concrete type

if () is empty seq the why :

(require '[clojure.zip :as zip])

(defn my-zipper [tree]
  (zip/zipper
    (fn branch? [node]
      (:args node))
    (fn children [node]
      (:args node))
    (fn make-node [node children]
      (assoc node :args (vec children)))
    tree))

(def z (my-zipper {:a :foo :args ()}))

(loop [loc z]
  (if (zip/end? loc)
    (zip/node loc)
    (recur
      (zip/next 
         (zip/edit loc #(assoc % :id :XX))))))

gives {:a :foo :args [{:id :XX}] :id :XX}

insted of {:a :foo :args [{:id :XX}] :id :XX} ?

or in other words single node with empty children makes zip/next to traverse the zipper tree as if there were 2 nodes.

I don't have time to look at that zipper code, but arguing that () is not the empty seq is wrong

I agree with that

user=> (seq? ())
true
user=> (empty? ())
true

clojure is not common lisp where nil == ()

I disagreed with the statement that nil is a empty seq

well, nil behaves as an empty seq on seq operations, but isn't an empty seq in the sense that (seq? nil) will return false

the zip/zipper children behaves differently on () and nil

I’ve answered my own question [here](https://stackoverflow.com/questions/45694351/empty-children-and-clojure-zippers/45695243#45695243)

i think your branch? impl needs to be (seq (:args node))

because if it sees nil there it will never grab the children

(empty list is true)

but (seq ()) is false

(:args node) will return [] or () which are truthy values

branch? should be true even if it has no children

i don't follow, why?

for the doc “branch? is a fn that, given a node, returns true if can have children, even if it currently doesn’t.”

ah

zippers allow you edit tree

it needs a knowledge what can have children added

Looks like zippers have bug in seq-zip as well

here is a question: How many nodes this zip tree has : (zip/seq-zip ()) ?

(zip/next (zip/seq-zip ())) => [nil {:l [], :pnodes [()], :ppath nil, :r nil}] e.g. not at the end yet

(zip/next (zip/next (zip/seq-zip ()))) => [() :end] ok after 2 zip/nexts we have reached the end

(zip/node (zip/next (zip/seq-zip ()))) => nil

(zip/node (zip/next (zip/next (zip/seq-zip ())))) => ()

@lambder there is a ticket about this

@alexmiller thanks

https://dev.clojure.org/jira/browse/CLJ-941 https://dev.clojure.org/jira/browse/CLJ-1317

one or both of those

neither is quite in a state to screen (even all these years later)

I’m happy to move it along if someone pays one or both of those some attention

anyone playing with DeepQ learning in Clojure?