I have in coming datastructures for requests like this

[{(ucv.ui.root.signon/login {:email "", :password "letmein"})
  [:session-key :logged-in? :user-id :firm-id :pos/id :user/id :firm/id]} :com.wsscode.pathom/trace]

I want to write a clojure function in java, and that function may throw an exception that is unknown at compile time. in clojure I can throw anything, anywhere :

(fn [error] (throw error))

new AFn() {
            public Object invoke(Object error) {
                throw (Throwable) error;
            }
        };

With clojure.tools.reader, how do I set the “current ns” when reading auto-namespaced keywords?

(binding [r/*alias-map* {? 'foo}] (read-expressions "(ns foo) #::{:b 1}"))

or do I set *ns* to 'foo?

that works:

(binding [*ns* (create-ns 'foo)
            r/*alias-map* {'foo 'foo}] (read-expressions "(ns foo) #::{:b 1}"))

read-expressions can't really work consistently in clojure jvm

consider "(ns foo (:use bar)) (foo) #::{:b 1}" with (ns bar) (defn foo [] (in-ns 'bar))

if you accept this limitaion, then yes, bind *ns* manually

no need for alias-map

but the model of clojure is read-eval-loop

not read-loop

read-expressions is my own function, which should emulate the read-eval loop

so I’m going to mess with *ns* there

then if you eval the ns form before reading the map it should set! *ns* automatically

and there should be no need to bind it

I’m not going to eval anything, just static code analysis

ok, that's what I'm saying

it cannot work in the general case in clojure

because clojure is not static like clojurescript

and the read/eval phases are not split

because there can be non-top-level in-ns expressions you mean?

same reason why you can't macroexpand a full file w/o step by step evaluation

this can work in clojurescript, not in clojure

it can work in clojure for the 90% of the real world code, but by convention

yeah, I guess I’m going to have to live with that

right, then yes, (binding [*ns* (create-ns ..)] ..) is the best you can do

modulo doing some crazy analysis but I don't think you want to go there

90% is good for now

I'm just inventing that % btw :)

I think you’re not far off 😉

being able to do this stuff is why CL has eval-when and racket has defined phases

clojure has nothing equivalent

it's not the easiest language to build tooling/analysis for

but often it doesn't really matter to be fair

Hello guys

what is the best way to override protected java method ?

for example:

i would like to write this piece of java in clojure

In theory with gen-class I think, in practice writing it in java feels cleaner/faster

there was also once a discussion about this on jira, but it's gathering dust: https://dev.clojure.org/jira/browse/CLJ-1255

Well aware of it, hoping to consider for 1.11 when we get there

excellent

👍

how useful are code reloading libraries like Component, Mount or Integrant? I worry that I'm diving into using a workflow I don't really need.

You could start with just an atom holding your database connection pool - then go with one of those libraries when you need a second atom and dependencies between them.

Just throwing this out there as a GUI alternative. I'm slow, still learning Clojure, time-constrained but I think a productive exercise is to translate the guiserver.lsp file written in newlisp to clojure. The actual GUI part is written in Java and spun up separately from a jar and the guiserver.lsp talks to it over a socket. I think it would be a very nice addition as a clojure librsry. If you play with it first in newlisp, you'll find its plenty responsive and complete enough.

Anyone know of something like clojure.core/eduction except where the input is itself a reducible?

Another way to say it would maybe be “something that could wrap a given reducible with a transducer xform”

that is what eduction does

my mistake, actually eduction doesn't call seq when printed either

it's the print mechanism that calls seq on it

oh, yes it does

I think I logged a bug on this

yeah, print-sequential

https://dev.clojure.org/jira/browse/CLJ-1747

(defn less-promises-eduction [xform coll]
  (reify clojure.lang.IReduceInit
   (reduce [_ f init]
     ;; NB (completing f) isolates completion of inner rf from outer rf
      (transduce xform (completing f) init coll)))

@hiredman Heh, how about that. I assumed from the docstring it needed a coll, and I saw that error when trying it at the repl 🙂

Thanks very much

I have a function that returns a lazy sequence, and I want to lazily concat invocations of this function. So I wanted to use concat, but I heard that it has performance issues and that each concatenation deepens the call stack. Is there some other way I can achieve this?

For instance if you had a function (get-page n) and it returns 10 items or nil, and you wanted to return a sequence of items that lazily calls get-page in the background as needed, what would you do?

and each call has a cost so you don't want to chunked-seq 32 calls at a time

https://dev.clojure.org/jira/browse/CLJ-1906 is a longer exploration of this problem

there are kind of 2 things there: 1. paginated api calls 2. concat

for concat I wouldn't worry

I heard a couple of people complain about that

the problem with concat occurs when you use it in particular ways, but for example (apply concat (get-pages ...)) is generally safe

And it's not (concat ...seqs...) it's really (concat page 1 (lazy-seq (concat page2 (lazy-seq (concat page-3...

A sequence of concats on 2 args

yeah, don't do it that way

build a seq of seqs, then apply concat

but I don't know in advance how many subsequences I need to fetch

that is fine

I'm not going to load all pages then apply

apply won't load all the pages

that defeats the purpose altogether

(apply concat s) forces the first two elements of s (the first two pages) and then the rest will be forced as you walk the seq

but in general, lazy-seqs are not the best abstraction for io, which is why in my initial proposal on CLJ-1906 linked above I suggested something that just implements IReduceInit

exactly how and when pages are forced if you use lazy-seqs will also depend a lot on where/if you put the (lazy-seq ...) inside get-page (assuming it has one)

yeah I am aware of that

I think I'll read the discussion in that ticket

https://ce2144dc-f7c9-4f54-8fb6-7321a4c318db.s3.amazonaws.com/reducers.html is a thing I wrote a while ago about using reduce for this kind of thing, it talks about reducers which are kind of old news these days, clojure has grown even more reduce related features since then (transducers, the interfaces Reduce and ReduceInit)

i seem to recall that there was a way to inspect or print out the intermediate values of the threading macros... like an audit or something... does that ring a bell for anyone?

(-> foo (f) (doto println) (g)) is one pattern for a quick hack

user=> (-> 42 (+ 10) (doto println) (* 2))
52
104

How do I add metadata, this doesn't work:

(-> (map (fn [x] ^{:a 1} x) [1 2 3])
    first
    meta)
;; ==> nil

numbers don't accept metadata, you need a type which supports it

the metadata is implemented as a field on the object that has it, if the object doesn't define the field there's nowhere for metadata to go

it might be more straightforward to use (fn [x] {:a 1 :val x}) and then use (map :val) at the last step, rather than putting the metadata on the thing, you mix the thing in with the metadata

hey everyone. i noticed that my heap usage according to visualvm has been increasing monotonically since i launched my application in the repl. is there anything going on under the hood that could be contributing to this outside of my application, or do i definitely have a leak somewhere?

about 1mb every two seconds or so

the biggest gotcha I can think of is an indefinite lazy-seq where you hold onto a reference to the head

oh, weird. it just dropped to about half and started increasing again

but also it's normal for the jvm gc to let your app usage ramp up indefinitely until some limit is hit - you can test this by specifying a lower max usage

OK, that's normal jvm behavior, it's batching some things for perf reasons

interesting

so this isn’t indicative of a problem?

a normal run of a well-behaved app will look like a sawtooth, where garbage slowly accumulates then all goes down at once

yeah, that’s exactly what it looks like

cool. thanks

so i wonder if i need to keep my maximum steady-state usage to less than the vertical offset of this sawtooth

or if it’ll clean up before pushing me over the edge

depends a lot on your app. how much resident memory does the app actually need? how fast does it produce garbage objects? etc. there are a few hundred knobs to turn for GC.

hmm, ok. are there any resources you could point me to in learning to formulate the right questions to ask here?

it's a big topic, probably worth doing some googling. I don't have a canonical resource to point you to.

@gtzogana Folks who are new to the JVM are often shocked by how much memory it takes up but it's a highly tuned platform and its ability to transparently use and release memory is part of what gives it the power it has... In production, we run processes with between 1GB and 4GB max heap typically -- mostly toward the low end of that -- and those are pretty high traffic processes.

(we have multiple, small services in Clojure now -- previously we had a monolithic web app in a different tech on the JVM and it needed 10-15GB of heap to stay high performance)

cool, much appreciated

The default GC for the JVM are optimized for performance, not for memory

Every GC run, that is, having to loop over objects, identify garbage, and clean it up, takes CPU away from your app

And also will hit your CPU caches and all. Making them cold again for your own computations

Thus what it generally does is wait until absolutely necessary before cleaning up

So it'll just let garbage accumulate until you run out of memory

That's a typical server workload style. Where it assumes your process is the main thing your OS is running, and thus it's better to maximise all your memory use and trade it for better performance

@gtzogana This is a good overview of the GC options: https://dzone.com/articles/choosing-the-right-gc

It's a bit old, so it's leaving out a new GC coming in Java 11 (https://www.opsian.com/blog/javas-new-zgc-is-very-exciting/)

Is there any concept of inheritance ala common lisp CLOS defclass extending another class and fulfilling its type checks of the parent (particularly for multi method dispatch)? Like, if I have a defrecord Person, and want multi dispatched on class. And want an Employee to extend person defrecord without redundant list of field names in arg vector, and would like a defmethod foo Person to work on an Employee instance

no

what you are describe is a typical oop type/class hierarchy, which to some degree clojure rejects(while still having to interop with that kind of thing on the java side) as a good way to organize data.

https://clojure.org/about/rationale#_object_orientation_is_overrated

Clojure rejects concrete inheritance