list? is 99.99% never what you want for checking "is this a list", I'd almost write a linter for this

Just plain Linux here.

For me just arch Linux with vscodium

Do you develop on a laptop or desktop? Is your dev machine the same machine as your main home machine?

Mainly desktop but laptop when traveling. Same machine for everything.

Samen laptop for everything

Lenovo Extreme 2 Laptop with Regolith Linux (Ubuntu+i3) Clojure CLI and my config with lots of additional aliases to extend the tooling Emacs (Spacemacs) and Neovim (Conjure) for editing, with Clojure LSP (Portal and other tools via a custom user namespace) Cljstyle & MegaLinter linting (driven by make locally and CI via GitHub workflows) Docker for local service build & orchestration (only when there are multiple local services and system integration work/testing) I had to use Microsoft windows with WSL in the past, with Clojure CLI and Emacs. It ran okay, but not as nice as Linux.

Linux on laptop and PC, pop os, java versions managed with jenv, clojure and lein installed manually, emacs as ide

The question isn’t general enough for my answer 😀 Mac. Everything Clojure I run natively. Databases and web servers and stuff I run in Docker.

IIRC the Clojure community survey asks a lot of questions like this, and provides useful insight into how the community is doing things at a given point in time. Results for this year should be out in a few months, I think. With that said, I personally work on a Mac with Emacs and Docker. My software deploys to an Alpine Linux container, and that container is then managed by Kubernetes.

Mac M1 at work; Linux and (sometimes) an older Mac for my own time

Typical survey results are 55% Mac, 35% Linux, 10% windows (split in half w or w/o wsl). I don’t have this years results handy but they are in that ballpark

Currently (since September 2022) I’m pretty happy with the following setup: • Intel Mac (waiting for Apple M3) • Kitty + Tmux + Neovim with Conjure and a bunch of other plugins • asdf-vm for managing versions of everything (jvm, node, clojure, neovim)

Re: WSL1 vs WSL2 - with the former, you do better if your files are on Windows, with the latter you do better if your files are on Linux. My dev env - on both my work desktop and my OSS laptop - is VS Code on Windows with everything Clojure-related on WSL2/Ubuntu, with Docker to run third-party services like Elastic Search, Percona, and Redis. Works great.

If you use the undocumented reader macro #=(...) and AOT it should do what you want: (def version #=(->> ...)

sweet, thanks!

FWIW sticking the full expression in #=(->> ..) doesn't work

Huh, I don't know why it wouldn't work either way 🤷:skin-tone-4:

> Is there a way to reliably store data from the environment at build time? read it from an io/resource . Spit such a resource at build time. You can have a dev convenience placed at dev-resources so that the same code works in all envs

When it comes time to package a work as an uberjar (include this, exclude that, resolve such-and-such a conflict by appending all the files, show a splash picture while loading, etc. etc), Maven plugins offer more of the essential monstrosities than "lein uberjar". So even when Leiningen, and its fabulous "checkouts" and "lein test" features, are used in development, the serious work of embedding a version number may usually arise in the context of Maven rather than Leiningen. In that case, you can use what Maven calls "filtered resources", of which one is a file that may say just "{mvn.version}" or something along those lines; Maven populates it and your program loads the resource. Perhaps someone has already made a Lein plugin to do something compatible?

Two args version accepts namespace as first argument which should be a string. Keyword itself can be created from keyword, string and symbol. See the source: https://github.com/clojure/clojure/blob/clojure-1.10.1/src/clj/clojure/core.clj#L620

Yes, but the second arg must also be a string. Also, every char allowed in a keyword can also be present in a string, so I don't see what advantage is gained from requiring a string for the namespace either.

ok, indeed (https://github.com/clojure/clojure/blob/clojure-1.10.1/src/jvm/clojure/lang/Keyword.java#L53). Anyway, I don't see the reason for calling (keyword :foo :bar)

Well, in my case I'm constructing the keyword at runtime and the data I receive for the namespace part happens to be provided as a keyword.

but more generally it would just be for consistency with the single arg variant, and maximum utility

Keywords and symbols can be namespaced already, so the (keyword :a/b :c/d) is confusing. For your case you can call (keyword (name keyword-one) (name keyword-two)).

Oh, interesting. (namespace (keyword "foo/bar" "foo/baz")) yields "foo/bar"

(keyword "a/b/c/d/e")
;; => :a/b/c/d/e

Yeah, and calling namespace on that will yield "a"

I've been taking advantage of that "feature" to my own ends

Yeah, there are some more keyword quirks. https://clojure.org/guides/faq#keyword_number

especially: > [...]no validation check is performed on the inputs to keyword (or symbol), which makes it possible to create keywords that, when printed, cannot be read back into a keyword (due to spaces or other non-allowed characters). If this is important to you, you should validate the keyword inputs first, before creating the keyword.

indeed. Thanks

Updating ring sorta seems to be working. Will keep posted if I make any progress.

There are jetty ring adapters for newer versions of jetty https://github.com/sunng87/ring-jetty9-adapter

I just updated the ring, excluded jetty-http from both aws-api and ring. The added a common jetty-http. It worked and unit tests were passing so I believe it should be good. Though it was kinda confusing. The jetty-http wasn't showing up under the ring as dependency when I did lein deps :tree. It was only showing the jetty-server and I had to go into the jetty-server GitHub and dig through dependency to find which is the common package between jetty-client and jetty-server. Is this common or am I missing something?

I would love a CL utility library and possibly contribute to it.

Though I’m not sure what added value we get in being able to choose comparators in Clojure. In Common Lisp we have to be careful because e.g. a hash-table defaults to EQL, so if we use string keys we’d need STRING= or EQUAL. Meanwhile = in Clojure more or less just works like EQUALP and doesn’t need us to worry much. I guess what I’m trying to get at here is that I can’t recall the last time = wasn’t enough for me in Clojure.

I don't really understand what the clojure example is doing, so it's hard to compare to the lisp ones.

The CLJ example picks out the first lesson with the matching route. To do this, we need to find the lesson, then (my whine) explicitly return it. CL list functions all understand the :key idea, which is "find the elt where (key elt) matches the value for which I am searching.

could you post the objects and output of the function?

Yeah, @U0479UCF48H, the CLJ = covers more ground than CL eql. But if we are going to call it cl-find , we should match the API.

(some even? [1 2 3]) => true

(some #(when (even? %) %) [1 2 3]) => 2

(cl-find even? [1 2 3]) => 2

(cl-find 2 [7 8 9 10] :key #(mod % 7)) => 9

Okay I just came up with a naive implementation of cl-find

(defn cl-find
  "Search for the `item` in the `sequence` bounded by `start` and `end` that
  satisfies the test `test` or `test-not`. If `from-end` is true, then we return
  the rightmost element satisfying the test. A `key` function can be supplied
  for extracting a value before the test is computed."
  [item sequence & {:keys [from-end test test-not start end key]
                    :or {from-end nil
                         test     =
                         test-not not=
                         start    0
                         end      nil
                         key      nil}}]
  (assert (or (list? sequence)
              (vector? sequence))
          "The provided sequence must be a list or vector.")
  (let [search-sequence (cond->> sequence
                          (some? start)    (drop start)
                          (some? end)      (drop-last end)
                          (true? from-end) reverse)
        maybe-key       (or key identity)]
    (loop [continuing true
           result     nil
           [x & xs]   search-sequence]
      (if (or (not continuing)
              (nil? xs))
        result
        (if (or (test item (maybe-key x))
                (not (test-not item (maybe-key x))))
          (recur false x   xs)
          (recur true  nil xs))))))

So far it works for (cl-find 2 [7 8 9 10] :key #(mod % 7))

to be more in-line with common lisp behavior, I should also (assert (or (list? sequence) (vector? sequence))) … I also just noticed my termination condition should be something like (or (not continuing) (nil? xs))

I’m also running into an interesting problem where I want FUNCALL in order to implement FIND-IF, but Clojure doesn’t have FUNCALL 😄

Oh, since the :test-not key and find-if-not function is deprecated, I wonder if people will be okay with an implementation of this function in Clojure leaving out those options. As far as I know, there are functions like remove-if-not that are deprecated but nonetheless allow some code to be easier to read, so a lot of people will use these functions anyway, and will probably be surprised if they’re absent from a Clojure implementation. Hm….

This should work for FIND-IF

(defn cl-funcall [f & args]
  (apply f args))

(defn cl-find-if [test sequence & {:keys [from-end start end key]}]
  (cl-find test sequence
           :test cl-funcall
           :from-end from-end
           :start start
           :end end
           :key key))

Apply

https://clojure.atlassian.net/browse/CLJ-2056

"an interesting problem where I want FUNCALL in order to implement FIND-IF," Wait. What does funcall offer? CLJ is a Lisp-1, we should leverage that, no?

> What does funcall offer? an easy implementation of FIND-IF in terms of FIND 🙂

I also just realized my cl-find function can be slightly faster if we decide to rseq instead of reverse when the input is a vector

Still do not see why we need funcall. Don't need it here, eg:

(defn find-if [test coll]
  (some #(when (test %) %) coll))

It is posted earlier in this thread

I like using the https://github.com/ptaoussanis/encore/ library from @UASETR481 for all sorts of stdlib extensions like this. E.g.

(enc/rfirst even? [1 2 3]) ;=> 2

It’s also in medley as find-first: http://weavejester.github.io/medley/medley.core.html#var-find-first

use specter? https://github.com/redplanetlabs/specter

(use '[com.rpl.specter :refer [select-first ALL]])
(select-first [ALL even?] [1 2 3 4])
; 2