simplify the functional header to contain the function objects only

Author: mnikander

CMakeLists.txt

@@ -8,7 +8,7 @@ set(CMAKE_CXX_STANDARD 17)
 find_package(GTest REQUIRED)
 include_directories(${GTEST_INCLUDE_DIRS})
 
-set(SOURCES src/functional.cpp)
+set(SOURCES )
 
 # Link unit_tests with what we want to test and the GTest and pthread library
 add_executable(unit_tests ${SOURCES}

src/_main.cpp

@@ -18,7 +18,7 @@ int main()
     vi32 v = vi32{1, 2, 4, 8, 16} | take(3) | drop(1) | reverse();
     std::cout << "    The answer: " << v << std::endl; // ( 4 2 )
 
-    vi32 squared_values = iota(5) | map(power() <<= 2);
+    vi32 squared_values = iota(5) | map(nv::Power{} <<= 2);
     std::cout << "Squared values: " << squared_values << std::endl; // ( 0 1 4 9 16 )
 
     // create a palindrome from those squared numbers

src/functional.cpp

@@ -41,64 +41,3 @@ struct GreatestCommonDivisor { template <typename T> T operator()(T lhs, T rhs)
 // note that OR is a specialization of GCD for booleans
 
 }
-
-namespace xpr {
-
-// functions which retrive the function object, see cpp file for implementation
-
-// unary
-nv::LogicalNot logical_not();
-nv::Identity identity();
-nv::Negate negate();
-
-// binary
-nv::LogicalAnd logical_and();
-nv::LogicalOr logical_or();
-nv::Plus plus();
-nv::Minus minus();
-nv::Multiply multipy();
-nv::Divide divide();
-nv::Modulo modulo();
-nv::Power power();
-nv::Minimum minimum();
-nv::Maximum maximum();
-nv::Equal equal() ;
-nv::NotEqual not_equal();
-nv::Less less();
-nv::LessEqual less_equal();
-nv::Greater greater();
-nv::GreaterEqual greater_equal();
-nv::LeastCommonMultiple least_common_multiple();
-nv::GreatestCommonDivisor greatest_common_divisor();
-
-// functions which retrieve and execute the function object
-
-// unary
-template <typename T> auto logical_not(T const& t) { return nv::LogicalNot{}(t); }
-template <typename T> auto identity(T const& t) { return nv::Identity{}(t); }
-template <typename T> auto negate(T const& t) { return nv::Negate{}(t); }
-
-// binary
-template <typename T> auto logical_and(T const& lhs, T const& rhs) { return nv::LogicalAnd{}(lhs, rhs); }
-template <typename T> auto logical_or(T const& lhs, T const& rhs) { return nv::LogicalOr{}(lhs, rhs); }
-template <typename T> auto plus(T const& lhs, T const& rhs) { return nv::Plus{}(lhs, rhs); }
-template <typename T> auto minus(T const& lhs, T const& rhs) { return nv::Minus{}(lhs, rhs); }
-template <typename T> auto multipy(T const& lhs, T const& rhs) { return nv::Multiply{}(lhs, rhs); }
-template <typename T> auto divide(T const& lhs, T const& rhs) { return nv::Divide{}(lhs, rhs); }
-template <typename T> auto modulo(T const& lhs, T const& rhs) { return nv::Modulo{}(lhs, rhs); }
-template <typename T> auto power(T const& lhs, T const& rhs) { return nv::Power{}(lhs, rhs); }
-template <typename T> auto minimum(T const& lhs, T const& rhs) { return nv::Minimum{}(lhs, rhs); }
-template <typename T> auto maximum(T const& lhs, T const& rhs) { return nv::Maximum{}(lhs, rhs); }
-template <typename T> auto equal(T const& lhs, T const& rhs) { return nv::Equal{}(lhs, rhs); }
-template <typename T> auto not_equal(T const& lhs, T const& rhs) { return nv::NotEqual{}(lhs, rhs); }
-template <typename T> auto less(T const& lhs, T const& rhs) { return nv::Less{}(lhs, rhs); }
-template <typename T> auto less_equal(T const& lhs, T const& rhs) { return nv::LessEqual{}(lhs, rhs); }
-template <typename T> auto greater(T const& lhs, T const& rhs) { return nv::Greater{}(lhs, rhs); }
-template <typename T> auto greater_equal(T const& lhs, T const& rhs) { return nv::GreaterEqual{}(lhs, rhs); }
-template <typename T> auto least_common_multiple(T const& lhs, T const& rhs) { return nv::LeastCommonMultiple{}(lhs, rhs); }
-template <typename T> auto greatest_common_divisor(T const& lhs, T const& rhs) { return nv::GreatestCommonDivisor{}(lhs, rhs); }
-
-}
-
-// Unfortunately 'not' 'and' 'or' are reserved keywords in C++, so I cannot create functions with that name.
-// This led me to introduce the postfix '_l' to all of the names.

src/functional.hpp

@@ -7,154 +7,132 @@ TEST(functional, logical_not)
 {
     const auto f = nv::LogicalNot{};
     EXPECT_EQ(f(false), true);
-    EXPECT_EQ(xpr::logical_not(false), true);
 }
 
 TEST(functional, logical_and)
 {
     const auto f = nv::LogicalAnd{};
     EXPECT_EQ(f(false, true), false);
-    EXPECT_EQ(xpr::logical_and(false, true), false);
 }
 
 TEST(functional, logical_or)
 {
     const auto f = nv::LogicalOr{};
     EXPECT_EQ(f(false, true), true);
-    EXPECT_EQ(xpr::logical_or(false, true), true);
 }
 
 TEST(functional, identity)
 {
     const auto f = nv::Identity{};
     EXPECT_EQ(f(5), 5);
-    EXPECT_EQ(xpr::identity(5), 5);
 }
 
 TEST(functional, negate)
 {
     const auto f = nv::Negate{};
     EXPECT_EQ(f(5), -5);
-    EXPECT_EQ(xpr::negate(5), -5);
 }
 
 TEST(functional, plus)
 {
     const auto f = nv::Plus{};
     EXPECT_EQ(f(4, 6), 10);
-    EXPECT_EQ(xpr::plus(4, 6), 10);
 }
 
 TEST(functional, minus)
 {
     const auto f = nv::Minus{};
     EXPECT_EQ(f(4, 6), -2);
-    EXPECT_EQ(xpr::minus(4, 6), -2);
 }
 
 TEST(functional, times)
 {
     const auto f = nv::Multiply{};
     EXPECT_EQ(f(4, 6), 24);
-    EXPECT_EQ(xpr::multipy(4, 6), 24);
 }
 
 TEST(functional, divided)
 {
     const auto f = nv::Divide{};
     EXPECT_EQ(f(12, 6), 2);
-    EXPECT_EQ(xpr::divide(12, 6), 2);
 }
 
 TEST(functional, modulo)
 {
     const auto f = nv::Modulo{};
     EXPECT_EQ(f(12, 5), 2);
-    EXPECT_EQ(xpr::modulo(12, 5), 2);
 }
 
 TEST(functional, power)
 {
     const auto f = nv::Power{};
     EXPECT_EQ(f(2, 3), 8);
-    EXPECT_EQ(xpr::power(2, 3), 8);
 }
 
 TEST(functional, minimum)
 {
     const auto f = nv::Minimum{};
     EXPECT_EQ(f(4, 6), 4);
-    EXPECT_EQ(xpr::minimum(4, 6), 4);
 }
 
 TEST(functional, maximum)
 {
     const auto f = nv::Maximum{};
     EXPECT_EQ(f(4, 6), 6);
-    EXPECT_EQ(xpr::maximum(4, 6), 6);
 }
 
 TEST(functional, equal)
 {
     const auto f = nv::Equal{};
     EXPECT_EQ(f(4, 6), false);
-    EXPECT_EQ(xpr::equal(4, 6), false);
 }
 
 TEST(functional, unequal)
 {
     const auto f = nv::NotEqual{};
     EXPECT_EQ(f(4, 6), true);
-    EXPECT_EQ(xpr::not_equal(4, 6), true);
 }
 
 TEST(functional, less)
 {
     const auto f = nv::Less{};
     EXPECT_EQ(f(4, 6), true);
-    EXPECT_EQ(xpr::less(4, 6), true);
 }
 
 TEST(functional, less_equal)
 {
     const auto f = nv::LessEqual{};
     EXPECT_EQ(f(4, 6), true);
-    EXPECT_EQ(xpr::less_equal(4, 6), true);
 }
 
 TEST(functional, greater)
 {
     const auto f = nv::Greater{};
     EXPECT_EQ(f(4, 6), false);
-    EXPECT_EQ(xpr::greater(4, 6), false);
 }
 
 TEST(functional, greater_equal)
 {
     const auto f = nv::GreaterEqual{};
     EXPECT_EQ(f(4, 6), false);
-    EXPECT_EQ(xpr::greater_equal(4, 6), false);
 }
 
 TEST(functional, least_common_multiple)
 {
     const auto f = nv::LeastCommonMultiple{};
     EXPECT_EQ(f(4, 6), 12);
-    EXPECT_EQ(xpr::least_common_multiple(4, 6), 12);
 }
 
 TEST(functional, greatest_common_divisor)
 {
     const auto f = nv::GreatestCommonDivisor{};
     EXPECT_EQ(f(4, 6), 2);
-    EXPECT_EQ(xpr::greatest_common_divisor(4, 6), 2);
 }
 
 // TEST(functional, foooo)
 // {
 //     const auto f = nv::foooo{};
 //     EXPECT_EQ(f(4, 6), 12);
-//     EXPECT_EQ(xpr::foooo(4, 6), 12);
 // }
 
 }

test/test_functional.cpp

@@ -101,13 +101,13 @@ TEST(map, xpr_vector)
 
 TEST(map, xpr_scalar_scalar)
 {
-    i32 result = 2 | xpr::map(xpr::plus(), 3);
+    i32 result = 2 | xpr::map(nv::Plus{}, 3);
     EXPECT_EQ(result, 5);
 }
 
 TEST(map, xpr_scalar_vector)
 {
-    vi32 result = 10 | xpr::map(xpr::plus(), xpr::iota(3));
+    vi32 result = 10 | xpr::map(nv::Plus{}, xpr::iota(3));
 
     ASSERT_EQ(size(result), 3);
     EXPECT_EQ(result[0], 10);
@@ -117,7 +117,7 @@ TEST(map, xpr_scalar_vector)
 
 TEST(map, xpr_vector_scalar)
 {
-    vi32 result = xpr::iota(3) | xpr::map(xpr::plus(), 10);
+    vi32 result = xpr::iota(3) | xpr::map(nv::Plus{}, 10);
 
     ASSERT_EQ(size(result), 3);
     EXPECT_EQ(result[0], 10);
@@ -127,7 +127,7 @@ TEST(map, xpr_vector_scalar)
 
 TEST(map, xpr_vector_vector)
 {
-    vi32 result = xpr::iota(3) | xpr::map(xpr::plus(), nv::reverse(nv::iota(3)));
+    vi32 result = xpr::iota(3) | xpr::map(nv::Plus{}, nv::reverse(nv::iota(3)));
 
     ASSERT_EQ(size(result), 3);
     EXPECT_EQ(result[0], 2);

test/test_map.cpp

@@ -18,19 +18,19 @@ TEST(reduce, five)
 
 TEST(reduce, xpr_add)
 {
-    i32 result = vi32{1, 2, 4, 8, 16} | xpr::reduce(xpr::plus(), 0);
+    i32 result = vi32{1, 2, 4, 8, 16} | xpr::reduce(nv::Plus{}, 0);
     EXPECT_EQ(result, 31);
 }
 
 TEST(reduce, xpr_mul)
 {
-    i32 result = vi32{1, 2, 4} | xpr::reduce(xpr::multipy(), 1);
+    i32 result = vi32{1, 2, 4} | xpr::reduce(nv::Multiply{}, 1);
     EXPECT_EQ(result, 8);
 }
 
 TEST(reduce, xpr_default_init)
 {
-    i32 result = vi32{1, 2, 4} | xpr::reduce(xpr::multipy());
+    i32 result = vi32{1, 2, 4} | xpr::reduce(nv::Multiply{});
     EXPECT_EQ(result, 8);
 }