 -    value = property(getValue, setValue, None, "Value of this Value")
 +        format = "<Result (done: %r errors: %r) for %r>"
 +        return format % (self.done, self.errors, self.event)
+diff --git a/tmp/lazy_evaluation.diff b/tmp/lazy_evaluation.diff
+--- a/tmp/lazy_evaluation.diff
++++ b/tmp/lazy_evaluation.diff
+@@ -48,19 +48,111 @@
+ diff --git a/circuits/core/values.py b/circuits/core/values.py
+ --- a/circuits/core/values.py
+ +++ b/circuits/core/values.py
+-@@ -22,11 +22,31 @@
++@@ -22,11 +22,124 @@
+  
+          super(ValueChanged, self).__init__(value)
+  
+-+class Value(object):
+++class Proxy(object):
+++
+++    __slots__ = ["_obj", "__weakref__"]
+++
+++    def __init__(self, obj):
+++        object.__setattr__(self, "_obj", obj)
+++    
+++
+++    # proxying (special cases)
+++    #
+++    def __getattribute__(self, name):
+++        print("__getattribute__")
+++        print(name)
+++        return getattr(object.__getattribute__(self, "_obj"), name)
+++    def __delattr__(self, name):
+++        print("__delattr__")
+++        print(name)
+++        delattr(object.__getattribute__(self, "_obj"), name)
+++    def __setattr__(self, name, value):
+++        print("__setattr__")
+++        print(name)
+++        print(value)
+++        setattr(object.__getattribute__(self, "_obj"), name, value)
+++
+++    def __nonzero__(self):
+++        print("__nonzero__")
+++        return bool(object.__getattribute__(self, "_obj"))
+++    def __str__(self):
+++        print("__str__")
+++        return str(object.__getattribute__(self, "_obj"))
+++    def __repr__(self):
+++        print("__repr__")
+++        return repr(object.__getattribute__(self, "_obj"))
+++
+++    #
+++    # factories
+++    #
+++    _special_names = [
+++        "__abs__", "__add__", "__and__", "__call__", "__cmp__", "__coerce__", 
+++        "__contains__", "__delitem__", "__delslice__", "__div__", "__divmod__", 
+++        "__eq__", "__float__", "__floordiv__", "__ge__", "__getitem__", 
+++        "__getslice__", "__gt__", "__hash__", "__hex__", "__iadd__", "__iand__",
+++        "__idiv__", "__idivmod__", "__ifloordiv__", "__ilshift__", "__imod__", 
+++        "__imul__", "__int__", "__invert__", "__ior__", "__ipow__", "__irshift__", 
+++        "__isub__", "__iter__", "__itruediv__", "__ixor__", "__le__", "__len__", 
+++        "__long__", "__lshift__", "__lt__", "__mod__", "__mul__", "__ne__", 
+++        "__neg__", "__oct__", "__or__", "__pos__", "__pow__", "__radd__", 
+++        "__rand__", "__rdiv__", "__rdivmod__", "__reduce__", "__reduce_ex__", 
+++        "__repr__", "__reversed__", "__rfloorfiv__", "__rlshift__", "__rmod__", 
+++        "__rmul__", "__ror__", "__rpow__", "__rrshift__", "__rshift__", "__rsub__", 
+++        "__rtruediv__", "__rxor__", "__setitem__", "__setslice__", "__sub__", 
+++        "__truediv__", "__xor__", "next",
+++    ]
+++    
+++    @classmethod
+++    def _create_class_proxy(cls, theclass):
+++        """creates a proxy for the given class"""
+++        
+++        def make_method(name):
+++            def method(self, *args, **kw):
+++                print(name)
+++                print(args)
+++                print(kw)
+++                return getattr(object.__getattribute__(self, "_obj"),
+++                        name)(*args, **kw)
+++            return method
+++        
+++        namespace = {}
+++        for name in cls._special_names:
+++            if hasattr(theclass, name):
+++                namespace[name] = make_method(name)
+++        return type("%s(%s)" % (cls.__name__, theclass.__name__), (cls,), namespace)
+++    
+++    def __new__(cls, obj, *args, **kwargs):
+++        """
+++        creates an proxy instance referencing `obj`. (obj, *args, **kwargs) are
+++        passed to this class" __init__, so deriving classes can define an 
+++        __init__ method of their own.
+++        note: _class_proxy_cache is unique per deriving class (each deriving
+++        class must hold its own cache)
+++        """
+++        try:
+++            cache = cls.__dict__["_class_proxy_cache"]
+++        except KeyError:
+++            cls._class_proxy_cache = cache = {}
+++        try:
+++            theclass = cache[obj.__class__]
+++        except KeyError:
+++            cache[obj.__class__] = theclass = cls._create_class_proxy(obj.__class__)
+++        ins = object.__new__(theclass)
+++        theclass.__init__(ins, obj, *args, **kwargs)
+++        return ins
+  
+--class Value(object):
++ class Value(object):
+ -    """Create a new future Value Object
++ 
++-    Creates a new future Value Object which is used by Event Objects and the
+ +    def __init__(self, value=None):
+ +        super(Value, self).__init__()
+- 
+--    Creates a new future Value Object which is used by Event Objects and the
+-+        self._value = value
+++
+++        self._value = Proxy(value)
+ +
+ +    def __get__(self, instance, owner):
+ +        print("Retriving value...")
+@@ -74,7 +166,7 @@
+ +        print(instance)
+ +        print(value)
+ +
+-+        self._value = value
+++        self._value = Proxy(value)
+ +
+ +class Result(object):
+ +    """Create a new Result Object
+@@ -83,7 +175,7 @@
+      Manager to store the result(s) of an Event Handler's exeuction of some
+      Event in the system.
+  
+-@@ -39,90 +59,31 @@
++@@ -39,90 +152,31 @@
+      :param onSet: The channel used when triggering ValueChagned events.
+      :type  onSet: A (channel, target) tuple.
+  
+@@ -144,77 +236,4 @@
+ -        return format % (value, self.result, self.errors, self.event)
+ -
+ -    def __str__(self):
+--        "x.__str__() <==> str(x)"
+--
+--        return str(self.value)
+--
+--    def getValue(self):
+--        value = self._value
+--        while isinstance(value, Value):
+--            value = value._value
+--        return value
+--
+--    def setValue(self, value):
+--        if isinstance(value, Value):
+--            value._parent = self
+--
+--        if self.result and isinstance(self._value, list):
+--            self._value.append(value)
+--        elif self.result:
+--            self._value = [self._value]
+--            self._value.append(value)
+--        else:
+--            self._value = value
+--
+--        def notify(o, v):
+--            if not isinstance(v, Value) and v is not None:
+--                o.result = True
+--                if o.manager is not None and o.onSet is not None:
+--                    o.manager.fireEvent(ValueChanged(o), *o.onSet)
+--            elif isinstance(v, Value):
+--                o.errors = v.errors
+--                o.result = v.result
+--            if not o._parent == o:
+--                o._parent.errors = o.errors
+--                o._parent.result = o.result
+--                notify(o._parent, v)
+--        
+--        notify(self, value)
+--
+--    value = property(getValue, setValue, None, "Value of this Value")
+-+        format = "<Result (done: %r errors: %r) for %r>"
+-+        return format % (self.done, self.errors, self.event)
+-diff --git a/tmp/test_lazy_evaluation.py b/tmp/test_lazy_evaluation.py
+-new file mode 100755
+---- /dev/null
+-+++ b/tmp/test_lazy_evaluation.py
+-@@ -0,0 +1,29 @@
+-+#!/usr/bin/env python
+-+
+-+from circuits import Component, Event
+-+
+-+class Test(Event):
+-+    """Test Event"""
+-+
+-+class Foo(Event):
+-+    """Foo Event"""
+-+
+-+class Bar(Event):
+-+    """Bar Event"""
+-+
+-+class App(Component):
+-+
+-+    def foo(self):
+-+        return 1
+-+
+-+    def bar(self):
+-+        return 2
+-+
+-+    def test(self):
+-+        a = self.fire(Foo())
+-+        b = self.fire(Bar())
+-+        return a.value + b.value
+-+
+-+from circuits import Debugger
+-+app = App() + Debugger()
+-+app.start()
++-        "x.__st
+\ No newline at end of file
 diff --git a/tmp/test_lazy_evaluation.py b/tmp/test_lazy_evaluation.py
 new file mode 100755
 --- /dev/null

+        print(instance)
+        print(value)
+
+        self._value = value
+
+class Result(object):
+    """Create a new Result Object

diff --git a/circuits/core/values.py b/circuits/core/values.py
--- a/circuits/core/values.py
+++ b/circuits/core/values.py
@@ -22,11 +22,124 @@
 
         super(ValueChanged, self).__init__(value)
 
+class Proxy(object):
+
+    __slots__ = ["_obj", "__weakref__"]
+
+    def __init__(self, obj):
+        object.__setattr__(self, "_obj", obj)
+    
+
+    # proxying (special cases)
+    #
+    def __getattribute__(self, name):
+        print("__getattribute__")
+        print(name)
+        return getattr(object.__getattribute__(self, "_obj"), name)
+    def __delattr__(self, name):
+        print("__delattr__")
+        print(name)
+        delattr(object.__getattribute__(self, "_obj"), name)
+    def __setattr__(self, name, value):
+        print("__setattr__")
+        print(name)
+        print(value)
+        setattr(object.__getattribute__(self, "_obj"), name, value)
+
+    def __nonzero__(self):
+        print("__nonzero__")
+        return bool(object.__getattribute__(self, "_obj"))
+    def __str__(self):
+        print("__str__")
+        return str(object.__getattribute__(self, "_obj"))
+    def __repr__(self):
+        print("__repr__")
+        return repr(object.__getattribute__(self, "_obj"))
+
+    #
+    # factories
+    #
+    _special_names = [
+        "__abs__", "__add__", "__and__", "__call__", "__cmp__", "__coerce__", 
+        "__contains__", "__delitem__", "__delslice__", "__div__", "__divmod__", 
+        "__eq__", "__float__", "__floordiv__", "__ge__", "__getitem__", 
+        "__getslice__", "__gt__", "__hash__", "__hex__", "__iadd__", "__iand__",
+        "__idiv__", "__idivmod__", "__ifloordiv__", "__ilshift__", "__imod__", 
+        "__imul__", "__int__", "__invert__", "__ior__", "__ipow__", "__irshift__", 
+        "__isub__", "__iter__", "__itruediv__", "__ixor__", "__le__", "__len__", 
+        "__long__", "__lshift__", "__lt__", "__mod__", "__mul__", "__ne__", 
+        "__neg__", "__oct__", "__or__", "__pos__", "__pow__", "__radd__", 
+        "__rand__", "__rdiv__", "__rdivmod__", "__reduce__", "__reduce_ex__", 
+        "__repr__", "__reversed__", "__rfloorfiv__", "__rlshift__", "__rmod__", 
+        "__rmul__", "__ror__", "__rpow__", "__rrshift__", "__rshift__", "__rsub__", 
+        "__rtruediv__", "__rxor__", "__setitem__", "__setslice__", "__sub__", 
+        "__truediv__", "__xor__", "next",
+    ]
+    
+    @classmethod
+    def _create_class_proxy(cls, theclass):
+        """creates a proxy for the given class"""
+        
+        def make_method(name):
+            def method(self, *args, **kw):
+                print(name)
+                print(args)
+                print(kw)
+                return getattr(object.__getattribute__(self, "_obj"),
+                        name)(*args, **kw)
+            return method
+        
+        namespace = {}
+        for name in cls._special_names:
+            if hasattr(theclass, name):
+                namespace[name] = make_method(name)
+        return type("%s(%s)" % (cls.__name__, theclass.__name__), (cls,), namespace)
+    
+    def __new__(cls, obj, *args, **kwargs):
+        """
+        creates an proxy instance referencing `obj`. (obj, *args, **kwargs) are
+        passed to this class" __init__, so deriving classes can define an 
+        __init__ method of their own.
+        note: _class_proxy_cache is unique per deriving class (each deriving
+        class must hold its own cache)
+        """
+        try:
+            cache = cls.__dict__["_class_proxy_cache"]
+        except KeyError:
+            cls._class_proxy_cache = cache = {}
+        try:
+            theclass = cache[obj.__class__]
+        except KeyError:
+            cache[obj.__class__] = theclass = cls._create_class_proxy(obj.__class__)
+        ins = object.__new__(theclass)
+        theclass.__init__(ins, obj, *args, **kwargs)
+        return ins
 
 class Value(object):
-    """Create a new future Value Object
 
-    Creates a new future Value Object which is used by Event Objects and the
+    def __init__(self, value=None):
+        super(Value, self).__init__()
+
+        self._value = Proxy(value)
+
+    def __get__(self, instance, owner):
+        print("Retriving value...")
