Transducers are recipes of what to do with a sequence of data without knowledge of what the underlying sequence is (how to do it). It can be any seq, async channel or maybe observable. They are composable and polymorphic. The benefit is, you don’t have to implement all standard combinators every time a new data … Read more
The difference is that for builds a lazy sequence and returns it while doseq is for executing side-effects and returns nil. user=> (for [x [1 2 3]] (+ x 5)) (6 7 8) user=> (doseq [x [1 2 3]] (+ x 5)) nil user=> (doseq [x [1 2 3]] (println x)) 1 2 3 nil … Read more
I highly recommend “The Joy of Clojure” or “programming Clojure” for a real answer to this question, I can reproduce a short snip-it of the motivations for each: start by watching this video on the notion of Identity and/or studying here. Refs are for Coordinated Synchronous access to “Many Identities”. Atoms are for Uncoordinated synchronous … Read more
Actually, there is a way! (comment (defn hey [] (“Hey there!”)) Check me out! ) Just wrap your comments in (comment ..) 🙂 Have fun!
classic recursion (watch this, it blows stack) (defn exp [x n] (if (zero? n) 1 (* x (exp x (dec n))))) tail recursion (defn exp [x n] (loop [acc 1 n n] (if (zero? n) acc (recur (* x acc) (dec n))))) functional (defn exp [x n] (reduce * (repeat n x))) sneaky (also blows … Read more
reduce and apply are of course only equivalent (in terms of the ultimate result returned) for associative functions which need to see all their arguments in the variable-arity case. When they are result-wise equivalent, I’d say that apply is always perfectly idiomatic, while reduce is equivalent — and might shave off a fraction of a … Read more
(map vector ‘(1 2 3) ‘(4 5 6)) does what you want: => ([1 4] [2 5] [3 6]) Haskell needs a collection of zipWith (zipWith3, zipWith4, …) functions, because they all need to be of a specific type; in particular, the number of input lists they accept needs to be fixed. (The zip, zip2, … Read more
They all have a lot in common: Dynamic languages Strongly typed Compiled Lisp-style syntax, i.e. code is written as a Lisp data structures (forms) with the most common pattern being function calls like: (function-name arg1 arg2) Powerful macro systems that allow you to treat code as data and generate arbitrary code at runtime (often used … Read more
There are several reasons why one should not use EVAL. The main reason for beginners is: you don’t need it. Example (assuming Common Lisp): EVALuate an expression with different operators: (let ((ops ‘(+ *))) (dolist (op ops) (print (eval (list op 1 2 3))))) That’s better written as: (let ((ops ‘(+ *))) (dolist (op ops) … Read more
The purpose of Protocols in Clojure is to solve the Expression Problem in an efficient manner. So, what’s the Expression Problem? It refers to the basic problem of extensibility: our programs manipulate data types using operations. As our programs evolve, we need to extend them with new data types and new operations. And particularly, we … Read more