Gave AI credit and remove my email address

Creamy-pie-96 · Creamy-pie-96 · commit c243115c007f · 2026-01-29T01:22:39.000+06:00
diff --git a/README.md b/README.md
@@ -31,13 +31,14 @@ We’re looking for users to test the library and provide feedback!
 Please open Issues or Discussions with any bug reports, questions, or feature ideas.
 **Note:** Direct code contributions are not accepted at this time.
 
+
+## Acknowledgments
+
+Parts of this project, including some code generation and much of documentation, were assisted by GitHub Copilot (AI programming assistant). Copilot provided suggestions and support throughout the development process.
+
 ---
 
 **AUTHOR:** MD. NASIF SADIK PRITHU
 **GITHUB:** [Creamy-pie-96](https://github.com/Creamy-pie-96)
 
 ---
-
-## Acknowledgments
-
-Parts of this project, including some code generation and much of documentation, were assisted by GitHub Copilot (AI programming assistant). Copilot provided suggestions and support throughout the development process.
diff --git a/docs/Math/math.md b/docs/Math/math.md
@@ -243,4 +243,5 @@ print(degrees(pi()));       // 180
 ---
 
 ## Next Check
+
 - [Error](../Errors/errors.md)
diff --git a/docs/Print/print.md b/docs/Print/print.md
@@ -145,4 +145,5 @@ int main() {
 While `print` and `pprint` are convenient for debugging and output, they may not be suitable for performance-sensitive logging. For large `var` objects or containers, consider serializing only the necessary parts to minimize overhead.
 
 # Next Check
+
 - [Var](../Var/var.md)
diff --git a/docs/Var/comparison_and_boolean.md b/docs/Var/comparison_and_boolean.md
@@ -96,3 +96,7 @@ try {
 - Comparison operators return `var` for Python-like chaining and high-level APIs.
 - Use `==`/`!=` for structural equality. Use `operator<(const var&)` for container ordering only.
 - Truthiness is determined by `operator bool()`; use in `if` or cast to `bool` as needed.
+
+## Next check
+
+- [Iterators, Mapping & Functional Helpers](iterators_mapping_functional.md)
diff --git a/docs/Var/construction_and_lifetime.md b/docs/Var/construction_and_lifetime.md
@@ -152,3 +152,7 @@ print(copy, moved);
 - Use converter helpers for explicit conversion or factory creation.
 - Prefer move for large containers to avoid unnecessary copies.
 - All containers and graphs are stored as heap-backed types inside `var`.
+
+## Next check
+
+- [Type Introspection & Conversion](type_introspection_and_conversion.md)
diff --git a/docs/Var/container_and_sequence_operations.md b/docs/Var/container_and_sequence_operations.md
@@ -133,3 +133,7 @@ var reduced_init = reduce(sum2, list(1, 2, 3), 10); // 16
 - Use `slice` or call syntax for sublists.
 - Use `items`, `keys`, `values` for dicts.
 - Iterators allow C++-style for loops over containers.
+
+## Next check
+
+- [String-like Methods (on string `var`)](string_like_methods.md)
diff --git a/docs/Var/dtypes.md b/docs/Var/dtypes.md
@@ -51,11 +51,11 @@ This page lists all the data types and containers supported by `var` in Pythonic
 - For construction and API usage, see:
   - [Construction & Lifetime](Var/construction_and_lifetime.md)
   - [Container & Sequence Operations](Var/container_and_sequence_operations.md)
-- Graph support is provided via `VarGraph` (see graph.md).
+- Graph support is provided via [`VarGraph`](graph_helpers.md).
 - Additional container types (e.g., linked lists) may be added in the future.
 
 ---
 
-## See Also
+## Next check
 
 - [Construction & Lifetime](construction_and_lifetime.md)
diff --git a/docs/Var/graph_helpers.md b/docs/Var/graph_helpers.md
@@ -156,3 +156,8 @@ g.show(false);
 - For advanced graph algorithms, see the full API or source.
 
 - `show(layout)` — If `layout` is true (default), the viewer will automatically arrange the graph layout. If false, the current node positions are preserved.
+
+
+# Next Check
+
+- [Math](../Math/math.md)
diff --git a/docs/Var/iterators_mapping_functional.md b/docs/Var/iterators_mapping_functional.md
@@ -85,3 +85,7 @@ print(unpack(std::make_tuple(1,2,3))); // [1,2,3]
 - All major iterator, mapping, and functional helpers are available for `var`.
 - Dict helpers (`items`, `keys`, `values`) only work for dict types.
 - Slicing supports negative indices and works for lists and strings.
+
+## Next check
+
+- [Graph Helpers (if using graph type)](graph_helpers.md)
diff --git a/docs/Var/numeric_arithmetic.md b/docs/Var/numeric_arithmetic.md
@@ -105,3 +105,7 @@ print(sum(list(1,2,3)));            // 6
 - All arithmetic and bitwise operators are overloaded for `var` and work with numeric types and containers where appropriate.
 - Compound assignment operators (`+=`, `-=`, etc.) are supported.
 - Use `abs`, `min`, `max`, `sum` for numeric helpers.
+
+## Next check
+
+- [Comparison & Boolean](comparison_and_boolean.md)
diff --git a/docs/Var/string_like_methods.md b/docs/Var/string_like_methods.md
@@ -71,3 +71,7 @@ print(var("7").zfill(3)); // "007"
 - All methods return a new `var` (string or list) and do not modify the original.
 - Use `split`/`join` for conversion between strings and lists.
 - Most methods match Python string semantics.
+
+## Next check
+
+- [Numeric / Arithmetic](numeric_arithmetic.md)
diff --git a/docs/Var/type_introspection_and_conversion.md b/docs/Var/type_introspection_and_conversion.md
@@ -155,3 +155,7 @@ if (auto *p = l.var_get_if<List>()) {
 - Use `get<T>()` or `var_get_if<T>()` for value access. These are the only user-facing accessors.
 - Use `to*()` or free functions for conversion.
 - All conversions throw on invalid types.
+
+## Next check
+
+- [Container & Sequence Operations](container_and_sequence_operations.md)
diff --git a/docs/Var/var.md b/docs/Var/var.md
@@ -24,4 +24,5 @@ Table of Contents
 - [Graph Helpers (if using graph type)](graph_helpers.md)
 
 # Next Check
+
 - [Math](../Math/math.md)
diff --git a/docs/examples/cookbook.md b/docs/examples/cookbook.md
@@ -2,9 +2,113 @@
 
 Practical recipes:
 
-- Parse CSV into `list<dict>` using `var`
-- Build and run a shortest-path example using `graph`
-- High-performance loop pattern using `is_*()` + `as_*_unchecked()`
-- Combining comprehensions and functional helpers
+Practical recipes for using the Pythonic C++ library.
 
-Each recipe has code and short explanation.
+---
+
+## 1. Parse CSV into `list<dict>` using `var`
+
+**Goal:** Read a CSV file and store each row as a dictionary in a list, using the dynamic `var` type.
+
+```cpp
+#include <pythonic/pythonic.hpp>
+using namespace pythonic;
+
+auto rows = list<dict<str, var>>{};
+auto file = open("data.csv");
+auto header = file.readline().strip().split(',');
+
+for (auto line : file) {
+	auto values = line.strip().split(',');
+	dict<str, var> row;
+	for (size_t i = 0; i < header.size(); ++i)
+		row[header[i]] = values[i];
+	rows.append(row);
+}
+```
+
+**Explanation:**
+
+- Reads the header to get column names.
+- For each line, splits values and builds a dictionary.
+- Appends each row dictionary to a list.
+
+---
+
+## 2. Build and run a shortest-path example using `graph`
+
+**Goal:** Create a graph, add edges, and compute shortest paths.
+
+```cpp
+#include <pythonic/Graph.hpp>
+using namespace pythonic;
+
+graph g(5); // 5 nodes
+g.add_edge(0, 1, 2);
+g.add_edge(1, 2, 3);
+g.add_edge(0, 3, 1);
+g.add_edge(3, 4, 4);
+
+auto dist = g.dijkstra(0);
+print(dist); // Output: shortest distances from node 0
+```
+
+**Explanation:**
+
+- Creates a graph with 5 nodes.
+- Adds weighted edges.
+- Runs Dijkstra’s algorithm from node 0.
+
+---
+
+## 3. High-performance loop pattern using `is_*()` + `as_*_unchecked()`
+
+**Goal:** Efficiently process a heterogeneous list by type-checking and fast casting.
+
+```cpp
+#include <pythonic/pythonic.hpp>
+using namespace pythonic;
+
+list<var> items = {1, "hello", 3.14, 42};
+
+for (const auto& x : items) {
+	if (x.is_int()) {
+		int val = x.as_int_unchecked(); // Fast, no type check
+		print("int:", val);
+	} else if (x.is_str()) {
+		str s = x.as_str_unchecked();
+		print("str:", s);
+	}
+}
+```
+
+**Explanation:**
+
+- Use `is_*()` to check type.
+- Use `as_*_unchecked()` for fast, unchecked access after confirming type.
+
+---
+
+## 4. Combining comprehensions and functional helpers
+
+**Goal:** Use list comprehensions and functional utilities for concise data processing.
+
+```cpp
+#include <pythonic/pythonic.hpp>
+using namespace pythonic;
+
+list<int> nums = {1, 2, 3, 4, 5};
+auto squares = [x * x for x : nums if x % 2 == 0]; // List comprehension
+
+auto doubled = map([](int x) { return x * 2; }, nums); // Functional map
+
+print(squares); // [4, 16]
+print(list<int>(doubled)); // [2, 4, 6, 8, 10]
+```
+
+**Explanation:**
+
+- List comprehensions for filtering and transforming.
+- Functional helpers like `map` for concise operations.
+
+---
diff --git a/docs/examples/operators.md b/docs/examples/operators.md
diff --git a/docs/index.md b/docs/index.md
@@ -27,5 +27,4 @@ Recommended reading order:
 - [Changelog](changelog.md) — release notes
 - **Examples & Quickstart**
   - [QuickStart](examples/quickstart.md)
-  - [Operators Example](examples/operators.md)
   - [Cookbook](examples/cookbook.md)
