Data Structures & Object-Oriented Programming

let nums = [3, 1, 4, 1, 5, 9]

// Adding elements
let expanded = push(nums, 26)       // or append(nums, 26)
println("Expanded:", expanded)      // [3, 1, 4, 1, 5, 9, 26]

// Slicing with positive and negative indices
let part = slice(nums, 1, 4)        // [1, 4, 1]
let tail = slice(nums, -2, len(nums)) // [5, 9]

// Sorting and Reversing
let sortedList = sort(nums)         // [1, 1, 3, 4, 5, 9]
let revList = reverse(nums)         // [9, 5, 1, 4, 1, 3]

// Membership inspection
println("Has 4:", contains(nums, 4)) // true

// Hash inspection and deletion
let user = {"id": 101, "role": "admin", "active": true}
let userKeys = keys(user)           // ["id", "role", "active"]
let userVals = values(user)         // [101, "admin", true]
delete(user, "active")
println("Has active:", contains(user, "active")) // false

// 1. Array destructuring with rest operator
let [head, second, ...tail] = [10, 20, 30, 40, 50]
println("Head:", head)        // 10
println("Second:", second)    // 20
println("Tail:", tail)        // [30, 40, 50]

// 2. Hash pattern destructuring
let user = { "name": "Bramand", "role": "Architect", "level": 99 }
let { name, role } = user
println("User:", name, "Role:", role)

// 3. Function signature destructuring
fn handle_coord({ x, y }) {
    return sqrt(x * x + y * y)
}

// 1. Array Spread: In-line element unpacking
let mid = [2, 3]
let full = [1, ...mid, 4, 5]
println("Full array:", full) // [1, 2, 3, 4, 5]

// Multiple spreads & string character unpacking
let parts = [..."ab", ...[10, 20]]
println("Unpacked parts:", parts) // ["a", "b", 10, 20]

// 2. Hash Spread: Progressive map merging & property override
let defaults = { "host": "127.0.0.1", "port": 8080, "timeout": 30 }
let server_config = { ...defaults, "port": 9000, "ssl": true }
println("Server Port:", server_config.port) // 9000 (overridden!)
println("Server Host:", server_config.host) // "127.0.0.1" (preserved!)

// Constructing tuples
let empty_tuple = ()
let single_item = (42,)
let point = (10, 20, 30)

// Indexing and negative offsets
println("First:", point[0])       // 10
println("Last:", point[-1])       // 30
println("Length:", point.len)     // 3

// Multi-variable destructuring
let (x, y, z) = point
println("Coordinates:", x, y, z)  // 10 20 30

// Immutability: assigning to tuple indices produces an error
// point[0] = 99 // Compile/Runtime Error: cannot mutate immutable tuple

let grid = {}

// Use (row, col) coordinate tuples as dictionary keys
grid[(0, 0)] = "Origin Station"
grid[(12, 45)] = "Waypoint Alpha"
grid[(88, 92)] = "Terminal Beta"

let query = (12, 45)
println("Located:", grid[query]) // "Waypoint Alpha"

import "std/iter" as iter

let naturals = iter.generator(fn(yield) {
    let n = 1
    while true {
        yield n
        n += 1
    }
})

// Fluent chaining: take 5 items, map, and collect to array
let squares = naturals.take(5).map(fn(x) { return x * x; }).to_array()
println("Squares:", squares) // [1, 4, 9, 16, 25]

let classify_point = fn(pt) {
    return match pt {
        case (0, 0) => {
            "origin"
        }
        case (0, y) => {
            "y-axis at " + str(y)
        }
        case (x, 0) => {
            "x-axis at " + str(x)
        }
        case (x, y) if x == y => {
            "diagonal point"
        }
        case (x, y) if x > 0 && y > 0 => {
            "quadrant 1"
        }
        case (x, y) => {
            "general point"
        }
        case _ => {
            "not a coordinate"
        }
    }
}

println(classify_point((0, 0)))  // "origin"
println(classify_point((4, 4)))  // "diagonal point"
println(classify_point((5, 12))) // "quadrant 1"

let authorize = fn(user) {
    return match user {
        case { "role": "admin" } => {
            "superadmin_granted"
        }
        case { "role": "editor", "level": lvl } if lvl >= 3 => {
            "senior_editor"
        }
        case { "name": n } => {
            "guest: " + n
        }
        case _ => {
            "denied"
        }
    }
}

println(authorize({ "role": "admin" }))                     // "superadmin_granted"
println(authorize({ "role": "editor", "level": 4 }))       // "senior_editor"
println(authorize({ "name": "Kiran" }))                     // "guest: Kiran"

import "std/math/sparse" as sparse

let dense_grid = [
    [10.0,  0.0,  0.0],
    [ 0.0,  0.0, 20.0],
    [30.0,  0.0, 40.0]
]
let csr = sparse.csr_from_dense(dense_grid)
println("Non-zero count:", csr.nnz()) // 4
println("Element at (2, 2):", csr.get(2, 2)) // 40.0

// Fast sparse matrix-vector multiplication (O(nnz))
let vec_result = csr.matmul_vec([1.0, 2.0, 3.0])
println("Sparse matmul vector:", vec_result) // [10.0, 60.0, 150.0]

import "std/dataframe" as df;

// Create DataFrame from row records
let records = [
    {"sensor": "temp_01", "reading": 32, "voltage": 3.2},
    {"sensor": "temp_02", "reading": 45, "voltage": 4.5},
    {"sensor": "temp_03", "reading": 89, "voltage": 8.9}
];
let frame = df.from_records(records);

// 1. Vectorized Column Extract and Summary Metrics
let voltage_col = frame.column("voltage");
println("Mean voltage:", voltage_col.mean()); // 5.533
println("Max voltage: ", voltage_col.max());  // 8.9

// 2. High-Performance Boolean Mask Slicing
let mask = voltage_col.gt(4.0); // [false, true, true]
let filtered_df = frame.filter_mask(mask);
println("Filtered Shape:", filtered_df.shape()); // [2, 3]

// 3. Bidirectional Columnar Conversions
let columnar_dict = frame.to_columnar();
// { sensor: ["temp_01", ...], reading: [32, 45, 89], voltage: [3.2, 4.5, 8.9] }
let reconstructed = df.from_columnar(columnar_dict);

// 4. In-Memory ANSI SQL Query Directly on DataFrame
let sql_df = frame.query("SELECT sensor, voltage FROM df WHERE voltage > 4.0 ORDER BY voltage DESC");
println("SQL Rows on DataFrame:", sql_df.to_records());