Does start just takes number of states present in namespace? according to https://github.com/tolitius/mount#recompiling-namespaces-with-running-states

This is an opinion, but if you're just starting I recommend against using mount

Start takes states explicitly or starts them implicitly by the order of require-s

Which one I can use?

In my opinion, start with Component

Next I was planning to learn it

Do you need something like ?

(-> ChronoUnit/DAYS
    EXPIRY_DAYS
    (Instant/now)
    .plus)

😄I mean when printing out

are they three parameters you are passing? or calling function one by one

(prn (.plus (Instant/now) EXPIRY_DAYS ChronoUnit/DAYS))

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/format/DateTimeFormatter.html contains some predefined formatters which might help you

NOt sure if it's what you're looking for, but I strongly recommend https://github.com/dm3/clojure.java-time, which is super easy to use, comes with formatters, easy to use functions and much more. I love it.

Your code would be re-written as:

(plus (instant) (days EXPIRY_DAYS))

(-> (instant)
    (plus (days EXPIRY_DAYS))
    (format))

I did something pretty hacky a while ago to make Date. more readable:

(defn v-time [timestamp]
  (let [dos (java.util.Date. timestamp)]
    (str (subs dos 0 10) " " (subs dos 24 48) " " (subs dos 10 20))))

You pass in unix time and you get something "human readable" out

There are tools for this, but personally, I’d say write your ‘api’ in an .api or .core namespace in plain old Clojure. Re-exporting comes with lots of tool caveats (for one, Cursive doesn’t understand re-exported vars).

The no-magic, no surprises approach sounds appealing indeed, thanks!

obvious code is best code 🙂

> I looked at simply re-`def`/`defmacro`-ing everything I agree, this is fine. It's your API, it's better to devote some of your time to it and be explicit about how you expect the users to use your library. I'd suggest that you also consider defn instead of def. def might seem like less effort because you don't have to type as much but with defn you can have different docstrings for the users vs for contributors and maybe even (slightly) different signatures, which can be useful.

both def and defn will ignore the original doc string, and require adding a new one

Right, didn't realize that def can also have a docstring, thanks. That makes sense actually.

and with either def or defn you can copy the metadata of the original as part of the declaration

or maybe it's simpler with intern actually

(cmd)noisesmith.gui=> (intern *ns* (with-meta 'my-conj (meta #'conj)) conj)
#'noisesmith.gui/my-conj
(cmd)noisesmith.gui=> (doc my-conj)
-------------------------
noisesmith.gui/my-conj
([coll x] [coll x & xs])
  conj[oin]. Returns a new collection with the xs
    'added'. (conj nil item) returns (item).  The 'addition' may
    happen at different 'places' depending on the concrete type.
nil

Probably because it is a subclass of ...gson.GsonFactory https://clojuredocs.org/clojure.core/cast#example-542692cdc026201cdc326ccd

cast doesn't change anything - it just adds an assertion to the compiled bytecode

if you were to do the same thing in java you'd get the same behavior

(defn type 
  "Returns the :type metadata of x, or its Class if none"
  {:added "1.0"
   :static true}
  [x]
  (or (get (meta x) :type) (class x)))

(defn class
  "Returns the Class of x"
  {:added "1.0"
   :static true}
  ^Class [^Object x] (if (nil? x) x (. x (getClass))))

JsonFactory JSON_FACTORY = (JsonFactory) GsonFactory.getDefaultInstance();
System.out.println(JSON_FACTORY.getClass());

in the context of clojure cast lets you avoid some reflection calls

clojure.core/cast is pretty much never what you want

the problem is that the Builder won´t recognize the ctor

No matching method Builder. found taking 4 args for class com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow$Builder

@U0YJJPFRA does the ctor have a varargs parameter?

ctor is that Builder does not fit with args

you aren't calling a constructor

you are calling a method named Builder on the class com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow$Builder and passing it 4 arguments

you want something like (com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow$Builder. 1 2 3 4) not whatever you are doing

(you added an extra /Builder in there, which is syntax for calling a static method)

oh, yes, you right

(defn handle-file-upload [params]
  (if (vector? (params :file))
    (doseq [file (params :file)]
      (if (vector? file)
        "Cannot parse request body. Found a vector within the file vector. Expected maps.\n"
        (copy-file-local file))
      )
    (if (map? (params :file))
      (copy-file-local (params :file))
      "Expected file request to be a map.\n"))
  )

(defn upload-route []
  (wrap-multipart-params
   (POST "/upload" {params :params}
         (let [res (handle-file-upload params)]
           (if (nil? res) (response "File uploaded\n")
               (bad-request res)))
         )))

so there are a few approaches

the most manual - loop

(if (vector? (params :file))
  (loop [[file & rest] (params :file)]
    (if (vector? file)
      "Cannot parse request body. Found a vector within the file vector. Expected maps.\n"
      (do 
        (copy-file-local file)
        (recur rest)))
  ...)

a little less manual - reduce and reduced

(reduce
  (fn [_ file]
    (if (vector? file)
      (reduced "Cannot parse request body. Found a vector within the file vector. Expected maps.\n")
      (copy-file-local file)))
  (params :file))

both work fine

Sweet, thank you very much for this.

So if you don’t recur a loop it won’t continue?

yep

and recur needs to be in tail position

my code there might be a bit wrong - i think you need to check if file is nil which happens at the end w/ the loop - but i think it still shows you some ways to do what you want

Yes it does, I just read through loop and reduced in the docs, just what I was looking for thank you. A little surprised there isn’t a foreach macro, I guess that’s pretty much just a loop ?

Of course it's super silly and stupid, but I can change an atom from the outside world.

(ns econ.core
  (:require [compojure.api.sweet :refer :all]
            [ring.util.http-response :refer :all]
            [schema.core :as s]))

(s/defschema Transaction {:amount s/Num
                          :account s/Str
                          :type (s/enum :outbound :inbound)})


(def transactions (atom []))


(defn add-transaction [transaction]
  (swap! transactions conj transaction))


(def app
  (api
   :swagger
   {:ui "/"
    :spec "/swagger.json"
    :data {:info {:title "Econ API"
                  :description "Econ API Documentation"}
           :tags [{:name "api" :description "Econ API documentation."}]}}

   (context "/api" []
     :tags ["api"])

   (GET "/transactions" []
     :return [Transaction]
     :summary "Returns all transactions"
     (ok @transactions))
   (POST "/transactions" []
     :return Transaction
     :body [transaction Transaction]
     :summary "Echoes a transaction"
     (do
       (add-transaction transaction)
       (ok transaction)))))

Struggling to find a way to filter the items suggests that you might want to structure your data differently, if it's in your control.

Do you explicitly want the returned list be a filtered version of list-B (ie. in the same order)?

One approach would be to (group-by :name list-A) and then check elements of list-B against that.

(let [list-A [{:name "unique_A_name" :age "99"} {:name "joyce" :age "25"} {:name "connor" :age "32"} {:name "brad" :age "21"}]
      list-B [{:name "joyce" :age "77"} {:name "connor" :age "60"} {:name "brad" :age "21"}]]
  (filter (fn [person]
            (some #(and (not= (:age %) (:age person))
                        (= (:name %) (:name person))) list-B))
          list-A))

the above is inefficient/brueforce though

but you can take it as a baseline to make it less wasteful maybe

and yes my instinct is also what @UCYS6T599 said, the datastructure feels wrong. It sounds like you want to deal with relations here (sets of maps) and maybe some of the clojure.set operations, depending on the context surrounding that code.

take a peek here if you didn’t have already, might be useful: https://clojuredocs.org/clojure.set

This is a nice tutorial on creating lookup maps which are generally very useful in my day to day job; https://www.youtube.com/watch?v=n0BTsKVs1Lw

(into {} (map (juxt :name identity) list-b)) might be how I'd start if I was solving the above problem

sorry I couldn’t figure out a better data structure. but I edited my above suggestions to be a bit more efficient. It works but I think there must be something more elegant and efficient.

I second finding a representation of your data more amenable to the kinds of queries you'd like to do. If that's not an option, you can get quite expressive using clojure.set. The following

(set/difference (set/join list-A list-B {:name :name})
                                    (set/join list-A list-B {:name :name :age :age}))

thank you all for your time and effort,

(let [list-A [{:name "unique_A_name" :age "99"} {:name "joyce" :age "25"} {:name "connor" :age "32"} {:name "brad" :age "21"}]
      list-B [{:name "joyce" :age "77"} {:name "connor" :age "60"} {:name "brad" :age "21"}]]
  (filter (fn [person]
            (some #(and (not= (:age %) (:age person))
                        (= (:name %) (:name person))) list-B))
          list-A))

i will try the other solutions also and read the links provided. Thanks

As long as all names are unique,@U01EFUL1A8M's solution will work perfectly. My solution is actually not correct, due to how set/join can pick a key's value from either list.

If a name can appear more than once in list-B, you need to deal with that somehow. I don't know if that's a possible scenario for your code.

(let [n (group-by :name list-B)
      na (group-by (juxt :name :age) list-B)]
  (filter (fn [person]
            (and (get n (:name person))
                 (nil? (get na (juxt :name :age person)))))
          list-A))