@qqq here is the long explanation: http://cr.openjdk.java.net/~jrose/values/shady-values.html

@pablore no, it is sort of like a struct in C, less indirection and higher performance than objects for certain use-cases

Is https://stackoverflow.com/questions/3132931/mutable-fields-in-clojure-deftype up to date? To make a field mutable, I need to mark it volatile

you can use ^:unsychronized-mutable as well

@ghadi well clojure’s data structures are not only inmutable, they are also persistent. And because of that I find it difficult to implement them with these new “values”.

I seem to be loosing the :p argument somewhere along the way here:

(defprotocol F
    (-f [this a & r]))

  (defn f [this a & r]
    (prn [:f {:this this :a a :r r}])
    (apply -f this a r))
  
  (defrecord Fer []
    F
    (-f [this a & r]
      (prn [:-f {:this this :a a :r r}])
      {:a a :r r}))

  (def fer (->Fer))
  
  (f fer :x :p {:args :foo})
  ;; => {:a :x, :r {:args :foo}}

  ;; stdout
  ;; {:this #user.Fer{}, :a :x, :r (:p {:args :foo})}
  ;; {:this #user.Fer{}, :a :x, :r {:args :foo}}

Looks like it's happening when the f wrapper function calls the -f protocol method implementation. Any ideas what's going on?

Compare with using only functions: :p isn't lost:

(defn -g [this a & r]
    (prn [:-g {:this this :a a :r r}])
    {:a a :r r})

  (defn g [this a & r]
    (prn [:g {:this this :a a :r r}])
    (apply -g this a r))

  (g :this :x :p {:args :foo})
  ;; => {:a :x, :r (:p {:args :foo})}

  ;; stdout
  ;; [:g {:this :this, :a :x, :r (:p {:args :foo})}]
  ;; [:-g {:this :this, :a :x, :r (:p {:args :foo})}]

protocols do not support varargs

you've accidentally defined a protocol that takes three arguments -- one of them is named & - if you printed & within the protocol implementation, you'll find your missing argument

Interesting. And surprising. Happen to have a reference?

I don't

worth an enhancement ticket to add a sentence to the defprotocol docstring

Indeed. And to spread the word far and wide.

Cheers.

i think that's one of the differences in clj/cljs. because of the host language cljs

does clojure guarantee evaluation order of its args?

Does lein not inject :test dependencies when you run a REPL? I thought it did, but I’m not able to explain how looking at the implementation of the repl task and my project’s profiles via show-profiles.

How is Clojure tested with JDK 10 which is on release candidate phase ? I can see reports of the Kotlin compiler breaking on JDK 10 early access releases : https://github.com/junit-team/junit5/issues/1169

Seems like there is a test case failing. Filed : https://dev.clojure.org/jira/browse/CLJ-2337

@xtreak29 it’s already been reported as https://dev.clojure.org/jira/browse/CLJ-2330

@bronsa Thanks. My bad "JDK 10" didn't bring up any tickets in JIRA search. I will close it then.

nw, jira search sucks

When a macro contains ~*ns*, does it imply that we are forcing it to evaluate at that point of time?

what's the go to jdbc/postgres driver these days?

squee seems quite nice/simple, clojure.java.jdbc seems like an obvious contender but it seems a bit bloated at first glance, maybe it doesn't matter

well squee is not even on clojars 😞

@mpenet You might get more responses on the #sql channel.

Has anyone seen similar exception to this? ERROR [compojure.api.exception:286] - clojure.pprint.proxy$java.io.Writer$IDeref$PrettyFlush$4923d848 cannot be cast to clojure.pprint.PrettyFlush Application is packaged as uberjar (tried both {:aot all} and only namespace with main), it works normally on localhost however it produces errors like this on AWS. Application works correctly, however it replaces original expcetion with this one on error. I tried to remove various dependencies and played with AoT but nothing so far helped 😕

@petr.mensik any particular reason why you're AOT'ing? That can lead to all sorts of trouble

@pesterhazy I ended up with :profiles {:uberjar {:aot [spc.core]} which is default - I thought that namespace containing the -main has to be AoTed

yeah right

another thing you can try is java -cp uberjar.jar clojure.main -e '(do (require 'myproj.main) ((resolve 'myproj.main/-main'))'

I think that should work right?

in which case you shouldn't have to AOT anything

Ok, I can try that, thanks

updated the snippet ^^ let me know if it works

And how do I workaround the fact that lein uberjar adds implicit AoT for the :main?

Warning: specified :main without including it in :aot. 
Implicit AOT of :main will be removed in Leiningen 3.0.0. 
If you only need AOT for your uberjar, consider adding :aot :all into your
:uberjar profile instead.
Compiling spc.core

@pesterhazy Ok, I removed the :main from project.clj and I am able to build it. However java -cp mayjar.jar clojure.main -e '(do (require [spc.core]) (resolve 'spc.core/-main'))' yields a Exception in thread "main" java.lang.ClassNotFoundException: spc.core, compiling:(NO_SOURCE_PATH:1:5)

@petr.mensik there's an apostrophe missing before the ns

`"(do (require 'spc.core) ((resolve 'spc.core/-main)))"

note the doulbe parentheses around resolve

@pesterhazy ok, it works locally so I'll let you know if it works on the AWS as well. However it's still not that nice since I have to change default run command on all instances 😕

But definitely thanks!

agreed. The other way should work as well (only aot a single ns)

Has anyone used an API that consumes com.fasterxml.jackson.databind.JsonNodes? I’m trying to figure out if an existing clj-library (like cheshire or jsonista) can produce such one from Clojure datastructures.

hello guys, a quick question about classloaders and require, maybe somebody here played with it: Even though I add a dependency to classpath with pomegrenate, the require of the dependency still fails... It IS definitely on the classpath of that given classloader. I tried tweaking *use-context-classloader* but it seems to make no difference. What am I missing? (Tried this so far only in repl, not sure whether that may be relevant?)

(let [new-cl (-> (Thread/currentThread)
                (.getContextClassLoader)
                (clojure.lang.DynamicClassLoader.))]
 (cemerick.pomegranate/add-dependencies :coordinates [['com.draines/postal "2.0.2"]]
                                       :classloader new-cl)
 (.setContextClassLoader (Thread/currentThread) new-cl)
 (require 'postal.core))
FileNotFoundException Could not locate postal/core__init.class or postal/core.clj on classpath.  clojure.lang.RT.load (RT.java:449)

Does anyone have experience using clojure.core/hash as a way to give a unique ID to maps? What are the pros and cons of using that vs something like sha256? I was surprised how few numbers are in the clojure hash and it seems like collisions would be much more likely, no?

My use case is I have a bunch of JSON objects and i want to detect dupes, but avoid false positives

Java hashes are constrained to be 32-bit integers

hash collisions are of course possible (the murmur hash changes in 1.6 have made this less common)

I would not use it as a way to obtain unique IDs (since they aren’t necessarily unique)

they can also change in between jvm restarts right?

replikativ has a subproject that deals with this

well they should probably be the same but would potentially vary across clojure versions.

or jvm vendors

well, clojure controls the collection hashes and I think the jvm spec controls primitive value hashes so that is probably not the case

@alexmiller would it be inadequate to add the '-m -M .clj' options to rlwrap for the 'clj' script in the repo? those flags fire up your $EDITOR with ctrl-^

did you mean .clj there?

correct

those options don’t work for me on mac at least

I don’t particularly want to lock in too hard to rlwrap as I’m hoping to actually integrate rebel-readline instead

https://github.com/hanslub42/rlwrap rlwrap has some serious options.

@alexmiller what version of rlwrap is on a mac?

depends on whose mac you mean :)

😛 on yours I guess

whatever brew installs :)

https://github.com/hanslub42/rlwrap

@alexmiller ok, haven't tried it in a mac, works fine on linux, weird it doesn't work in osx though, didn't know about rebel-readline, fair enough

okay, so in theory the -M .clj should work.

looks like I have 0.43

@alexmiller me too

rlwrap: warning: on this system, the getopt() library function doesn't
grok optional arguments, so '-M' is taken as an argument to the -m option
Is this what you meant? If not, please provide an argument

so I think that’s about the -m part which expects an argument

yeah, me too. I don't understand why it would be -m -M, only -M makes sense.

@alexmiller would rebel-readline be optional? or at least opt-out, don't want to slow down that start-up time 😉

still needs evaluation. why do you think it’s slower?

I would happily trade a small amount of time for the vastly increased functionality

yes, was just about to say that I don't really know how much overhead it would bring, just that is another dependency (which has its own dependencies, jline) that is needed for boot up

that doesn’t make it any slower necessarily

ok, these are all very nice features anyway 😉

@alexmiller Try -m' \ ' -M ".clj" that seems portable

@devicesfor you can try it with clojure -Sdeps "{:deps {com.bhauman/rebel-readline {:mvn/version \"0.1.1\"}}}" -m rebel-readline.main yourself (but ignore the first timing as it has to download and cache deps)

note that b/c of how it’s being started there are some inefficiencies that can be reduced - for me I see ~2 seconds to start a repl with clj and maybe 7 seconds with rebel-readline

consider that an upper bound - if included and packaged with clj, I’m sure this can be reduced

given what rebel-readline gives you (multi-line editing, completion, doc arglist and source inline), it’s pretty useful

@alexmiller I'm sure clojure 1.10 will bring that down too 🙂

why?

I thought there was some performance improvements planned for 1.10?

oh, there are other ideas in work but I’m not sure they would affect this necessarily

;; lazy, will only traverse once
 
(def colors ["red" "green" "blue"])
 
(println
  (map #(str % "foo") (map first colors))
;; => ("rfoo" "gfoo" "bfoo")

I assumed colors had to be a list instead of vector, for it to be a lazy seq?

@bravilogy what result do you expect?

I would’ve thought that there would be 2 iterations happening

compared to js equivalent

oh I’m not talking about the result, but rather - why will it only traverse once?

asked about the result cause I'm trying to understand what you want to accomplish

map always returns a lazy seq

@hiredman yes, map returns a lazy sequence. so when (map first colors) runs, doesn’t it iterate over colors vector to generate that lazy sequence?

@bravilogy Creating a lazy sequence from a lazy sequence doesn't require traversal.

See the code snippet above for the equivalent.

https://clojure.org/reference/reader#_symbols is there a reason % is not listed here?

@pauld so the second (outer) map doesn’t actually iterate over the lazy sequence generated by the first one?

@bravilogy it does

that snippet makes sense why there would be just 1 iteration

but I don’t get why there’s also 1 iteration in the example I posted

@bravilogy there are twoo, inner and outer map

I would’ve thought there’d be two

@bravilogy evaluate (map first colors) in your REPL

Then, take the result and evaluate it with (map #(str % "foo") ...)

That's what is happening.

@bravilogy why do you think there is only one?

because the comment says so @devicesfor

I’m looking at this page basically https://kanaka.github.io/clojurescript/web/synonym.html

under ‘lazy sequences’

@the2bears I think I’m not explaining correctly which part I don’t understand 😄 I know what the result would be and how 2 maps work but what I don’t get is that the comment in there - why will it only be traversed once

because you don't traverse the vector to create a lazy seq

@bravilogy to understand you might have to look at the code of (map) in clojure. But the key is just knowing you can create a lazy sequence from a lazy sequence without realizing / traversing the first one.

if you are familiar with iterators, think of it as a stack of iterators

calling seq on the vector returns the iterator over the vector

map takes an iterator, and returns an iterator that calls the mapped function on each value as you take it from the iterator

so it’s kinda like a transducer

in a sense of creating stacks

yeah

sure, but you are generating intermediate seqs as you go, where transducers don't do that

aah ok that makes more sense now

That's why my clip above was more or less equivalent to your code.

My syntax may have been off a bit.

maybe no # required.

no that’s fine, I think I understand now. so basically that example is sort of similar to

(take 5 (range))

in a sense that the inner map will generate a sequence that will be ‘fed’ to the outer map and that’s what will actually ‘realise’ it

and it only get's realized when print is called on it.

yeah

damn, that’s cool

😄

@bravilogy oh I see, yes colors is only iterated once, but your example has two iterations

so if I don’t call println, then there’s basically nothing happening

we just have some sort of a sequence that’s waiting for something to happen

correct, unless you are in the repl

lazy sequences can sometimes be confusing as you may get surprised by when the sequence is evaluated or realized.

yes, the repl has an implied print on everything.

would it be the same result if I was to simply change it to

(def my-seq (map #(str % "-foo") (map first colors)))
(println my-seq)

yeah

ok that repl part makes sense now

or if in repl, just 'my-seq' without println.

and it makes sense why is automatically ‘realising’ the sequence

yeah that’s exactly what I did there

thank you all 🙂

now I’m one step closer to becoming clojurian

@alexmiller seems the -Sdeps option is quite new? 4.2s for the rebel-readline on my ubuntu box, 4.8s on a fairly recent mbp

@mbjarland The -Sdeps option came in January with TDEPS-19 Add support for command line deps config data

https://github.com/clojure/brew-install/blob/1.9.0/CHANGELOG.md

@seancorfield Is there a way to use TemporalAdjusters with joda.time? I am referring to clj-time but I cant find functions for dayOfWeekInMonth and firstInMonth

@vellalpavani You'll have to use Java interop to call those. Not everything in Joda Time is exposed directly in clj-time.

(and, for all sorts of reasons, I'd recommend using Java Time over Joda Time these days -- and looking at clojure.java-time as a wrapper if you don't like Java interop)

When would it be a good idea to use a StructMap over a Record? The documentation for StructMap says "Most uses of StructMaps would now be better served by records.". What would "most" not cover?

ignore structs

they're deprecated

Ah, I didn't see it say that anywhere.

"effectively"

structmaps are mostly about optimizing storage, Records can integrate with protocols, and still have optimized storage

Isn't there an overhead for creating a proper JVM class?

sure, but all functions do it

even all function invocations, right?

no

just definitions

Hello, I am trying to transform a UTC date string into a Local date string: “2018-03-20T12:40:40Z” -> “3/20/18 8:40am”. I’ve tried various to-local-date-time and unparse-local functions, but I can’t seem to put it together. I’m getting an error:

ClassCastException org.joda.time.DateTime cannot be cast to org.joda.time.ReadablePartial  clj-time.format/unparse-local-date (format.clj:212)

(def local-date (local/to-local-date-time "2018-03-20T12:40:40Z"))
=> #'recruit-app.util.date/local-date

local-date
=> #object[org.joda.time.DateTime 0x311f327a "2018-03-20T08:40:40.000-04:00"]

(tf/unparse-local-date (tf/formatter :mysql) local-date)
ClassCastException org.joda.time.DateTime cannot be cast to org.joda.time.ReadablePartial  clj-time.format/unparse-local-date (format.clj:212)

I'm trying to understand locals clearing, I'm looking at the bytecode for this simple function (m is a Java hash map):

(defn put [m k v]
  (.put m k v))

0  aload_0 [m]
     1  aconst_null
     2  astore_0 [m]

the clearest case for it is holding on to the head of a seq in a binding but passing it in tail position to another function

@schmee see https://groups.google.com/forum/#!topic/clojure/FLrtjyYJdRU

I saw that thread bronsa but I wasn't sure it was still relevant since it's all the way from 2009

@tlomberg Are you wedded to Joda Time (`clj-time`)? If you're on Java 8 or later, the Joda Time folks recommend using Java Time instead, and there's a nice wrapper called clojure.java-time.

Here's that parsing / add timezone / formatting using clojure.java-time:

user=> (require '[java-time :as jt])
nil
user=> (-> (jt/zoned-date-time "2018-03-20T12:40:40Z") (jt/with-zone-same-instant "America/Los_Angeles") (->> (jt/format "MM/dd/yy hh:mma")))
"03/20/18 05:40AM"

@schmee yeah nothing much has changed for locals clearing since then

there's been a few improvements and it happens in places where it didn't use to but the general principle is the same

@seancorfield: Thanks, I’ll look into it

@bronsa aight, thanks :thumbsup: I guess I want to follow the PathNodes in the compiler to figure out how it's done?

(FWIW, I'm one of the maintainers of clj-time and I just updated the repo to include the notice from the Joda Time website that recommends users migrate to JSR-310 a.k.a. Java Time)

@schmee yeah

or you can look at https://github.com/clojure/tools.emitter.jvm/blob/master/src/main/clojure/clojure/tools/emitter/passes/jvm/clear_locals.clj for an alternate impl

Is there any language with Clojure-like syntax and is good for high performance numerical computing?

i think there’s a lib that can do hardware acceleration and stuff for clojure….trying to remember the name of it

neandertheral / clojurcl / clojurecuda ?

https://github.com/uncomplicate/neanderthal

not sure if that’s what you’re looking for or not

@jgh: it's a wonderful answer to the question I asked, but not the question I intended to ask, as the cuda/opencl 'kernels' are still not written in clojure 🙂

oh i see

could you make clojure macros that compile to the cuda/opencl kernel language?

eg Apple’s Metal uses LLVM so some enterprising upstart could use a different language than C++ for the kernel language

(btw possibly one of the worst API names ever…at least go uses golang)