Clojure and the technology adoption curve

Post by emidln » Tue, Nov 10, 2015, 11:11 PM UTC

KingMob wrote: post #51

emidln wrote: post #37

Earlier quoted context omitted.

multi-methods at least are isa?-based. This implies that they obey ad-hoc hierarchies created via derive as well as traditional java inheritance hierarchies. protocols are little more than open-ended interfaces (i.e. I can extend them at run-time to my things and to other things).

Just a slight addendum: Clojure multimethods can resolve to a concrete method implementation based on any function of their parameters. So, in addition to single dispatch based on class (a la Java), you could also dispatch based on the classes of multiple parameters or on the value of the field 3 objects deep.

    (defmulti cares-about-a-and-c 
      "multimethod that cares about the first and third args" 
      (fn [a b c] [a c]))
    
    (defmethod cares-about-a-and-c [:alpha :gamma]
      [a b c]
      (prn "got :alpha and :gamma"))
    
    (defmethod cares-about-a-and-c [1 3]
      [a b c]
      (prn "got 1 and 3"))

    (defmethod cares-about-a-and-c [String String]
      [a b c]
      (prn "Got two things that match (isa? String)"))

   
    (cares-about-a-and-c "foo" nil "bar") ;; doesn't call our last method

    (defmulti cares-about-class-of-a-and-c
      ""
      (fn [a b c] (mapv class [a c])))

    (defmethod cares-about-class-of-a-and-c [String String]
      [a _ c]
      (println "Got the strings: " a " and " c))

Post by nickbauman » Wed, Nov 11, 2015, 1:28 AM UTC

sbov wrote: post #47

nickbauman wrote: post #11

It is a myth that you have to be a genius programmer to pick up Lisp dialects like Clojure. I think it's the opposite: the cognitive load of more complex languages that are "easier to learn" than Clojure (like Scala or even Java itself, for instance), a complexity I consider accidental and not essential to whatever problem you are solving, is more difficult. The hard part of Clojure really boils down to one thing: yo…

For myself, there are a couple things that make Clojure difficult. I believe they all stem in part from the language being simple. First, there seems to be at least two ways to do things: the verbose way and the succinct way. This creates more things beginners have to memorize. Second, so many :keywords. Presumably some function/macro needed to be made more flexible and/or more succinct for certain circumstances so t…

Post by dmichulke » Wed, Nov 11, 2015, 9:31 AM UTC

talloaktrees wrote: post #56

dmichulke wrote: post #9

Earlier quoted context omitted.

Traverse a hashmap, remove all strings with an even key string size and sort it by the last character in the string, then add the string size to the integer (here you have a list of integers) and sum the product of the numbers at index 0 and n-1, 1 and n-2, ... Compare the the code size in Java and Clojure. If that is not enough, do the same thing but start with java objects (and their clojure equivalent: a hashmap)…

I'd love to see some example code for doing this. I'm trying to implement it in Kotlin and am curious how it would compare.

  (def mymap {"asd" 1 "qwe" 2 "rtz" 3 "foo" 4 "bar" 5 "quz" 6 "bnm" 7})

  (let [ints (->> (filter (comp odd? count key)  mymap)
                                   (sort-by (comp int last first))
                                   (map (fn [[s i]]
                                          (+ (count s) i))))]
                     (reduce + 0 (map * ints (reverse ints))))