tones of up

Author: behnamasadi

CMakeLists.txt

@@ -174,7 +174,8 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
   - [lists](src/lists.cpp)
   - [C arrays, std::array, span](docs/array_span.md)
   - [set, map, pair, tuple, tie, unordered_map, multimap, unordered_set, multiset](docs/set_map_pair_tuple.md)
-  - [stack, queue, priority_queue, deque](docs/stack_queue_priority_queue_deque.md)
+  - [Queue, Priority queue, deque](docs/stack_queue_priority_queue_deque.md)
+  - [Stack](docs/stack.md)
 - [Const, Constexpr and Mutable](docs/const_constexpr_mutable.md)
 - [Immutable Objects](docs/immutable_objects.md)
 - [Data Types, Numerical Limits, Machine Epsilon, Precision, std::nan](docs/primitive_data_types_numerical_limits_machine_epsilon_precision.md)
@@ -246,8 +247,9 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
   - [Cast Base Class to Derived/ Derived to Base](src/class/cast_Base_to_Derived_to_Base.cpp)
   - [Class Forward Declaration](docs/class_forward_declaration.md)
   - [Class Constructor Initializationlist](src/class/constructor_initialization_list.cpp)
-  - [Class Constructor Aggregate/ Copy/ Default/ Direct/ Value/ Uniform/ Zero Initialization, Initializer List](docs/aggregate-copy-default-direct-value-zero_initialization.md)
+  - [Class Constructor Aggregate/ Copy/ Default/ Direct/ Value/ Uniform/ Zero Initialization, Initializer List](docs/initialization.md)
   - [Copy Constructor, Copy Assignment, Move Constructor, Assignment](docs/copy_constructor_move_constructor.md)
+  - [Shallow Copy, Deep CCopy](docs/shallow_copy_deep_copy.md)
   - [Cyclic (Circular) Dependency](docs/circular_dependencies.md)
   - [Default(=default), Deleted (=delete) Constructors](docs/default_constructors_=default_0_delete.md)
   - [Diamond Problem Virtual Inheritance](src/class/diamond_problem_virtual_inheritance.cpp)
@@ -329,10 +331,15 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
 - [JSON](docs/json.md)
 - [XML](docs/tinyxml2.md)
 
-## [REST API and Microservices with C++](#)
+## [REST API, Microservices, and Communication Libraries with C++](#)
 
 - [Monolithic Architecture vs REST API and Microservices](docs/microservices/REST_API_microservices.md)
-- [gRPC](docs/microservices/grpc.md)
+- [REST APIs / Webhooks with cURL (libcurl)](https://github.com/curl/curl)
+- [gRPC C++ (official)](https://github.com/grpc/grpc)
+- [WebSockets with IXWebSocket](https://github.com/machinezone/IXWebSocket)
+- [WebRTC with libdatachannel](https://github.com/paullouisageneau/libdatachannel)
+- [GraphQL with cppgraphqlgen](https://github.com/microsoft/cppgraphqlgen)
+- [XML SOAP with tinyxml2 + cURL](docs/microservices/xml_soap.md)
 - [REST API with crow](docs/microservices/REST_API_with_crow.md)
 - [mocking APIs with Mockoon](docs/microservices/mockoon.md)
 - [Test API with Postman](docs/microservices/test_API_with_postman.md)
@@ -399,6 +406,7 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
 - [High-Performance Computing (HPC) Patterns](docs/system_design/hpc_patterns.md)
 - [Serialization and Deserialization (Protobuf, FlatBuffers)](docs/system_design/serialization.md)
 - [Error Handling Strategies and Fault Tolerance](docs/system_design/error_handling_strategies.md)
+- [Design a reusable library](docs/system_design/design_a_reusable_library.md)
 
 ## [VSCode](#)
 

README.md

@@ -1,47 +1,192 @@
-# SFINAE
-SFINAE, which stands for "Substitution Failure Is Not An Error," is a concept in C++ template programming. It's a rule that applies during the template instantiation process. The idea is that if a substitution of template parameters into a template results in an invalid code, this is not in itself an error. Instead, the invalid template is simply discarded from the set of potential templates to use.
+## 1. What problem are we solving?
 
-This concept is particularly useful for creating template specializations that are only valid for certain types or conditions, enabling more flexible and powerful template designs.
+We want this behavior:
 
-### Basic Example of SFINAE
+```cpp
+divide(10, 2);          // OK
+divide(10.0, 2.0);     // OK
+divide(std::string{}, std::string{});   // ❌ not allowed
+```
+
+But **C++ templates are instantiated only when used**, so we need a way to:
+
+* **Enable** a function for some types
+* **Disable** it for others
+* **Without producing a compilation error**
+
+This is exactly what **SFINAE** does.
+
+---
+
+## 2. What is SFINAE?
+
+**SFINAE** means:
+
+> **Substitution Failure Is Not An Error**
+
+When the compiler tries to substitute a template type, and that substitution **fails**, the compiler:
+
+* ❌ does **not** error
+* ✅ simply **removes that function from overload resolution**
+
+So the function **silently disappears**.
+
+---
+
+## 3. Detecting whether a type supports division
+
+We first ask:
+
+> “Can I write `a / b` for this type?”
+
+### Step 3.1 – Primary template (assume NO division)
+
+```cpp
+template <typename T, typename = void>
+struct has_division : std::false_type {};
+```
+
+This says:
+
+* By default, `T` **does not** support division
+
+---
+
+### Step 3.2 – Specialization (only exists if `T / T` is valid)
+
+```cpp
+template <typename T>
+struct has_division<
+    T,
+    std::void_t<decltype(std::declval<T>() / std::declval<T>())>
+> : std::true_type {};
+```
+
+What happens here:
+
+* `std::declval<T>()` creates a **fake T** (no object needed)
+* `decltype(a / b)` checks if the expression is valid
+* `std::void_t<...>` turns a valid expression into `void`
+
+If `T / T` is:
+
+* ✅ valid → this specialization exists → `true_type`
+* ❌ invalid → substitution fails → specialization ignored
 
-Here's a simple example to illustrate SFINAE:
+**This is SFINAE in action.**
+
+---
+
+## 4. Enabling the function only when division exists
+
+### Step 4.1 – Function enabled for divisible types
+
+```cpp
+template <typename T, std::enable_if_t<has_division<T>::value, int> = 0>
+T divide(const T& a, const T& b) {
+    return a / b;
+}
+```
+
+Key idea:
+
+* `enable_if_t<condition, int>` exists **only if condition is true**
+* If `has_division<T>::value == false`
+  → the function is **removed from overload resolution**
+
+---
+
+### Step 4.2 – Fallback for non-divisible types
+
+```cpp
+template <typename T, std::enable_if_t<!has_division<T>::value, int> = 0>
+void divide(const T&, const T&) {
+    std::cout << "No division available for this type\n";
+}
+```
+
+So now:
+
+| Type          | Which overload exists |
+| ------------- | --------------------- |
+| `int`         | division overload     |
+| `double`      | division overload     |
+| `std::string` | fallback overload     |
+
+---
+
+## 5. Full working example
 
 ```cpp
 #include <iostream>
+#include <string>
 #include <type_traits>
+#include <utility>
+
+// 1) Detect division support
+template <typename T, typename = void>
+struct has_division : std::false_type {};
 
-// Base template
 template <typename T>
-typename std::enable_if<std::is_integral<T>::value, bool>::type isIntegral(T) {
-    return true;
+struct has_division<
+    T,
+    std::void_t<decltype(std::declval<T>() / std::declval<T>())>
+> : std::true_type {};
+
+// 2) Enabled only if T supports division
+template <typename T, std::enable_if_t<has_division<T>::value, int> = 0>
+T divide(const T& a, const T& b) {
+    return a / b;
 }
 
-// Template specialization for non-integral types
-template <typename T>
-typename std::enable_if<!std::is_integral<T>::value, bool>::type isIntegral(T) {
-    return false;
+// 3) Enabled only if T does NOT support division
+template <typename T, std::enable_if_t<!has_division<T>::value, int> = 0>
+void divide(const T&, const T&) {
+    std::cout << "No division available for this type\n";
 }
 
 int main() {
-    std::cout << std::boolalpha;
-    std::cout << "isIntegral(10): " << isIntegral(10) << std::endl;   // Outputs: true
-    std::cout << "isIntegral(3.14): " << isIntegral(3.14) << std::endl; // Outputs: false
+    std::cout << divide(10, 2) << "\n";          // OK
+    std::cout << divide(10.0, 2.0) << "\n";      // OK
 
-    return 0;
+    std::string s1 = "a", s2 = "b";
+    divide(s1, s2);                              // graceful fallback
 }
 ```
 
-In this example, there are two versions of the `isIntegral` function template. The first version is enabled (via `std::enable_if`) only for integral types, while the second version is enabled for non-integral types. When you call `isIntegral` with an integer, the first version is instantiated. If you call it with a non-integer, the second version is instantiated.
+---
+
+## 6. Why this matters in real APIs
+
+You’ll see SFINAE used to:
+
+* Enable algorithms only for **numeric types**
+* Prevent misuse of generic APIs
+* Create **type-safe** libraries (Eigen, STL, ranges, fmt, etc.)
+* Provide **better overload selection** instead of runtime checks
+
+---
+
+## 7. Mental model to remember
+
+Think of SFINAE like this:
+
+> “If this template substitution doesn’t make sense,
+> pretend this function never existed.”
+
+No error. No warning. Just… gone.
+
+---
+
+## 8. Interview-level takeaway
 
-### Explanation
+If asked:
 
-- `std::enable_if`: This is a standard library utility that provides a member typedef `type` if the given boolean constant is true. If the boolean is false, there's no member typedef. This utility is commonly used for controlling template instantiation.
+> *“What is SFINAE and why do we need it?”*
 
-- `std::is_integral`: This is a type trait that checks if a type is an integral type (like int, char, etc.).
+Answer:
 
-### How SFINAE Comes Into Play
+> SFINAE lets template overloads disappear when a type does not satisfy certain compile-time requirements, enabling safe, expressive, and type-checked generic APIs without runtime overhead.
 
-In the example, if `T` is an integral type, the `std::enable_if<std::is_integral<T>::value, bool>::type` becomes `bool`, so the first `isIntegral` function template is valid. If `T` is not an integral type, this substitution fails, but due to SFINAE, this failure is not an error; instead, the first `isIntegral` template is simply discarded, and the compiler looks for other templates (in this case, the second `isIntegral`).
+---
 
-SFINAE allows for powerful metaprogramming techniques in C++, enabling the creation of templates that can adapt to different types and conditions at compile time, leading to more efficient and tailored code.