deprecate do_return.

Should have just deleted it before releasing 1.0, but I forgot. Oh well!

Author: radix

effect/_test_do_py3.py

@@ -5,6 +5,7 @@
 """
 
 import types
+import warnings
 
 from . import Effect, Func
 from ._utils import wraps
@@ -18,19 +19,15 @@ def do(f):
         @do
         def foo():
             thing = yield Effect(Constant(1))
-            yield do_return('the result was %r' % (thing,))
+            return 'the result was %r' % (thing,)
 
         eff = foo()
         return eff.on(...)
 
     ``@do`` must decorate a generator function (not any other type of
-    iterator). Any yielded values must either be Effects or the result of a
-    :func:`do_return` call. The result of a yielded Effect will be passed back
-    into the generator as the result of the ``yield`` expression. Yielded
-    :func:`do_return` values will provide the ultimate result of the Effect
-    that is returned by the decorated function. Note that :func:`do_return` is
-    only necessary for Python 2 compatibility; return statements can be used
-    directly in Python 3-only code.
+    iterator). Any yielded values must be Effects. The result of a yielded Effect will be passed
+    back into the generator as the result of the ``yield`` expression. A returned value becomes the
+    ultimate result of the Effect that is returned by the decorated function.
 
     It's important to note that any generator function decorated by ``@do``
     will no longer return a generator, but instead it will return an Effect,
@@ -43,7 +40,7 @@ def foo():
             try:
                 thing = yield Effect(Error(RuntimeError('foo')))
             except RuntimeError:
-                yield do_return('got a RuntimeError as expected')
+                return 'got a RuntimeError as expected'
 
     (This decorator is named for Haskell's ``do`` notation, which is similar in
     spirit).
@@ -77,15 +74,19 @@ def do_return(val):
     """
     Specify a return value for a @do function.
 
+    This is deprecated. Just use `return`.
+
     The result of this function must be yielded.  e.g.::
 
         @do
         def foo():
             yield do_return('hello')
-
-    If you're writing Python 3-only code, you don't need to use this function,
-    and can just use the `return` statement as normal.
     """
+    warnings.warn(
+        "do_return is deprecated. Just return as normal.",
+        DeprecationWarning,
+        stacklevel=1,
+    )
     return _ReturnSentinel(val)
 
 
@@ -119,6 +120,6 @@ def _do(result, generator, is_error):
         )
     else:
         raise TypeError(
-            "@do functions must only yield Effects or results of do_return. "
+            "@do functions must only yield Effects. "
             "Got %r from %r" % (val, generator)
         )

effect/do.py

@@ -1,7 +1,7 @@
 import sys
 from functools import partial
 
-from py.test import raises
+from py.test import raises, warns
 
 from . import (
     ComposedDispatcher,
@@ -34,19 +34,25 @@ def test_do_return():
     """
     When a @do function yields a do_return, the given value becomes the
     eventual result.
+
+    This is deprecated.
     """
 
     @do
     def f():
         yield do_return("hello")
 
-    assert perf(f()) == "hello"
+    with warns(DeprecationWarning):
+        assert perf(f()) == "hello"
 
 
-def test_do_return_effect():
+def test_return_effect():
     @do
     def f():
-        yield do_return(Effect(Constant("hello")))
+        return Effect(Constant("hello"))
+        # this is a dumb trick we're playing on Python to make sure this function is a generator,
+        # even though we never want to yield anything.
+        yield
 
     assert perf(f()) == "hello"
 
@@ -57,7 +63,7 @@ def test_yield_effect():
     @do
     def f():
         x = yield Effect(Constant(3))
-        yield do_return(x)
+        return x
 
     perf(f()) == 3
 
@@ -83,8 +89,7 @@ def f():
     with raises(TypeError) as err_info:
         perf(result)
     assert str(err_info.value).startswith(
-        "@do functions must only yield Effects or results of "
-        "do_return. Got 1 from <generator object"
+        "@do functions must only yield Effects. Got 1 from <generator object"
     )
 
 
@@ -100,7 +105,7 @@ def f():
             yield Effect(Error(ZeroDivisionError("foo")))
         except Exception as e:
             got_error = e
-        yield do_return(got_error)
+        return got_error
 
     exc = perf(f())
     assert type(exc) is ZeroDivisionError
@@ -114,7 +119,7 @@ def test_works_with_sync_perform():
     @do
     def perform_myintent(dispatcher, myintent):
         result = yield Effect(Constant(1))
-        yield do_return(result + 1)
+        return result + 1
 
     class MyIntent(object):
         pass
@@ -133,7 +138,7 @@ def test_promote_metadata():
 
     def original(dispatcher, intent):
         """Original!"""
-        yield do_return(1)
+        return 1
 
     original.attr = 1
     wrapped = do(original)
@@ -166,7 +171,7 @@ def test_repeatable_effect():
     @do
     def f():
         x = yield Effect(Constant("foo"))
-        yield do_return(x)
+        return x
 
     eff = f()
     assert perf(eff) == "foo"
@@ -196,7 +201,11 @@ def f():
 
 def test_py3_return():
     """The `return x` syntax in Py3 sets the result of the Effect to `x`."""
-    from effect._test_do_py3 import py3_generator_with_return
+
+    @do
+    def py3_generator_with_return():
+        yield Effect(Constant(1))
+        return 2  # noqa
 
     eff = py3_generator_with_return()
     assert perf(eff) == 2

effect/test_do.py

@@ -18,7 +18,7 @@
     sync_perform,
     sync_performer,
 )
-from .do import do, do_return
+from .do import do
 from .fold import FoldError, sequence
 from .testing import (
     _ANY,
@@ -397,7 +397,7 @@ def test_perform_sequence():
     def code_under_test():
         r = yield Effect(MyIntent("a"))
         r2 = yield Effect(OtherIntent("b"))
-        yield do_return((r, r2))
+        return (r, r2)
 
     seq = [
         (MyIntent("a"), lambda i: "result1"),
@@ -417,7 +417,7 @@ def test_perform_sequence_log():
     def code_under_test():
         r = yield Effect(MyIntent("a"))
         r2 = yield Effect(OtherIntent("b"))
-        yield do_return((r, r2))
+        return (r, r2)
 
     seq = [(MyIntent("a"), lambda i: "result1")]
     with pytest.raises(AssertionError) as exc:
@@ -505,13 +505,13 @@ class WrappedIntent(object):
     def internal():
         yield Effect(1)
         yield Effect(2)
-        yield do_return("wrap")
+        return "wrap"
 
     @do
     def code_under_test():
         r = yield Effect(WrappedIntent(internal(), "field"))
         r2 = yield Effect(MyIntent("a"))
-        yield do_return((r, r2))
+        return (r, r2)
 
     seq = [
         (

effect/test_testing.py

@@ -48,7 +48,7 @@ def perform_sequence(seq, eff, fallback_dispatcher=None):
         def code_under_test():
             r = yield Effect(MyIntent('a'))
             r2 = yield Effect(OtherIntent('b'))
-            yield do_return((r, r2))
+            return (r, r2)
 
         def test_code():
             seq = [
@@ -142,7 +142,7 @@ def code_under_test():
             r = yield Effect(SerialIntent('serial'))
             r2 = yield parallel([Effect(MyIntent('a')),
                                  Effect(OtherIntent('b'))])
-            yield do_return((r, r2))
+            return (r, r2)
 
         def test_code():
             seq = [
@@ -576,7 +576,7 @@ def intent_func(fname):
         def code_under_test(arg1, arg2, eff_returning_func=eff_returning_func):
             r = yield Effect(MyIntent('a'))
             r2 = yield eff_returning_func(arg1, arg2)
-            yield do_return((r, r2))
+            return (r, r2)
 
     you will need to know the intents which ``eff_returning_func`` generates
     to test this using :func:`perform_sequence`. You can avoid that by doing::