Hi! Quick question: how can I add a CSS class to an element based on a condition in Hiccup? I tried [:div.foo {:class (if error "has-error")}] but it sets (if error "has-error") as the class of the element :thinking_face: @weavejester

@hmaurer How are you using it?

user=> (use 'hiccup2.core)
nil
user=> (def error true)
#'user/error
user=> (str (html [:div.foo {:class (if error "has-error")}]))
"<div class=\"foo has-error\"></div>"
user=> (def error false)
#'user/error
user=> (str (html [:div.foo {:class (if error "has-error")}]))
"<div class=\"foo\"></div>"

It sounds like you're accidentally quoting your code.

@weavejester I was not quoting it I think, but i was on v1.0.5 of Hiccup; perhaps that explains it? Trying v2 now 🙂 Thanks for the prompt reply

It might have been an issue fixed since then.

Is there anyway, using clojure.zip to replace a node with two new nodes?

(let [btree [45 [10] [57]]
      root-loc (zip/zipper vector? rest
                           (fn [[x _ _] children]
                             (vec (cons x children)))
                           btree)]
  (-> root-loc
      zip/down ;[10]
      (replace-with [11] [12]) ; instead of zip/replace
      zip/root))
;=> [45 [11] [12] [57]]

I can't really see any other way around this besides going up and replacing the children in the parent node.

I see I could replace and possibly insert left or right, will try that next.

the way a zipper works, you can think of replace as a mapping operation, you are a particular node, an you map (constantly replacement-value) over the value of that node, what you are talking about would be mapcat

in theory maybe possible, but there are kind of edge cases, like if are visiting node N, and you replace it with nodes N1 and N2, which are node are now visiting? you can make a choice, but there is no single "right" answer there

Yeah maybe my particular case warrants a new replace with function, like you said no right answer

I really want to split a node in two

I don't really care which node i'm visiting because i zip the tree right after

I think you have to do it from the parent

Combining zip/replace with insert-right works... since i don't really care if it goes left or right in my case:

(defn replace-with
  [loc node1 node2]
    (let [[x {r :r :as path}] loc]
      (with-meta [node1 (assoc path :r (cons node2 r) :changed? true)] (meta loc))))

This seems to work

I mean, if you don't want to dig in to the internals of zippers and figure out how to mapcat

These are the originals:

(defn insert-right
  [loc item]
    (let [[node {r :r :as path}] loc]
      (if (nil? path)
        (throw (new Exception "Insert at top"))
        (with-meta [node (assoc path :r (cons item r) :changed? true)] (meta loc)))))

(defn replace
  [loc node]
    (let [[_ path] loc]
      (with-meta [node (assoc path :changed? true)] (meta loc))))

(which I guess you did)

I was just hoping I maybe missed something but it helped talking to you lol

The only reason I didn't want to do it from the parent is because I did not want to go through at worst n many children to find and replace it with two new children

What is the easiest way to achieve the following: I want to split the sequence after the element for which a predicate is true.

you can use split-with

split with will split before the element

not after

Like suppose you have [1 11 8 -3 9 33] and you want [1 11 8 -3] and [9 33], based on predicate neg?.

I'm facing a very weird problem with require. For some reason, when I'm saying (require my-ns-var :refresh) the changes are not applied to that namespace. I'm pretty confident my logic is solid but I'm just missing some intricate detail about require here. Just for reference: this is about reloading changed Garden CSS declarations within my REPL

Problem manifests itself when I have structure main style-ns / page style-ns / component style-ns <- change to last one

I'm requiring the files in correct order, meaning that I first require namespaces which have no dependencies and from there I progress towards the main style-ns

But for some strange reason those changes are not applied

If however I go and reload those namespace manually within REPL in that same order the changes are applied

:refresh is not a thing - you want :reload

Ah sorry about that. Using :reload

So as much as I would have hoped that would have been my problem but alas it isn't 😞

:)

you could also try :reload-all (which also reloads dependent namespaces)

Yeah, tried that. Only thing that changes is the CSS compilation time since requiring takes more time. No help

I'm just using normal Clojure vars here, nothing special really

I don’t know anything about garden, but state has to live somewhere, typically in a var, so I’d investigate where Garden state is getting cached

defs referring to other defs

Garden just takes a bunch of Clojure data structures in and spits out a string of CSS

I've debugged this so far that the actual data structures do not update

So the bug happens way before Garden steps into play

But apparently I'm not missing something special require magic here that I should be aware of

not much other magic to know

Yeah. I actually also tried to use remove-ns before requiring but that proved to cause all kinds of nasty problems

other places where state hides in the runtime are in multimethods (dispatch table) and protocols

I'm wondering if I'm hitting garbage collection somehow

Meaning, my old vars are left dangling and old references are still there for some reason

doubt it

It's really strange since if I go and reload all namespace in order manually it works

But not if I do the same via require

(manually meaning via Cursive "load namespace")

Ahem... Ok. Got it working.

Now using :reload-all

AND

I restarted my REPL...

Still confused what caused all this

I had tried restarting my REPL previously

I really need to dig in deeper into this at some point but I've wasted too much time already

Thanks for ideas!

Hi! I’ve encountered an issue when a protocol is reloaded causing the implementing objects to no longer satisfies? the protocol. Example:

(defprotocol A (foo [_]))
(def a (reify A (foo [_])))

(prn (satisfies? A a))        ;; => true
(defprotocol A (foo [_]))
(prn (satisfies? A a))        ;; => false

In short, no

but you can wrap it in a defonce:

(defonce do-once (defprotocol ...))

Thanks for your answers :slightly_smiling_face: It looks like this wasn't the cause of the problem after all, the protocol is only loaded once. The object that implements the protocol is loaded twice – why that would break things is very mysterious :man-shrugging: _edit: &lt;--- I now realize this doesn't make that much sense in the context of my example, sorry :sweat_smile:_

my guess would be you are aot compiling and somewhere you are importing the class created by a defrecord without requiring the namespace that defines it, so the import is loading the old aot compiled version

I think you are onto something with regards to aot. I will post the minimum code that breaks lein uberjar in thread.

hm. is there some kind of practical difference between seq and lazyseq that i'm missing?

sorry, lazy-seq. to me it looks like they're basically equivalent

they aren't similar much at all. check out the examples on https://www.conj.io/store/v1/org.clojure/clojure/1.9.0/clj/clojure.core/lazy-seq

seq is for consuming seqs from things that are seq'able, lazy-seq is for constructing lazy seqs recursively

Do any libraries exist where I can do collection transformations like (map, filter, reverse, rest, ect) but it keeps the type of collection

I know about mapv and filterv but more would be awesome.

that sounds like one of the core tenants of specter

https://github.com/nathanmarz/specter

I was thinking more of a library with heaps of sequence functions that would instead return vectors for example.

for clojure's built in datatypes other than seq, you can use (into (empty coll) (filter f) coll) etc.