examples here: https://github.com/thheller/reagent-react-native

To clojure/clojurescript the languages it is just a keyword like :a or :b or :<

But that keyword is being used as part of the syntax of whatever dsl, I guess reagent

Apparently it is syntax for using react components in reagent

Ohh interesting, thanks

To my understanding it's used when you want to use a javascript component like material ui:

[:> muc/Tabs options [...]]

["@material-ui/core" :as muc]

Yup, it's a particularity of their hiccup-like syntax, you can see it in action here: https://cljdoc.org/d/reagent/reagent/1.2.0/doc/tutorials/interop-with-react#creating-reagent-components-from-react-components

Still a little confused about the syntax here - my understanding that per the linked doc, :> is shorthand for a function, but it’s called like [:> rn/Text "Text"], so an element in a vector. If it’s a function, shouldn’t it be called like [(:> rn/Text "Text")] ?

:> is just keyword

the meaning is given to it by the library that is processing the datastructure it appears in

Oh so it’s creating a data structure that Reagent knows “this keyword means that the next symbol is a JavaScript component”?

user=> [:> 1 2]
[:> 1 2]
user=> (type [:> 1 2])
clojure.lang.PersistentVector
user=> (mapv type [:> 1 2])
[clojure.lang.Keyword java.lang.Long java.lang.Long]
user=> 

When it’s compiling to JS

runtime more likely, not compile time, given the examples I've seen, but I am not sure

Is compile “take this CLJS and write a JS file”? wouldn’t that be the only time this would be possible?

no

the compiled output for something like (fn [] [:> 1 2]) is compiled for clojurescript, but in generally you can assume it will generate javascript code that when it is run will produce a function that when called will return a cljs vector where the first element is the keyword :> and the second is the number 1, etc

there is no reason other code cannot traverse and do whatever it wants with that datastructure

the cljs world is a little bit fonder of ridiculous macros, which is how you would handle this at compile time, so I won't rule that out, but with the examples I've seen there would be significant challenges to doing this all as a macro at compile time, so my guess would be the datastructure is run through an interpreter at runtime

https://github.com/reagent-project/reagent/blob/a14faba55e373000f8f93edfcfce0d1222f7e71a/src/reagent/impl/template.cljs#L282 part of the little interpreter

if-letonly handles one binding

I do sometimes use some-> for exactly this purpose.

(let [[a b c :as var-list] [1 3 2
                             ;;; (op-1) (op-2 a) (op-3 b)
                            ]]
  (if (not-any? nil? var-list)
    :success
    :not-very-successful
    )
  )

some->> some-> cond-> cond->> are nice for situations where they work

I think he's intending that if-let works the same as let with an if inside. So I think

(if-let [result (some-> (op-1) op-2 op-3)]
  :success
  :fail)

Being able to retain the individual bindings is nice, but not strictly necessary for my use case. Was also mostly curious how others are solving this, so thanks for the feedback, both 😄

I didnt use this and have a quite vague understanding of monads but just lately came across this project: https://github.com/clojure/algo.monads where in tutorial 1 they do said task with

(defn f [x]
  (domonad maybe-m
    [a  x
     b  (inc a)]
    (* a b)))

Ya, I don't need to do this very often, but it's a shame if-let doesn't support more bindings

Yeah this pattern is encoded well with the “maybe monad” - that doesn’t mean you have to use the monad library but it’s a good source for a search term and validation that this is a familiar pattern!

elixir has a with statement that acts like if-let with multiple bindings, but it isn't conditional, if any of the bindings fail then there is some catch like statement for handling that. maybe something similar could be done in clojure, possibly more intuitive than if-let with multiple bindings.

you could maybe look at the value of *ns* ?

exec-a1bd4801-48c2-4151-96ae-50c63588de11

that is the ns in which your tasks run, but not the ns in which your tests run

you want to determine the ns inside your fixture right?

yeah, so my idea would be that each of the test files imports some generic fixture, which in turn will use the files from the test’s directory. if that’s not completely unreasonable.

I guess I could “just” parameterize the fixtures, give them the working dir (or the config file path directly) as argument. I guess that would be more explicit?

being more explicit is usually best

OK I’ll just go with that. I think I should be able to figure that out myself. thanks!

let me know if you're stuck

thank you!

(ns data-kafka-test
  (:require [clojure.test :refer [deftest is testing use-fixtures]]
            [babashka.http-client :as http]
            [babashka.process :as process]
            [test_utils :as util]))

(def dir "test/data-kafka")

(def messages "{\"id\": \"bob\", \"permissions\": [{\"path\": [\"cars\"], \"method\":\"GET\"}]}\n")

(defn publish-messages []
  (process/shell {:dir dir :in messages} "docker compose run -T kcat -P -b broker:29092 -t users"))

(defn with-messages [f]
  (publish-messages)
  (f))

(use-fixtures :once (util/with-dc dir) with-messages)

(ns test_utils
  (:require [babashka.process :refer [shell]]))

(defn start-docker-compose [dir] (shell {:dir dir} "docker compose up --wait --quiet-pull"))
(defn stop-docker-compose [dir] (shell {:dir dir} "docker compose down"))

(defn with-dc [dir]
  (fn [f]
    (start-docker-compose dir)
    (f)
    (stop-docker-compose dir)))

not at all, very nice

thanks for bearing with me. all that help! and it also helps to have a place where you (well, I) feel like no question is too basic or embarrassing.

glad you figured it out :)

What do you mean by "store data"?

But in answer to the Q I think you're asking, qualified keywords do not need to match code namespaces.

You can even use a long qualifier, like :.qualifier/my-key and say [this.is.my.qualifier :as-alias q] in your :require so you can use ::q/my-key in your code without needing a namespace of code for this/is/my/qualifier.clj

(`:as` will load a namespace of code but :as-alias will not)

Sorry for being vague, I was just trying not to get too far into the weeds. I'm using CouchDB which structures data from db -> design -> views. So I was going to use the namespace part as the design name, and keyword name as the view name. Something like: (get-document db :design-name/view-name document-id) . I'm still not sure if I'm abusing the namespace part, or if I should just do`(get-document db [:design-name :view-name] document-id)`

It's good to know that there's no consequence for not matching code namespaces, and thanks for the tip about aliasing, I'll use it

The main idea behind qualified keyword is to provide context and uniqueness: if you have :id or :name it doesn't tell you much and it will collide with any other unqualified :id or :name keywords; if you have :user/id or :account/name you can tell more about it -- and you can have :page/name and :account/name in the same hash map.

Sounds like it fits with my use case. I'll play around with it. Thanks! I appreciate the help

reduce over coll and throw the values into sets in a map or something, and then count the sets

(defn count-all-counties [coll]
  (count (reduce (fn [acc i]
                   (-> acc
                       (conj (:key1 i))
                       (conj (:key2 i))))
                 #{} coll)))

it might be desirable to keep the values separate, assuming that there could be overlaps in the values and they should be counted separately

true!

clojure.core/frequencies might come in handy here as well, at least if you're okay with entries with nil values being discarded.