What use case are you aiming at? You can wrap Clojure's range with with some set-like behavior to get both

I need to basically check if my ranges are contiguous and/or have overlaps.

You're adding them up in some manner then checking?

You could use interval trees

yeah well I have intervals and I basically need to check for existing gaps

I actually really like how they are showing at the REPL

(interval->guava-range i1)
#object[com.google.common.collect.Range 0x56a8dbf7 "[1.0..10.0)"]

If I understand correctly interval trees are trees that have intervals as keys?

(will google more, thanks for the hint)

Cheers Also see https://github.com/dthume/data.interval-tree

yeah it does not fulfill my use case, we have open/closed bounds (in Guava called endpoints) but thanks for the link!

You can also start from something like this

(defn -range
  [{:keys [min max]}]
  (let [^clojure.lang.Range r (range min (inc max))]
    (reify
      clojure.lang.IPersistentSet
      (contains [_ k] (and (< k max) (< min k)))
      clojure.lang.IChunkedSeq
      (chunkedFirst [_] (.chunkedFirst r))
      (chunkedNext [_] (.chunkedNext r))
      (chunkedMore [_] (.chunkedMore r))
      clojure.lang.ISeq
      (first [_] (.first r))
      (next [_] (.next r))
      (more [_] (.more r))
      (cons [this o]
        (if (.contains this o)
          this
          ???)))))

i’d say not worth having it for your problem. probably worth someone doodling up a cljc library if someone else has the same problems

I know I could implement this myself but Google Guava fits the bill and it's reliable - I just wished it was packaged as separate jar so that I could use only what I need

yeah - the eternal conundrum of Apache/Guice

doseq and run! don't return anything, while mapv does. doseq has a bit of a DSL to support conditions and nested loops, run is straightforward

i have this HTTP connection which returns data intermittently over time. since the response class implements Iterable, i can seqover it to process the data when it's available. but i'm seeing some curious differences between these three options.

That's odd, what sort of differences are you seeing?

there's some logging in there when data comes in. with mapvand run I see the log immediately as expected. with doseqi only see everything at the end, when the connection is terminated (this is on a several minute interval).

Sounds like chunking. I don't recall off the top of my head but I think calling seq on iterable creates a chunked seq

It's often convenient and definitely depends on the case but personally I'm not sure it's good design. Like you said, why not return just the value you're changing and let the consumer do whatever they want (assoc or something else)?

It depends on how the function is expected to be used. I find returning an augmented map works really well for functions in a threading pipeline. But if a function is intended to be used standalone, a straightforward return value makes sense a lot of the time.

For example, at work we have a number of image-processing functions that are intended to be threaded, so they all return their input hash map with "results" assoc'd in.

Yes, I’m assuming the function is useful in a threading pipeline. My main problem is this:

(-> some-map
    some-operation
    (assoc :some-key (some-func ??)))

Also, when I'm not sure about future extensions of the argument and result value, in my experience, taking and returning a map is the best bet.

Maybe I'm overthinking it but my "worry" is that computing the value and enriching a map might be a kind of complecting. Like, maybe it would be better to have x functions that each computes a value and an extra function that does just the enriching by calling the others and assoc'ing their result. But yeah I agree that returning a map is often more convenient!

There's also a performance consideration. Very low level functions might not have the luxury of creating maps for each results.

So it kind of depends, but in most cases it's probably ok

(-> some-map
    ...
    (as-> m (assoc m :some-key (some-operation m))
    ...)

Or at least writing a wrapper function: (defn with-result [m k f] (assoc m k (f m))) so you can do:

(-> some-map
    (with-result :some-key some-operation)
    ...)

I like the with-results function. When your first reaction is ‘I should have though of that’ you know it’s good 🙂

Generally, I think it’s nicer not to assume any composition in your value-producing fn, but let your callers do the composition. I don’t have a no hard rule, though.

Modified the code in core.clj to make an instance of the record: `

(defn foo
  []
  (let [db (DhPgBackside "database")]
    (db/put-proxy  "foo"))
  (println "Hello, World!"))

I left a comment - maybe that clarifies things up. Btw, naming the namespace and record class with the same identifier is really confusing, that's why your IDE is confused perhaps. The comment: https://gist.github.com/KnowledgeGarden/2dc4d57ac59ba856584fb59f206e957e#gistcomment-3976260

@U0JEFEZH6 that solved the issue and, what's more, gave me a much clearer picture of what's going on than I could find in books. Many thanks 👍

Simpler, I think

(defn pull
  [^Iterable coll]
  (let [it (.iterator coll)]
    (fn [] (.next it))))

you'll need to check that the iterator is over and stop consuming somehow

like so

(defn pull
  [^Iterable coll]
  (let [it (.iterator coll)]
    (fn [] (when (.hasNext it) (.next it)))))

Now the obvious question, why?

@UK0810AQ2 can you do that without Java interopt

How about this with an atom?

dev=> (defn keys-sequence [ks]
 #_=>   (let [data (atom ks)]
 #_=>     (fn [] (let [[[x] _] (swap-vals! data next)] x))))
#'dev/keys-sequence
dev=> (def kf (keys-sequence [1 2 3 2 1]))
#'dev/kf
dev=> (kf)
1
dev=> (kf)
2
dev=> (kf)
3
dev=> (kf)
2
dev=> (kf)
1
dev=> (kf)
nil
dev=> 

Technically, that's [[x & _] _] -- swap-vals! returns the old value and the new one, and you only care about the first element of the old value.

I guess this would be nicer:

dev=> (defn keys-sequence [ks]
 #_=>   (let [data (atom ks)]
 #_=>     (fn [] (ffirst (swap-vals! data next)))))

@U14K4HW3T You don't need ref unless you are trying to coordinate multiple updates in a single "transaction". ref is almost never needed, to be honest.

@UK0810AQ2 to emulate a sequence of line-read in a test.

@U04V70XH6 cool, the last code is much better, thanks for share it. One question, isn’t var a better option in this context? Just a fake sequence for a unit test…. Thanks…

What do you mean "var"?

@UEENNMX0T possible, but outside of cljc compatibility I'd reach for an iterable here

@U04V70XH6 something like this:

(defn keys-sequence [ks]
  (def index -1)
  (fn []
      (let [next (alter-var-root (var index) inc)]
        (nth ks next))))

I'd say you shouldn't write your code to begin with in such a manner which is coupled to line read. You have an initial state and a series of inputs. Do you need to model the source of inputs for it to work? (f [state line]) -> new-state Then you can even test this flow in a loop or reduce. Separate the source of inputs

Yep, I guess my problem is to understand simple concepts. Just for illustrate metaphorically the conceptual problem. Imagine I have a simple calculator, and it accumulate values like this.

(defn calculator [ns] 
  (reduce + 0 ns))

(defn calculator-fn [acc, n]
  (if (= acc 10)
    acc
    (recur (+ acc (first acc)) (read-line)))) 

Okay, after some studies, I realise I can do it this way:

(defn acc[a c]
  (let [sum (+ a c)]
    (if (>= sum 10)
      (reduced sum)
      sum)))

;; user real inputs
(reduce
 acc
 0
 (map #(Integer/parseInt %) (repeatedly read-line)))

;; unit test
(reduce
 acc
 0
 (range 9 11))

Re: your "var" example -- having def inside a function is pretty much always wrong. And treating Clojure Vars like mutable "vars" from other languages is definitely not the approach you should be considering -- it's very non-functional.