I'm not sure this is the issue actually because i have it working in another project, and over there as well there's the same discrepancy between time zones

using the watchtower library which ring-refresh uses i added my own watcher with

(watcher ["src" "resources"]
         (rate 100)
         (on-change
           (fn [n] (println n))))

What if you run watch -d -n1 'stat -c %Y filename on one of the files? Perhaps something is running in the background touching your files for some reason. Or maybe you have some weird filesystem that doesn't store mtime and always returns the current time when asked.

when i run

watch

as far as the filesystem, i do not have this issue on a different project on this same computer

i dont know if this is relevant, but for previous projects i was using calva. for this project i am using cursive. though when i tried opening this same project in calva it has the same issue

Might be the Cursive's aggressive autosaving? I had a similar problem with a CLJS project. It made hot-reloading pretty much unusable. I couldn't find a way to disable the auto-save or make it less aggressive.

i don't know, there's nothing to save

munge?

beat me to it

(munge 'doit!)
;; => doit_BANG_

Thats it - perfect thanks both of you 🙂. Finally adding pass-by-value to dtype-next's ffi mapping.

I'd suppose you'd just stick all of your results in a vector and return that, no?

(flatten (for [x (range 0 3)] [ [:div] [:div] [:div]]))

Figured it out. flatten wouldn't work, because it would flatten the hiccup. But

(apply concat (for ... [[:div] [:div] [:div]]))

Because it only remove one layer of array

so, what apply does is it basically picks out the elements of a collection, and places each of the elements into the place of one of the arguments the function expects (someone can probably explain that better than I)

Useful lesson.

Note that there's also #C053AK3F9.

(for [x (range 0 3) i (range 0 3)] [:div i]) Added the "i" inside the div so you can see what's going on

Just so you know, (apply concat ...) returns almost the same thing as [ ... ]. The reason the first works and the other doesn't is because apply concat returns a seq instead of a vector, and hiccup treats the two differently. Vectors are always assumed to be html elements and seqs are allowed to be a seq of elements.

True enough. But also: "Clojure Don't's: concat" https://stuartsierra.com/2015/04/26/clojure-donts-concat ... If you have a vector and wish you didn't, you may efficiently wrap it with seq to cloak its concrete structure.

I don't think so, mainly because there would be two router-libs in there. compojure and reitit are routers and it wouldn't make too much sense imho to add both of them.

Ah I mispoke, I meant ring not compojure.

well, I was using kit lately. it's basically comprised of the libs that I would use. it's based on reitit and integrant. you can just add malli to it. maybe it's good for you?

Meyvn does what you want. In my latest https://www.youtube.com/watch?v=RimWHVLkkTw, I've shown how templates work. You'll want to look for "Hello Meyvn web" or "react" if you want client-side deps too. You can use Meyvn to kickstart the template and then turn back to your preferred build tool.

@U067TPTUL Ha I didn't connect "Meyvn" with מבין until I went to your site. Love how it's also a pun for Maven as well.

Loop/recur do not work across function call boundaries

if thats what you are trying to figure out

trampoline is the mechanism for that

the above code works in Clojure though:

user=> (loop2 [[1 2] [3 4]])
[[1 2] [3 4]]

oh it works

but it doesn't get rid of stack frames

hmm, so that's not a good thing to use anyway?

loop/recur are implemented in the really basic

Object s = ...;
Object res1 = ...;

loop:
while (true) {
  if (...) {
     s = rest(s);
     res1 = conj(res1, first(s));
  }
  else {
     break loop;
  }
}

its fine - but this is ~= to how its implemented

i'm just saying that your example doesn't do anything special

within loop1 , loop2 is the same as any function

no, it's just a contrived example of mutually recurring loops

right. loop does not handle mutual recursion

hmm, interesting. I haven't actually tried using a regular loop in the host language so I'll give that a try

what is the host language you are targetting, if i can ask?

JavaScript

it's based on kanaka/mal (Make-a-Lisp)

I might have figured out the problem. At loop, I store just the body in a variable for recur to jump back to with the redefined locals. But I'm thinking maybe if I jump back to the actual (loop ...) form and replace the binding vector, I won't have this issue where it doesn't know which loop we are in

I put in some printlns to get a clear picture of the execution flow:

(defn loop1 [coll]
  (loop [s coll res1 []]
    (do (println "loop1 coll:" coll " res:" res1)
    (if (empty? s) res1
      (recur (rest s) (conj res1 (first s)))))))

(defn loop2 [colls]
  (loop [s colls res2 []]
    (do (println "loop2 colls:" colls " res:" res2)
    (if (empty? s) res2
      (recur (rest s) (conj res2 (loop1 (first s))))))))

(loop2 [[1 2] [3 4]])

loop2 colls: [[1 2] [3 4]]  res: []
loop1 coll: [1 2]  res: []
loop1 coll: [1 2]  res: [1]
loop1 coll: [1 2]  res: [1 2]
loop2 colls: [[1 2] [3 4]]  res: [[1 2]]
loop1 coll: [3 4]  res: []
loop1 coll: [3 4]  res: [3]
loop1 coll: [3 4]  res: [3 4]
loop2 colls: [[1 2] [3 4]]  res: [[1 2] [3 4]]
[[1 2] [3 4]]

omg I finally got it

case "loop":
    var loop_body = [types._symbol('do')].concat(ast.slice(2))
    var loop_env = new Env(env);
    var loopLocals = []
    for (var i = 0; i < a1.length; i += 2) {
        loop_env.set(a1[i], EVAL(a1[i + 1], loop_env));
        loopLocals.push(a1[i], EVAL(a1[i + 1], loop_env))
    }
    ast = loop_body
    env = loop_env
    break
case "recur":
    loopLocals.__isvector__ = true;
    // duplicate each recur form
    var recurForms = ast.slice(1).flatMap(i => [i, i])
    for (let i = 1; i < recurForms.length; i += 2) {
        let f = EVAL(recurForms[i], loop_env)
        f.__isvector__ = true;
        loopLocals[i] = f
    }
    ast = [types._symbol('loop')].concat([loopLocals, loop_body])
break

It seems so innocent sitting there like that. This took me like a whole week