;; Various Operators on Pure Functions

 ;;

 ;; Open source Liscence and all that

 (ns 

     rlm.function-utils

   "Collection of Operators on Pure Functions"

   {:author "Robert McIntyre"}

   (:use [clojure.contrib.profile]))

 

 (def void ::void)

 

 (comment

 

   "Please help me out here.  I'm trying to make a higher order function that takes

    pure functions that are mathmaticaly the same but have different times and returns another

    function that runs them both and returns the resut of the one that finishes first."

 

 

   "here's a repl session:

 

 mobius> " (time (dotimes [_ 500]((mix-futures + +) 40 3 3 3 3 3))) "

 Elapsed time: 85.792995 msecs

 nil

 mobius> " (time (dotimes [_ 500](+ 40 3 3 3 3 3))) "

 Elapsed time: 6.956338 msecs

 nil

 mobius> " (time (dotimes [_ 500]((mix-threads + +) 40 3 3 3 3 3))) "

 Elapsed time: 706.227065 msecs

 nil

 

 

 mobius> " (defn fast-five [& args] 5) "

 #'mobius/fast-five

 

 mobius> " (defn slow-five [& args] (Thread/sleep 5000) (println "Oh YEAH!!!!") 5) "

 #'mobius/slow-five

 

 mobius> " (profile (time (dotimes [_ 5000] (thread-five)))) "

 \"Elapsed time: 12187.981587 msecs\"

           Name      mean       min       max     count       sum

    create-atom      9621      2025   4433928      5000  48106830

 create-threads      5156      2724   2880268      5000  25783796

   kill-threads     91313     27866  11175718      5000  456567066

           loop   2124249     38482  18470781      5000  10621249899

         return      1242       838      5309      5000   6212626

  start-threads    252985    110348  12272835      5000  1264927953

 nil

 

 mobius> " (profile (time (dotimes [_ 5000] (future-five)))) "

 \"Elapsed time: 607.266671 msecs\"

           Name      mean       min       max     count       sum

    create-atom      1472      1047     31708      5000   7363139

 create-futures     30539      2514   1330660      5000  152697998

   kill-threads     54158      2444   3938833      5000  270792897

           loop     81117      8800   6083059      5000  405587516

         return      1215       838    618782      5000   6078146

 nil

 

 

 

 What can I improve here, and why is the future version sooo much faster than the

 thread version? Is there a better way than using loop?

 "

 

 )

 

 

 (defn race 

   "Takes any number of mathematically equal functions with

    possibly different run-times and returns a function that

    runs each in a separate thread, returns the result from

    the first thread which finishes, and cancels the other threads."

   {:author "Robert McIntyre"}

   ([& functions]

      (fn [& args]

        (let [result (promise)

 	     futures (doall (for [fun functions]

 			      (future (deliver result (apply fun args)))))

 	     answer @result]

 	 (dorun (map future-cancel futures))

 	 answer))))

 

 (defn race-pred

   "Takes any number of mathematically equal functions with possibly

    different run-times and returns a function that runs each in a

    separate thread, and returns the first available result x for

    which (pred x) returns true (or not-valid, if (pred x) returns

    false on all the results).  Cancels the other threads upon

    returning early."

   {:author "Robert McIntyre"}

   ([pred not-valid & functions]

      (fn [& args]

        (let [result (promise)

              latch (java.util.concurrent.CountDownLatch.

                     (count functions))

              failure-case (future (.await latch)

                                   (deliver result not-valid))

 	     futures

              (doall

               (cons failure-case

                     (for [fun functions]

                       (future

                         (let [answer? (apply fun args)]

                           (if (pred answer?)

                             (deliver result answer?)

                             (.countDown latch)))))))

 	     answer @result]

 	 (dorun (map future-cancel futures))

 	 answer))))

 

 

 

 (defn mix-threads

   " Takes any number of pure functions that take the same arguments and

    compute the same value and returns a function that runs each in a separate

    thread, returns the result from the first thread which finshes, and cancels 

    the other threads. Explicitly uses nasty Threads.

 

    For example: 

    (do

    (defn fun1 [] (Thread/sleep 5000) 5)

    (defn fun2 [] (Thread/sleep 700000) 5)

    (time ((mix fun1 fun2))))

    

    Returns: 

     | Elapsed time: 5000.66214 msecs

    5"

   [& functions]

   (fn [& args]

     (let [result (prof :create-atom (atom void))

 	  threads

 	   (prof :create-threads (map 

 	   (fn [fun] 

 	     (Thread. 

 	      (fn [] 

 		(try (let [answer (apply fun args)]

 		       (reset! result answer))

 		     (catch Exception _ nil)))))

 	   functions))]

       

       (prof :start-threads (dorun (map #(.start %) threads)))

       (prof :loop (loop []

 	(if (=  (deref result) void)

 	  (recur)

 	  (do (prof :kill-threads (dorun (map #(.stop %) threads)))

 	      (prof :return (deref result)))

 	  ))))))

 

 (defmacro defmix

   " Defines a function from any number of pure functions that take the same 

    arguments and compute the same value which:

 

    Runs each in a separate thread.

    Returns the result from the first thread which finshes.

    Cancels the other threads.

            

    Use this whenever you want to combine two pure functions that

    compute the same thing, but use different algorithms with different

    run times for various inputs.

 

    For example: 

      (do

      (defn fun1 [] (Thread/sleep 5000) 5)

      (defn fun2 [] (Thread/sleep 700000) 5)

      (defmix fun3 \"combination of fun1 and fun2\" fun1 fun2)

      (time (fun3))

    

    Returns: 

      | Elapsed time: 5000.66214 msecs

      5"

 

 {:arglists '([name doc-string? functions*])}

 

   [name & functions]

   (let [doc-string (if (string? (first functions)) (first functions) "")

 	functions (if (string? (first functions)) (rest functions) functions)

 	arglists (:arglists (meta (resolve (eval `(quote ~(first functions))))))

 	name (with-meta name (assoc (meta name) :arglists `(quote ~arglists) :doc doc-string))]   

     `(def ~name (mix ~@functions))))

 

 

 (defn runonce

   "Decorator.  returns a function which will run only once. Inspired

    by Halloway's version from lancet."

   {:author "Robert McIntyre"}

   [function]

   (let [sentinel (Object.) 

 	result (atom sentinel)]

     (fn [& args]

        (locking sentinel

 	 (if (= @result sentinel) 

 	   (reset! result (apply function args)) 

 	    @result)))))

 

 

 

 ;I'm thinking this will be the docstring for mix eventually.

 

   ;; " Takes any number of pure functions that take the same arguments and

   ;;  compute the same value and returns a function that runs each in a separate

   ;;  thread, returns the result from the first thread which finshes, and cancels 

   ;;  the other threads.

 

   ;;  For example: 

   ;;  (do

   ;;  (defn fun1 [] (Thread/sleep 5000) 5)

   ;;  (defn fun2 [] (Thread/sleep 700000) 5)

   ;;  (time ((mix fun1 fun2))))

    

   ;;  Returns: 

   ;;   | Elapsed time: 5000.66214 msecs

   ;;  5"