Why are Clojure frequencies not faster than Python.Counter collections?

Benchmarking something in the JVM is a tricky exercise. The JVM will optimize your code when it runs, but it is not easy to predict when this will happen or will control it. To get anything more than the most general performance hint between the two functions (like Clojure), you need to use a custom comparison library. Criterium is the most used library in the Clojure community for this.

Reasoning about performance is pretty tricky, especially between two very different platforms. I think benchmarking and measuring a lot of code would be the best way to develop intuition between the two languages. Digging into the underlying data structures and understanding their performance characteristics will help you. As you saw in frequencies2

, you can achieve better performance using a modified HashMap than with Clojure's persistent maps. However, if you go down this route, you lose all unfailing kindness.

The Clojure version is missing type hints for several reasons.

• Frequencies are a general purpose function, so they can deal with any value.

• The type hint is really a performance value for interacting with Java classes . From Clojure Programming , page 367

  The type of hints for function arguments or returns is not a signature declaration: they do not affect the types that a function can accept or return. Their only effect is to allow Clojure to call Java methods and access Java fields using compile-time generated code, rather than the much slower use of run-time reflection to find methods or fields that match the form of interaction. Thus, if the prompt does not report interaction operations, they are not actually processed. [...] This conflicts with the signature declarations that Clojure provides, but only for primitive arguments and return types.

If you are exclusively working with Java primitives in a function, you can use the declarationsfor optimization. Again from Clojure Programming , page 438

When Clojure compiles a function, it generates a corresponding class that implements clojure.lang.IFn, one of the Java w1210 interfaces. IFn defines several invoke methods; this is what gets called under the covers when a Clojure function is called.

All arguments and return values ​​are objects within function boundaries (no decoding).These call methods all take arguments and return values ​​of the root type java.lang.Object. This allows Clojure s dynamic input parameters (i.e., your function implementations define the range of valid argument types, not static type declarations that are enforced by the language), but has the side effect of forcing the JVM to inject any primitives passed as arguments or returned the results of these functions. So, if we call a Clojure function with a primitive argument - for example, long - that argument will be put into a Long object to match the type signature of the Clojure functions underlying the calling method. Likewise, if the result of a function is a primitive value, the underlying type of the returned object ensures that such primitives are boxed beforehow the recipient will receive the result. [...]

(defn round ^long [^double a] (Math/round a))
;= #'user/round
(seq (.getDeclaredMethods (round foo)))
;= (#<Method public java.lang.Object user$round.invoke(java.lang.Object)> 
#<Method public final long user$round.invokePrim(double)>)

      

        
        
        
      

    

If you wanted to optimize this further, and you were dealing exclusively with primitive Java integers, then you could use type declarations ^int

for your arguments or return function values. However, I don't think it will be useful for your current code. Another way to go down is to parallelize the counts and concatenate them at the end. You can also take a look at http://java-performance.info/implementing-world-fastest-java-int-to-int-hash-map/ for more ideas, although at this point you are indeed writing Java in funny domain syntax ...