Try concat: https://clojuredocs.org/clojure.core/concat

I tried to use it but it threw an error whenever I invoked the function.

Clojure is designed around immutability. So you don't generally want try to changing things in place like that. Beyond that, it's hard to point you in the right direction from the info provided, because: My first step would be to change add-num to take in a collection and return an updated collection...

(defn add-nums [nums & more-nums]
  (into nums more-nums))

What are you trying to accomplish with this list of numbers?

I just want to access the items in the list for another function to make use of it. Since it is nested within another list, I am having problem with fetching items from the list. Let us say, I want to retrieve the first item with peek or first built-in function, it will return a different result than my desired outcome when the said list is not nested within another list.

A lot of different ways to traverse nested data, depending on the data, the context, and your personal taste. Can you share some code?

I am actually trying to follow some tutorials. Let me show you the code first.

(defn new-list "Creates an empty list of languages to practice." [] (def lang-list (list )) lang-list) (new-list) (defn add-language "Adds a language to the list." [& lang] (new-list) (conj lang-list lang)) (add-language "Python" "PHP") (defn first-language "Returns the first language on the list." [lang-list] (peek '(lang-list))) (defn remove-language "Removes the first language added to the list." [lang-list] (pop '(lang-list))) (defn count-languages "Returns the total number of languages on the list." [lang-list] (count '(lang-list))) (defn learning-list "Creates an empty list, adds Clojure and Lisp, removes Lisp, adds Java and JavaScript, then finally returns a count of the total number of languages." [] (new-list) (add-language '(lang-list) "Lisp" "Clojure") (remove-language '(lang-list)) (add-language "Java" "JavaScript") (count '(lang-list)))

If you notice, in the learning-list function, I have to invoke several functions that were defined previously.

For me to be able to invoke the first-language function or the remove-language function, I must be able first to produce a list. However, since the list is nested to another list, I cannot directly fetch the item as it has to go through the main list upon which the lang-list is nested on.

Hold, on. I'm trying to work out what your goal is from the code. Using def inside a function is a very bad code smell. There are good uses for it, but they are (mostly) limited to "programs writing programs" types of situation. As a rule of thumb def and defn should only occur at the top level.

How can I pass an empty list for another function to make us of it?

Not sure what you mean. You can pass an empty list to any function that accepts lists.

(def result (my-list-using-fn '()))

Initially, the code was like this: (defn new-list [] '()) or this: (defn new-list [] (list ))

The tutorial says that first, you have to define a function that creates an empty list.

What tutorial is that? You don't need to define a function to create an empty list. Even if you need a function for that, list with no arguments can already do that.

(list) ;; => ()

It was in Exercism. Though I know what you mean but with the instruction from the tutorial, I just try to make way to follow what it instructs in the hope that I may learn something from what it tries to make us do.

(def practice-list '()) (defn add-language "Adds a language to the list." [m & lang] (apply conj m lang)) (def with-ps (add-language practice-list "Python" "PHP")) practice-list ;; => () with-ps ;; => ("PHP" "Python")

Maybe it is an exercise designed for another language that translates poorly to Clojure.

If you really must have a list to edit in place, use an atom. https://clojuredocs.org/clojure.core/atom . Not totally sure how Exercism works. But if the process allows it, I suggest only using the instructions as a rough guide, and focus instead on using functions over immutable data structures to reach the end goal. You can come back to atoms after you have a strong foundation in functional design.

Initially, that was what I had in my mind as it would be simple for me to do. However, in the codes given to us, we only need to supply the missing algorithm. Thus, I followed by just supplying the codes that I suppose to think that makes it work.

Anyway, thanks a lot for the response.

What is the target of the exercise? Even though I think this exercise is terribly misguided for Clojure, I still might be able to point you in the right direction.

The aim was to supply some codes to pre-defined functions and on the last function, you supply all these predefined functions to the learning-list function.

Is this the exercise? https://exercism.org/tracks/clojure/exercises/tracks-on-tracks-on-tracks

The problem is that you're trying to apply what you know from imperative languages to Clojure. The exercise doesn't seem to be restricting you to use the functions as steps of an algorithm independently from each other (which requires you to have side effects - if you don't know what that is look it up). In Clojure the proper way would be to use the output of the previous steps as input to the next ones. On my phone right now but give me a moment and I'll come up with something.

This is what I am trying to complete.

(defn learning-list
  "Creates an empty list, adds Clojure and Lisp, removes Lisp, adds
  Java and JavaScript, then finally returns a count of the total number
  of languages."
  []
  (new-list)
  (add-language '(lang-list) "Lisp" "Clojure")
  (remove-language '(lang-list))
  (add-language "Java" "JavaScript")
  (count '(lang-list)))

First, I try to supply the codes for every function that I would eventually need for the learning-list function. Once those functions are ok, I will then invoke them in a particular sequence where the output of the previous function will serve as the input for succeeding function.

Alright, forget about bringing them all together, you should start with new-list:

(defn new-list []
      (list))

    (new-list)
    ;; => ()

(defn add-language [l lang]
      (conj l lang))

    (add-language '("Clojurescript") "JavaScript")
    ;; => '("JavaScript" "Clojurescript")

Yes, I can. If I have to do the codes like your example, then it would be easy.

Give me some time to edit my codes and I will send the codes to you for you to evaluate them.

(defn add-language
  "Adds a language to the list."
  [lang-list lang]
  (conj lang-list lang))

(add-language '("ClojureScript") "JavaScript") ;; returns ((("ClojureScript") "JavaScript"))

My function returns

=> ((("ClojureScript") "JavaScript"))

What's in lang-list?

("ClojureScript")

Something else is happening because what you wrote above is correct.

Maybe you're using an older version of add-language?

Make sure you re-evaluate the functions as you change them

I check your code sample, it also returns this: ;=> ((("Clojurescript") "JavaScript"))

(defn add-language [l lang]
  (conj l lang))

(add-language '("Clojurescript") "JavaScript")

Does it have something to do with Calva or VS code editor?

I'm not sure but the problem is definitely on your side.

Did you override conj by any chance?

I will try to install another editor and from there, I will check again. I will let you know once I have tried again in another editor.

No need to install another editor just for this, VS Code & Calva is a quite decent combination. Restarting the REPL should suffice.

what does conj evaluate to?

I have been changing the codes to find which one will return a list. But I suppose that repl will only read and evaluate the forms that I have written.

It throws an error. I will disconnect and reconnect my repl again.

> I have been changing the codes to find which one will return a list. But I suppose that repl will only read and evaluate the forms that I have written. That's correct but you've been doing lots of side-effects so you might have changed something inadvertently

It is now ok.

It returns this: => ("JavaScript" "ClojureScript")

I will get back to you as I want to complete this particular tutorial. I will just have to try a different editor as I am getting seemingly conflicting evaluation from VS Code editor.

Thanks a lot for the response and assistance.

If you're having issues with your editor you can ask at #calva I wouldn't change editors if I were you, the other decent ones I know is emacs (and vim) and they're not very beginner-friendly... 🙂

I have tried emacs with vim on it. This time around, I would try intellij. I am having problem evaluating forms with Calva.

I use IntelliJ with Cursive, as do many. If you know the beast 🙂 that might be best.

I have not tried it yet but I want to know if it is better than vs code + calva.

Oooh, totally forgot about Cursive! Yes, it's nice. 🙂 > I am having problem evaluating forms with Calva. @U03JN22B596 I'm sure @U0ETXRFEW and the rest of the folks over at #CBE668G4R would be more than happy to help you.

@U03JN22B596 Cursive is great. Though I am pretty sure this is not about Calva. Calva is just sending the forms on to the REPL to be evaluated. Do the same things in some other editor (or even a bare REPL prompt) and you will get the same results. This will rather be about your expectations and your (lacking) experience with the Clojure REPL. Let's see if we can help you with those, regardless of which editor you use.

Can you share the steps you take to evaluate things in your file, @U03JN22B596?

Feel free to DM me if you need help with IntelliJ/Cursive @U03JN22B596. btw, @U03JN22B596, I understand your desire to stick closely to the tutorial. That is wise, because once we deviate from the instructions all bets are off. I agree with @UEQPKG7HQ that this is not a great tutorial, but agree also we can still help you with it. The problem is that the instructions say only "Define a learning-list function, within which you will use...the functions you've defined above." and then describes the steps in natural language. And it leaves out a huge, unstated requirement: how to combine the results of two or more functions. The examples it provides all cheat in this regard:

(remove-language '("Common Lisp" "Racket" "Scheme"))
;; => '("Racket" "Scheme")

(defn learning-list
  "Creates an empty list, adds Clojure and Lisp, removes Lisp, adds
  Java and JavaScript, then finally returns a count of the total number
  of languages."
  []
  (new-list)
  (add-language '(lang-list) "Lisp" "Clojure")
  (remove-language '(lang-list))
  (add-language "Java" "JavaScript")
  (count '(lang-list)))

Thanks a lot. Actually, the codes that I sent was not fully done yet as I was figuring out how to generate a list out from a function. That was the first step. However, since it was pointed out that it does not have to be that way, then I try to follow the inputs given by pavlosmelissinos. As I was doing it, something seemed not properly working with my vs code editor because I have to disconnect the repl and reconnect again before making any evaluation. It is very frustrating. Thus, I want to try using IntelliJ with cursive to see whether repl evaluation with forms will be smooth or without problems.

Well, if you get frustrated installing Cursive I am sure the #CBE668G4R crowd can get you sorted out. See you back in our DM....

If you open a bare repl in the terminal, it starts you off in the user namespace, which already has clojure.core required in for you. But in Calva you typically evaluate directly from a file, where Calva evaluates in that file's namespace, which does not have clojure.core functions available until you evaluate`(ns my.namespace)`. So after a repl restart, you need scroll to the top and evaluate (ns my.namespace) before trying to eval any other code in a file. If your code is in good enough state to not throw any exceptions, then you can alternatively use the command Calva: Load/Evaluate Current File, which will evaluate the whole file at once and make all your defs, defns, etc. available in one go.

After seeing the actual exercise, I still say this is very poorly written for Clojure; though not for the reason I thought it was. If you look closely, it does mostly follow the expectation that functions will take a list as input.

;; Takes a list and an element as args and returns a new list.
;; Here '("Clojurescript") is a stand-in for an existing list.
(add-language '("Clojurescript") "JavaScript")

(def new-list list)
(def add-language cons) ;; or `conj`
(def first-language first)
(def remove-language rest)
(def count-languages count)

(defn learning-list []
  (let [first-langs (cons (cons (list) "Clojurescript")) "JavaScript")
        ...]
    (count final-langs)))

(defn learning-list []
  (-> (list)
      ;; `->` passes the list as first arg of each fn
      (cons "Clojurescript") ;; so this line is actually `(cons '() "Clojurescript")`
      (cons "JavaScript")
      ...
      count))

Exercism does not try to confuse the reader. That’s very unfair to say about an honest attempt to help with learning to code.

I agree, it's not intentional, but it is a bit confusing. Other languages don't have the constructs Clojure does so some of the exercises don't translate very well.

I was personifying the list of instructions, not intending to accuse the writer of being nefarious. Sorry if that didn't come through. I definitely blame this on the totally understandable need to recycle exercises across different languages.

I did not take "try to confuse" literally. 🙂 I took it as, "Man this exercise is poorly crafted!" Anyway... Who knows what was intended, or even what had been covered previously, hence been assumed by the author of the exercise? For one thing, having the tutee do things in functions that are part of Clojure, eg. implementing first, is standard pedagogy. Hell, I was asked to implement mod in a tech interview. I laughed and let them know my earliest languages did not have mod, here is how we did it in 1982. They were stunned by our boomer code, btw. More concerning was leaving out the need to repeatedly operate on the same result, but I wondered if the author thought it would be neat to let the student crash into the need, effectively, to use a threading macro or an atom or a sequence of let bindings. ie, discover immutability on their own. But then I would expect a warning, such as "Do not be surprised if your naive solution does not work -- combining even two of these functions will be a challenge!" But teaching is hard, and good exercise design harder, so...I suggested Winston try Brave Clojure. (Wait, did that have exercises?) OT: Paul Graham is famous for On Lisp, but I recall the exercises in his other title, ANSI Common Lisp, were great.

The author/translator might be able to answer about intents in #C010UTRT0BZ. All I know that an enormous amount of work and energy has been put into making the Clojure track possible and enjoyable. It is also open source.

I think that the ”recycling” of exercises is a good thing. Some exercises are easier in some languages than in others. With a a rich standard library like Clojure's, along with effective core abstractions, Clojure comes out strong, even OP in many of the earlier steps. But there are always things to learn. Reimplementing core functions is certainly worthy efforts.

> For one thing, having the tutee do things in functions that are part of Clojure, eg. implementing first, is standard pedagogy. True. But not usually 5 reimplentations in a row without any preface of "let's pretend x-functions do not already exist". This seems pretty clear to me as an exercise designed for a C-like language, where nobody has found sufficient time for more than a surface level translation to Clojure. If it was reworked properly, it would probably include relevant discussion about combining functions over immutable data. That does not mean Exercism is bad. It just means that this particular exercise is in bad shape.

maps change their type once they become larger than 8 items

(def m (zipmap (range 8) (range 8)))
  (type m)
  ;; => clojure.lang.PersistentArrayMap

  (-> (assoc m :foo :bar)
      type)
  ;; => clojure.lang.PersistentHashMap

In other words it doesn't have to do with group-by/reduce/map/into, it's about the data structure you're using

There's also https://clojure.org/reference/data_structures#ArrayMaps, but: > it has linear lookup performance, and is only suitable for very small maps

@UEQPKG7HQ Thanks for responding. But in my case the order is important becuase this unordered data is displayed on the UI.

Hence I am trying to find a way to return ordered data.

You have to choose another data structure then. This is Clojure being honest with you. It can either give you ordered data or O(1) lookup

Do you need O(1) lookup?

If not, just replace the map with a vector. If you need it, you can keep the map and have a vector to keep track of the order of your keys.

I am open to both the approaches.

Alright, there you go, choose one and go ahead. Or do you have another question?

If I have to get the desired output like this which way do I have to follow ? {["a"] [{:type "chart" :val "a"}] ["b"] [{:type "chart" :val "b"}] ["c"] [{:type "chart" :val "c"}] ....... ..["j"] [{:type "chart" :val "j"}]}

That's an unusual way to represent data

Do the keys have to be vectors?

Also when you say "ordered" do you mean "sorted alphabetically"?

Yes, the keys should be in vector

No, not in alphabetical order. For understanding purpose i have used abcdj.

> If I have to get the desired output like this which way do I have to follow ? It doesn't matter what the desired output will look like. First of all you need to decide if you want fast lookup and this isn't Clojure-related. • Will the data be big? (hundreds/thousands of keys) • Will you need to get the value of an arbitrary key often? If you answer yes to both of the above, then you need O(1) and it's probably better to use a map (to store the data) and a vector (to keep track of the key order)...

data:

{["a"] [{:type "chart" :val "a"}]
["b"] [{:type "chart" :val "b"}]
["c"] [{:type "chart" :val "c"}] .......
..["j"] [{:type "chart" :val "j"}]}

[["a"] ["b"] ["c"] ... ["j"] ...]]

I have input like this: (def data [{:type "graph" :id "memo"} {:type "graph" :id "load"} ... {:type "graph" :id "usage"}]) After doing (group-by :id data) (first time order is getting changed here) and some business logic the output looks like this. {["load"] [load data] ["memo" [memo data] ["usage"] [usage-data]}

Using the original order of the data I need to sort it and return it to the UI.

I am able to sort the data using sort-by with .indexOf [origonal order] function.

But the output is not the desired one.

How do you produce the keys?

If you map the function that computes the keys over the original data you'll get the keys in a seq (but with duplicates). Once you have that, you can use distinct to remove the duplicates.

That will give you the key order, so all you'll have to do is ((apply juxt key-order-vector) unordered-map) and you'll get the values in order

Yes, I did use map function to get keys from the input data to store the original data.

Alright, so you're good to go or do you have another question?

((apply juxt ordered-keys) intermediate-output) I tried your solution, but it thrown me an exception, string cannot be cast to clojure.lang.ifn

should be a vector, not a string

Do have to convert ordered-key/s to vector?

Your ordered-keys should look like this, it's all of the "keys" of the original data, ordered: [["a"] ["b"] ["c"] ... ["j"] ...]] If it does look like that, then this should give you the values of the intermediate output, also in order: (map #(get intermediate-output %) ordered-keys) edit: (you're right, the juxt thing would only work if the keys of the map were keywords)

Let me try this, will let you know the results. Thanks 😊

@UEQPKG7HQ Observations from your approaches: 1. ((apply juxt .....) Throws an exception like key must be an integer 2. (Map #(get ....) This returned only values in the sorted order based on the ordered-key vector. Something like this ([{:type "graph", :id "memo"}] ..... [{:type "graph", :id "usage"}]) Type: lazySeq and output is missing the keyword

Alright, so what's your question?

My question here is, how to get the output in a map with key value

Why do you need the output as a map?

Maps are not meant to be ordered

Output Like this: {["memo" [memo data] ["load"] [load data] ["usage"] [usage-data]}

Agree, maps will not be in order, but is there way to create dat structure like that ?

Why do you need that data structure? This sounds like an XY problem.

What actual goal would having that serve?

In my case, this map item will be processed down further to functions, which is expecting a map of that data structure

And those functions further down expect an ordered map?

Sorry for asking too many questions.

Yes, they require it to be in ordered map.

That's the problem. Maps are associative data structures, their contract is to do fast lookups, not keep the insertion order.

Agree

You could create a new type that satisfies both constraints or add a second "key-order" argument to those functions that expect an ordered map. > Sorry for asking too many questions. You're not asking too many questions but I think they're a bit misguided. You should take a step back and rethink how the data flows through your functions.

A third option would be to replace the maps with another data structure that is ordered but then you lose the ability to do fast lookups.

Yes, currently i am kind of stuck third option. Will try to pass on the ordered-key vector to the downstream functions. Hope it works there.v

Thank you @UEQPKG7HQ

you don’t need all of them 🙂

IFn should be enough but don’t forget that IFn extends Callable and Runnable — to cover those you will need run and call methods

ooh okay that makes things easier

thanks

Q1: Am I understand correctly. There is no such behavior (mainly?) because of promesa is targeting both clj and cljs and there is no such thing as cancellable promise in js?

Q2: Is there a better way to get this behaviour other than copy any from https://github.com/funcool/promesa/blob/master/src/promesa/core.cljc#L297 with one extra form?

(defn any
  "Given an array of promises, return a promise that is fulfilled when
  first one item in the array is fulfilled."
  ([promises]
   (any promises ::p/default))
  ([promises default]
   (let [state (atom {:resolved false
                      :counter (count promises)
                      :rejections []})]
     (p/create
      (fn [resolve reject]
        (doseq [p promises]
          (-> (p/promise p)
              (p/then (fn [v]
                        (when-not (:resolved @state)
                          (swap! state (fn [state]
                                         (-> state
                                             (assoc :resolved true)
                                             (update :counter dec))))
                          #?(:clj (doseq [p promises] (p/cancel! p))) ;; <-- This extra form
                          (resolve v))))
              (p/catch (fn [e]
                         (swap! state (fn [state]
                                        (-> state
                                            (update  :counter dec)
                                            (update :rejections conj e))))
                         (let [{:keys [resolved counter rejections]} @state]
                           (when (and (not resolved) (= counter 0))
                             (if (= default ::p/default)
                               (reject (ex-info "No promises resolved"
                                                    {:rejections rejections}))
                               (resolve default)))))))))))))

no, but you can call rand-nth on a set if you cast it to a sequential collection first (with seq or similar)

(comp rand-nth seq) should give you that function

Sweet, thanks!

Hm, is (rand-nth (seq my-set)) O(n)? I think it probably is. May not matter much for your case, but just throwing it out there.

If performance is any concern.

It might be worth converting the set to a vector up front if it is more than a few elements and you plan to sample many random values. Some discussion here: https://groups.google.com/g/clojure/c/dMFZhEXE88s

no performance is not an issue, only a couple of elements in the set. Thanks btw

no, it's an anonymous instance

if you want something stable, defrecord may be a better match

it doesn't have to be stable, but it'd be nice to give a hint to the gensym i guess? so it'd be more obvious in the stacktrace and easier to parse in (class my-thing)

Yes. require only imports things that are on your project's classpath; your project.clj defines the classpath.

This also means that you will need to restart your REPL when you've added a new dependency, as the classpath doesn't change dynamically at runtime.

Then I got a follow up question.

As you see in the above screenshot, the dependency I have has a specific version.

Let's say I want to import clojure.data.csv how would I know the version number?

lein deps :tree will give you the full dependency tree of whatever you explicitly declare as a dependency

The best place to look to start off is probably Clojars: https://clojars.org/ - you can search there for the latest version.

So each time I need a library I will need to look it up on that website to know what version number I am supposed to import?

Actually I just tried searching for data.csv on Clojars and the official version didn't seem to turn up - the library's GitHub project has the information as well. Usually Googling "clojure + [library name]" will turn it up. https://github.com/clojure/data.csv

And yes, Clojure requires you to be explicit about which version of a library you're installing. In my experience, the benefits of always knowing what library version I have loaded outweigh the costs of looking up the version number. Recording versions in lockfiles or stuff like requirements.txt is now being recommended as a best practice in languages like Python for similar reasons.

the clojure artifacts live in maven: https://search.maven.org/search?q=g:org.clojure the community ones tend to live in clojars

You can also do:

lein deps :query org.clojure/data.csv

@UABEM258C that's handy! I didn't realize that was built into lein. Is there a similar tool for deps.edn?

@UABEM258C , sorry for my noobiness, but am I supposed to write that in repl? I tried but it did not work. And it automatically adds a dependency to project.clj?

No, that's a CLI command that you'd execute from your terminal that uses leiningen to search for versions of a given project. So the workflow would be something like: 1. run lein deps :query from a terminal to get a version number 2. add appropriate entry in project.clj 3. restart REPL 4. require new dependency and go!

@UFTRLDZEW Yes! There is one for deps.edn. Let me find it…

clj -X:deps find-versions :lib org.clojure/data.csv 

I'm not sure if it adds anything beyond what people have already helped with here, but the Deps and CLI guide covers this as well... https://clojure.org/guides/deps_and_cli

maybe something like:

(take 50 (mapcat #(repeat (rand-int 10) %) (range)))

use partition-all

oh... I misunderstood the intent... sry

maybe a combination of partition-by and partition-all

that would work for single stage of removal, but you may need to switch to iterate or a custom lazy-seq builder when it is more complicated

iterate would let you do basically the same thing as the reduce, while still being lazy (which the reduce is not)

I have:

(let [s [1,1,1,1,2,2,2,-2,3,3,4,8,8,8,9,5,5,12,6]]
    (loop [prior nil
           [next & more] s
           result []]
      (cond
        (nil? next)
        result

        (nil? prior)
        (recur next more [next])

        (or (= next prior)
          (= next (inc prior)))
        (recur next more (conj result next))

        :else (recur prior more result))))

https://github.com/seancorfield/clj-new

is this an external tool?

an empty directory is a valid deps.edn project

by default it will look for source under src/

you might find some of what the clj-new template creates for you useful, but you don't need any of it really

it is external, but requires only Clojure cli

thank you both

i use neil like this

neil add build gets me a template very close to what lein new app foo would do

https://github.com/babashka/neil

neil is pretty snappy

indeed. empty directory, neil add build and you are off to the races

@U04V4KLKC I would prefer folks recommend deps-new over clj-new but, as @U064X3EF3 rightly points out, you can have just an empty folder with code in that you can run with clojure script.clj or you can create src and put files in there and use clojure -M -m my.main (to run -main in src/my/main.clj). You only need deps.edn when you want to use additional dependencies @U01188CHUFL

It depends on a person's understanding of the definition of a project (or empty project) Some editors will look for a deps.edn file to automatically determine its a Clojure CLI project, so I usually start with a deps.edn file with an empty map {} When running a terminal Repl prompt, then no file is actually needed (as many people have started previously). I'll use clj-new or deps-new to create a project from a template (clj-new can use the same templates as Lein new), especially if there is config and code that is not really useful to remember how to write from scratch or some libraries I don't use very often (e.g Figwheel-main template with reagent saves me a bunch of time when creating a ClojureScript app). One day (given time and health) there are some templates I'd like to write for deps-new. For now I just have a number of common config and code files in a GitHub repository that I pick and choose from when relevant.

An empty directory may be a valid deps.edn project, but I think most people (and perhaps the OP) relate "empty project" to "project template" or "project with scaffolding" - which lein new ... and clj-new always seemed to do the trick well (I hadn't heard of deps-new) - for the pedantic answer, I think the question might be phrased more similarly to "what is the bare minimum required to be considered a valid deps.edn or clojure project"

For discoverability, if I search "clojure clj-new" on duckduckgo, the first result is the github project page - if I search "clojure deps-new", the first positive match is the 5th result (a reddit thread asking if anyone uses it) - I wonder why it's DDG result is so poor and the project page on github isn't even listed on page 1 of ddg search results

Probably because I wrote clj-new some years back and I wrote deps-new more recently?

I haven't put any notices on clj-new to deprecate it or discourage usage in favor of deps-new. I fell the latter is much more in the spirit of the CLI tools: simple, and depends only on official Clojure core team libraries (specifically tools.build), whereas the former includes Leiningen code and Boot code (that I wrote back in 2015 or 2016).

It's odd, I'm sure it has something to do with the project name - when I've chosen a unique name ("ahflate" being the most recent example) it was listed within an hour on duckduckgo as the top result - I figured since ddg pulls some data from bing, and microsoft controls GH+bing atm

but I see deps-new (commit wise) looks to be a year+ in age - did it just recently move to GH, with those commits being private previously?

As I said above: "Probably because I wrote clj-new some years back and I wrote deps-new more recently?"

I'm sure 4+ years of existence vs 1+ year of existence of a project has some impact on how widely-used and therefore how widely-referenced it is, and therefore how high it places in search results... Bing delivered 🙂

Google too:

(defn assoc-from
  "Call `assoc` on a coll with the matching key value of another coll.
     
  

"
  [target source key & keys]
  (if keys
    (let [keys (cons key keys)
          vals (map source keys)]
      (apply assoc target (interleave keys vals)))
    (assoc target key (key source))))

(defn gen-keys-from [m]
  (-> m keys gen/elements gen/vector-distinct gen/not-empty))

(def gen-2-maps
  (gen/let [ks (gen/not-empty (gen/vector gen/keyword))]
    (gen/tuple
     (gen/map (gen/elements ks) gen/any-equatable)
     (gen/not-empty (gen/map (gen/elements ks) gen/any-equatable)))))

(def gen-2-maps+2nd-keys
  (gen/let [[m1 m2] gen-2-maps]
    (gen/tuple (gen/return m1)
               (gen/return m2)
               (gen-keys-from m2))))

(def result-has-kv-pairs-from-map-2
  (prop/for-all [[m1 m2 ks] gen-2-maps+2nd-keys]
                (let [m3 (apply assoc-from m1 m2 ks)]
                  (doseq [k ks]
                    (= (k m3) (k m2))))))

(tc/quick-check 100 result-has-kv-pairs-from-map-2)

{:fail [[{} {:* {}} [:*]]],
 :failed-after-ms 3,
 :failing-size 0,
 :num-tests 1,
 :pass? false,
 :result false,
 :result-data nil,
 :seed 1668455832429,
 :shrunk {:depth 9,
          :pass? false,
          :result false,
          :result-data nil,
          :smallest [[{} {:A 0N} [:A]]],
          :time-shrinking-ms 7,
          :total-nodes-visited 15}}

gen-2-maps+2nd-keys is intended to create a 3-tuple of 2 maps from the same list of keys, and a list of keys generated from the 2nd map.

Then the property is intended to apply each tuple to assoc-from (which assoc's the value of each listed key from map 2 onto map 1), and test that the values from map 2 show up in the result.

Doseq returns nil which is false

Use every?

thx

Hey @U044Y4Z2R8D map first is the best solution in XTDB here, for the time being, although the "correct" solution is out there but needs implementation effort, see the find specs https://github.com/xtdb/xtdb/issues/1449 feel free to ask questions over in #xtdb or via the other channels 🙂 (e.g. https://discuss.xtdb.com/ or https://juxt-oss.zulipchat.com/)

> keys becomes another thing to maintain and it can lead to some strange bugs also if you've seen something that might be a bug please do flag it 😅

Thanks. It’s not a bug. I mean :keys are based on an order of keys in vector and any mistake in the order can lead to hard to find bugs in code sometimes

clojure.lang.Indexed is the interface needed for nth

https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/Indexed.java

https://insideclojure.org/2016/03/16/collections/ may be useful in getting the lay of the land, and there's some more info in Clojure Applied

Thanks for the references

If your data happens to fit a map-like representation, you can get a lot collection functionality for free by going the other direction: making a protocol to extend a Record type with a few custom methods.