https://clojure.org/api/cheatsheet

the dynamic vars *print-length* and *print-level* might be of interest:

user=> (set! *print-length* 20)
20
user=> (range)
(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ...)

you can also simply take some small prefix of the range:

(take 10 (range))

Or just (range 10)

Yeh, for this specific case - but take is more general

(apply map * misc)

Try (map vector [1 2 3 4] [5 6 7 8] [9 10 11 12]) and see that map can take multiple collections and applies the function to the first of each, and then the second etc. etc...

yep I can give multiple collections to map

problem is the three collections are in a list

Just use apply

yep that is what I do in my example, just seemed a bit convoluted

You don't need the convoluted anonymous function... just (apply map * misc)

wow

OK cool I just didn't realise I can do that. Thanks!

No problem. Has the advantage of handling any number of collections, but of course, stops once one of the collections has been used...

e.g. (map vector [1 2 3 4 5] [1 2])

gives ([1 1] [2 2]) which may not be what you want....

although it often is.... 🙂

nope this is fine as this example was just psudocode. my real use-case is implementing a "save all" functionality on table of data from a web app. Here is my real code for your curiosity (after applying your fix):

(defn always-vector
  "this function takes something which may or may not be a vector and makes it always a vector"
  [item]
  (cond
    (= (type item) clojure.lang.PersistentVector) item
    (nil? item) []
    :else [item]))

(defmulti app-page-post (fn [request] ((:params request) :action)))

...

(defn modify-habit [habit_id habit_name freq_value freq_unit date_scheduled]
  (db/modify-habit! (map-of habit_id habit_name freq_value freq_unit date_scheduled)))

(defmethod app-page-post "save_changes_habits" [request]
  (let [{:keys [habit_id
                habit_name
                freq_value
                freq_unit
                date_scheduled]} (request :params)]
    (doall (apply map modify-habit (map always-vector [habit_id habit_name freq_value freq_unit date_scheduled])))))

if you're wondering why I need always-vector it's because of how the framework handles posted data, if there is one item with a given name it's just a string, else it's a vector. which break everything so I need to sanitize that

well today I've learned something new about apply which is great! thanks

vecturns most things into a vector. And see vector? Have a good rest of day.

vec does not do what I want but vector? I can use. thanks!

I realise now my minimal example is not really valid

I've updated my original thread with an example which better captures what I am trying to do

not from the core, but clojure programs can use new (still experimental afaik) virtual threads from latest JVM 19

iirc continuations jdk have been moved to an internal api

Hi. I do this using deftype and then pass around as an opaque handle. I then use a systems library (e.g. component or mount or integrant) to handle its lifecycle management in a running application or REPL. Personally I wouldn't use an atom for this. In many situations, I don't need to pass it around, because I then incorporate that opaque handle into a context (e.g. in a server implementation). In my implementation level code, which uses Lucene directly, I do pass around explicit handles to the required Lucene objects e.g. Searcher. Mostly, at that level, because functions do one thing, they only need one of the basic Lucene objects.

Here is an example: https://github.com/wardle/hermes if it is of any help.

thanks @U013CFKNP2R ! Very helpful. I’m just diving back into Clojure after about a year and forgot about how something like integrant could help here. Thanks for the code sample too.

I understand that I'd have to also re-evaluate any associated defmethods

def it to nil Alternatively, wrap the dispatch function next time

what do you mean def it to nil

(def your-multi nil)

thanks

AFAIK I could have a defmulti dispatching on either a defrecord or deftype by using class to determine the "type" I'm dealing with

I ran through this in CL with CLOS and was able to use multiple dispatch to do relatively the same thing but I'm just balking doing this in clj

For the difference between deftype and defrecord, take a look at https://clojure.org/reference/datatypes (if you haven't already). I'd go for defrecord and see if that works for all your needs.

Should work to start

thanks

defrecord creates a Record type, which has built-in implementations for a many core protocols, giving it out-of-the-box behavior fairly similar to a Map. deftype creates an empty type, with no implementations of anything except what you implement yourself.

If you can benefit from having key value pairs on your data structure, then Record will likely be easier to get going with than an empty type. The basis fields (the keys named in defrecord) will generally show improved performance characteristics than kv pairs of a map would. Additional keys assoc'ed on later will not get this boost. If you dissoc a basis field, you will lose your custom type, as it gets downgraded to a regular map.

If you're planning on implementing something that requires multiple dispatch you may be better off not using protocols and just sticking to multimethods + data. Protocols are a way of hooking into the high performance single dispatch mechanism provided by the JVM, which is not too say that multimethods are "slow". You may find them fast enough ;)

I originally was dispatching on "metadata" in the graph data structure I had which communicated the "representation" of the graph but I found that to be a little too fast and loose for my liking. I think I prefer being able to dispatch on the result of the class fn for this specific application at least.

but yeah, fair point definitely

If you're only dispatching on the class then protocols might be more appropriate. In case you haven't already seen this, take a look at https://cemerick.com/blog/2011/07/05/flowchart-for-choosing-the-right-clojure-type-definition-form.html