README updated with Kotlin usage

Author: rp-bg

README.md

@@ -53,6 +53,8 @@ dependencies {
 
 ### Using `Tuple`
 
+#### Java
+
 Create a tuple with `Tuple.of()`:
 
 ```java
@@ -68,8 +70,25 @@ Object o = tuple.getObject(2);
 System.out.println("Size: " + tuple.size()); // Size: 3
 ```
 
+#### Kotlin
+
+```kotlin
+import com.appxiom.ax.tuple.Tuple
+
+val tuple = Tuple.of("Hello", 42, 3.14)
+
+// Access by index
+val s = tuple.get(0)                    // Inferred type
+val i = tuple.get(1, Integer::class.java) // Explicit type
+val o = tuple.getObject(2)
+
+println("Size: ${tuple.size()}") // Size: 3
+```
+
 ### Using `NamedTuple`
 
+#### Java
+
 Create a named tuple from a `Map`:
 
 ```java
@@ -89,10 +108,30 @@ Boolean isActive = user.get("active", Boolean.class);
 System.out.println(user.toString());
 ```
 
+#### Kotlin
+
+```kotlin
+import com.appxiom.ax.tuple.NamedTuple
+
+val user = NamedTuple.of(mapOf(
+    "id" to 1,
+    "username" to "robin",
+    "active" to true
+))
+
+// Access by key
+val username = user.get("username")
+val isActive = user.get("active", Boolean::class.java)
+
+println(user.toString())
+```
+
 ## Using as HashMap Keys
 
 ### Using Tuple as a key
 
+#### Java
+
 Both `Tuple` and `NamedTuple` override `equals()` and `hashCode()`, making them perfectly suitable for use as keys in a `HashMap` or as elements in a `HashSet`.
 
 Two tuples are considered equal if they contain the same elements in the same order. Two named tuples are equal if they contain the same key-value pairs.
@@ -110,8 +149,24 @@ cache.put(key, "Cached Result");
 System.out.println(cache.get(Tuple.of("request", 12345))); // Output: Cached Result
 ```
 
+#### Kotlin
+
+```kotlin
+import com.appxiom.ax.tuple.Tuple
+
+val cache = mutableMapOf<Tuple, String>()
+val key = Tuple.of("request", 12345)
+
+cache[key] = "Cached Result"
+
+// Retrievable with a different Tuple instance containing identical data
+println(cache[Tuple.of("request", 12345)]) // Output: Cached Result
+```
+
 ### Using NamedTuple as a key
 
+#### Java
+
 ```java
 import java.util.HashMap;
 import com.appxiom.ax.tuple.NamedTuple;
@@ -128,6 +183,22 @@ NamedTuple key2 = NamedTuple.of(Map.of("id", 101, "role", "admin"));
 System.out.println(userRegistry.get(key2)); // Output: Admin Account
 ```
 
+#### Kotlin
+
+```kotlin
+import com.appxiom.ax.tuple.NamedTuple
+
+// Using NamedTuple as a key
+val userRegistry = mutableMapOf<NamedTuple, String>()
+val key1 = NamedTuple.of(mapOf("id" to 101, "role" to "admin"))
+
+userRegistry[key1] = "Admin Account"
+
+// Retrieve using a new instance with identical keys and values
+val key2 = NamedTuple.of(mapOf("id" to 101, "role" to "admin"))
+println(userRegistry[key2]) // Output: Admin Account
+```
+
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.