@joelwallis there is an #exercism channel where people contributing to the Clojure track hang out

Awesome!!!

what should the output look like?

is this right?

(let [car-names ["audi" "bmw" "fiat" "haval"]
      car-models ["" ["x1" "i3"] "500" ""]]
  (map vector car-names car-models))
;; => (["audi" ""] ["bmw" ["x1" "i3"]] ["fiat" "500"] ["haval" ""])

but i would adjust car-models to be [[] ["x1" "i3"] ["500"] []], if possible

which gets you

(let [car-names ["audi" "bmw" "fiat" "haval"]
      car-models [[] ["x1" "i3"] ["500"] []]] ;; empty list instead of empty string
  (map vector car-names car-models))
;; => (["audi" []] ["bmw" ["x1" "i3"]] ["fiat" ["500"]] ["haval" []])

or even

(let [car-names ["audi" "bmw" "fiat" "haval"]
      car-models [[] ["x1" "i3"] ["500"] []]] ;; empty list instead of empty string
  (->> (map vector car-names car-models)
       (into {})))
;; => {"audi" [], "bmw" ["x1" "i3"], "fiat" ["500"], "haval" []}

This is the desired output ; desired output of the function = “Audi, BMW X1, BMW i3, Fiat 500, Haval”

I’m going to try the empty lists

(let [car-names ["audi" "bmw" "fiat" "haval"]
      car-models ["" ["x1" "i3"] "500" ""]]
  (->> (map (fn [car-name car-model]
              (cond
                (= "" car-model) [car-name]
                (coll? car-model) (map (fn [model] [car-name model]) car-model)
                :else [car-name car-model]))
            car-names car-models)
       flatten))
;; => ("audi" "bmw" "x1" "bmw" "i3" "fiat" "500" "haval")

map would fit better for that case

(def cars {"Audi" []
           "BMW" ["X1" "i3"]
           "Fiat" ["500"]
           "Haval" []})
           
=> #'user/cars
(for [brand (keys cars) 
      model (or (seq (cars brand)) [""])]
  (str brand (when (seq model) " ") model))
=> ("Audi" "BMW X1" "BMW i3" "Fiat 500" "Haval")

alternative to looking up the keys is grabbiing keys and vals together:

(for [[brand models] cars
      model (or (seq models) [nil])
      :let [model-str (if model
                          (str " " model)
                          "")]]
   (str brand model-str))

Yes I think so. Note that Clojure has thread-first -> and thread-thru ->>

https://clojuredocs.org/clojure.core/-%3E%3E and https://clojuredocs.org/clojure.core/-%3E

@U02313K7TSL the important difference is that OCaml piping is semantic, and clojure threading macros (as all macros) are syntactic - a pipe creates a series of applications, a threading macro does a code rewrite to be more concrete, OCaml piping can't do this:

user=> (->> (+ a b) (let [a 23 b 19]))
42

user=> (macroexpand '(-> y (fn [x] (+ x x))))
(fn* y ([x] (+ x x)))

lists of symbols that are not yet compiled is a lower level, more flexible, and more error prone domain compared to the operatioins the pipes do the macro rearranges symbols in lists, the pipe operator does higher order application and value capture

I think it's good style to use the clojure threading macros as if they were semantic, but you can't really use them fluently without understanding they are syntactic

Thanks!

Off topic: That site has an awesome dark mode!

I am trying to log the sql statements.

There’s currently nothing built into the library for that. For execute! and execute-one! you could write a wrapper that logged the sql-params vector.

In theory you could write something like next.jdbc.default-options that lets you wrap a connectable in something that would log the sql-params prior to calling the implementation.

There are some interesting edge cases: what should you do for a prepare call? It doesn’t actually run the query, it just builds a PreparedStatement, and in general you can’t get the actual SQL back out of those in a generic JDBC way. What about plan which doesn’t do anything until it is reduced? What about sensitive data being passed in as parameters?

Logging result sets is even more fraught since they can be arbitrarily large — and for plan they are not really exposed since the whole point is to reduce over the ResultSet, iterating across it without even producing Clojure data structures.

yup, I wrote a macro with logging.

If you want to see what a variant of default options would be for logging:

(! 1574)-> clojure -M:rebel:test:dev/repl
Downloading: com/bhauman/rebel-readline/maven-metadata.xml from clojars
Selected port 61666 for the Socket REPL...
Starting Rebel Readline as the REPL...
[Rebel readline] Type :repl/help for online help info
dev=> (require '[next.jdbc :as jdbc] :reload-all)
nil
dev=> (def db-spec {:dbtype "h2:mem" :dbname "example"})
#'dev/db-spec
dev=> (def ds (jdbc/get-datasource db-spec))
#'dev/ds
dev=> (def lds (jdbc/with-logging ds println))
#'dev/lds
dev=> (jdbc/execute-one! lds ["create table foo (name varchar(32))"])
execute-one! [create table foo (name varchar(32))]
#:next.jdbc{:update-count 0}
dev=> (require '[next.jdbc.sql :as sql])
nil
dev=> (sql/insert! lds :foo {:name "Sean"})
execute-one! [INSERT INTO foo (name) VALUES (?) Sean]
nil
dev=> (sql/insert! lds :foo {:name "Piyer"})
execute-one! [INSERT INTO foo (name) VALUES (?) Piyer]
nil
dev=> (sql/find-by-keys lds :foo {:name "Piyer"})
execute! [SELECT * FROM foo WHERE name = ? Piyer]
[#:FOO{:NAME "Piyer"}]
dev=> 

That’s available on develop as an experiment, if you want to try it out via :git/url.

nice! does that log via log4j2 or simple stdout?

@munichlinux You supply the logging function(s) so it can do whatever you want.

(I’ve updated it a bit since the post above — see my note in #sql)

❤️