Yes that is interesting. I just tried out ‘(def -str #(str %))’ and ‘(update [] 0 #(-str \a))’ and works.. ofc that isnt good idea

@U2T2ZEVPC I don't think you tried exactly that -- it does not work, for exactly the same reason as I observed: #(-str \a) is still a function of no arguments and is not compatible with update:

user=> (def -str #(str %))
#'user/-str
user=> (update [] 0 #(-str \a))
Execution error (ArityException) at user/eval151 (REPL:1).
Wrong number of args (1) passed to: user/eval151/fn--152
user=>

I tried and worked. Strange. On mobile Replete REPL.

That's ClojureScript -- it may well behave differently than Clojure.

(but Clojure on the JVM should be considered the "reference")

Yes, I see.

I would consider it a bug in cljs to allow that invocation, but I suspect it's because JS itself doesn't check function arities strictly?

It should also be noted that cljs doesn't have the character data type like Clojure does: in Clojure \a is a single character, in cljs \a is just a single character string "a".

(! 733)-> clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "RELEASE"}}}' -M -m cljs.main
ClojureScript 1.10.773
cljs.user=> \a
"a"
cljs.user=> "a"
"a"
cljs.user=> (= \a "a")
true
cljs.user=> ^D

Sun Feb 21 22:18:35
(sean)-(jobs:0)-(~/clojure)
(! 734)-> clj
Clojure 1.10.2
user=> \a
\a
user=> "a"
"a"
user=> (= \a "a")
false
user=> 

Interesting, I dont know that. Thanks the info. I check these things deeply later today

Unfortunately, there are lots of small differences between Clojure and cljs (but nowhere near as many now as there used to be!).

https://clojuredocs.org/clojure.core/defn- public or non-public function, check the example

thanks

I wouldn't get too invested in making functions private

a lot of experienced Clojurists don't make too much use of this. You can also hide things in an internal or impl namespace if you really don't want people calling internal functions

this is only a convention, though

Your (map inc data) benchmark is not doing the work due to laziness (wrap a doall around that or something)

Ok thanks! I check it

Same for r/map I think - you have to reduce the reducible collection to actually do the work

Yes, maybe the map inc isn’t a best test. I re-write later to different task.

My point is that these transducers are fast, you’re just not getting the correct slow times for sequences

Ok, I test it. Thank you!

I don't have a function handy to give you that I know already does this, but if you can take a string s, and any number of {:line <x> :column <y>} maps, and calculate for each one the 0-based index in s where that line and column is, and those indices are start-idx and end-idx, then I think all you need to do after that is (str (subs s 0 start-idx) replacement-string (subs s end-idx)) (perhaps with some off-by-one mistakes there).

Thank you for the response! Hum, I think I got your point, it makes sense, I just need to find the start-idx / end-idx like you said. Probably can get that with some for loops

Sorry, I gave you the answer for the easy part, not the harder part 🙂

Np, any help is welcome 😄 I'm having a hard time with that function haha

@ericdallo what about something like:

String myName = "domanokz";
String newName = myName.substring(0,4)+'x'+myName.substring(5);

you can first split the original string and then update only the relevant lines

and then concat them together again with the newlines

but what about changes that add more lines? for example

(update-text "some \ncool\n text" "boring\n text" {:start {:line 2
                                                      :column 1}
                                              :end {:line 3
                                                    :column 6}})

Are you trying to do deltas for clojure-lsp?

Yep, incremental text change hahaha

Check https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_didChange

TextDocumentContentChangeEvent

working on htis one

are lines indexed by 1?

Yeah, the line and column start with 1

what if the middle contains more than one line?

how is the replacement done then?

I don't get it, it should behave like a block of code change, you remove a block of code and replace by another

ahh okay i see

but the start and end line + cols always match the replacing input length?

oh, no, it matches the old-text

so maybe an algorithm: cut out the original delta and then concat the new input in between

yes, that was @andy.fingerhut suggestion, I'm trying to find the start and end idx so that would work

right

@ericdallo

(require '[clojure.string :as str])

(defn offset [lines line col]
  (loop [lines (seq lines)
         buf (java.lang.StringBuffer.)
         idx 0]
    (if lines
      (if (= line idx)
        (+ (count (str buf)) col line)
        (recur (next lines)
               (.append buf (first lines))
               (inc idx)))
      offset)))

(def string "foobar\nbar\nbaz")
(def os (offset (str/split-lines "foobar\nbar\nbaz") 1 1))
(prn (.charAt string os)) ;;=> \a

Maybe something like this

Then you can use these offsets, to split the original string into three parts and create the new one from the first and last part + the new one in the middle

You can optimize this by searching for the next end line and end col by just continuing the loop

You should take into account Windows newline delimiters, which can be two characters

Yes, this looks a alternative indeed to https://clojurians.slack.com/archives/C053AK3F9/p1614006073168100

The above will probably a bit more performant

thanks borkdude, I'll try if the above solution don't work

yes, it seems to me too

Beware of Windows though, should require careful testing

Always use the file system specific delimiter

Yes, had issues with that some time ago in clojure-lsp crawler 😛

Damm, that was fast! Thank you!! Let me try

It might have an off-by-one error on the columns, but I'm pretty sure it works

partition-by is really the key function here that does all the hard work

yes there is an error*

let me fix

Really cool!

fyi always require namespace clojure.string explicitly

yup just wanted to illustrate

Thank you! I'll test it with some weird inputs and check if it's working, thank you very much for the help 😄

It's working but cropping the first col

(update-text "some \ncool\n\n text" "boring" {:start {:line 2
                                                      :column 1}
                                              :end {:line 2
                                                    :column 4}})
=> "some boring\n text"

it should print "some \nboring\n text"

remove (dec start-column)

and replace with start-column

almost there: "some cboring\n text"

wait what was wrong with the dec?

it was removing the \n

"some boring\n text" should be "some \nboring\n text"

yeah so stick a newline in between prefix and middle-pre

go back to dec

[prefix "\n" middle-pre update-text middle-suff "\n" suffix]

sorry i closed my repl

it works 😄

sweet

will try multiple inputs, thanks @U01G47XUNHM ❤️

no problem!

(require '[clojure.string :as str])

(defn offset [lines line col]
  (loop [lines (seq lines)
         buf (java.lang.StringBuffer.)
         idx 0]
    (if lines
      (if (= line idx)
        (+ (count (str buf)) col line)
        (recur (next lines)
               (.append buf (first lines))
               (inc idx)))
      offset)))

(def string "xxxxxxx\n123\n123")

(defn replace-str [original line col end-line end-col replacement]
  (let [lines (str/split-lines string)
        start-offset (offset lines line col)
        end-offset (offset lines end-line end-col)
        [prefix suffix] [(subs original 0 start-offset)
                                 (subs original end-offset (count original))]]
    (str/join [prefix replacement suffix])))

(prn (replace-str string 1 1 2 1 "dude")) ;;=> "xxxxxxx\n1dude23"

You can optimize offset by collapsing the finding of the first and second offset into one loop

Just another possibility ;)

@ericdallo I have similar code in the clj-kondo LSP server ;) https://github.com/clj-kondo/clj-kondo.lsp/blob/d9d29a5d4a7955daef0f5c196a2054f9c75b7609/server/src/clj_kondo/lsp_server/impl/server.clj#L137

@U04V15CAJ nice solution

definitely more production than mine, i'm fond of code golfing myself

with similar I mean, it doesn't do the incremental stuff, but I had to fix some stuff related to how it shows diagnostics which also required me to split the lines, etc

Nice, it looks easier to understand indeed, I wonder about the performance, if it's relevant

Weren't you starting with this because of performance in the first place? ;)

I would say anything that is executed on each keystroke should be as performant as possible

yes, agree

if you're really after performance you should just write a loop with StringBuffer

I could have sworn I had StringBuffer available in babashka, but that is java.lang.StringBuilder I see now...

Ah, StringBuilder is more efficient I read now

but not thread-safe, well, that doesn't matter here

@U01G47XUNHM what about texts that don't contain new lines?

(update-text "(+ 1 1)" "2" {:start {:line 1 :column 6}
                            :end {:line 1 :column 7}})

I'm getting NPE 😔

@ericdallo My version returns:

(prn (replace-str "(+ 1 1)" 0 5 0 6 "2" ))
;;=> "(+ 1 2)"

(it's 0-based)

let me try

Yeah it works perfectly @U04V15CAJ

thank you both, I'll do some tests yet and later a performance check

@ericdallo on Windows this line (+ (count (str buf)) col line) should probably by incremented by one, if the newline is represented by 2 characters

no, (+ ... (* 2 line)) even

I am adding one offset for each line due to the newline char

maybe LSP already does some normalization on the newlines? don't know

probably not

wait, windows has URI issues related to double \ and etc, why this is related with replacing a text?

because we are splitting on new line and then trying to find the offset by calculating the length of each line + one for the newline

but a newline is represented by 2 characters on Windows

oh yeah, the \r char... damm

you can also just split literally on \n which probably also works

ignoring the \r

yeah, I think that works

so you only have to change the str/split-lines part to split on \n

But your script is already using string/split-lines that take cares of that, right?

hum, got it

on windows it splits by \r\n , got it

so foo\r\nbar will be foo\r and bar

this will then calculate the right offset on each OS

so in this case: totally ignore the file system specific newline :)

changed, I'll create a test for that case as well

it makes sense

thanks!

Here is the more optimized version:

(require '[clojure.string :as str])

(defn offsets [lines line col end-line end-col]
  (loop [lines (seq lines)
         buf (java.lang.StringBuilder.)
         idx 0]
    (when lines
      (if (= line idx)
        [(+ (count (str buf)) col line)
         (loop [lines lines
                buf buf
                idx idx]
           (when lines
             (if (= end-line idx)
               (+ (count (str buf)) end-col end-line)
               (recur (next lines)
                      (.append buf (first lines))
                      (inc idx)))))]
        (recur (next lines)
               (.append buf (first lines))
               (inc idx))))))

(defn replace-str [original line col end-line end-col replacement]
  (let [lines (str/split-lines original)
        [start-offset end-offset] (offsets lines line col end-line end-col)
        [prefix suffix] [(subs original 0 start-offset)
                         (subs original end-offset (count original))]]
    (str/join [prefix replacement suffix])))

(prn (replace-str "xxxxxxx\n123\n123" 1 1 2 1 "dude")) ;;=> "xxxxxxx\n1dude23"
(prn (replace-str "(+ 1 1)" 0 5 0 6 "2" )) ;;=> "(+ 1 2)"

It collapses the finding of both offsets into one loop

Using that works too 🙂 Thank you @U04V15CAJ will follow with that

@ericdallo 2 improvements: - don't use StringBuilder, it isn't necessary - don't use OS specific newline delimiter

(require '[clojure.string :as str])

(defn offsets [lines line col end-line end-col]
  (loop [lines (seq lines)
         offset 0
         idx 0]
    (when lines
      (if (= line idx)
        [(+ offset col line)
         (loop [lines lines
                offset offset
                idx idx]
           (when lines
             (if (= end-line idx)
               (+ offset end-col end-line)
               (recur (next lines)
                      (+ offset (count (first lines)))
                      (inc idx)))))]
        (recur (next lines)
               (+ offset (count (first lines)))
               (inc idx))))))

(defn replace-str [original line col end-line end-col replacement]
  (let [lines (str/split original #"\n") ;; don't use OS specific line delimiter!
        [start-offset end-offset] (offsets lines line col end-line end-col)
        [prefix suffix] [(subs original 0 start-offset)
                         (subs original end-offset (count original))]]
    (str/join [prefix replacement suffix])))

(prn (replace-str "xxxxxxx\n123\n123" 1 1 2 1 "dude")) ;;=> "xxxxxxx\n1dude23"
(prn (replace-str "(+ 1 1)" 0 5 0 6 "2" )) ;;=> "(+ 1 2)"

Nice, mine is just missing the StringBuilder removal so

@U04V15CAJ For some reason your function is failling for some cases, I could only reproduce with that test:

(is (= "(+ 1 1)\n" (#'f.file-management/replace-text "(+ 1 1)\n" "\n" 1 0 1 0)))

I'll take a look

@ericdallo

(require '[clojure.string :as str])

(defn offsets [lines line col end-line end-col]
  (loop [lines (seq lines)
         offset 0
         idx 0]
    (if (or (not lines)
            (= line idx))
      [(+ offset col line)
       (loop [lines lines
              offset offset
              idx idx]
         (if (or (not lines)
                 (= end-line idx))
           (+ offset end-col end-line)
           (recur (next lines)
                  (+ offset (count (first lines)))
                  (inc idx))))]
      (recur (next lines)
             (+ offset (count (first lines)))
             (inc idx)))))

(defn replace-str [original line col end-line end-col replacement]
  (let [lines (str/split original #"\n") ;; don't use OS specific line delimiter!
        [start-offset end-offset] (offsets lines line col end-line end-col)
        [prefix suffix] [(subs original 0 start-offset)
                         (subs original end-offset (count original))]]
    (str/join [prefix replacement suffix])))

(prn (replace-str "xxxxxxx\n123\n123" 1 1 2 1 "dude")) ;;=> "xxxxxxx\n1dude23"
(prn (replace-str "(+ 1 1)" 0 5 0 6 "2" )) ;;=> "(+ 1 2)"
(prn (replace-str "(+ 1 1)\n" 1 0 1 0 "\n")) ;;=> "(+ 1 1)\n\n"

Also notes that this now works:

(prn (replace-str "(+ 1 1)\n" 0 3 0 3 "1 ")) ;;=> "(+ 1 1 1)\n"

Thanks! I'll try

@UJ5N28CL8 that happens because (conj ids (:id jdoc)) is just returning the new seq, but never updating in place your ids binding.

Remember that things are inmutable on Clojure

So conj returns a new collection

you're probably looking for something along the line of:

(map :id [{:id "1" :data "x"} {:id "2" :data "y"}])

thanks guys, yea that’s definitely the problem

I ended up using a very similar when-let*