How do I sort by the list of lists to make sure they are in sorted order ? I have '((1) (2) (3) (2 1) (1 2) (3 1) (1 3) (3 2) (2 3) (3 2 1) (2 3 1)) and I want it to be ((1) (2) (3) (1 2) (1 3) (2 1) (2 3) (3 1) (3 2) (2 3 1) (3 2 1)) . Is there an idiomatic way to do this ? sort doesn't help. In sort-by how can I compare two lists. (juxt first second) doesn't help. It can have any number of elements for every sub-list. Expecting something like Python's sorted sorted([[1], [2, 1], [1, 2]]) # [[1], [1, 2], [2, 1]]

@xtreak29 Vectorize your inner lists, then the sort be like you want

@rauh Thanks a lot

neat, repl-driven clojure slack 🙂

hey, does anyone know where clojure.contrib.duck-streams went?

@tjtolton I don't see it listed here https://dev.clojure.org/display/community/Where+Did+Clojure.Contrib+Go so maybe it disappeared from Contrib before 1.3 appeared?

hrm. must be something that it got folded into or something though right?

https://github.com/clojure/clojure-contrib/blob/1.2.x/src/main/clojure/clojure/contrib/duck_streams.clj

July 23, 2010: DEPRECATED in 1.2. Use instead.

oh, how about that

I only actually need slurp* from there

so that's perfect

just assembling this really neat pattern from an article back in 2009

string interpolation/super templating

https://cemerick.com/2009/12/04/string-interpolation-in-clojure/

really nice for dev tooling/scripting against a ring server running in a docker environment. just set up all my things using some constants i defined up at the top, etc

like the new f'{variable} strings' in python

What does duck-streams/slurp* give you that the built-in slurp does not?

(it says it's "like slurp but opens f with reader" -- but slurp also seems to call reader on f...)

it actually seems to define its own reader, which is possibly obsolete now. I'm going to be honest, I just kind of wanted to make it work blackbox without inspecting the internals. And I'm getting what I deserve 😂

It's telling that duck-streams was deprecated even before the break-up of monolithic contrib that came with Clojure 1.3 🙂

yeah for real

Looks like you can just use the built-in slurp (based on limited playing in the REPL).

boot.user=> ((juxt read slurp) (-> "Hello, World!" java.io.StringReader. java.io.PushbackReader.))
[Hello ", World!"]

@seancorfield could you elaborate silent-read without the try/`catch`?

@lovuikeng Based on the code in the blog that @tjtolton linked to. The blog uses old, outdated libraries but has a function that takes a string and tries to return a pair of the first readable (Clojure) form from the string and the rest of the (unread) string.

The full function (using built-in slurp) would be

(defn silent-read
  [s]
  (try
    ((juxt read slurp) (-> s java.io.StringReader. java.io.PushbackReader.))
    (catch Exception _)))

@tjtolton Did you get that interpolation example working?

Oh, yeah I did! It's real neat.

And did you also see that the functionality is part of https://github.com/clojure/core.incubator/blob/master/src/main/clojure/clojure/core/strint.clj ?

So you can just depend on [org.clojure/core.incubator "0.1.4"] and then require [clojure.core.strint :refer [<<]] and use that?

whaat, oh man

I did not see that!

that's great! thanks!

thank you <@U04V70XH6>! `strint.clj`: _"originally proposed/published at <http://cemerick.com/2009%22_|http://cemerick.com/2009"_>, you just got to love Hickey :slightly_smiling_face:

sean@sean-xps:~$ boot -d org.clojure/core.incubator repl
nREPL server started on port 64540 on host 127.0.0.1 - 
...
boot.user=> (require '[clojure.core.strint :refer [<<]])
nil
boot.user=> (<< "It is ~(java.util.Date.) right now!")
"It is Fri Oct 13 15:58:41 GMT 2017 right now!"
boot.user=>

man, it just gets better and better 🙂

man, this is so slick

feels like cheating

(I love that Boot lets me just pull in an arbitrary library without needing to create a project etc)

thanks for the great tips @seancorfield!

Now I must go grab lunch before the sessions start back up in 50 minutes!

Conj?

no wonder clojurians channels been quite these couple of days... 🙂

Hey is there a map with a stable key order?

sorted-map and sorted-map-by - there’s also one from a github project that preserves insertion order

The insertion order is what I'm looking for.

you can also use the various java mutable hash-maps of course

Do you remember anything about the github project?

@eraserhd I have a lot of respect for the author, but haven’t tried this code https://github.com/amalloy/ordered

@noisesmith Wow, thanks!

@bpiel Watching your talk about Guildsman right now. Super interesting but pleeease start thinking about writing readmes! 😄

@nooga ha! Thanks. I promise there'll be docs and examples once this is ready for the public. Missing README is not remotely the biggest problem

@bpiel some would argue that having a readme could attract more hands or heads to help you out 🙂

@nooga Those hands/heads will be critical to success. But, I don't think anyone can help yet. Ex. there's no tests

I promise there will be a readme ☺️

google could help by fixing their C api 😉

@nooga that's very true. Actually, people can help, just not via the guildsman code yet

Maybe the readme (for now) could just explain what contributions to focus on in TF

I like that

yeah!

Ok. I'll do that soon

Thanks for reaching out

my pleasure 🙂

Does anyone know of a forum for asking Cider specific questions? Or perhaps this is the right place..?

#cider @wpcarro

oh there’s a dedicated IRC channel? that’s lovely

@wpcarro slack channel 🙂

@dominicm thank you for clarifying … the IRC channel had 3 members haha

does clojure have a builtin whee I provide: state f :: state -> state still-run :: state -> bool and it iteratively call 'f' on 'state' until (still-run state) becomes false ?

would (take-while still-run (iterate f state)) count?

does this keep around all the old states ?

only if you capture them

if you don’t bind them, they are gcd

I guess I'll just do a loop ` (loop [state state] (if (still-run state) (recur (f state)) state)))

(reduce (fn [prevoius-states current-state] (if (still-run current-state) (conj previous-states (f current-state)) (reduced previous-states)))

something like that

but there’s nothing to reduce over

(range) 🙂

that does a lot of extra work and a lot of extra syntax to do something like the take-while / iterate except it’s not lazy and always holds all states in memory whether you need them or not, I don’t see any advantage

@qqq if range was the input current state would always be a number

(yes you could fix that by changing the binding vector to [previous-states _] but that doesn’t really make things much better)

yeah his suggestion is way better

now, if f took a second arg, eg. one that delivers an event or message (a common design for me at least) (reduce f state (repeatedly get-event)) can be a decent way to do that (reductions instead of reduce if you need all the values in a sequence as they are produced)

this is a good setup if you have an external data source because it means you can unit test by passing in a lazy-seq of events that provoke the behavior you care about

is there a good read about web app security for Clojure?

Almost every tutorial explains basic routes using compojure and they don’t really go into details of middlewares and such

and actually connecting to the database

@bravilogy what sort of thing are you looking for?

I’m trying to build a SPA and I have an SQL database. And basically was wondering what’s the best approach to creating RESTful apis and working with databases?

for example, let’s say Laravel offers its own ORM, which I understand is for OOP programming but perhaps there’s something similar approach in Clojure too?

Will clojure compiler optimize stuff like (let [a (-> foo :x :y :z) b (-> foo :x :y :q)] ...) by noticing common expression?

no

@bronsa funny thing, I’m actually watching your talk from conj right now 😄

hah

hope you like it :)

@bronsa I sure do! ❤️ compiler tech. About the common expression. I wonder is that something that JVM could optimize later on…

mhh, i don't know, that would require some hardcore purity analysis which I don't think hotspot does

hotspot never ceases to amaze me but i'd be really surprised if it did this

yeah, that is what I’d expect

good to know, I need to refactor several fns now 😄

if those expressions are actually like what you're doing then the cost of it not being "optimised" is likely close enough to zero

function indirection is cheap

okay, so roughly what does (:x y) compile into?

(let [thing {:a {:b {:c 3}}}]
  (time (dotimes [_ 10000000] (-> thing :a :b :c))))
"Elapsed time: 282.271115 msecs"

(:x y) compiles to xsingletonobject.invoke(y)

which might even be inlined by the jit

@nooga the best way to find the answer to a question like that is to use no.disassemble https://github.com/gtrak/no.disassemble

@bfabry oh, cool

@bfabry not quite

clojure emits inline caches for (:foo <whatever>)

ah, so even better than I thought

yeah but they're only useful for records :)

the inline caches are there so that if you're doing keyword access on a record, it'll get optimized into a direct field access

no difference for maps other than some extra indirection

that I heard of, smart move

i'm actually not 100% sure those inline caches make an actual difference in real life

I know V8 does a lot to optimize field lookups away

but i've honestly never benchmarked that

but that’s a bit different

ok, be back in 6 months, started reading clojure compiler’s src 😄

there be monsters

no.disassemble helps too 😄

I contributed to pixie-lang once so I’m sorta prepared 😂

heh, I have to admit that I almost never care about optimizing anything when writing clojure because everything runs fast enough “out of box” - even stuff like async proxy that parses megabytes/s of binary from the wire, grinds huge maps and unparses them to other wire. It just warms up and does its job.

Are there any good libraries to create CLI applications?

Is there a boot channel?

Is there a way to change the font colors of the boot repl on windows 10?