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
#5

 

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

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