That's what I'm trying to do, but it doesn't seem that it loads. I even put a println in it and it doesn't fire. I do (:require [myapp.mynamespace]) inside my .app namespace that is called on entrypoint. I do it in ClojureScript, but I don't think it matters in this case.

I never use it, since I just want to add an implementation of multimethod

No idea about cljs so maybe ask in #clojurescript ?

I'll try, thanks!

while "don't use atoms if you can help it" is certainly helpful, this seems to rather be about a case for "make sure you're using/not using lazy-sequences where you expect you're using them"

Yeah, I don't think the moral of this story should be "don't use atoms".

@U093DA4QY, there’s https://github.com/mabe02/lanterna, but you have to suffer a Java API

I recently used lanterna to add a terminal graphics backend to https://github.com/phronmophobic/membrane, but I haven’t released it. If you’re interested in something a little experimental, I can make a new release.

here’s TODO mvc running in the terminal (with mouse support!)

interesting, thanks @U7RJTCH6J!

fyi, there was a similar thread in #off-topic with a good suggestion if you’re using cljs, https://clojurians.slack.com/archives/C03RZGPG3/p1588543676426200?thread_ts=1588541027.424900&cid=C03RZGPG3

Yeah there is https://github.com/CITGuru/PyInquirer if you are okay using libpython-clj

Maybe a lazy-seq would be better?

(defn split-when
  "Like partition-by but splits collection only when `pred` returns
  truthy value. E.g. `(split-when odd? [1 2 3 4 5]) => ((1 2) (3 4) (5))`"
  [pred coll]
  (when-first [x coll]
    (if (not (pred x))
      (cons (list x) (lazy-seq (split-when pred (rest coll))))
      (let [tail (lazy-seq (split-when pred (rest coll)))
            coll (first tail)]
        (cons (conj coll x) (rest tail))))))

suggestion: name: split-at api: [pred coll] will return a lazy seq, [pred] will return a transducer?

@UK0810AQ2 split-at already exists in core

I don't need a transducer myself, but that would be good to add if this went into a public library

so split-when makes most sense, I guess

At the example in the docstring do you mean even? instead of odd?

I want a new collection every time the predicate returns true.

Oh I see. Then the result should have been something like ((1) (2 3) (4 5)) or am I misinterpreting?

no, the predicate is odd, so it should only start a new collection when it returns true

so it starts with 1, because that's odd, until it encounters a new odd number, then you'll get a new coll

Ah ok I had partition-by in my mind that's why I had it the other way

(split-when odd? [0 10 12 3 4 5]) returns ((0) (10) (12) (3 4) (5)) so I assume there is a bug somewhere there?

you're right

I think it is because it's a bit ambiguous on the starting element. It seems to me that you want to start with a list with the first element in no matter what the predicate, and then split when pred is thruthy else accumulate on the list.

[eeeoe] => ((eee) (oe)) [oeeoe] => ((oee) (oe))

yeah

I was thinking this could maybe also done with partition-by + a stateful predicate

You actually want partition-by but with a twist. When partition-by splits it includes the split element at the new list while you want to retain it in the current list. But with this approach you will end up with an empty list in the sequence in certain occasions if you want to refrain from crazy things like including the first element regardless of the predicate.

how about something like this:

(defn split-when                                                   
  [pred coll]                                                      
  (lazy-seq                                                        
    (when-let [s (seq coll)]                                       
      (let [fst (first s)                                          
            f (complement pred)                                    
            run (cons fst (take-while #(f %) (next s)))]           
        (cons run (split-when pred (seq (drop (count run) s))))))))

basically a copy of partition-by with the logic tweaked in the run part

@U1XTUTPMY That looks like it!

my original use case was more like this:

(split-when symbol? ['foo 1 2 3 'bar 5 6]) ;;=> ((foo 1 2 3) (bar 5 6))

@U1XTUTPMY nice! One small detail is that you are wrapping the drop call with seq instead of lazy-seq

I'm not sure why/if the seq needs to be there. I just copied the code from partition-by

so... presumably it is correct enough

partition-by has the lazy-seq there and I think it is there to defer the drop call on the "next" consumption

ah, I suppose you're right. The projet I was messing around in is still using 1.8 so (source partition-by) didn't have the lazy seq there. @U04V15CAJ ^

@U1XTUTPMY oh, so seq should be lazy-seq just before drop on the last line?

yep

cool, thanks

[.. looks like it's the same answer as above lol .. I just used the first one.] I wound up solving a similar problem (in gap scheduling) with the partition-between from the answer here (for a contrast). https://stackoverflow.com/questions/23207490/partition-a-seq-by-a-windowing-predicate-in-clojure?rq=1

Yeah, Cursive doesn’t have good support for it, at least in part because I don’t have a clear mental model of how it should work.