###Support for Curry and Function Composition in C++
#####1. Can be enabled on - Global, Member, Functor and Lambda Functions as well as Member Variables.
auto f1 = fn(foo); //Global function.
auto f2 = fn(&A::bar); //Member function of a class.
auto f3 = fn(B()); //Functor
auto lambda = [](auto arg1) {
return arg1*10.0;
};
auto f4 = fn(lambda); //Lambda. Anonymous lambda works too.
//Binding a member variable. Creates a one argument function.
auto f5 = fn(&std::pair::second); #####2. Partial application of Functions
//foo is a function that takes four arguments. Two are partially applied here.
auto partially_applied = fn(foo, arg1, arg2);
//The remaining two arguments are supplied here. Calls foo(arg1, arg2, arg3, arg4);
partially_applied(arg3, arg4);#####3. Currying of Functions
//foo is a function that takes four arguments.
auto curried_function = fn(foo);
auto one_arg_applied = curried_function(arg1);
auto some_more_applied = one_arg_applied(arg2, arg3);
auto the_rest_applied_and_invoked = some_more_applied(arg4);#####4. Placeholders
auto f1 = fn(foo); //foo takes four arguments.
auto f2 = f1(_4, _1, _3, _2); //Reorder arguments.
auto f3 = f2(arg1, arg2, arg3, arg4); //Calls foo(arg4, arg1, arg3, arg2)#####5. Anonymous Placeholders
auto f1 = fn(foo); //foo takes four arguments.
auto f2 = f1(_, arg1, arg2, _); //Some arguments are applied. It waits for more.
//Remaining arguments provided. Invokes foo(arg3, arg1, arg3, arg4)
auto f3 = f2(arg3, arg4);#####6. Function Composition ( Using composition operator '*' )
//foo takes four arguments
auto f1 = fn(foo);
//bar is a function that takes two arguments. It is composed in.
auto f2 = f1(arg1, _, arg2, arg3) * bar;
//Calls foo(arg1, bar(arg4, arg5), arg2, arg3)
auto f3 = f2(arg4, arg5);#####7. With Each ( Binding containers to values just like Monads and Applicative Functors )
int add_three_numbers(int a, int b, int c) {
return a + b + c;
}
std::vector<int> v1 = { 19,17,21 };
std::vector<int> v2 = { 23,49 };
std::vector<int> v3 = { 7, 13 };
auto adder = fn(add_three_numbers);
auto result = adder(with_each(v1), with_each(v2), with_each(v3));
//result will be a vector with 12 values {49, 55, 75, 81, 47, 53, 73, 79, 51, 57, 77, 83}#####8. Maybe
int add_three_numbers(int a, int b, int c) {
return a + b + c;
}
auto value1 = maybe(10);
auto value2 = maybe(20);
auto value3 = maybe(30);
auto adder = fn(add_three_numbers);
auto result = adder(value1, value2, value3);
//result will be maybe_t<int>(60)
auto value4 = maybe(10);
auto value5 = maybe_t<int>();
auto value6 = maybe(30);
auto adder = fn(add_three_numbers);
auto result = adder(value4, value5, value6);
//result will be maybe_t<int>() which is empty since value5 is empty
#####9. Pipe Operator '|'
auto print = fn([](const std::string& str) { std::cout << str << std::endl; });
auto world = _ + std::string("world");
"hello " | world | print; //prints "hello world" to the console#####10. On the fly function creation with placeholders
auto times10 = _ * 10;
auto result1 = times10(4.2); //result1 will be 42.0
auto greaterThan42 = 42 < _;
auto result2 = 32 | greaterThan42; //result2 will be false#####11. Immutable list (Code inspired by Bartosz Milewski's SimpleList)
auto lst = make_list<int>({1,2,3,4,5,6,7,8,9});
auto lst2 = tail(lst); //lst2 will be [2,3,4,5,6,7,8,9]
auto val = head(lst2); //val will be 2
auto lst3 = 1 + lst2; //lst3 will be [1,2,3,4,5,6,7,8,9]
auto is_lst_empty = empty(lst); //result will be false
auto second_item_of_lst3 = head(tail(lst3)); //result will be 2
auto square = fmap(_1*_1); //on the fly function creation with curried fmap application
auto fmap_result = square(lst3); //result will be [1,2,9,16,25,36,49,64,81]
auto sum = foldl(_+_, 0); //curried foldl application
auto product = foldr(_*_, 1); //curried foldr application
auto sum_result = sum(lst3); //result will be 45
std::cout << sum_result << std::endl;
auto product_result = lst3 | product; //result will be 362880
std::cout << product_result << std::endl;