Protocol and multimethods are complementary and intended for slightly different use cases. Protocols provide efficient polymorphic dispatch based on the type of the first argument. Because the is able to exploit some very efficient JVM features, protocols give you the best performance. Multimethods enable very flexible polymorphism which can dispatch based on any function of … Read more
As of Leiningen 2.x, :java-source-path has been replaced with :java-source-paths, whose value is now specified as a vector rather than a string. A good place to find a full (up-to-date) documentation of Leiningen features is to peruse the sample project file. In this case, you will see: :java-source-paths [“src/main/java”]
I guess it’s ok if you think it helps, but many Clojure projects don’t do so — cf. Compojure (using a top-level compojure ns and various compojure.* ns’s for specific functionality), Ring, Leiningen… Clojure itself uses clojure.* (and clojure.contrib.* for contrib libraries), but that’s a special case, I suppose. Yes! You absolutely must do so, … Read more
Basic Predicates/F-functions McCarthy‘s Elementary S-functions and Predicates were: atom Which was necessary because car and cdr are defined for lists only, which means you cannot count on any sort of answer to indicate what was happening if you gave car an atom. eq For testing equality between atoms. car For returning the first half (address) … Read more
First, see https://jdbc.postgresql.org/documentation/83/query.html#query-with-cursor. Solved it like this. (jdbc/with-db-transaction [tx connection] (jdbc/query tx [(jdbc/prepare-statement (:connection tx) “select * from mytable” {:fetch-size 10})] {:result-set-fn (fn [result-set] …)})) where :result-set-fn is a function that consumes the lazy result set. with-db-transaction takes care of autoCommit set to false. :fetch-size is not passed from query so you have to make … Read more
#(f %) is expanded by the reader into (fn [%] (f %). Likewise, #({:key %}) is expanded into (fn [%] ({:key %}). The python equivalent of this would be lambda v: {‘key’: v}(), which has the exact same problem as the Clojure version. What you are looking for is something equivalent to (fn [v] {:key … Read more
Citation from official documentation: Keywords implement IFn for invoke() of one argument (a map) with an optional second argument (a default value). For example (:mykey my-hash-map :none) means the same as (get my-hash-map :mykey :none). See get. And Clojure can call keyword as function, because it implements same interface as function. The same is for … Read more
Let’s do this. • I know that lazy sequences only evaluate the items in the sequence that are asked for, how does it do this? Lazy sequences (henceforth LS, because I am a LP, or Lazy Person) are composed of parts. The head, or the part(s, as really 32 elements are evaluated at a time, … Read more
Here’s another approach that celebrates Clojure’s Java interop. This takes 374ms on a 2.4 Ghz Core 2 Duo (running single-threaded). I let the efficient Miller-Rabin implementation in Java’s BigInteger#isProbablePrime deal with the primality check. (def certainty 5) (defn prime? [n] (.isProbablePrime (BigInteger/valueOf n) certainty)) (concat [2] (take 10001 (filter prime? (take-nth 2 (range 1 Integer/MAX_VALUE))))) … Read more
[Edit from non-author: this is from 2010, and the process has been significantly simplified since May 2011. I’ll add a post to this answer with my setup notes as of Feb 2012.] You’ll need to put together a few pieces: Emacs, SLIME (which works perfectly well with Clojure — see swank-clojure), swank-clojure (the Clojure implementation … Read more