Is there such a thing as a "lazy set" collection in Clojure?

I'm imagining something with constant-time contains? lookup for items that have already been realized, but which lazily defers additional elements which are not yet needed

(def primes
  (lazy-set (filter prime? (range 10000))))

;; Only computes as many elements as needed until a match is found
(contains? all-primes 7) ;; => true

;; constant-time, because `3` has already been found in the set
(contains? all-primes 3) ;; => true

;; Forces evaluation of the entire collection to ensure an item does *not* exist in the set
(contains? all-primes 6) ;; => false

@qythium

(defn make-lazy-predicate
  [coll]
  (let [state (atom {:mem #{} :unknown coll})
        update-state (fn [{:keys [mem unknown] :as state} item]
                       (let [[just-checked remainder]
                             (split-with #(<= % item) unknown)]
                         (if (seq just-checked)
                           (-> state
                               (assoc :mem (apply conj mem just-checked))
                               (assoc :unknown remainder))
                           state)))]
    (fn [item]
      (let [next-value (first (:unknown @state))]
        (get-in (if (or (nil? next-value)
                        (< item next-value))
                  @state
                  (swap! state update-state item))
                [:mem item])))))

(def lazy-even? (make-lazy-predicate 
                  (filter (fn [n] 
                            (Thread/sleep 100) 
                            (even? n)) 
                          (iterate inc 0))))

Hello! Using clojure.xml, how do I output XML with double quotes, not single ones? (e.g. <foo bar="123"></foo> not <foo bar='123'></foo>)?

Hello. Can you give me some examples of clean functions, that can be tail or non-tail recursive and made stackoverflow and/or calculated long time (better both of these) without memoization? I wanna test something.

with arguments on which it occurs

@ivana it's e.g.

user=> (defn boom1 [] (loop [] (recur)))
#'user/boom1
user=> (boom1)

but what do you mean "clean" functions?

what about without jokes?

something like

(defn coin-change [s coins]
  (cond (= s 0) 1
        (or (< s 0) (empty? coins)) 0
        :else (+
                  (coin-change s (rest coins))
                  (coin-change (- s (first coins)) coins))))
(coin-change 10000  '(1 5 10 25 50))

@ivana w/o jokes, I clearly remember one first videos on core.typed has given example of functions which give StackOverflow. Only I can't find that video now 😞

ah, here it is: https://youtu.be/a0gT0syAXsY?t=15

thanks, I'l see

it seems that video explains an example of SO cause of error in code, but not correct function with limited Java stack, like my example above

I have a Clojure process that's not exiting despite me calling shutdown-agents — what else might I be missing here?

so maybe there is another Cllojure messenger where I can ask my question? can anyone suggest?

@martinklepsch check what threads are running on it by calling jstack on the pid. You might have another naughty thread that isn't the agent executors

There are programmatic ways of enumerating the running threads, too

@ivana Fibonacci is a good example of that. It can be written recursively with or without tail recursion.

Without tail recursion:

(defn fib [n]
 (if (<= n 1)
  n
  (+
   (fib (- n 1))
   (fib (- n 2)))))

(defn fib [n]
 (loop [n n a 0 b 1]
  (cond
   (= n 0)
   a
   (= n 1)
   b
   :else
   (recur
    (- n 1)
    b
    (+ a b)))))   

is there a built in function/macro that takes a set of symbols and returns a map with keys that mirror the symbol and value being the value behind the symbol. for example (let [a 1 b 2] (toMap a b)) -> {:a 1 :b 2}

no

there was a clojureverse discussion on this which included at least one implementation

i think its a great idea by the way

https://clojureverse.org/t/shortand-clojure-syntax-for-properties-on-hashmaps/1918/24

it's one of the few things I like in JS lol

is it save to use persistent vector reference from which transient one was created?

Yes, (transient my-var) creates a transient version of the original var without changing the original one

@didibus thanks. But even exponential recursive Fibonacci can not fall in SO, cause universe is died before 🙂 And iterative one is a simply tail-recursive. I wanna test my SO-problem solver I write in Clojure. I just want more test cases, for make me sure. Cause all tests I can create are passed 🙂

Hello All! I'm using clj-jade to render a Jade template, passing an array as parameter: (jade/render "index.jade" {"param1" [1 2 3]}) My friend is using Pug.js, and can do param1.length to get the size of the array, but it doesn't work when using clj-jade. How can I extent clojure.lang.PersistentVector to add a static field length that will be initialized when the vector is created?

You should not want to do this

Vectors implement Java Collection which has a size method and Clojure collections which have a count function.

@alexmiller Yes, size method works fine in clj-jade.

@gseyffert but transient is not about vars 😃

Yeah it’s about seqs, but a seq will always be bound to a var?..

its about collections

How is a collection different from a seq?

sequence is abstraction

Sure

well collection too, nvm

however they are different entities in terms of implementation

People, I have two questions:

- who is using the Clojure client, for Kubernetes?

- which ZeroMQ bindings are used?

so two questions, the scopes of those are unrelated to each other

@gseyffert seq are collections which support the first, next, and more fns. While collections only support count and empty and =.

See: https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/ISeq.java and https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/IPersistentCollection.java

Also more relevant to Clojure, functions that work over seq takes the seq as the last argument, while those that work over coll (that aren't seq) take it as the first argument.

http://insideclojure.org/2015/01/02/sequences/

http://insideclojure.org/2016/03/16/collections/

^^ those might be helpful

Sure, but in the context of transients they’re used identically? Just (transient ...) to create a transient version

And that’s the same for seqs and collections

*treated vs. used

I’ve also just gotten into the colloquial habit of referring to a lot of things as seqs even if they aren’t technically...

Which is maybe worth breaking