sorry is this is a tired old question, what is the right and proper type to extend a protocol with if I want this implementation to be called for all kinds of core.async channels?

@arthur are you looking for clojure.core.async.impl.protocols/ReadPort and WritePort ?

that is what I needed to check for to write a chan? function

if the first argument to the implementation function is any kind of chan, then this function should be called

I want to extend a protocol such that the implementation receives a chan

there’s also Channel (same namespace)

that sounds better than clojure.core.async.impl.channels.ManyToManyChannel

I don’t remember that existing when I wrote my chan? predicate, it would have been the natural thing…

which seems overly specific

oh wait, the ports were totally wrong, I’m misremembering something

double self correction, heh

=> (supers (class (clojure.core.async/chan)))
#{clojure.core.async.impl.protocols.Channel java.lang.Object clojure.lang.IType clojure.core.async.impl.protocols.WritePort clojure.core.async.impl.protocols.ReadPort clojure.core.async.impl.channels.MMC}

how do I go about referencing the previous state of an atom?

@grounded_sage when you change an atom via swap! or reset!, you can use a watch to get the old value https://clojuredocs.org/clojure.core/add-watch

watch -> log

@grounded_sage also, an upcoming release of clojure will have support for accessing the previous version using swap, instead of the new version. in the meantime, see something like this: http://stackoverflow.com/questions/43599473/get-the-state-of-an-atom-and-reset-it-atomically/43599982?s=3%7C0.0000#43599982

beyond that, from a 10 second glance at the java code, once an AtomicReference is set, there's no looking back at the previous value

@joshjones you mean like you can swap back to a previous version? That definitely sounds good. Pretty much what I am needing to do now. Swap in some new content but then swap back.

https://dev.clojure.org/jira/browse/CLJ-1454 has an implementation of this

you can find a less invasive impl in something like this: https://github.com/overtone/overtone/blob/e200075da27375727db1f5ce342e2e1c22ea1dbd/src/overtone/helpers/ref.clj#L6

as posted above @grounded_sage , this will return the prior value:

(defn reset-return-old!
  [atm new-value]
  (let [old-value <@U169ZE1J4>]
    (if (compare-and-set! atm old-value new-value)
      (do
        (.notifyWatches atm old-value new-value)
        old-value)
      (recur atm new-value))))

Hi all, does anyone know of a natural language API similar to IBM Watson’s personality insights? What I’m looking for is a service that analyses unstructured text, but does more than just sentiment analysis or entity extraction, and whose results are more directly useable

@achesnais this would be a good discussion for #off-topic

ah right, fair enough ^^

does clojure havea function which captures the idea of: here's a list of functions, try them all, in this order, and return me the firt one that succeeds

so I have some x, and a bunch of f1, f2, f3, ....

and I want the first of (f1 x), (f2 x) .... that succeeds

(or (f1 x) (f2 x) ) ?

Curiousity question ... Is anybody here using clojure in an enterprise/large corporate distributed system way? .. if so, what kind of system architecture did you use? Micro-services?

at this stage, enterprises still tend to prefer java/.net and object-oriented designs

hence my curiosity

if you want to know more of what I mean by enterprise/large corporate... imagine a large bank

or anything sizeable

@placeboza https://www.clojure.org/community/success_stories

@qqq (some #(% x) fnseq)

Oh cool, tx @lincpa

How do people solve indentation issues in a team? The problem: team members use {Atom, IntelliJ, Emacs}. True to its name, my Emacs's aggressive-indent mode reformats code it touches (or it seems just sees) with much enthusiasm, leading to diff noise. How do you approach this technially trival yet socially complex issue?

cljfmt

Although that either means you need to include cljfmt in your build pipeline (with a potential commit if you use fix mode) or add git hooks to run it.

or have a rule that it must pass cljfmt prior to committing

it's quite easy

You can customise the indent policies on most of those editors (including emacs) so you could produce std formatting across all editors.

@mpenet relies on ppl remembering tho

same for tabs vs space, it's a rule ppl must follow

a lot of editors have cljfmt plugins

well the main ones at least

tabs vs spaces is usually something u set in your editor tho. So fire and forget. cljfmt plugins are good way to go

cider follows cljfmt rules by default

i think cursive might as well

Cursive differs a bit around alignment of vars

but both can be customised

yeah I was wondering how an automated tool might fit in

The main point of contention is indenting function arguments, essentially boiling down to the three options laid out here: https://github.com/clojure-emacs/clojure-mode#indentation-options - always-align, always-indent, align-arguments

git status -> take the changed files -> Use lumo + clj-fmt to rewrite the files. That could be nice.

why lumo? because it's faster?

It'd be a standalone tool instead of having a lein/boot

@pesterhazy If you're using the right GIT indentation config, I think that issue would go away...

what's git got to do with it?

I'm saying if you're sharing your code in the team via a git repo

and you've set the indentation handling config

then git would sort it out for you

so I know my answer assumes a lot

just throwing it out there

we're using git, but can you point me to a reference where git reindents lisp code?

hmm you know what, I think I'm talking rubbish

Friday brain

confusing it with something else

😸

nevertheless, someone has done what Im suggesting

see if this helps at all : http://stackoverflow.com/questions/2316677/can-git-automatically-switch-between-spaces-and-tabs/2318063#2318063

not going to auto-indent, but will manage spaces/tabs

tabs v spaces is not the issue in our team. 2 spaces have won the battle luckily 🙂

ah ok. I see

nvm then. You're referring to actual formatting issues

code formatting prettiness concerns

in which case, I have nothing other than perhaps to have the team try to standardize their preferences 🙂

some editors use this style:

(some-function 10
  1
  2)

others (such as clojure-mode by default) use this style:

(some-function 10
               1
               2)

if two people using those two editors work on the same code, you pingpong back and forth between the two

right.. although emacs is famously configurable, so..

perhaps just a matter of choosing a style and putting effort into configuring the tools to match up

right I think that's what it boils down to

perhaps aided by a cljfmt or boot-fmt style

yup if necessary

anyway, Im not much help today it seems

and I have to deploy to production tonight. great. 😛

gonna give cljfmt a spin

gl

hi all!

any suggestions for fast off-heap (preferably, but not necessarily directly on disk) storage of clojure maps? (the assumption being that the data is too large to fit in memory)

really dumb question

i have a clojure library i cloned from github

and i've modified

i want to add it into the dependencies of a new project

without publishing it up to clojars just yet

how do i do that?

change the version number in project.clj then lein install

Is this an acceptable way to use a macro:

(defmacro only-without-nil
  [ex]
  (if (some nil? (rest ex))
    nil
    ex))

=> (only-without-nil (+ 2 4 6 nil nil 5))
nil
=> (only-without-nil (+ 2 4 6 10 5))
27

checkouts is an option too i believe

if have it locally

though you have to still list it

so basically what @bostonaholic said

cool, never realised leiningen had an install option

thanks @bostonaholic and @zylox

yup, np

Hi, any know big web project in clojure on github or bitbucket?

Is there a way to conditionally assoc a value into a map literal?

so instead of

(merge 
    {:foo "foo"}
    (when x {:x x})))

{:foo "bar"
 (when x :x x)}

(cond-> {..} condition (assoc :foo bar))

no

Thanks @bronsa

I wonder, is there any correct usage of merge that can’t be replaced with conj?

I guess trivially there’s (merge) => nil and (conj) => []

I was surprised before that conj on maps works like merge

but if you have a hash map as a first arg, I think conj works for everything merge handles

just didn’t seem like the same sort of operation to me

I guess that is good it works? hah

also map conj errors would make a lot more sense if conj didn’t accept another map

(because the last thing it tries is to treat the arg as a hash-map, so that’s the one you see in the error message)

but that horse is out of the barn, no version of clojure will change that behavior

(conj {} {:a 2 :b 3} [:c 2])

just seems so odd to me

@noisesmith what error are you referring to?

(ins)user=> (conj {} (list :a :b))
ClassCastException clojure.lang.Keyword cannot be cast to java.util.Map$Entry  clojure.lang.APersistentMap.cons (APersistentMap.java:42)

Oh fun

it wants keyword to be a map entry because it wants the list to be a map

and that’s the last failure, so it’s the one reported

very counterintuitive

yeah, it’s one of those garbage in, garbage out cases I guess

well, I guess maybe not, garbage error msg out hah

haha

I think the surprise-factor to me with conj behavior on maps is just that it accepts other maps

It just surprises me that that would have even been special-cased in

(conj {} [:a 5] [:b 6]) that is normal conj-like behavior on a collection. It is adding items (entries) to a collection (the map)

(conj {} {:a 5 :b 6}) - it is adding items (other maps?) to the collection (the map)

😛

oh, well

(def id (reify clojure.lang.IFn (invoke [_ x] x)))
(def one (id 1))

raises a compilation error is it a known bug ?

wow - that’s weird

at the repl, the compiler will for some "simple" expressions choose to try and interpret code instead of compiling it

and the interpreter effectively uses apply to invoke functions, which the reify is missing

(def one ((fn [] (id 1)))) the extra fn here forces the compiler to actually compile the code which then works

(I dunno if there is an existing issue for that)

thanks for the explanation @hiredman

ahh, so you could fix it by implementing applyTo for it, right?

yep

is it idiomatic for custom types that implement IFn to define all arities and throw a custom exception when behaviour is undefined ?

I am usually pretty lazy about it and just implement the arity of invoke I want, but I've also never run in to that error before

>at the repl, the compiler will for some “simple” expressions choose to try and interpret code instead of compiling it @hiredman this seems weird to me. The main Clj REPL is doing this? Going through the “apply” flow instead of direct invocation? That’d be interesting to look at. Never heard of it.

sure, there are vestiges of an interpreter in the compiler, which the compiler uses for very simple expressions at the repl

weird, I’ll have to check that out

the rules for that are something like: only for top level forms, only for defs, only for defs where the value is directly result of a function call, and only when the arguments to the function call are also simple

you will pretty much only ever see that behavior when typing stuff in to a repl

is it safe to assume that *ns* in the context of macroexpansion is the namespace being expanded at the time?

to be pedantic, namespaces aren’t expanded, forms are expanded, and if they use defining forms *ns* is the namespace they mutate

which is basically yes - that is where the current definitions will end up unless they use something wacky like intern

ah I see

it seemed like @pesterhazy’s real question was how to solve the social problem of code formatting, which i don’t think anyone answered, but is definitely the more interesting and challenging one. i wish i knew the answer to that. some possible strategies: 1. appeal to community standards--if there is a most popular style, just use that. e.g. maybe there’s a reason :always-align is the clojure-mode default. 2. let the person with the most experience in the language be the authority.

just like with lots of engineering decisions, sometimes people can’t reach a consensus on their own, and someone needs to be the authority that makes a decision for everyone.

good and eponysterical points @wiseman

@wiseman cljfmt answers that with “everybody uses what the tool says is right”

which is what my team adopted, I have not regretted it at all

@noisesmith there are definitely tools that have opinions about code that i don’t think everyone, or even most people agree with. it sure can help to have a “community standard”, which is what ideally something like cljfmt would embody

that's the path I'm going down right now

the tool respects bbatsov's guide, so there's double authority there (human & machine)

right, it didn’t invent it’s rules out of a vacuum, it implements human invented best practices

haha - but that is the current community consensus - you can create more lines with comments

I have a directory of .clj .cljs *.cljc filles. I want to count "lines of code", but not use wc -l . What is suggedsted ?

@qqq http://cloc.sourceforge.net/ supports clojure

cloc or sloc

oh, i'm too slow.

https://gist.github.com/andrewvc/3161953 <-- this is the first result on google

use this script or something else for sloc?

@qqq there’s an app, cloc, you can get it via however you usually get command line apps, it supports clojure

I get it via homebrew

(or apt at home)

it's a perl script. also has a node wrapper on npm (npm i -g cloc)

apt-get install cloc ; yeah, it works

surprised my last 3 months of work is only 1.2k loc

this means I wrote about 10 lines / day, or 1 line / hour.

you mean that’s the output

you probably wrote a lot more :)

if P = NP, I could have just written the correct 1.2k lines of code and ignored all the churn

https://github.com/clojure/core.match/wiki/Basic-usage <-- are there more detailed examples of guards?

something that shows guards and capturing at the same time

very elegant way of anding a list's items?

probably every?, but you'd have to say more about what you want

(every? identity my-list-of-booleans)

but might possibly be a more elegant way

true? is an option too if it is booleans and not for truthiness

as your predicate that is

right, a tad more readable I think

actually this might get better by lazily evaluating the original collection which produces the list of booleans

something like while

but that will be too specific to and, while or would require a differently looking expression

don't overcomplicate it, every? is lazy

🙂

despite what it sounds like

just trying to be elegant here

I think reduce is the real solution

not lazy! (but short circuiting)

(via reduced that is)

yep

i 💙 reduce, but I promise that it would not look elegant

I wonder how come no one added the > you can write a macro to do that reply yet

😭

because that would be cheating!

wheres the fun in playing fair

kind of annoying that and is a macro, so we can't

(apply and my-list-of-booleans)

@zylox good point. (defmacro my-and...) easy peasy!

all the best functions are prefixed by my-

even better: (defmacro my-list ...) throws an exception it you give it a falsey?

beats me why and was implemented as a macro not a function

honestly if it doesnt occasionally throw an exception based on the current millis are you even trying?

@matan otherwise it can’t short circuit

what's the alternative?

a simple while loop can easily short-circuit

ao you need an "and*" macro.

not preventing its args from being evaluated

maybe this could work (reduce (fn ([] false) ([x y] (and x y))) my-list-of-booleans)

@jfigueroa the standard definition is that every item in a collection matches the predicate, if there are no items in the collection

which means the first arity can be skipped, by starting with true as the init

for short-circuiting, (reduce (fn [_ x] (if (nil? x) (reduced x) x)) true [])

getting kind of ugly…

well in Scala 😛 collection.forall(identity) // and a collection collection.exists(identity) // or a collection

pardon my French

my eyes are bleeding

guess I'm too tired to properly participate in a chat now

I think the (every? true? bools) is better 🙂

I agree

(not (some false? bools)) The truth is that I don't know which is the purpose of this 🙃 saludos!