that's a category error, sorry.

the other nice thing about transients is that they act as a shallow state monad

instead of having to thread the new state through all the time, we can just make modifications, and the modifications are carried through until the persistent! call

i think the more salient issue is that reality usually categorizes only approximately, so if you need exact categorization, or an exact taxonomy of something that is supposed to be a representation of reality, the more realistic you make your representation, the more often you have to revise or rethink your whole taxonomy

i like to compare the ease with which mathematics can be categorized, and the ease with which simulations can be categorized against the difficult of categorizing (with exactness) biology, economy, or even something more mundane like postage stamps

The crucial difference between these two classes of things is rampant chaos-- its not present in all the structures of mathematics, and can be avoided a priori in a simulation; but it is inextricably a part of our reality

thus any time you try to hedge yourself against chaos by adopting rigid types, you are hedging yourself against reality

(except in the cases where you aren't dealing with reality in the first place, for instance a haskel library for matrix algebra)

"transient" is shallow right? in the sense if if we have a map of map of values, i.e. k1 k2 -> v, then in using transient, it's on the "top level of keys" that become transient, the 'inner map' of k2 -> v is still persistent

There s a wrong assumption that using a strongly typed lang like ocaml will be less productive. Also a huge diff with schema/spec and the like is inference. Very often with ocaml you dont even have to add any type annotation and you get whole program coverage for free. That said that language has other issues (for now) imho. But that s #offtopic material

https://clojuredocs.org/clojure.core/definline <-- is this the right way to inline functions in clojure?

(slightly concerned as it's marked EXPERIMENTAL)

is there a builtin for checking whether something is a transient ?

(doseq [:let [x 20]]
  (println x))

The doc string indicates the latter, the keywords are modifiers of the previous sequence. I suspect this is a pathological case, since you're binding a constant value. I guess the real surprise to me is that with an empty set of bindings, it executes the body at all. 🙂

m = a map ks = a list of keys What is the fastets way to write (reduce dissoc m ks) ?

@qqq (apply dissoc m ks)?

@rauh: why would this be faster?

(-> amap keys set (clojure.set/difference , (set ks) ) (#(select-keys amap %))) if amap have a lot of keys.

does anybody use this library? https://github.com/funcool/cats

Most recently, it has been mentioned here: https://blog.skyliner.io/fourteen-months-with-clojure-beb8b3e4bf00

They used it for an Either monad.

cheshire seems to have a lot of CBORfactory annotations that it doesn’t import: https://github.com/dakrone/cheshire/blob/master/src/cheshire/core.clj

is that a bug or am I missing something about annotations

(also sorry I mean type hints, not annotations)

which one is not used?

Im reading the HN comments on https://blog.skyliner.io/fourteen-months-with-clojure-beb8b3e4bf00 Which you can find here: https://news.ycombinator.com/item?id=14006242#14011870 and their is a specific complaint that inexperienced clojure devs are more likely to create a single global state then inexperienced devs in other languages. Also that this single application state is bad: > I know Python doesn't come with atoms, but you could certainly stick the whole application state in a global variable. You wouldn't though if you're a working programmer with a modicum of experience on your first Python project. Do people just see some new idioms and forget everything they already knew about programming? Isn't a single application state what Om.Next does? Is the complain about how its done? Or i'm I missing something. I thought a single DB was a very common and reliable pattern in clojure because it put all the real state in one place and made sure your changes were more transnational.

@istvan The problem isn’t that it isn’t used; the problem is that it annotates with CBORFactory but doesn’t import it

Yeah, I have to disagree with the whole one atom is bad thing.

@drewverlee it matters if you have atomic reference in the language and you put the global state or you have python where everything is global and there is no atomic reference 😉

From what I understand, even Datomics transactor works that way

And normally Clojure programs use pure functions to mutate that state.

my favorite python programming question for python programmers is the following:

def addList(val, list=[]):
    list.append(val)
    return list

addList(10)
addList(10,[])
addList(10)
addList(10)

please tell me what are these going to print out and why 🙂

90% failure rate

its because the list=[] isnt doing what you think

drewverlee for one

[10], [10], [10, 10], [10, 10, 10] when evaluated in that order

(note: please don’t ask gotchas as interview questions unless you can demonstrate they’re predictive (and they’re probably not))

but it is also highlights why idempotent functions are important 🙂

lvh this is not a gotcha, this is a source of pretty serious bugs in production

and this is by design

if you are not aware of it you cannot write reliable code

okiedokie

and if cannot write reliable code you cannot deliver mission critical systems and my company is in the business of delivering mission critical systems (but we do not use python 🙂 )

So is the real complaint isn't having global mutable state, its that you don't have good tools to deal with it?

Scratch that, the complaint is that when people write bad code in clojure its harder then usually to figure out whats going on.

Is there a way to get core.match to only be required at compile time? I’m trying to avoid e.g. org.objectweb.asm.* being in the resulting uberjar; that is pulled in tools.analyzer.jvm, and I think it should only be required at compile time (but i’m happy to be wrong about that)

i watched clj talk on clojureTV about java9 modules ( https://www.youtube.com/watch?v=4fevIDAxQAM ) i feel concerned could someone maybe shine little bit of light on the topic? are modules really a problem that affects us deeply? Will at some point clojure have to let go of it's unique philosophy to still be able to run on JVM? (btw i am beginner)

while it’s pretty clear oracle wants modules to happen, they don’t get to comically break the ecosystem

is there something weird about instant? that would make removing clj sources (in an :aot uberjar) fail?

Caused by: java.io.FileNotFoundException: Could not locate clojure/core_instant18__init.class or clojure/core_instant18.clj on classpath. Please check that namespaces with dashes use underscores in the Clojure file name.

question: does figwheel work for clojure, or is it clojurescript only?

I have a list of items. Each is of the form [a b c d e] What is the fastest (runtime) way to create a 4- level map of the form {a {b {c { d e}}}} ? There's group-by, but it only does it 1 level.

@qqq assoc-in

@tbaldridge: reduce + assoc-in ? this is performance sensistive

@dthurn Pretty sure it’s ClojureScript only. Not sure what it’s even mean for clojure

@qqq no, assoc-in knows how to build new maps

just try it

I have a list of [a1 b1 c1 d1 e1] [a2 b2 c2 d2 e3] [a3 b3 c3 d3 e3[ .... with assoc-in, I'd have to use reduce

how else does it process the entire list ?

yes then assoc-in + reduce

if its too slow you can sometimes replace assoc-in with a macro

@lepistane no reason to cross post between channels. Most of us hang out in both this channel and #beginners

Well, I was hoping for some figwheel-like way to auto-reload files in my clojure application when I modify them. The figwheel workflow is pretty great.

dthurn have you looked at https://github.com/clojure/tools.namespace?

it is not auto-reload but it simplifies reloading clj code a lot

it looks like I could maybe get what I want by hooking that up to a filesystem watcher

although figwheel also avoids reloading code with warnings, which is very useful

Guys, I need a mentor. Really successful person who wants to grow another successful person. I am in Turkey, but my English is not really bad. I want to become a professional.

Is there anyone to guide me ?

pick an open source project; start contributing patches, people will review your code

I don’t have time to weste. I need a mentor to guide me to the right way.

then hire someone as a tutor

Yes, I need it. 😄

Do you know someone ?

check the #jobs channel -- this is off topic here

Zach Oakes Here ?

Ok sorry.

What's the best way to make a macro in one namespace have reference to a function in that namespace, regardless of where it is called

Something like (defmacro a (b) (...Replace all symbol K with a call to C, a function defined in this namespace...)

Like replacing all instances of + with a function package.core/add-ten

@emccue syntax quoting will namespace qualify symbols, isn't that enough?

No, because it will namespace qualify ALL symbols

is that a problem?

And I'll get clojure.core/+ passed into my functions

Where I only want '+

use ~'+ then

But the + is in a user supplied form

So if I had the [body]

Everything is already quoted

could you show an example signature with the expected return value?

Sure one moment

keep in mind that I am fairly new to this

right now Im just doing simple symbol substitutions, but I want a more robust way of replacing function calls

just make it explicit? or wrap stuff in let to bind the sym? (let [+ package.core/add-ten] ...). (untested, guessing from memory 😉 )

yeah, the problem there is that clojure complains if I reassign certain symbols

I dont want to generate warnings for the user

though im not sure if that applies in a let block

or "binding" or some such. i've done this sort of thing but it's been a while. pt being i don't think you need to crawl the input if you just want to rebind some syms.

My other question would be how to bundle this into a library

right now im just running off of the "app" template from leiningen

which is fine, but the end goal is to have something I can just include in a project

clojure complaining about symbol rebinding is not unusual. you can use "refer-clojure" to deal with that.

@emccue here's my take on what I believe you're trying to do: https://gist.github.com/moxaj/da60985e609916361a550a5f130df11f

clojure.walk is a good tool, so I thank you for showing me that

but as far as keywordizing the macro, that misses the mark

Im trying to support the functions in a literal copy paste way

(edited for a simpler solution, handles t -> true)

what do you mean by your last sentence

if you understand abstract algebra, and you're bordeline insane, you can study the code behind . https://github.com/mobileink/lab.clj.polymorphism/blob/master/src/clojure/multimodels/examples.clj it demonstrates among other things how to make the same group multiplication operator work for the 2 basic groups (+, 0, N) and (*, 1, N+), using clojure's binding ops.

and im gonna be honest

`((replacements expr expr) @exprs)

I have no clue what that does

the difference between ', `, , @ is lost on me right now

i know ' does a syntax quote

single quote is "quote"

and ` does a quasiquote

and ~ unquotes

but ~@ is completely foreign

~@ is unquote-splice

splice

and quasiquote and unquote have some wierd behaviour in clojureland that I have yet to reconcile in my head

@emccue it's well documented - we call it syntax-quote and it always qualifies symbols https://clojure.org/reference/reader#syntax-quote

Okay I'll read up

Thank you for the reference

hey guys, is there any protocol to implement a channe l?

lxsameer I think you want the first three in this file, at least https://github.com/clojure/core.async/blob/master/src/main/clojure/cljs/core/async/impl/protocols.cljs#L13

ReadPort, WritePort, Channel

(well, maybe just two if you are read-only / write-only I guess)

oh man, (empty x) and (empty? x) means very different things when x = nil

different than what?

they always mean different things. one is an expression, the other is a predicate.

yeah; and I have now learned the difference

(empty? (transient {}))

dammed if i know.

a clojure wart.

see http://stackoverflow.com/questions/9396987/how-do-you-get-the-keys-from-a-transient-map-in-clojure maybe it will hwlp.

maybe try

(empty? (persistent (transient {})))

@mobileink : that explains it; thanks!

(not that i have the slightest understandin of this stuff.)

@noisesmith thanks man

@qqq - turning a transient persistent is just a single bit flip, use persistent! with empty?

clojurewest was a thrill!