rename ERef to Reference for clarity, thanks @glyph

Author: radix

effect/ref.py

@@ -5,7 +5,7 @@
 from ._sync import sync_performer
 
 
-class ERef(object):
+class Reference(object):
     """
     An effectful mutable variable, suitable for sharing between multiple
     logical threads of execution, that can be read and modified in a purely
@@ -19,44 +19,47 @@ def __init__(self, initial):
 
     def read(self):
         """Return an Effect that results in the current value."""
-        return Effect(ReadERef(eref=self))
+        return Effect(ReadReference(ref=self))
 
     def modify(self, transformer):
         """
         Return an Effect that updates the value with ``fn(old_value)``.
         """
-        return Effect(ModifyERef(eref=self, transformer=transformer))
+        return Effect(ModifyReference(ref=self, transformer=transformer))
 
 
-@attributes(['eref'])
-class ReadERef(object):
-    """Intent that gets an ERef value."""
+@attributes(['ref'])
+class ReadReference(object):
+    """Intent that gets a Reference's current value."""
 
 
-@attributes(['eref', 'transformer'])
-class ModifyERef(object):
-    """Intent that modifies an ERef value in-place with a transformer func."""
+@attributes(['ref', 'transformer'])
+class ModifyReference(object):
+    """
+    Intent that modifies a Reference value in-place with a transformer func.
+    """
 
 
 @sync_performer
-def perform_read_eref(dispatcher, intent):
-    """Performer for :obj:`ReadERef`."""
-    return intent.eref._value
+def perform_read_reference(dispatcher, intent):
+    """Performer for :obj:`ReadReference`."""
+    return intent.ref._value
 
 
 @sync_performer
-def perform_modify_eref(dispatcher, intent):
+def perform_modify_reference(dispatcher, intent):
     """
-    Performer for :obj:`ModifyERef`.
+    Performer for :obj:`ModifyReference`.
 
-    Note that while :obj:`ModifyERef` is designed to allow strong consistency,
-    this performer is _not_ threadsafe, in the sense that it's possible to
-    overwrite unobserved values. This may change in the future.
+    Note that while :obj:`ModifyReference` is designed to allow strong
+    consistency, this performer is _not_ threadsafe, in the sense that it's
+    possible to overwrite unobserved values. This may change in the future.
     """
-    new_value = intent.transformer(intent.eref._value)
-    intent.eref._value = new_value
+    new_value = intent.transformer(intent.ref._value)
+    intent.ref._value = new_value
     return new_value
 
 
-eref_dispatcher = TypeDispatcher({ReadERef: perform_read_eref,
-                                  ModifyERef: perform_modify_eref})
+reference_dispatcher = TypeDispatcher({
+    ReadReference: perform_read_reference,
+    ModifyReference: perform_modify_reference})

effect/test_ref.py

@@ -3,39 +3,40 @@
 from ._base import Effect
 from ._sync import sync_perform
 from .ref import (
-    ERef, ModifyERef, ReadERef,
-    eref_dispatcher)
+    Reference, ModifyReference, ReadReference,
+    reference_dispatcher)
 
 
-class ERefTests(TestCase):
-    """Tests for :obj:`ERef`."""
+class ReferenceTests(TestCase):
+    """Tests for :obj:`Reference`."""
 
     def test_read(self):
         """``read`` returns an Effect that represents the current value."""
-        ref = ERef('initial')
-        self.assertEqual(ref.read(), Effect(ReadERef(eref=ref)))
+        ref = Reference('initial')
+        self.assertEqual(ref.read(), Effect(ReadReference(ref=ref)))
 
     def test_modify(self):
         """``modify`` returns an Effect that represents modification."""
-        ref = ERef(0)
+        ref = Reference(0)
         transformer = lambda x: x + 1
         eff = ref.modify(transformer)
         self.assertEqual(eff,
-                         Effect(ModifyERef(eref=ref, transformer=transformer)))
+                         Effect(ModifyReference(ref=ref,
+                                                transformer=transformer)))
 
     def test_perform_read(self):
         """Performing the reading results in the current value."""
-        ref = ERef('initial')
-        result = sync_perform(eref_dispatcher, ref.read())
+        ref = Reference('initial')
+        result = sync_perform(reference_dispatcher, ref.read())
         self.assertEqual(result, 'initial')
 
     def test_perform_modify(self):
         """
         Performing the modification results in transforming the current value,
         and also returns the new value.
         """
-        ref = ERef(0)
+        ref = Reference(0)
         transformer = lambda x: x + 1
-        result = sync_perform(eref_dispatcher, ref.modify(transformer))
+        result = sync_perform(reference_dispatcher, ref.modify(transformer))
         self.assertEqual(result, 1)
-        self.assertEqual(sync_perform(eref_dispatcher, ref.read()), 1)
+        self.assertEqual(sync_perform(reference_dispatcher, ref.read()), 1)