i have a weird question to community: how many columns considered to be a standard style for clojure source code width?

i think we’ve settled on 100, which is the widest that two panes of code can fit side by side on one of our engineer’s funny 1280x900 laptops

we all have an emacs thing that colours stuff beyond that point differently

@ul I don’t think there’s a “community standard” for that

i guess we have no one, consider my question like a poll or something. i'm in doubts, so happy to hear numbers and reasoning, exactly in the same way @robert-stuttaford wrote (thanks!). I'm using 80 for a year, chosen it just to stick to smth. sane, but sometimes it seems too narrow, code becomes too much extended vertically, especially taking in account lisp-style argument alignment

Here's an argument from authority for <=80 loc: https://github.com/bbatsov/clojure-style-guide#80-character-limits

But I only follow that when it's convenient.

otherwise i just turn off whitespace-mode (the emacs thing that highlights columns >80)

@escherize: thanks for the link, when i've read this guide last time it had no note about character limit

There was a reason for 80 chars, back in the day when we thought vt100 terminals were cutting edge. But, surely, not any more. I'm absolutely a 100 char guy these days. That 80 char thing was a completely arbitrary limit forced by hardware and nothing to do with a good software reading/layout experience.

narrower columns make for nice side-by-side diffs or three-way diffs. helps!

I have mine set to 120 chars these days

I’ve found that 80 character width is just too narrow - 100 characters works well for me

Sometimes a wider row can be a code smell, but a value between 100 and 120 is working well for the team.

does any shortcut already exist to extend protocol for several types with identical functions? like this:

(extend-protocol IProtocol
  AType
  BType
  (protocol-fn [_] "hello!"))

(extend-protocol IProtocol
  AType
  (protocol-fn [_] "hello!")
  BType
  (protocol-fn [_] "hello!"))

@ul Perhaps define your own simple extend-protocols macro? Don't think there's a shorthand in core

yes, that the path i will follow if no smth. standard. and i guess it actually doesn;t exist

@ul there is clojure.core/extend (http://conj.io/store/v1/org.clojure/clojure/1.7.0-alpha4/clj/clojure.core/extend/)

@thheller: thanks, its a good base for a little hand-rolled macro doing the job

How would I use test.check for functions that do CRUD on my db?

I like to stick to 80, because my font (Monaco 14) and side-by-side Emacs windows wrap at 86 chars. But no biggie.

(Already at Monaco 14, I wonder if others can comfortably see my text.)

you should try M+ as a font: http://mplus-fonts.osdn.jp/

it’s very narrow but still readable, ideal if you split windows a lot

@martinklepsch: Ah cool, I'll check it out!

http://www.fsd.it/fonts/pragmatapro.htm#.VXbD8Sp7ZE4 for me - the best font ever for programming

@delaguardo: that looks also interesting, thx

@ul 80 columns for me. I just disable Lisp argument alignment in all my editors. I find it unbearable. 2 space indent always except for data structure literals.

in what sense unbearable? hard to read quickly? too fast getting too wide?

@ul taste. I find it ugly and an impediment for reading.

http://www.paulgraham.com/taste.html

But I like hitting C-c n and having everything "where it should be"

And I break lines if auto-format + current line-breaks look fugly

@dnolen: Is there an easy way to do that in Emacs or do you just redefine all these: https://github.com/clojure-emacs/clojure-mode/blob/master/clojure-mode.el#L798-L869

@scttnlsn: pretty sure clojure-mode has an option for this

@dnolen: Ahh, okay great. I’ll poke around. Thanks!

@dnolen the day it is the indentation in my code that makes it ugly is the day I will be happy 😉

Does anyone know Scala?

I got this Scala method : def apply[T](clauses: (Double, Element[T])*) which I would like to call from Clojure.

Reflecting on the method I see clauses is a scala.collection.Seq - but what is it a Seq of?

@steph: my guess would be Tuple2's

but i've been out of that game for quite awhile

Ah yes of course.

Thanks, looks to be the case.

@stephen: no prob

@stephen: i’ve used this a bit while trying do use sparkling https://github.com/t6/from-scala

I have been using that library.

It is invaluable!

Looking at the code is useful

I love the component library

Wondering: (first (remove nil? (map (fn [x] (println x) x) [:tolo nil :test]))) in my understanding this should be lazy and only print :tolo — why isn’t it?

vectors are not lazy?

lol 😄

(first (remove nil? (map (fn [x] (println x) x) '(:tolo nil :test)))) works as expected

thought so

I don’t really need it but now I’m wondering how I can turn a vector into a lazy seq, is that possible at all?

(seq [1 2 3])

If you run this: (first (remove nil? (map (fn [x] (println x) x) (seq [:tolo nil :test])))) it’s not lazy @stig

hm.

map is chunked.

look up "chunked sequences" (it's an optimization)

ghadi: that might be it. But why did the literal ‘(:tolo nil :test) work as expected then?

Maybe it’s the right time to go “one level up”: What I’m really trying to achieve is some short circuit like behaviour that returns the first non-nil result — not executing f on any remaining items

because vectors are chunked but lists aren't

martinklepsch: move your side effect to the outside

(let [item (first (remove ... coll))] (print item))

it’s not about the side effect, the function that returns nil or something (which I want) is expensive

the vector literal has it's own evaluation semantic

err, its

@martinklepsch: : e.g. it behaves like (vector 1 2 (doto 3 println)), evaluating its contents before returning itself

relevant: https://github.com/Prismatic/plumbing/blob/master/src/plumbing/core.cljx#L172-L195

Thanks everyone, somehow I thought that if I use map it will just treat any passed list as lazy

@martinklepsch: Perhaps make use of reduced to terminate?

(reduce (fn [acc x] (println x) (if-not (nil? x) (reduced x))) nil [:tolo nil :test])

(You’d apply your f inside the nil? check, perhaps saving the value with an if-let or somesuch.)

@martinklepsch: (reduce (fn [acc x] (println x) (if-some [y (identity x)] (reduced y))) nil [:tolo nil :test]), replacing identity with your f?

New blog post on Reader Conditionals - http://danielcompton.net/2015/06/10/clojure-reader-conditionals-by-example

nice!!

on the top-level thing, in some cases you could also wrap in a (do ) instead of splicing, although at that point you should probably question whether you should be using reader conditionals in the first place or just provide different namespace implementations specific to the platform

@alexmiller: I thought I did describe that? > or use a do to wrap all of the top level functions:

or do you mean somewhere else?

you did :)

I hadn't finished reading :)

I think my pull request for the clojure-maven-plugin went in today to support cljc files :)

@alexmiller: I was wondering about that. Will that support .cljc test files too?

should

I still don't get what `'~ does, is there any article or simple explanation about it

i guess it gives you quoted symbol inside macro

oh, wait, you are asking about `'~ in a row, or generally about quoting?

Specifically that combination

sometimes you want macro to put one of its arguments literally as it is typed in source code

this combination allows this, i'm not sure about correctness of my terms, but it is one of the ways to break macros' hygiene

something reverse to using x#

=> (defmacro f [x] `'~x) (f z)
z

@chipf0rk: Mastering Clojure Macros by Colin Jones covers `'~ in his Secret Macro Voodoo section, on page 25.