I have a kind of random question that may not make any sense, but I'm going to throw it out there.
Is it possible to create "generic" macros? I mean macros are basically a way to extend the compiler, right? Wouldn't it be useful to be able to dispatch a macro based on the type hint of its parameters (or some other criteria)? So a macro could expand to a call to some optimized version for numeric types (max) if possible, but otherwise it would expand to a version that uses Comparable or compare or something generic. Instead of having to add this optimization directly to the compiler, it could be done with a "generic" macro. Paul On Tue, Nov 4, 2008 at 10:55 AM, Graham Fawcett <[EMAIL PROTECTED]> wrote: > > On Tue, Nov 4, 2008 at 10:00 AM, Christian Vest Hansen > <[EMAIL PROTECTED]> wrote: >> >> On Tue, Nov 4, 2008 at 3:12 PM, Rich Hickey <[EMAIL PROTECTED]> wrote: >>> On Nov 4, 9:00 am, "Christian Vest Hansen" <[EMAIL PROTECTED]> >>> wrote: >>>> "Generally" by custom but not required by contract of the Comparable >>>> interface. And those are all Numbers, right? >>>> >>>> Comparable imposes natural ordering, and the individual implementor is >>>> free to decide how to handle objects of different types; throwing a >>>> ClassCastException only being one of the possible reactions. >>>> >>> >>> True, except the individual implementors of Integer, Long, Double etc >>> have already decided to have them compare only to their exact type, so >>> we're stuck with that fact. >> >> So it does. I did not expect that; thought the standard numeric >> coercion rules applied. > > > For discussion's sake, here are a couple (lightly tested) functions > that might be helpful in determining the "greatest thing in a > sequence", given an arbitrary comparator or an arbitrary coercion > function. Two coercion-based fns are given -- a simpler one, and a > more efficient one (for expensive coercions). > > Best, > Graham > > (defn greatest-by > "Return the 'largest' argument, using compare-fn as a comparison function." > [compare-fn & args] > (reduce #(if (pos? (compare-fn %1 %2)) %1 %2) args)) > > (defn greatest-coerce > "Return the 'largest' argument by first coercing each argument to > some type using coerce-fn, which must return a Comparable > instance." > [coerce-fn & args] > (apply greatest-by #(compare (coerce-fn %1) (coerce-fn %2)) args)) > > (defn greatest-coerce-2 > "Return the 'largest' argument by first coercing each argument to > some type using coerce-fn, which must return a Comparable > instance. This one performs a minimum number of coercions, which > may be important if the coercion function is expensive." > [coerce-fn & args] > (second (reduce (fn [[bc b] a] > (let [ac (coerce-fn a)] > (if (pos? (compare ac bc)) > [ac a] > [bc b]))) > [(coerce-fn (first args)) (first args)] > (rest args)))) > > ;; example > > (let [nums [1 23423424.234234 2.1 4/5 1/10 1/256 2341/2]] > (list (apply greatest-coerce float nums) > (apply greatest-coerce-2 float nums))) ;; both should return same value > > > > --~--~---------~--~----~------------~-------~--~----~ You received this message because you are subscribed to the Google Groups "Clojure" group. To post to this group, send email to clojure@googlegroups.com To unsubscribe from this group, send email to [EMAIL PROTECTED] For more options, visit this group at http://groups.google.com/group/clojure?hl=en -~----------~----~----~----~------~----~------~--~---