@gseyffert see, transient wants implementation of IEditableCollection interface as its input, only few collections implement that interface https://gyazo.com/23105ead02ad141f14e8243c3e17ea17.png

https://gyazo.com/dac646e544a72b82a5f02dd45289a832.png

anyway i found the answer in Emerick's book

Yeah, you’re right. I’ve gotten in the bad habit of just referring to anything I can call seq on as a seq, which is incorrect

But my original answer is correct I believe

answer to my question was, 'yes'

If you pass a collection to transient, you can still safely use the original reference

Right

right

😃

👍

That would be terrible if you couldn’t!

yeah, transients is a bit tricky to understand at first

but thanks to awesome clojure design it's all uniform https://gyazo.com/8c6e5901537e02c95073ef290956eb64.png

People of Clojure, I have a question. I read somewhere that it's possible to connect Clojure REPL to java app in debug mode. Did Anybody try that? Could you please share your experience/links here ? I saw one repo in GitHub, but it's more than 5 years old. It would be nice to have a modern way of doing that.

Is there a way to force use-context-classloader false for an Uberjar?

axiom-dom.jar won't load because it expects to classload /META-INFO/axiom.xml

is there a way to get the "next" item of an item in a sorted map?

@roti what kind of items do you store in the sorted map?

a record type

but I have found another way to implement what I want

essentially I need to keep an index which will allow traversing the collection one at a time

and I just found out .indexOf is implemented for vectors, therefore I can use a vector instead of a sorted map and just play with the index

@roti drop over seq of map doesn't work for you?

the use case is following: the keys are strings (the filename), the values are record types, and I need to iterate over the sortedmap (either by keeping the index, but this does not exist in a map, or by keeping the key)

i'm not an expert, i think we can split sequence by take-while \\ drop-while so effectively next item will be the first element of drop-while sequence

I wonder if it's possible to implement the functions "loeb" and "moeb" in Clojure? https://github.com/quchen/articles/blob/master/loeb-moeb.md

just out of curiosity, I tried playing around with lazy-seq and memoization but couldn't get it to behave lazy enough to actually evaluate

here's a (non-working) translation of the Haskell code

(defn loeb [fs]
  (lazy-seq
    (map (fn [f]
           (f (loeb fs)))
      fs)))

(loeb
  [(constantly 1)
   #(inc (second %))
   #(inc (first %))])
;; should=> (1 3 2)

@roti

(def my-map (sorted-map "e" 5 "d" 4 "c" 3 "b" 2 "a" 1))

(defn create-iterator
  [coll]
  (let [state (atom (seq coll))
        update-state (fn [state] (swap! state rest))]
    (fn []
      (let [item (first @state)]
        (update-state state)
        item))))


(def my-iterator (create-iterator my-map))

;;=> #'junk.core/my-map
;;=> #'junk.core/create-iterator
;;=> #'junk.core/my-iterator
;;(my-iterator)
;;=> ["a" 1]
;;(my-iterator)
;;=> ["b" 2]
;;(my-iterator)
;;=> ["c" 3]
;;(my-iterator)
;;=> ["d" 4]
;;(my-iterator)
;;=> ["e" 5]
;;(my-iterator)
;;=> nil

must be thread safe

Hi, does anyone have good solution to a fast reset-able timeout. I'm already using core.async, but I'm thinking about a classical problem of making a action foo depending on the last time action bar was called, but action bar could be called dozen or hundred times a second and so performance matters a bit.

are you saying you only want the reaction to be run once every x interval, even if the trigger is fired n number of times within the interval?

@lilactown think of it a bit like idle counter, last time there was an interaction then fire the action once (screen saver for example)

I'm thinking now of timeout in an atom and close! it every time there's an action (and replace it with a new timeout)

I can't tell if you're saying no, my interpretation is wrong, or yes, my interpretation is right

I think you're talking about debouncing

🙂 that could be

in which case there's this simple CLJS example: https://gist.github.com/swannodette/5888989

there's probably a simpler way, without core.async

thanks, exactly what I need!

How can I "subclass" a lazy sequence to extend a custom protocol?

similar to defrecord for maps

ie. I don't want all clojure.lang.Sequential or such to support the protocol, but only a custom type which should still remain compatible with all library functions

@nxtk thanks, but I need to go both ways, forward and backward (it's essentially scrolling though a file list). it needs to be fast. i started with a sorted map, because I wanted to also have fast access by filename. i am now using a vector instead, which works, but does not have fast access by filename

a combination of sorted-map with vector would probably work, I was just trying to use only sorted-map, but I guess I need something like LinkedHashMap

i'm trying to calculate a per-frame movement factor for a cursor i'm drawing For example I have

(defn next-pointer
  "Moves the pointer, taking to account speed"
  [{:keys [x y direction speed active] :as pointer} frame fps]
  (let [[dx dy] direction
        norm-time (mod frame fps)
        d-pixels (if (zero? norm-time)
                   speed
                   0)]
    (assoc pointer
           :x (+ x (* dx d-pixels))
           :y (+ y (* dy d-pixels)))))

direction is simply a unit vector so it's either 0 1 or -1 for any element in the vector

here's some more code for context https://github.com/dantheobserver/drawing-experiments/blob/master/src/experiments/12_pixel_paintbrush.clj

I guess I need to keep track of dt