Lazy evaluation

是一段源码，关于Lazy evaluation的，看了很久才懂，记录一下

一，lazy方法返回的比较复杂，一层一层将其剥开。

1. wraps(func)跳转到curry(update_wrapper, func, WRAPPER_ASSIGNMENTS, WRAPPER_UPDATES)，最后return一个闭包，通过type(wraps(func))可以看到这是一个<function _curried>。
2. wraps(func)(__wrapped)则会调用_curried(__wrapped__)，进而调用update(func, __wrapped__ ,WRAPPER_ASSIGNMENTS, WRAPPER_UPDATE)，这里注意WRAP这两个都是dict，所以会被收纳进**kwargs中。
3. 通过update函数会把func的__module__，__name__，__doc__内容复制到<function __wrapper__>中，这样type(wrap(func)(__wrapper__))时，会返回一个<function func>。

这样lazy的返回就解析完了，这时候我们获得了一个__proxy__的构造函数。

 def curry(_curried_func, *args, **kwargs):
     def _curried(*moreargs, **morekwargs):
         return _curried_func(*(args+moreargs), **dict(kwargs, **morekwargs))
     return _curried

 WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__doc__')
 WRAPPER_UPDATES = ('__dict__',)
 def update_wrapper(wrapper,
                    wrapped,
                    assigned = WRAPPER_ASSIGNMENTS,
                    updated = WRAPPER_UPDATES):
     """Update a wrapper function to look like the wrapped function

        wrapper is the function to be updated
        wrapped is the original function
        assigned is a tuple naming the attributes assigned directly
        from the wrapped function to the wrapper function (defaults to
        functools.WRAPPER_ASSIGNMENTS)
        updated is a tuple naming the attributes off the wrapper that
        are updated with the corresponding attribute from the wrapped
        function (defaults to functools.WRAPPER_UPDATES)
     """
     for attr in assigned:
         try:
             setattr(wrapper, attr, getattr(wrapped, attr))
         except TypeError: # Python 2.3 doesn't allow assigning to __name__.
             pass
     for attr in updated:
         getattr(wrapper, attr).update(getattr(wrapped, attr))
     # Return the wrapper so this can be used as a decorator via curry()
     return wrapper

 def wraps(wrapped,
           assigned = WRAPPER_ASSIGNMENTS,
           updated = WRAPPER_UPDATES):
     """Decorator factory to apply update_wrapper() to a wrapper function

        Returns a decorator that invokes update_wrapper() with the decorated
        function as the wrapper argument and the arguments to wraps() as the
        remaining arguments. Default arguments are as for update_wrapper().
        This is a convenience function to simplify applying curry() to
        update_wrapper().
     """
     return curry(update_wrapper, wrapped=wrapped,
                  assigned=assigned, updated=updated)
 class Promise(object):
     """
     This is just a base class for the proxy class created in
     the closure of the lazy function. It can be used to recognize
     promises in code.
     """
     pass

 def lazy(func, *resultclasses):
     """
     Turns any callable into a lazy evaluated callable. You need to give result
     classes or types -- at least one is needed so that the automatic forcing of
     the lazy evaluation code is triggered. Results are not memoized; the
     function is evaluated on every access.
     """
     class __proxy__(Promise):
         """
         Encapsulate a function call and act as a proxy for methods that are
         called on the result of that function. The function is not evaluated
         until one of the methods on the result is called.
         """
         __dispatch = None

         def __init__(self, args, kw):
             self.__func = func
             self.__args = args
             self.__kw = kw
             if self.__dispatch is None:
                 self.__prepare_class__()

         def __prepare_class__(cls):
             cls.__dispatch = {}
             for resultclass in resultclasses:
                 cls.__dispatch[resultclass] = {}
                 for (k, v) in resultclass.__dict__.items():
                     if hasattr(cls, k):
                         continue
                     setattr(cls, k, cls.__promise__(resultclass, k, v))
             cls._delegate_str = str in resultclasses
             cls._delegate_unicode = unicode in resultclasses
             assert not (cls._delegate_str and cls._delegate_unicode), "Cannot call lazy() with both str and unicode return types."
             if cls._delegate_unicode:
                 cls.__unicode__ = cls.__unicode_cast
             elif cls._delegate_str:
                 cls.__str__ = cls.__str_cast
         __prepare_class__ = classmethod(__prepare_class__)

         def __promise__(cls, klass, funcname, func):
             # Builds a wrapper around some magic method and registers that magic
             # method for the given type and method name.
             def __wrapper__(self, *args, **kw):
                 # Automatically triggers the evaluation of a lazy value and
                 # applies the given magic method of the result type.
                 res = self.__func(*self.__args, **self.__kw)
                 for t in type(res).mro():
                     if t in self.__dispatch:
                         return self.__dispatch[t][funcname](res, *args, **kw)
                 raise TypeError("Lazy object returned unexpected type.")

             if klass not in cls.__dispatch:
                 cls.__dispatch[klass] = {}
             cls.__dispatch[klass][funcname] = func
             return __wrapper__
         __promise__ = classmethod(__promise__)

         def __unicode_cast(self):
             return self.__func(*self.__args, **self.__kw)

         def __str_cast(self):
             return str(self.__func(*self.__args, **self.__kw))

         def __cmp__(self, rhs):
             if self._delegate_str:
                 s = str(self.__func(*self.__args, **self.__kw))
             elif self._delegate_unicode:
                 s = unicode(self.__func(*self.__args, **self.__kw))
             else:
                 s = self.__func(*self.__args, **self.__kw)
             if isinstance(rhs, Promise):
                 return -cmp(rhs, s)
             else:
                 return cmp(s, rhs)

         def __mod__(self, rhs):
             if self._delegate_str:
                 return str(self) % rhs
             elif self._delegate_unicode:
                 return unicode(self) % rhs
             else:
                 raise AssertionError('__mod__ not supported for non-string types')

         def __deepcopy__(self, memo):
             # Instances of this class are effectively immutable. It's just a
             # collection of functions. So we don't need to do anything
             # complicated for copying.
             memo[id(self)] = self
             return self

     def __wrapper__(*args, **kw):
         # Creates the proxy object, instead of the actual value.
         return __proxy__(args, kw)

     return wraps(func)(__wrapper__)

二，我们现在学着怎么使用lazy。

1. 这里我们新建了两个类，分别为A、B，其中B是A的子类。
2. 当调用x = lazy(func, A, B)(1, 2)的时候，会返回一个__proxy__对象，这里注意，因为类的定义是在lazy方法中，所以__func为func。
3. 这中间会调用__prepare_class__方法，这是一个类方法。他会从resultclasses（这里是A，B）中逐个选择，它维护一个类字典cls.__dispatch，对其中每一个类都把类的__dict__中不包括__main__、__name__、__doc__的属性都经过__promiss__闭包将__wrap__赋给__proxy__类。
4. 在__wrap__执行之前，会在cls.__dispatch中添加一个名为funcname的属性为func。而当调用__wrap__的时候，则会使用func计算初始的*args和**kwargs，解析返回对象的类型列表。

这里要注意一点，任何一个类的__dict__是不会自动包括它父类的属性和方法的，所以最后结果，x.func_a()是会报错的。这应该是这段代码的一个不足或者BUG吧。

 def func(a, b):
     print 'func'
     return B()

 class A(object):
     """docstring for A"""
     def __init__(self):
         super(A, self).__init__()
     def func_a(self):
         print 'in func_a'

 class B(object):
     """docstring for B"""
     def __init__(self):
         super(B, self).__init__()
     def func_b(self):
         print 'in func_b'

 print B.mro()
 x = lazy(func, A, B)(1, 2)
 print x.func_a(), x.func_b()

 #[<class '__main__.B'>, <class '__main__.A'>, <type 'object'>]
 #func
 #in func_b
 #None

三，怎样实现lazy evaluation？

　　将上面的代码改一下便可以实现lazy evaluation。

 def func(num1, num2):
     return B(num1, num2)

 class A(object):
     """docstring for A"""
     def __init__(self):
         super(A, self).__init__()
     def func_a(self):
         pass

 class B(A):
     """docstring for B"""
     def __init__(self, num1, num2):
         super(B, self).__init__()
         self.num1 = num1
         self.num2 = num2

     def func_b(self, num1, num2):
         print num1 + num2

 a = 1
 b = 2
 c = 3
 x = lazy(func, A, B)(a, b)
 a = b
 b = c
 print a, b, c
 x.func_b(a, b)

 #2 3 3
 #

参考：http://blog.csdn.net/g9yuayon/article/details/759778

http://blog.donews.com/superisaac/archive/2006/03/16/771387.aspx