here’s a clue:

(let [fs [inc inc dec inc]
      n  5]
  (reduce #(%2 %1) n fs))

https://blog.fogus.me/2010/09/28/thrush-in-clojure-redux/

(defn thrush [& args] 
  (reduce #(%2 %1) args))

(thrush 5 inc inc dec inc)

a couple of styles here :)

Ah, interesting! Thanks for the link. He uses comp in reverse, too. I was thinking it's sort of a reduce, but I just couldn't get my head around the fact that I'm not "folding" the functions themselves, but making a pipeline. I guess that works though: the accumulator is the thing being transformed, which seems so obvious now that I see it.

(let [fs (repeat 5 inc), f (apply comp fs)] (f 0))

user=> (doc comp)
-------------------------
clojure.core/comp
([] [f] [f g] [f g & fs])
  Takes a set of functions and returns a fn that is the composition
  of those fns.  The returned fn takes a variable number of args,
  applies the rightmost of fns to the args, the next
  fn (right-to-left) to the result, etc.

that's what i would do over trying to understand what thrush means in a codebase. composition is straightforward. thrush is non-standard. certainly understandable but there's a built-in idiom

You'd need to reverse fs before comping though, right? In this case, it doesn't matter, but in general the above would apply the transformations backwards. I like the reduction a bit better for that reason: less moving parts

(defn returns-a-map ^Type [a b]
  {:arg1 a :arg2 b})

I want to load a config file, which is file containing a clojure map

(defn load-config!
  "Returns the content of config file as a clojure data structure"
  [^String config]
  (let [config-path (.getAbsolutePath (io/file config))]
    (try
      (read-string (slurp config-path))
      (catch java.io.FileNotFoundException e
        (log/info "Missing config file" (.getMessage e)
                  "\nYou can use --config path_to_file to specify a path to config file")))))

hm... type hints are useful only together with java interop. For example:

(defn foo ^java.util.Properties [] 
  (java.util.Properties.))

(.setProperty (foo) "qwe" "qwe")

I don't think you need type hints at all in your example

oh, ok, thank you:slightly_smiling_face:

Are you using typehints as a "type system" marks for your code?

I'm asking because there are few libraries that offers much better features to cover validation: clojure spec, malli, plumatic schema, etc.

I am using type hints for documentation mostly and code readability, in this case another lib it is too much 🙂 thanks

The type hints are just metadata, not enforceable, so liable to rot like doc strings

you are seeing it printed. A postgres connection is a complicated object and it just prints out it’s type and hashcode

Oh, ok. How can i “expand” this object and extract data from it (eg. Host, port..etc)?

objects have methods. if there’s a method that servers your purpose, call it

https://javadoc.io/doc/org.postgresql/postgresql/42.2.5/org/postgresql/jdbc/PgConnection.html

the connection itself probably doesn’t have a notion of host and port. But i suspect where you got the connection does

> I don’t know if this is a leak so much as a design assumption that the number of dispatch values is bounded.

it’s a tradeoff. each time it sees a new value that dispatches to the default case it remembers that in order to be faster in the future (so it doesn’t have to recompute that it dispatches to the defaul). If you dispatch on reference identity objects, you’ll have this issue. Not with value based identity objects though.

;; reference based
(= (Object.) (Object.))
false
parse-test=> 
;; value based
(= [] [])
true

i suspect it’s also not just to the default case though

actually it does seem to just be the default case

user=> (defmulti f :foo)
#'user/f
user=> (dotimes [_ 10000000] (f (java.util.HashMap. {:foo 1})))
nil

the method cache is a map from dispatch value (output of the dispatch function) to a function

Oh i get it. Thanks a lot for the explanation. So this should be safe from that issue

(defmulti receive-feed :sportcode)

(defmethod receive-feed :default [msg]
  (timbre/info "Ignoring feed message - unsupported title"))

(defmethod receive-feed "CS" [msg]
  ;;whatever
  )

it is a cache for all successful dispatch values, so this can be an issue any time there are an arbitrary number of successful dispatch values. if there is a default method, then all values are successful dispatch values so that may increase the likelihood of this being an issue. in practice, most uses of defmultimethods use a small number of dispatch values.

is there an easy way to get the cardinality of the cache? I’d be interested to see if we’ve got some cache build up we haven’t noticed

that methodCache field isn't public, but you could use reflection to go after it

or connect with a debugger