how to decide, i mean

for functions that are mutually recursive and require closed-over data

understood, ty

I wonder if you could replace your nested conditionals with one cond - eg. (let [idx (mod n 3) (cond (and odd-n? (= idx 0)) ... (and odd-n? (= idx 1)) ... ... (and (not odd-n?) (= idx 0)) ...)

just a thought - not sure that's an improvement

well, i'm also looking for a way to make it less verbose but not too clever\\complex

or even (case [odd-n? (mod n 3)] [true 0] .... [true 1] ... ... [false 0] ...)

right, that's an important balance

also you don't need odd-n? to be a captured value, it could be calculated in the let block of move

yeah making cond cases based on odd-n? looks like a logical improvement

well capturing odd-n? is a premature optimization from my side

I wouldn't even think about "optimization" there, yeah - it's more a question of "does this make the code more straightforward, or not"

looks like iterate

by which I mean, you can rewrite it as single step, getting rid of building a seq and recursing, and use iterate to do that

but iterate makes of inf seq isnt it?

(take-while some-pred? (iterate ....))

that's a great idea ty

another thing to consider - instead of [from to spare] it could internally use {:keys [from to spare]} the advantage being that the new state can be something like (-> state (update :from pop) (update :to conj (peek from))) (spare doesn't change in this case, no need to mention it)

I think that (plus some line breaks) make sit more clear what operation is actually being done

of course the printed form should still be a vector, that's much better than a fully named hash map

great, thank you so much for the valuable feedback, i'll get back to you as i'm done with above improvements

hope it helps - these are all pretty subjective

well i see a valid point in all of them

Is there any difference (from the point of lazy evaluation) between lazy-cat lazy-seq + cons or just cons if i need to concatenate a value and a lazy sequence?

i mean lazy-.. stuff will wrap first argument into LazySeq and using it in case of already existing first value has no sense right?

cons evaluates both its arguments whereas lazy-seq defers evaluation until the sequence is realized

((fn zeros []
   (lazy-seq (cons 0 (zeros)))))

Using cons for that would produce a StackOverflowError

@qythium yeah i know that cons evaluates its argument, but my case is (cons 0 (lazy-seq ...

since 0 is already there, using lazy- stuff instead of cons has no meaningful reason right?

yeah I suppose, since you don't care about 0 being evaluated

exactly what i thought, ty

Can defs be marked for running by the compiler? e.g. statically run this

(def v1 {:key :val})
(def v2 {:key2 :val2})

(def v3 (merge v1 v2))

you mean you want delayed merge?

Not quite. I'd like to have the compiler replace the merge with {:key :val :key2 :val2} by running the code like macros are

I have dozens of this kind of chained def running at the start of my cljs app, and it's starting to take a hit

@jatkin you can also ask in #clojurescript, i never touched cljs so can't help you with compiletime

Would that be redundant? Seems like it should be the same for both clj and cljs

Macros are done by the clojure compiler typically.

well on jvm compilation and evaluation are mixed, so technically there is no difference, it's just that macros are expanded before evaluation all happens on runtime

So, this will happen by itself on the clojure compiler?

thats why you should ask that question at #clojurescript most likely there is someone to help you who knows cljs specifics of macroexpansion.

I may be misinterpreting. Ok, sounds different enough. Thanks!

In Clojure, those chained def s will be evaluated when the namespace is loaded -- so in that respect it's going to be the same for both Clojure and ClojureScript @jatkin

So if you do that a lot in Clojure, you will take a hit at startup, just like in cljs. My question would be: what problem are you solving to arrive at your current solution? (perhaps there are more performant alternatives?)

I'm using code to save myself a bunch of typing for come config stuff. I have a tool with about 50 config parameters in one part, each one applicable for different items that may appear on the page. To keep it minimal I have code running in this way to dedupe alot of the config possibilities for the ~30 types of options.

Is this just fixed data, computed just once at startup time?

How about defining it in a separate process that you run to compute the full set of data that writes it to a cljs file in fully-expanded form, as a preprocessing step before building you cljs app to js?

@seancorfield i think in that case it would be fixable by a macro

All fixed. Possibly. I was about to write a thunk macro that forces the code in question to run in the compiler, maybe building up a map. If I actually needed the intermediate values I can have it write into a map and assign each def to one of the keys of the map

@nxtk Do you want to have a stab at that macro? I think it's harder than it looks because it relies on combining runtime values -- it's not just compile-time stuff...

oh i'm far from cljs, i only know iterop is different, and it translates to js by google closure

@nxtk Even in pure Clojure...

hmm

@seancorfield whats hard about it? I probably doesn't see what are you talking about.

(def x 5)
(def y 3)

(defmacro m-sum
  [a b]
  `(def z (+ ~a ~b)))

(m-sum x y)

(println z)
(println (str (macroexpand '(m-sum x y))))

x y are runtime, and m-sum is at macro-expansion stage

i mean lisp macros are just a functions which take forms as input and produce forms as output, so i'm not sure how you look at it in that case

please elaborate, so we can be on the same page

You are are generating a form that does the sum at runtime

ok that's true

Which would be the same as what you already have with the merges

if your data is strictly a valid return for a macro then you can do something like this

no i mean in cljs macro will be evaluated on compile time right?

The reason it is tricky is you have to manually do the resolving of symbols to values (at macroexpand time) and them call whatever function on the values. And it is even trickier because the macro language for cljs is clj not cljs

(defmacro compile-eval [& body]
  (eval body))

(def [a b c] (compile-eval (let [x 3 y 5] [x y (+ x y)]))

The macro is expanded to the code, the code them is compiled an run as normal

ymmv though

ah, nvm, def doesnt destructure

yeah i see 😃

It's one of those "simple, obvious" problems that you tend to think just ought to be straightforward with a macro... but the compile-time / run-time divide is hard to cross...

(defn run-chain [items]
  (reduce
    (fn [acc [k f]]
      (assoc acc k (f acc)))
    {}
    (partition 2 items)))

(defmacro compile-eval [& items]
  (eval `(run-chain ~items)))

(def x (compile-eval
         :x (constantly 1)
         :y (constantly 2)
         :combined (fn [{:keys [x y]}] (+ x y))))

(println x)

I think this is working ok. At least for my use case.

Hard to get working on cljs, since constantly has a different symbol and doesn't cross the divide safely.

Yeah, eval... 🙂

Or just, I dunno, def one big map and don't do all the merges?

Hello enlightened souls! Save me please from my Dart prison. I have to build a bunch of apps using Flutter and I'd really want to use Clojure. Anyone know of a transpiler to Dart? Interested in writing one? I'm definitely happy to put some of my own money toward it.

Another question: any book you'd recommend for general good practices coming from an OO background? For example if not inheritance and encapsulation then what model should I use for naturally hierarchical entities? Think UI library with Buttons, Labels etc. Or any good examples of software I should look into that has source code available?

You might find https://leanpub.com/fp-oo helpful @geo.ciobanu

But a lot of how you think in OO isn't applicable in FP -- Clojure in particular favors plain, open data (often, hash maps), over closed, encapsulated data that is "typed"

as far as books go I loved Getting Clojure. and there are clojurescript front-end frameworks you could look to for handling UI

Hierarchical entities are just nested hash maps. But UI stuff often still tends to be a bit OO because of the mutable state. Swing (use Seesaw) or JavaFX (use cljfx I think?).

Getting Clojure is a good intro book, yes. As is Living Clojure.

@geo.ciobanu why flutter and not say, react?

React Native (and ClojureScript) for native mobile apps is a reasonable choice. I was only really addressing backend concerns.

correct me if i'm wrong, but CLJS, specifically redux, makes react faster because of optimized dom updates based on immutable data structures and cheap dirty-checking?

I wouldn't say that was specific to Redux but, yeah, the immutable data structures mean that React-style virtual DOM updates can be figured out faster.

I mean we have flutter vs react performance comparisons, which have nothing to do with cljs, i can see how some new comer making his judgment based on such articles.

I haven't seen Flutter vs React performance comparisons, but the cljs performance benefits come from immutability.

The issue is about how fast it is to compare subtrees of the virtual DOM. If you have an immutable DOM, identity comparisons are valid. If you have a mutable DOM, you have to use deep equality which is much slower.

JS doesn't have immutability, although it has "immutable" libraries where you need to follow a bunch of conventions. ClojureScript has that immutability out of the box.

do we have something like that in clj?

(fn [f pred val]
  (if (pred val)
    (f val)
    val))

The closest is (cond-> val (pred val) (f))

We have a variant at work (open sourced on GitHub): (condp-> val (pred) (f))

https://github.com/worldsingles/commons/blob/master/src/ws/clojure/extensions.clj#L19-L30 if you want to depend on it as a library.

@noisesmith @hiredman related to hanoi-tower, made few variants of move function old https://gist.github.com/nxtk/7c646697240fff2833d104211c8f36c1 new https://gist.github.com/nxtk/c4ea2267c3e865bcbe3d1e32371a38c1

what do you think about latest move not to clever?

@seancorfield i would appreciate if you take a look aswell, it's a classic iterative hanoi-tower algo as lazy seq

How can i write serialized java objects into a file and read them back into java objects in clojure? any serialization library for this?

@lokanadham100 you mean java to json and back?

or java serialization binary?

There's https://github.com/sylvainhalle/Azrael and https://github.com/google/gson and http://genson.io/

hey, when implementing a Java interface with overloading methods on a Clojure defrecord or via reify I need to call the a method from its overloaded implementation. is that possible?

(import '[com.github.benmanes.caffeine.cache.stats StatsCounter CacheStats])

(defrecord CacheMetricsNew 
  [hit-count miss-count load-success-count load-failure-count total-load-time eviction-count eviction-weight]
  StatsCounter
  (recordEviction [this]
    (recordEviction this 1)) ;; this is where the compiler yells
  (recordEviction [_this weight]
    (inc! eviction-count)
    (inc! eviction-weight 1))
  (recordHits [_this hits]
    (inc! hit-count hits))
  (recordLoadFailure [_this load-time]
    (inc! load-failure-count) 
    (update! total-load-time load-time TimeUnit/NANOSECONDS))
  (recordLoadSuccess [_this load-time]
    (inc! load-success-count) 
    (update! total-load-time load-time TimeUnit/NANOSECONDS))
  (recordMisses [_this hits]
    (inc! miss-count hits))
  (snapshot [_this]
    (CacheStats. hit-count miss-count load-success-count load-failure-count total-load-time eviction-count eviction-weight)))

https://www.infoq.com/news/2019/07/rust-elixir-performance-at-scale/ Can this happen with Clojure? 'Interfacing Clojure with Rust'

Clojure can use the JVM's support for native calls, just like Java (via JNA or JNI)

is there any way to retrieve the name of an anonymous function object, as in

(fn foobar [_} ...)

I can see the name as part of the printed object

no, other than by demunging the class name

closest I can get is

(clojure.repl/demunge (.getName (class (fn [] ...)))

right. thanks @alexmiller

Hi all, probably an embarrassing newbie question: I'm getting a baffling message when trying to use clojure.java-time: No single method: start of interface: java_time.interval.AnyInterval found for function: start of protocol: AnyInterval Do I need to construct something somewhere, maybe? The stack trace doesn't even get to my code, so I'm not sure the below is helpful, but here it is (assuming [java-time :as jt]: (defn parse-datetime [s] (when (string? s) (try (jt/offset-date-time s) (catch Throwable _ nil)))) (defn serialize-datetime [d] (when (jt/offset-date-time? d) (try (str (jt/offset-date-time d)) (catch Throwable _ nil))))

@thegobinath there's a talk by lvh that touches on interfacing clojure with c: https://www.youtube.com/watch?v=Lf-M1ZH6KME libpython-clj interfaces with python via c iirc at least one thing from blueberry / dragan uses javacpp (though i'm not having success finding that bit now -- there is mention of org.bytedeco/dnnl-platform in deep-diamond, and iiuc that uses javacpp)

Hi. I like to switch to records for some of my maps. In that records, keys are still mostly optional. So fields can be nil. I still have specs for my maps. In that keys specs, I mark optional keys as optional (as usual). The keys spec op tests for keys with contains?. Now my problem: Records still “contain” nil keys. The value is just nil. So my spec’s don’t work anymore. Instead I have to wrap all optional keys in s/nilable. I think about an option for defrecord to change valAt to return else for nil fields. Anyone had this problem before? Are I miss something here? Related problem: chesire outputs nil values. Third, using __extmap for all optional keys would negate the performance improvements, I see from using records.

if you can have records with nil fields, then yes, you'll need to modify your specs to be nilable

alternately, you could s/conform the record to a plain map and strip nil-valued fields before validating the spec

Yes using conform to change the record before validating is an idea worth exploring. Should have less friction as the nilable stuff. But I still like the idea to have records with “optional” fields which don’t count into contains?. What do you think? For maps it’s good practise to not include nil kvs. In records it’s not possible to do the same.

@alexmiller I went the conformer route - thanks!

Any success stories on doing Natural Language Processing with Clojure? Looking for categorization/topic modelling/similarity/clustering of hundreds of documents. I’m very new to the field of NLP.

Two questions: 1. Does anyone remember that site that had comparisons between lisps in code? It had CL, emacs lisp, and Clojure IIRC. It was something like http://hypermetaobject.com or something. 2. Does anyone know where that ruby->clojure cheat sheet is? It’s out of date I’m sure, but I’m helping someone up their ruby game enough to be effective (don’t ask) and it had a table of clojure fn -> ruby enumerable method.

I found the first one: http://hyperpolyglot.org/lisp

and I got the second. googling is hard 😉 https://gist.github.com/gus/245786

there's also http://www.rosettacode.org/wiki/Rosetta_Code

Bing found the first one as the third regular result for comparison common lisp emacs lisp clojure (in case Google isn't finding it based on a similar phrase). Finding the Gist is definitely harder 🙂

Possibly an incorrect memory from my side, but didn't the clj compiler have some sort of flag to trace what it's doing? So one can debug the cases when it gets stuck (e.g. a top-level (while 1))

Hi, I need an associative data structure with defined order… As of now I use nested vectors like (def vec [[:a "aa"] [:b "bb"]]) and then do the lookup like so (:a (into {} vec)). Is there any better/received way of doing this? Performance is secondary since the structures involved are small (< 20 elements).

Hi. I have some existing tests where there are one or more (future (update-database data)) -type calls going on. Currently, we are doing things like (Thread/sleep 100) to give enough time for the futures to complete before checking they affected things as expected. However, this has unwanted effects like non-deterministic tests that fail randomly if the sleep is too short, and having to always wait that amount of time regardless of how fast it might have completed. Is there anything out of the box to help me do this better? Bar that, I am about to bite the bullet to learn macros, just so I can make something using with-redefs promise and timeouts that can block until the db functions are signaled to complete, or the operation times out.

isn't just promise enough?

with-redefs is not a reliable thing to do with multi-threaded code so probably taking on a different set of pain

Is there such a thing as an in memory writer? I want to use the writer interface but not actually write anything to disk