Gave AI credit and remove my email address

Author: Creamy-pie-96

docs/Includes_and_namespaces/incl_name.md

@@ -0,0 +1,76 @@
+[⬅ Back to Table of Contents](../index.md)
+
+# Includes and Namespaces
+
+## The Easy Way (Recommended)
+
+Just include the main header—this pulls in everything under the `Pythonic` (or `py`) namespace:
+
+```cpp
+#include "pythonic/pythonic.hpp"
+
+using namespace Pythonic;
+// or
+using namespace py;
+```
+
+## The Manual Way
+
+Or, pick exactly what you need:
+
+```cpp
+#include "pythonicVars.hpp"      // var, list, dict, set
+#include "pythonicPrint.hpp"     // print(), pprint()
+#include "pythonicLoop.hpp"      // range(), enumerate(), zip() + macros
+#include "pythonicFunction.hpp"  // map, filter, comprehensions
+#include "pythonicFile.hpp"      // File I/O
+#include "pythonicMath.hpp"      // Math functions (trig, logarithms, etc.)
+
+using namespace pythonic::vars;
+using namespace pythonic::print;
+using namespace pythonic::loop;
+using namespace pythonic::math;
+using namespace pythonic::file;
+using namespace pythonic::func;
+using namespace pythonic::graph;
+using namespace pythonic::fast;
+using namespace pythonic::overflow;
+using namespace pythonic::error;
+```
+
+> **Caution:**  
+> If you import namespaces globally, be careful with `std` and other namespaces—they might clash or cause ambiguity. We recommend using `std::` explicitly if you make the `pythonic` namespace global.
+
+---
+
+## About Namespaces
+
+- `pythonic::vars` – Core `var` type, containers, type conversion
+- `pythonic::print` – Printing and formatting (`print()`, `pprint()`)
+- `pythonic::loop` – Iteration helpers (`range()`, `enumerate()`, `zip()`, `reversed()`)
+- `pythonic::func` – Functional programming (`map()`, `filter()`, comprehensions)
+- `pythonic::file` – File I/O
+- `pythonic::math` – Comprehensive math library (`trig`, `logarithms`, `random`, etc.)
+- `pythonic::graph` – Graph data structure and algorithms
+- `pythonic::error` – Exception hierarchy and error handling
+- `pythonic::fast` – Hot-loop optimizations
+- `pythonic::overflow` – Checked arithmetic helpers
+
+You can use them all at once with:
+
+```cpp
+using namespace Pythonic;
+// or
+using namespace py;
+```
+
+---
+
+> **Note:**  
+> We highly recommend including the whole library at once, as many parts have dependencies on others (e.g., the math library depends on `var`). If you try to use the math library without including `pythonicVar.hpp` and the `var` namespace, your code may not work as expected.
+
+---
+
+## Next
+
+- [Print](../Print/print.md)

docs/Print/print.md

@@ -1,4 +1,5 @@
 [⬅ Back to Table of Contents](../index.md)
+[⬅ Back to Include and namespaces](../Includes_and_namespaces/incl_name.md)
 
 # Print and Pretty Print
 
@@ -14,15 +15,22 @@ The `print` and `pprint` helpers in Pythonic provide a convenient way to output
 
 ## `print`
 
-The `print` function is used for standard output of `var` objects and other types. It supports multiple arguments, custom separators, and end characters.
+### Function Signatures and Parameters
 
-### Features
+| Function                              | Description                                                                                                                                         |
+| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `print(args...)`                      | Prints any number of arguments (of any type), separated by a space, ending with a newline. For `var` types, uses the simple `str()` representation. |
+| `pprint(var v, size_t indent_step=2)` | Pretty-prints a `var` object with indentation. `indent_step` sets the number of spaces per indent level (default: 2).                               |
 
-- Outputs `var` objects and other types using `str()` or `operator<<`.
-- Supports multiple arguments, separated by a customizable separator (default is a space).
-- Allows customization of the end character (default is a newline `\n`).
+**Parameters:**
 
-### Example
+- `args...` (print): Any number of arguments of any type.
+- `v` (pprint): The `var` object to pretty-print.
+- `indent_step` (pprint): (Optional) Number of spaces for each indentation level. Default is 2.
+
+> **Note:** The current implementation does not support custom separators or end characters for `print`. Output always ends with a newline, and arguments are separated by a single space.
+
+### Usage Examples
 
 ```cpp
 #include "pythonicPrint.hpp"
@@ -44,13 +52,23 @@ int main() {
 
 ## `pprint`
 
-The `pprint` function is designed for pretty-printing complex or nested structures. It uses `pretty_str()` to format the output with indentation and line breaks for better readability.
+### Function Signature
+
+```cpp
+pprint(const var& v, size_t indent_step = 2);
+```
+
+### Parameters
+
+- `v`: The `var` object to pretty-print.
+- `indent_step`: (Optional) Number of spaces to use for each indentation level. Default is 2. Increase for wider indentation.
 
 ### Features
 
 - Outputs nested structures in a human-readable format.
 - Automatically applies indentation and line breaks for clarity.
 - Ideal for debugging and inspecting large or deeply nested data.
+- Allows customizing indentation width via `indent_step`.
 
 ### Example
 
@@ -146,4 +164,4 @@ While `print` and `pprint` are convenient for debugging and output, they may not
 
 # Next Check
 
-- [Var](../Var/var.md)
+- [Var](../Var/var.md)

docs/index.md

@@ -5,6 +5,8 @@
 Central table of contents for the project documentation.
 
 Recommended reading order:
+
+- [Include and namespaces](Includes_and_namespaces/incl_name.md) — Talkes about the namespaces and include files
 - [Print](Print/print.md) — `print` Python style printing
 - [Variable](Var/var.md) — `var` fundamentals, ownership, type model
   - [Types & DTypes](Var/dtypes.md)