Merge branch 'main' of https://github.com/alelom/python-concurrentCollections

Author: alelom

README.md

@@ -1,22 +1,27 @@
 # Python Concurrent (thread-safe) collections
-
-Thread-safe Python collections: `ConcurrentBag`, `ConcurrentDictionary`, and `ConcurrentQueue`.
-
 ## tl;dr
 
-Python's built-in `list`, `dict`, and `deque` are thread-safe for some operations, but not all. 
+Despite what many people think, Python's built-in `list`, `dict`, and `deque` are thread-safe for [_some operations_, but not all](https://docs.python.org/3/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe). This created a lot of confusion in the Python community.
 
 `concurrent_collections` provides thread-safe alternatives by using locks internally to ensure safe concurrent access and mutation from multiple threads.
 
+Inspired from the amazing [C#'s concurrent collections](https://learn.microsoft.com/en-us/dotnet/api/system.collections.concurrent?view=net-9.0).
+
 ## Why use these collections?
 
 **_There is a lot of confusion on whether Python collections are thread-safe or not_**<sup>1, 2, 3</sup>.
 
 The bottom line is that Python's built-in collections are **not fully thread-safe** for all operations. While some simple operations (like `list.append()` or `dict[key] = value`) are thread-safe due to the Global Interpreter Lock (GIL), **compound operations and iteration with mutation are not**. This can lead to subtle bugs, race conditions, or even crashes in multi-threaded programs.
 
-See the [Python FAQ: "What kinds of global value mutation are thread-safe?"](https://docs.python.org/3/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe) for details. The FAQ explains that only a handful of simple operations are guaranteed to be atomic and thread-safe. For anything more complex, you must use your own locking or a thread-safe collection.
+See the [Python FAQ: "What kinds of global value mutation are thread-safe?"](https://docs.python.org/3/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe) for details. The FAQ explains that only some (if common) operations are guaranteed to be atomic and thread-safe, but for anything more complex, you must use your own locking.  
+The docs even go as far as to say:
+
+> When in doubt, use a mutex!
+
+Which is telling.
 
-I could not find any simple concurrent implementation, so `concurrent_collections` provides drop-in replacements that handle locking for you, making concurrent programming safer and easier.
+`concurrent_collections` provides drop-in replacements that handle locking for you, making concurrent programming safer and easier.  
+Suggestions and feedbacks are welcome.
 
 <sub>
 
@@ -33,13 +38,13 @@ I could not find any simple concurrent implementation, so `concurrent_collection
 Pip:
 
 ```bash
-pip install python-nameof
+pip install concurrent_collections
 ```
 
 My recommendation is to always use [`uv`](https://docs.astral.sh/uv/) instead of pip – I personally think it's the best package and environment manager for Python.
 
 ```bash
-uv add python-nameof
+uv add concurrent_collections
 ```
 
 ## Collections