;; Various Operators on Pure Functions

 ;;

 ;; Open source Liscence and all that

 (ns 

     rlm.function-utils

   "Collection of Operators on Pure Functions"

   {:author "Robert McIntyre"})

 

 (def void ::void)

 

 (defn mix 

   "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 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)))))