From a68796b645bad7ebe4c4865d8d798016da09da42 Mon Sep 17 00:00:00 2001
From: abitmore <abitmore@users.noreply.github.com>
Date: Sat, 5 Jun 2021 22:29:08 +0000
Subject: [PATCH] Make the return types of lambda functions implicit

---
 libraries/protocol/custom_authorities/list_1.cpp  | 5 +++--
 libraries/protocol/custom_authorities/list_10.cpp | 5 +++--
 libraries/protocol/custom_authorities/list_11.cpp | 5 +++--
 libraries/protocol/custom_authorities/list_12.cpp | 5 +++--
 libraries/protocol/custom_authorities/list_13.cpp | 5 +++--
 libraries/protocol/custom_authorities/list_14.cpp | 5 +++--
 libraries/protocol/custom_authorities/list_2.cpp  | 5 +++--
 libraries/protocol/custom_authorities/list_3.cpp  | 5 +++--
 libraries/protocol/custom_authorities/list_4.cpp  | 5 +++--
 libraries/protocol/custom_authorities/list_5.cpp  | 5 +++--
 libraries/protocol/custom_authorities/list_6.cpp  | 5 +++--
 libraries/protocol/custom_authorities/list_7.cpp  | 5 +++--
 libraries/protocol/custom_authorities/list_8.cpp  | 5 +++--
 libraries/protocol/custom_authorities/list_9.cpp  | 5 +++--
 14 files changed, 42 insertions(+), 28 deletions(-)

diff --git a/libraries/protocol/custom_authorities/list_1.cpp b/libraries/protocol/custom_authorities/list_1.cpp
index 4c185e192d..99893b808d 100644
--- a/libraries/protocol/custom_authorities/list_1.cpp
+++ b/libraries/protocol/custom_authorities/list_1.cpp
@@ -29,13 +29,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_1(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_1::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_1::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_10.cpp b/libraries/protocol/custom_authorities/list_10.cpp
index cfeaba7a73..3e768c8e12 100644
--- a/libraries/protocol/custom_authorities/list_10.cpp
+++ b/libraries/protocol/custom_authorities/list_10.cpp
@@ -29,13 +29,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_10(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_10::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_10::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_11.cpp b/libraries/protocol/custom_authorities/list_11.cpp
index 3b51666b5d..3ec1e93252 100644
--- a/libraries/protocol/custom_authorities/list_11.cpp
+++ b/libraries/protocol/custom_authorities/list_11.cpp
@@ -29,13 +29,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_11(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_11::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_11::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_12.cpp b/libraries/protocol/custom_authorities/list_12.cpp
index 267d6fc6da..8311b66c0d 100644
--- a/libraries/protocol/custom_authorities/list_12.cpp
+++ b/libraries/protocol/custom_authorities/list_12.cpp
@@ -29,13 +29,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_12(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_12::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_12::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_13.cpp b/libraries/protocol/custom_authorities/list_13.cpp
index 7e2afd1ff6..8c4f74c508 100644
--- a/libraries/protocol/custom_authorities/list_13.cpp
+++ b/libraries/protocol/custom_authorities/list_13.cpp
@@ -29,13 +29,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_13(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_13::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_13::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_14.cpp b/libraries/protocol/custom_authorities/list_14.cpp
index d1e1d67535..2560321b49 100644
--- a/libraries/protocol/custom_authorities/list_14.cpp
+++ b/libraries/protocol/custom_authorities/list_14.cpp
@@ -29,13 +29,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_14(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_14::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_14::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_2.cpp b/libraries/protocol/custom_authorities/list_2.cpp
index 62bc7abfc3..6cf5b982c5 100644
--- a/libraries/protocol/custom_authorities/list_2.cpp
+++ b/libraries/protocol/custom_authorities/list_2.cpp
@@ -30,13 +30,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_2(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_2::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_2::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_3.cpp b/libraries/protocol/custom_authorities/list_3.cpp
index e23db34f42..9ba40efce3 100644
--- a/libraries/protocol/custom_authorities/list_3.cpp
+++ b/libraries/protocol/custom_authorities/list_3.cpp
@@ -30,13 +30,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_3(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_3::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_3::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_4.cpp b/libraries/protocol/custom_authorities/list_4.cpp
index 32f094585b..2453728c83 100644
--- a/libraries/protocol/custom_authorities/list_4.cpp
+++ b/libraries/protocol/custom_authorities/list_4.cpp
@@ -30,13 +30,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_4(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_4::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_4::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_5.cpp b/libraries/protocol/custom_authorities/list_5.cpp
index d67b9997ad..9997c20b86 100644
--- a/libraries/protocol/custom_authorities/list_5.cpp
+++ b/libraries/protocol/custom_authorities/list_5.cpp
@@ -30,13 +30,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_5(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_5::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_5::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_6.cpp b/libraries/protocol/custom_authorities/list_6.cpp
index 872c490732..60933d5142 100644
--- a/libraries/protocol/custom_authorities/list_6.cpp
+++ b/libraries/protocol/custom_authorities/list_6.cpp
@@ -30,13 +30,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_6(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_6::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_6::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_7.cpp b/libraries/protocol/custom_authorities/list_7.cpp
index 2cd386d5cc..4bb31c9315 100644
--- a/libraries/protocol/custom_authorities/list_7.cpp
+++ b/libraries/protocol/custom_authorities/list_7.cpp
@@ -30,13 +30,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_7(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_7::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_7::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_8.cpp b/libraries/protocol/custom_authorities/list_8.cpp
index a0b3b34289..9d576305bd 100644
--- a/libraries/protocol/custom_authorities/list_8.cpp
+++ b/libraries/protocol/custom_authorities/list_8.cpp
@@ -30,13 +30,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_8(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_8::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_8::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }
diff --git a/libraries/protocol/custom_authorities/list_9.cpp b/libraries/protocol/custom_authorities/list_9.cpp
index 4f1e2a7524..f709960a57 100644
--- a/libraries/protocol/custom_authorities/list_9.cpp
+++ b/libraries/protocol/custom_authorities/list_9.cpp
@@ -30,13 +30,14 @@ namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
 result_type get_restriction_pred_list_9(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_9::list(), idx, [&rs] (auto t) -> result_type {
+   return typelist::runtime::dispatch(operation_list_9::list(), idx, [&rs] (auto t) {
       using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
+      result_type to_return = [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
                    "Supplied operation is incorrect type for restriction predicate");
          return p(op.get<Op>());
       };
+      return to_return;
    });
 }
 } }