API Reference

collections.new_stack() -> Stack
collections.new_queue() -> Queue
collections.new_set() -> Set
collections.new_linked_list() -> LinkedList
collections.new_bst() -> BinarySearchTree
collections.new_bst(compareFn) -> BinarySearchTree
collections.new_array() -> Array
collections.new_map() -> Map

collections.new_concurrent_stack() -> ConcurrentStack
collections.new_concurrent_queue() -> ConcurrentQueue
collections.new_concurrent_set() -> ConcurrentSet
collections.new_concurrent_linked_list() -> ConcurrentLinkedList
collections.new_concurrent_bst() -> ConcurrentBinarySearchTree
collections.new_concurrent_map() -> ConcurrentMap

collections.array_from_slice(slice) -> Array
collections.linked_list_from_array(array) -> LinkedList
collections.bst_from_array(array) -> BinarySearchTree
collections.set_from_array(array) -> Set
collections.map_from_entries(entries) -> Map

var stack = collections.new_stack()
stack.reserve(100)        // Pre-allocate for performance
stack.push(42)
stack.push("hello")

if !stack.is_empty() {
    var top = stack.peek()    // "hello"
    var item = stack.pop()    // "hello"
}

var array = stack.to_array()  // [42]

var queue = collections.new_queue()
queue.reserve(50)         // Pre-allocate circular buffer
queue.enqueue("first")
queue.enqueue("second")

var front = queue.peek()      // "first"
var item = queue.dequeue()    // "first"

var set1 = collections.new_set()
set1.add("apple")
set1.add("banana")

var set2 = collections.new_set()
set2.add("banana")
set2.add("cherry")

var union = set1.union(set2)          // {"apple", "banana", "cherry"}
var intersection = set1.intersection(set2)  // {"banana"}
var difference = set1.difference(set2)      // {"apple"}

var list = collections.new_linked_list()
list.add_last(1)
list.add_last(2)
list.add_first(0)         // [0, 1, 2]

list.add_at(1, 0.5)       // [0, 0.5, 1, 2]
var item = list.get(2)    // 1
var index = list.index_of(2)  // 3

var doubled = list.map(((x) =>) x * 2)     // [0, 1, 2, 4]
var evens = list.filter(((x) =>) x % 2 == 0)  // [0, 2]

var tree = collections.new_bst()
tree.insert(50)
tree.insert(30)
tree.insert(70)

var min = tree.min()      // 30
var max = tree.max()      // 70
var sorted = tree.in_order_traversal()  // [30, 50, 70]

var range = tree.range_query(25, 60)    // [30, 50]
var successor = tree.successor(30)      // 50

var array = collections.new_array()
array.reserve(100)        // Pre-allocate
array.append(3)
array.append(1)
array.append(4)

array.insert_at(1, 2)     // [3, 2, 1, 4]
array.sort()              // [1, 2, 3, 4]

var doubled = array.map(((x) =>) x * 2)        // [2, 4, 6, 8]
var evens = array.filter(((x) =>) x % 2 == 0)  // [2, 4]
var sum = array.reduce(|acc, x| acc + x, 0)  // 10

var map = collections.new_map()
map.reserve(50)           // Pre-allocate buckets
map.set("name", "Alice")
map.set("age", 30)

var has_name = map.contains_key("name")     // true
var has_alice = map.contains_value("Alice") // true

var keys = map.keys()     // ["name", "age"]
var values = map.values() // ["Alice", 30]

var filtered = map.filter(|k, v| k.starts_with("n"))  // {"name": "Alice"}

struct ConcurrentStats {
    read_count: int
    write_count: int
    contention_count: int
    avg_wait_time: float
}

var concurrent_map = collections.new_concurrent_map()

// Thread-safe operations
do {
    for i in range(1000) {
        concurrent_map.set("key_" + i.to_string(), i)
    }
}

do {
    for i in range(1000) {
        var value = concurrent_map.get("key_" + i.to_string())
    }
}

var stats = concurrent_map.get_stats()
fmt.Println("Reads:", stats.read_count)
fmt.Println("Writes:", stats.write_count)

var collection = collections.new_linked_list()
collection.add_last(1)
collection.add_last(2)
collection.add_last(3)

var iter = collection.iterator()
for iter.has_next() {
    var item = iter.next()
    fmt.Println(item)

    if item == 2 {
        iter.remove()  // Remove current item
    }
}

var result = collection.get(index)
if result.type() == "ERROR" {
    fmt.Println("Error:", result.message())
    return
}

// Safe operations
if !collection.is_empty() {
    var item = collection.pop()  // Safe
}

// Bounds checking
if index >= 0 && index < collection.size() {
    var item = collection.get(index)  // Safe
}