todd-coxeter: fix rtype of lookahead/behind methods

Author: james-d-mitchell

src/todd-coxeter.cpp

@@ -384,7 +384,9 @@ node corresponding to index *i* back to the root of that tree.
 
       thing.def(
           "perform_lookahead",
-          [](ToddCoxeter_& self) { return self.perform_lookahead(); },
+          [](ToddCoxeter_& self) -> detail::ToddCoxeterImpl& {
+            return self.perform_lookahead();
+          },
           R"pbdoc(
 :sig=(self: ToddCoxeter) -> ToddCoxeter:
 
@@ -404,7 +406,8 @@ style and extent of this lookahead are controlled by the settings
 
       thing.def(
           "perform_lookahead_for",
-          [](ToddCoxeter_& self, std::chrono::nanoseconds t) {
+          [](ToddCoxeter_&            self,
+             std::chrono::nanoseconds t) -> detail::ToddCoxeterImpl& {
             return self.perform_lookahead_for(t);
           },
           py::arg("t"),
@@ -426,7 +429,8 @@ happens first.
 
       thing.def(
           "perform_lookahead_until",
-          [](ToddCoxeter_& self, std::function<bool()> const& pred) {
+          [](ToddCoxeter_&                self,
+             std::function<bool()> const& pred) -> detail::ToddCoxeterImpl& {
             return self.perform_lookahead_until(pred);
           },
           py::arg("pred"),
@@ -447,7 +451,9 @@ This function runs a lookahead until the nullary predicate *pred* returns
 
       thing.def(
           "perform_lookbehind",
-          [](ToddCoxeter_& self) { return self.perform_lookbehind(); },
+          [](ToddCoxeter_& self) -> detail::ToddCoxeterImpl& {
+            return self.perform_lookbehind();
+          },
           R"pbdoc(
 :sig=(self: ToddCoxeter) -> ToddCoxeter:
 
@@ -510,7 +516,8 @@ Pro).
       thing.def(
           "perform_lookbehind_no_checks",
           [](ToddCoxeter_&                           self,
-             std::function<Word(Word const&)> const& collapser) {
+             std::function<Word(Word const&)> const& collapser)
+              -> detail::ToddCoxeterImpl& {
             auto wrap = [&collapser](auto d_it, auto first, auto last) {
               Word copy(first, last);
               // Shame to do so much copying here but couldn't figure out how to
@@ -578,7 +585,8 @@ function :any:`ToddCoxeter.reduce_no_run`.
 
       thing.def(
           "perform_lookbehind_for",
-          [](ToddCoxeter_& self, std::chrono::nanoseconds t) {
+          [](ToddCoxeter_&            self,
+             std::chrono::nanoseconds t) -> detail::ToddCoxeterImpl& {
             return self.perform_lookbehind_for(t);
           },
           py::arg("t"),
@@ -606,7 +614,8 @@ happens first.
           "perform_lookbehind_for_no_checks",
           [](ToddCoxeter_&                           self,
              std::chrono::nanoseconds                t,
-             std::function<Word(Word const&)> const& collapser) {
+             std::function<Word(Word const&)> const& collapser)
+              -> detail::ToddCoxeterImpl& {
             auto wrap = [&collapser](auto d_it, auto first, auto last) {
               Word copy(first, last);
               // Shame to do so much copying here but couldn't figure out how to
@@ -649,7 +658,8 @@ happens first. See :any:`perform_lookbehind_no_checks` for more details.
 
       thing.def(
           "perform_lookbehind_until",
-          [](ToddCoxeter_& self, std::function<bool()> const& pred) {
+          [](ToddCoxeter_&                self,
+             std::function<bool()> const& pred) -> detail::ToddCoxeterImpl& {
             return self.perform_lookbehind_until(pred);
           },
           py::arg("pred"),
@@ -676,7 +686,8 @@ This function runs a lookbehind until the nullary predicate *pred* returns
           "perform_lookbehind_until_no_checks",
           [](ToddCoxeter_&                           self,
              std::function<bool()> const&            pred,
-             std::function<Word(Word const&)> const& collapser) {
+             std::function<Word(Word const&)> const& collapser)
+              -> detail::ToddCoxeterImpl& {
             auto wrap = [&collapser](auto d_it, auto first, auto last) {
               Word copy(first, last);
               // Shame to do so much copying here but couldn't figure out how to

tests/test_todd_coxeter.py

@@ -420,22 +420,24 @@ def test_todd_coxeter_return_policy():
 def test_todd_coxeter_perform_lookahead():
     p = examples.full_transformation_monoid_Aiz58(10)
     tc = ToddCoxeter(congruence_kind.twosided, p)
-    tc.perform_lookahead()
+    assert tc.perform_lookahead() is tc
     tc.run_for(timedelta(seconds=0.01))
     num_nodes = tc.number_of_nodes_active()
-    tc.perform_lookahead()
+    # Check the return type is correct
+    assert tc.perform_lookahead() is tc
     assert tc.number_of_nodes_active() < num_nodes
 
 
 def test_todd_coxeter_perform_lookahead_for():
     p = examples.full_transformation_monoid_Aiz58(10)
     tc = ToddCoxeter(congruence_kind.twosided, p)
-    tc.perform_lookahead()
+    assert tc.perform_lookahead() is tc
     tc.run_for(timedelta(seconds=0.01))
     num_nodes = tc.number_of_nodes_active()
     start_time = time.time()
-    tc.perform_lookahead_for(timedelta(seconds=0.1))
-    assert time.time() - start_time <= 0.2
+    # Check the return type is correct
+    assert tc.perform_lookahead_for(timedelta(seconds=0.1)) is tc
+    assert time.time() - start_time <= 1.0
     assert tc.number_of_nodes_active() < num_nodes
 
 
@@ -445,7 +447,8 @@ def test_todd_coxeter_perform_lookahead_until():
     tc.perform_lookahead()
     tc.run_for(timedelta(seconds=0.01))
     num_nodes = tc.number_of_nodes_active()
-    tc.perform_lookahead_until(lambda: tc.number_of_nodes_active() < num_nodes)
+    # Check the return type is correct
+    assert tc.perform_lookahead_until(lambda: tc.number_of_nodes_active() < num_nodes) is tc
     assert tc.number_of_nodes_active() < num_nodes
 
 
@@ -456,8 +459,9 @@ def test_todd_coxeter_perform_lookbehind_for():
     tc.run_for(timedelta(seconds=0.01))
     num_nodes = tc.number_of_nodes_active()
     start_time = time.time()
-    tc.perform_lookbehind_for(timedelta(seconds=0.1))
-    assert time.time() - start_time <= 0.2
+    # Run and check the return type is correct
+    assert tc.perform_lookbehind_for(timedelta(seconds=0.1)) is tc
+    assert time.time() - start_time <= 1.0
     assert tc.number_of_nodes_active() < num_nodes
 
 
@@ -467,7 +471,8 @@ def test_todd_coxeter_perform_lookbehind_until():
     tc.perform_lookbehind()
     tc.run_for(timedelta(seconds=0.01))
     num_nodes = tc.number_of_nodes_active()
-    tc.perform_lookbehind_until(lambda: tc.number_of_nodes_active() < num_nodes)
+    # Run and check the return type is correct
+    assert tc.perform_lookbehind_until(lambda: tc.number_of_nodes_active() < num_nodes) is tc
     assert tc.number_of_nodes_active() < num_nodes
 
 
@@ -478,8 +483,9 @@ def test_todd_coxeter_perform_lookbehind_for_no_checks():
     tc.run_for(timedelta(seconds=0.01))
     num_nodes = tc.number_of_nodes_active()
     start_time = time.time()
-    tc.perform_lookbehind_for_no_checks(timedelta(seconds=0.1), lambda w: [])
-    assert time.time() - start_time <= 0.2
+    # Run and check the return type is correct
+    assert tc.perform_lookbehind_for_no_checks(timedelta(seconds=0.1), lambda w: []) is tc
+    assert time.time() - start_time <= 1.0
     assert tc.number_of_nodes_active() < num_nodes
 
 
@@ -489,7 +495,11 @@ def test_todd_coxeter_perform_lookbehind_until_no_checks():
     tc.perform_lookbehind()
     tc.run_for(timedelta(seconds=0.01))
     num_nodes = tc.number_of_nodes_active()
-    tc.perform_lookbehind_until_no_checks(
-        lambda: tc.number_of_nodes_active() < num_nodes, lambda w: []
+    # Run and check the return type is correct
+    assert (
+        tc.perform_lookbehind_until_no_checks(
+            lambda: tc.number_of_nodes_active() < num_nodes, lambda w: []
+        )
+        is tc
     )
     assert tc.number_of_nodes_active() < num_nodes