On Mar 31, 2009, at 16:32, Rich Hickey wrote:

> Here are some problems/limitations of existing OO/GF systems that I
> don't intend to repeat:
...

I agree that these are not desirable features. I have had to work  
around some of them many times in the past. Traditional OO combines  
aspects that should better be handled separately.

> Here are the areas I'm looking to improve:
>
> - There's no easy way to talk about "the method you would get if you
> were dispatch value X". Note that this is not the same as call-next-
> method, which reintroduces global ordering requirements, but allows
> for easy explicit reuse of already-defined methods.

That would be VERY nice to have. More than once I ended up writing a  
private function that I then called from several methods in the same  
multimethod, to avoid code duplication.

> - Currently, a preference doesn't encompass the path through the
> preferred value to its ancestors, but could.
>
> - If you have a set of common preferences, there's no easy way to
> create them in advance and share them among methods. There are issues
> here related to ensuring preference consistency and caching.

At the moment, a multimethod takes two dispatch-oriented parameters:  
a hierarchy and a dispatch function that returns a single item from  
the hierarchy.

How about generalizing the dispatch function in two ways:
- it can return a sequence of items that will be tried in order
- it can access the hierarchy

Accessing the hierarchy is a minor point since this is already  
possible (write a dispatch function that uses parents, ancestors,  
etc.; for a hierarchy other than the global one, make the dispatch  
function a closure that refers to the hierarchy). Maybe it could be  
made more convenient.

Returning a sequence should be sufficient to let the dispatch  
function handle any kind of preference. prefer-method could thus go  
away. Instead, there would be a set of utility functions to  
facilitate writing dispatch functions for common cases. A single  
dispatch function could be used for any number of multimethods.

I think this should be sufficient to cover all cases you mentioned,  
but of course it needs to be tried in practice.

Konrad.


--~--~---------~--~----~------------~-------~--~----~
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 
clojure+unsubscr...@googlegroups.com
For more options, visit this group at 
http://groups.google.com/group/clojure?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to