simplify naming of logical operators

Author: mnikander

src/functional.hpp

@@ -7,9 +7,9 @@
 namespace nv {
 
 // Logical operators
-struct LogicalNot   { template <typename T> T operator()(T t) const { return !t; } };
-struct LogicalAnd   { template <typename T> T operator()(T lhs, T rhs) const { return lhs && rhs; } };
-struct LogicalOr    { template <typename T> T operator()(T lhs, T rhs) const { return lhs || rhs; } };
+struct Not          { template <typename T> T operator()(T t) const { return !t; } };
+struct And          { template <typename T> T operator()(T lhs, T rhs) const { return lhs && rhs; } };
+struct Or           { template <typename T> T operator()(T lhs, T rhs) const { return lhs || rhs; } };
 
 // unary ops, which are both: (1) a tag which represents the operation and (2) the implementation of that operation
 struct Identity     { template <typename T> T operator()(T t) const { return t; } };

test/test_functional.cpp

@@ -3,21 +3,21 @@
 
 namespace {
 
-TEST(functional, logical_not)
+TEST(functional, not)
 {
-    const auto f = nv::LogicalNot{};
+    const auto f = nv::Not{};
     EXPECT_EQ(f(false), true);
 }
 
-TEST(functional, logical_and)
+TEST(functional, and)
 {
-    const auto f = nv::LogicalAnd{};
+    const auto f = nv::And{};
     EXPECT_EQ(f(false, true), false);
 }
 
-TEST(functional, logical_or)
+TEST(functional, or)
 {
-    const auto f = nv::LogicalOr{};
+    const auto f = nv::Or{};
     EXPECT_EQ(f(false, true), true);
 }