callable updated

Author: behnamasadi

CMakeLists.txt

@@ -56,9 +56,10 @@ read more [here](https://ros-developer.com/2017/11/08/docker/)
    * [Assert](docs/assert.md) 
    * [Atomic operations and Types](docs/atomic.md)    
    * [Attribute [[ attribute-list ]] ](docs/attribute.md) 
-   * [Basic IO Operation, Streams, Reading/Writing Files, Formating Output, cin, scanf, gets, getline, printf](docs/basic_IO_operation.md)  
+   * [Basic IO Operation, Streams, Reading/Writing Files, Formatting Output, cin, scanf, gets, getline, printf](docs/basic_IO_operation.md)  
    * [Bitset, Bit field, Bitwise Operations](docs/bitset_bit_field_bitwise_operations.md)  
-   * [Callbacks, Callable Objects, std::function, std::bind, std::invoke, Lambda](docs/callbacks.md)  
+   * [Callbacks](docs/callbacks.md)  
+   * [Callable Objects, std::function, std::bind, Lambda](docs/callable_objects_function_bind_lambda.md)
    * [Clock, Date, Time](docs/date_time.md)   
    * [Conditional Compilation](src/conditional_compilation.cpp)  
    * [Containers](docs/containers.md)  
@@ -83,6 +84,7 @@ read more [here](https://ros-developer.com/2017/11/08/docker/)
    * [Functions, Extern Function, Function Objects, Function Pointer, Inline Functions](docs/functions.md)  
    * [Hash](src/hash.cpp)    
    * [Heap and Stack, Memory Layout of C Programs](docs/heap_and_stack_memory_layout_of_C_programs.md)  
+   * [Invoke](docs/std_invoke.md)   
    * [Iterator, for_each loop, range-for loop, Loop optimization](docs/iterator_loop.md)  
    * [Lambda](docs/lambda.md)     
    * [Literals](docs/literals.md)  

README.md

@@ -0,0 +1,29 @@
+# Callable object
+In C++, a callable object is an object that can be invoked like a function. Callable objects can be used in a variety of ways, including as function objects, function pointers, and lambdas.
+
+There are several types of callable objects in C++, including:
+
+1. Function pointers: These are pointers that point to functions. They can be used to call the function that they point to.
+
+2. Function objects: These are objects that behave like functions. They implement the function call operator, operator(), and can be invoked like functions.
+
+3. Lambda expressions: These are anonymous functions that can be defined inline. They can capture variables from their enclosing scope and can be used as function objects.
+
+4. Member function pointers: These are pointers that point to member functions of a class. They can be used to call the member function that they point to.
+
+5. Function references: These are references to functions. They can be used to call the function that they refer to.
+
+Callable objects provide a lot of flexibility and can be used in many different situations, from implementing algorithms to passing functions as arguments to other functions.
+
+
+
+#Partial application
+In computer science, partial function application refers to the process of fixing a number of arguments to a function, 
+
+The C++ standard library provides `bind(function, args..)` to return a function object that is the result of partial application of the given arguments to the given function. Alternatively, lambda expressions can be used.
+
+## std::bind
+
+Refs: [1](https://www.youtube.com/watch?v=ZlHi8txU4aQ), [2](https://stackoverflow.com/questions/6610046/stdfunction-and-stdbind-what-are-they-and-when-should-they-be-used), [3](https://en.wikipedia.org/wiki/Partial_application)
+
+[code](../src/bind.cpp)

docs/callable_objects_function_bind_invoke_lambda.md

@@ -0,0 +1,10 @@
+
+`std::invoke` is a generic way to activate any callable. `std::invoke` takes something callable, and arguments to call it with, and does the call. `std::invoke( f, args... )` is a slight generalization of typing `f(args...)` that also handles a few additional cases.
+
+
+
+## std::bind
+
+Refs: [1](https://www.youtube.com/watch?v=ZlHi8txU4aQ)
+
+[code](../src/bind.cpp)

docs/callable_objects_function_bind_lambda.md

@@ -1,128 +1,74 @@
-- [Callbacks](#callbacks)
-  * [Function pointers (including pointers to member functions)](#function-pointers--including-pointers-to-member-functions-)
-  * [std::function](#std--function)
-  * [Lambda expressions](#lambda-expressions)
-  * [Bind expressions](#bind-expressions)
-  * [Function objects (classes with overloaded function call operator operator())](#function-objects--classes-with-overloaded-function-call-operator-operator---)
-- [Sending a function as parameter to an other function](#sending-a-function-as-parameter-to-an-other-function)
-
-
 # Callbacks
 
-A callback is a callable  accepted by a class or function, used to customize the current logic depending on that callback. `std::invoke` is a generic way to activate any callable. `std::invoke` takes something callable, and arguments to call it with, and does the call. `std::invoke( f, args... )` is a slight generalization of typing `f(args...)` that also handles a few additional cases.
-
-## Function pointers (including pointers to member functions)
-## std::function 
-Class template std::function is a general-purpose polymorphic function wrapper. Instances of std::function can store, copy, and invoke any Callable target:
-1. functions
-2. lambda expressions
-3. bind expressions
-4. functors
+A callback function is a callable passed as an argument to a class or function, used to customize the current logic depending on that callback. 
+For instance imagine you have a class for modeling a robot and you want to give this freedom to user to define and use different motion planner. You can ask the user to pass the solver function to the robot class so the robot class use that one for moving around.
 
 ```cpp
-void print(int value)
-{
-    std::cout<< value<<std::endl;
-}
-```
+typedef std::function<std::vector<double>(double, double)> CallbackFunction;
 
-storing a functions:
-```cpp
-std::function<void(int)> funcPrint=print;
-funcPrint(3);
-```
+class robot {
 
-store a bind expressions:
+public:
+  CallbackFunction m_callback;
 
-```cpp
-std::function<void (int)> funcPrint=std::bind(&print,std::placeholders::_1);
-std::function<void (int)> f(funcPrint);
-f(3);
-```
+  void makeMotion(std::vector<double> trajectory) {
+    std::cout << "robot is traversing the generated trajectory:" << std::endl;
+    for (const auto &p : trajectory)
+      std::cout << p << std::endl;
+  }
 
-store lambda expressions:
-```cpp
-auto lambda=[](int value){std::cout<< value<<std::endl;};
-std::function<void(int)>f(lambda);
-f(3);
-```
+  void move(double start, double goal) {
 
-store a functors:
-```cpp
-void (*printfunctor)(int);
-printfunctor=print;
-std::function<void(int)>f(printfunctor);
-f(3);
+    std::vector<double> trajectory = m_callback(start, goal);
+    makeMotion(trajectory);
+  }
+};
 ```
 
-## Lambda expressions
-## Bind expressions
-`std::bind` works as a Functional Adaptor i.e. it takes a function as input and returns a new function Object as an output with with one or more of the arguments of passed function bound or rearranged (partial function application).
+Now we can have different solvers:
 
-first example:
 ```cpp
-void print(int firstParam, int secondParam)
-{
-	std::cout << "First Param is: " << firstParam << " Second Param is: " << secondParam << std::endl;
+std::vector<double> planer1(double start, double goal) {
+  return {start, (start + goal) / 2, goal};
+}
+std::vector<double> planer2(double start, double goal) {
+  return {start, start + (start + goal) / 3, 2 * (start + goal) / 3, goal};
 }
 ```
-in the main:
+Now we can assign and use different solvers:
+
 ```cpp
-int firstParam=3;
-int secondParam=5;
-auto MyPrinter=std::bind(&print,firstParam,secondParam);
-MyPrinter();
+robot myrobot1;
+myrobot1.m_callback = planer1;
+myrobot1.move(start, goal);
 ```
-You can use `std::placeholders::_` to set the order of the parameters:
+  
+or 
 
 ```cpp
-auto reversePrintFunc = std::bind(&print, std::placeholders::_2, std::placeholders::_1);
-
-int firstParam = 3;
-int secondParam = 5;
-
-print(firstParam, secondParam);
-reversePrintFunc(firstParam, secondParam);
+std::function<std::vector<double>(double, double)> planer2_ptr =
+      std::bind(&planer2, std::placeholders::_1, std::placeholders::_2);
 
+myrobot1.m_callback = planer2_ptr;
+myrobot1.move(start, goal);
 ```
-You can use it like a lambda expression:
 
+or
 
 ```cpp
-std::vector<int> vec={1,2,3};
-std::vector<int> values(vec.size(),0);
-
-// raise every value in vec to the power of 3
-auto f=std::bind(&std::pow<int,int>,std::placeholders::_1,3);
-std::transform(vec.begin(), vec.end(), values.begin(), f);
-        
-for(auto value:values)
-    std::cout<< value<<std::endl;
-```
-an other example:
+ auto planer_lambda = [](double start, double goal) {
+    return std::vector<double>(10, 2);
+  };
 
-```cpp
-int param=3;
-auto printer=std::bind(&printTemplate<int>,param);
+  myrobot1.m_callback = planer_lambda;
+  myrobot1.move(start, goal);
 ```
-or
-```cpp
-auto printer=std::bind(&printTemplate<int>,std::placeholders::_1);
-```
-an calling it:
-```cpp
-std::function<void (int)>f(printer);
-f(param);
-```
-
-
-Refs: [1](//https://www.youtube.com/watch?v=ZlHi8txU4aQ)
+[code](../src/callbacks.cpp)
 
-[code](../src/bind.cpp)
+  
 
+Refs: [1](https://stackoverflow.com/questions/2298242/callback-functions-in-c) 
 
-Refs: [1](https://stackoverflow.com/questions/2298242/callback-functions-in-c), [2](https://stackoverflow.com/questions/6610046/stdfunction-and-stdbind-what-are-they-and-when-should-they-be-used), [2](https://en.wikipedia.org/wiki/Partial_application)
-[source code](../src/callbacks.cpp)
 
 
 

docs/callbacks.md

@@ -0,0 +1,37 @@
+## std::invoke
+`std::invoke` is a generic way to activate any callable. `std::invoke` takes something callable, and arguments to call it with, and does the call. `std::invoke( f, args... )` is a slight generalization of typing `f(args...)` that also handles a few additional cases.
+
+The advantage of using std::invoke over directly invoking a callable object is that it provides a uniform syntax that works for all callable objects. This means that you can use the same syntax to invoke a function pointer, member function, function object, or lambda, without needing to know the specific type or signature of the callable object.
+
+
+
+```cpp
+void foo(int x) {
+    std::cout << "foo(" << x << ")" << std::endl;
+}
+
+struct bar {
+    void operator()(int x) const {
+        std::cout << "bar(" << x << ")" << std::endl;
+    }
+};
+```
+now you can invoke them as followings:
+
+
+1. Invoke a function pointer:
+```cpp
+int x = 42;
+std::invoke(foo, x);
+```
+
+2. Invoke a member function:
+```cpp
+bar b;
+std::invoke(&bar::operator(), b, x);
+```
+
+3. Invoke a function object:
+```cpp
+std::invoke(std::function<void(int)>([](int x) { std::cout << "lambda(" << x << ")" << std::endl; }), x);
+````