docs: update documentation for objective method syntax

BREAKING CHANGE: Document removal of arr_*/str_* builtin functions

- Remove arr_append, arr_pop, arr_extend, arr_chunk, arr_get, arr_len docs
- Remove str_len, str_find, str_get docs
- Add Array methods reference (27 methods)
- Add String methods reference (25+ methods)
- Add Number methods reference (28 methods)
- Add Boolean methods reference (9 methods)
- Add HashMap methods reference (18 methods)
- Mark array/string stdlib modules as legacy
- Add 'Primitive Methods' section to built-in-functions.md
- Update quick-start.md example to use .length()

Author: Almas-Ali

docs/arrays.md

@@ -1,31 +1,100 @@
 # Arrays
 
-## Built-in Array functions
-
-- `arr_len(array)` or `len(array)` — returns the length of the array
-- `arr_append(array, item)` — adds an item to the end of the array
-- `arr_pop(array, index)` — removes and returns the item at the specified index
-- `arr_extend(array1, array2)` — appends all items from `array2` to `array1`
-- `arr_get(array, index)` — returns the item at the specified index
-- `arr_chunk(array, size)` — groups the array into chunks of the given size
+## Array Methods
+
+Arrays have built-in methods accessible via dot notation. No imports required.
+
+### Mutating Methods
+
+| Method | Description |
+|--------|-------------|
+| `.append(value)` | Add element to end of array |
+| `.pop(index=-1)` | Remove and return element at index (default: last) |
+| `.extend(array)` | Append all elements from another array |
+| `.insert(index, value)` | Insert element at specified index |
+| `.remove(value)` | Remove first occurrence of value |
+| `.set(index, value)` | Set element at index |
+| `.clear()` | Remove all elements |
+| `.reverse()` | Reverse array in place |
+| `.sort(reverse=false)` | Sort array in place |
+
+### Query Methods
+
+| Method | Description |
+|--------|-------------|
+| `.length()` | Get number of elements |
+| `.get(index)` | Get element at index |
+| `.find(element)` | Find index of element (-1 if not found) |
+| `.index_of(element)` | Alias for find |
+| `.includes(element)` | Check if element exists (returns boolean) |
+| `.first()` | Get first element |
+| `.last()` | Get last element |
+| `.count(element)` | Count occurrences of element |
+| `.is_empty()` | Check if array is empty |
+
+### Transform Methods
+
+| Method | Description |
+|--------|-------------|
+| `.slice(start, end)` | Get sub-array from start to end |
+| `.chunk(size)` | Split into sub-arrays of given size |
+| `.copy()` | Create shallow copy |
+| `.unique()` | Return array with duplicates removed |
+| `.join(separator="")` | Join elements into string |
+| `.map(func)` | Transform each element with function |
+| `.filter(func)` | Filter elements by predicate function |
+
+### Aggregation Methods
+
+| Method | Description |
+|--------|-------------|
+| `.sum()` | Sum all numeric elements |
+| `.min()` | Get minimum element |
+| `.max()` | Get maximum element |
+| `.every(func)` | Check if all elements satisfy predicate |
+| `.some(func)` | Check if any element satisfies predicate |
+
+### Conversion Methods
+
+| Method | Description |
+|--------|-------------|
+| `.to_string()` | Convert to string representation |
 
 ```rn linenums="1" title="methods.rn"
-const arr = [1, 2, 3, 4, 5]
-print(arr_len(arr)) # 5
+var arr = [1, 2, 3, 4, 5]
+
+# Mutating
+arr.append(6)
+print(arr)              # [1, 2, 3, 4, 5, 6]
+
+arr.pop()
+print(arr)              # [1, 2, 3, 4, 5]
+
+arr.extend([6, 7, 8])
+print(arr)              # [1, 2, 3, 4, 5, 6, 7, 8]
 
-arr_append(arr, 6)
-print(arr) # [1, 2, 3, 4, 5, 6]
+# Querying
+print(arr.length())     # 8
+print(arr.get(0))       # 1
+print(arr.includes(5))  # true
+print(arr.first())      # 1
+print(arr.last())       # 8
 
-arr_pop(arr, 5)
-print(arr) # [1, 2, 3, 4, 5]
+# Transforming
+print(arr.slice(0, 3))  # [1, 2, 3]
+print(arr.chunk(3))     # [[1, 2, 3], [4, 5, 6], [7, 8]]
 
-arr_extend(arr, [6, 7, 8])
-print(arr) # [1, 2, 3, 4, 5, 6, 7, 8]
+# Functional
+var doubled = arr.map(fun(x) -> x * 2)
+print(doubled)          # [2, 4, 6, 8, 10, 12, 14, 16]
 
-print(arr_get(arr, 0)) # 1
-print(arr_get(arr, 1)) # 2
+var evens = arr.filter(fun(x) -> x % 2 == 0)
+print(evens)            # [2, 4, 6, 8]
 
-print(arr_chunk(arr, 3)) # [[1, 2, 3], [4, 5, 6], [7, 8]]
+# Aggregation
+print(arr.sum())        # 36
+print(arr.min())        # 1
+print(arr.max())        # 8
 ```
 
 ## Array slicing
@@ -55,40 +124,31 @@ print(arr1 + arr2) # [1, 2, 3, 4, 5, 6]
 print(arr1 * 2) # [1, 2, 3, 1, 2, 3]
 ```
 
-## Array standard library
+## Array standard library (Legacy)
 
-- `map(func)` - returns a new array with the result of calling the specified
-  function on each item of the array
-- `append(item)` - adds an item to the end of the array
-- `pop(index)` - removes an item from the end of the array
-- `extend(list)` - adds all the items of an array to the end of the array
-- `find(index)` - returns the item at the specified index
-- `slice(start, end)` - returns the items from the specified start index to
-  the specified end index
-- `len()` - returns the length of the array
-- `is_empty()` - returns `true` if the array is empty, otherwise `false`
-- `to_string()` - returns the string representation of the array
-- `is_array()` - returns `true` if the value is an array, otherwise `false`
+!!! note "Built-in Methods"
+    Array methods are now built-in on all arrays. The `import array` module is kept for backwards compatibility but is no longer required.
 
-```rn linenums="1" title="array-standard-library.rn"
-import array # Include the array standard library
+```rn linenums="1" title="array-methods.rn"
+# No import needed - methods work directly on arrays
+var arr = [1, 2, 3, 4, 5]
 
-# Create an array instance using the Array class
-const arr = array.Array([1, 2, 3, 4, 5])
+print(arr.length())     # 5
+print(arr.is_empty())   # false
+print(arr.to_string())  # "[1, 2, 3, 4, 5]"
 
-print(len(arr)) # 5
-print(arr.is_empty()) # false
-print(arr.to_string()) # "[1, 2, 3, 4, 5]"
-print(arr.is_array()) # true
+# Functional methods
+print(arr.map(fun(x) -> String(x)))  # ["1", "2", "3", "4", "5"]
 
-print(arr.map(fun (item) -> str(item))) # ["1", "2", "3", "4", "5"]
+arr.append(6)
+print(arr)              # [1, 2, 3, 4, 5, 6]
 
-print(arr.append(6)) # [1, 2, 3, 4, 5, 6]
-print(arr.pop(5)) # [1, 2, 3, 4, 5]
+arr.pop()
+print(arr)              # [1, 2, 3, 4, 5]
 
-print(arr.extend([6, 7, 8])) # [1, 2, 3, 4, 5, 6, 7, 8]
-print(arr.find(0)) # 1
-print(arr.find(1)) # 2
+arr.extend([6, 7, 8])
+print(arr)              # [1, 2, 3, 4, 5, 6, 7, 8]
 
-print(arr.slice(0, 5)) # [1, 2, 3, 4, 5]
+print(arr.find(3))      # 2 (index of element 3)
+print(arr.slice(0, 5))  # [1, 2, 3, 4, 5]
 ```

docs/built-in-functions.md

@@ -37,21 +37,6 @@ Radon exposes a fixed set of interpreter built-ins. The list below reflects the
 - `is_fun(value)` returns whether the value is a function.
 - `is_null(value)` returns whether the value is null.
 
-## Array Helpers
-
-- `arr_append(array, value)` appends a value to an array.
-- `arr_pop(array, index=-1)` removes and returns an element.
-- `arr_extend(arrayA, arrayB)` appends all elements from one array to another.
-- `arr_chunk(array, size)` groups an array into chunks.
-- `arr_get(array, index)` returns the element at an index.
-- `arr_len(array)` returns the number of elements.
-
-## String Helpers
-
-- `str_len(string)` returns string length.
-- `str_find(string, value)` returns the index of a substring, or `-1`.
-- `str_get(string, index)` returns the character at an index.
-
 ## Runtime and Interop
 
 - `require(module)` executes a standard library module name or a `.rn` file path.
@@ -113,3 +98,45 @@ print(res.text)
 ### `builtins`
 
 Provides access to the built-in scope as an object. Used for reflection and tooling; not normally needed in application code.
+
+---
+
+## Primitive Methods
+
+All primitive types (Array, String, Number, Boolean, HashMap) support objective method syntax via dot notation. Methods are called directly on values without needing any imports.
+
+```rn linenums="1" title="primitive_methods.rn"
+# Array methods
+var arr = [1, 2, 3]
+arr.append(4)           # [1, 2, 3, 4]
+arr.length()            # 4
+arr.pop()               # removes and returns 4
+
+# String methods
+var s = "hello world"
+s.upper()               # "HELLO WORLD"
+s.split(" ")            # ["hello", "world"]
+s.length()              # 11
+
+# Number methods
+var n = 42
+n.is_even()             # true
+n.sqrt()                # 6.48...
+(-5).abs()              # 5
+
+# Boolean methods
+var b = true
+b.toggle()              # false
+b.to_string()           # "true"
+
+# HashMap methods
+var hm = {"a": 1, "b": 2}
+hm.keys()               # ["a", "b"]
+hm.has("a")             # true
+```
+
+For complete method references, see:
+
+- [Arrays](arrays.md) - 27 methods
+- [Strings](strings.md) - 25+ methods
+- [Data Types](data-types.md) - Number (28), Boolean (9), HashMap (18) methods