@std/table

⚠️ Deprecated: @std/table is deprecated. Use the built-in table type instead:

// Before (deprecated)
let table = import @std/table
let t = table.table(data)

// After (recommended)
let t = data.parseCSV()           // CSV string → table
let t = CSV(@./data.csv) <==      // CSV file → table
// Or work directly with arrays of dictionaries
let data = [{name: "Alice"}, {name: "Bob"}]
data.map(fn(row) { row.name })

Tables are now a built-in type. See Tables for the current API.

SQL-like data manipulation for arrays of dictionaries. Tables are immutable — all operations return new tables.

let table = import @std/table

Constructors

let data = [
    {name: "Alice", age: 30, dept: "Eng"},
    {name: "Bob", age: 25, dept: "Sales"},
    {name: "Carol", age: 35, dept: "Eng"}
]

let t = table.table(data)
t.count()                        // 3

// From dictionary — each key-value pair becomes a row
let counts = {a: 1, b: 2, c: 3}
let t2 = table.table.fromDict(counts, "letter", "count")
// [{letter: "a", count: 1}, {letter: "b", count: 2}, {letter: "c", count: 3}]

Query Methods

All query methods return a new Table, so they can be chained.

let engineers = t.where(fn(row) { row.dept == "Eng" })
engineers.count()                // 2

let sorted = t.orderBy("age", "asc")
sorted.column("name")[0]         // "Bob" (youngest first)

let subset = t.select(["name", "age"])
subset.columnCount()             // 2

let page = t.orderBy("name").offset(1).limit(1)
page.count()                     // 1

Chaining

let result = t
    .where(fn(row) { row.age > 25 })
    .orderBy("name", "asc")
    .select(["name", "dept"])
    .limit(5)

Aggregation Methods

t.count()                        // 3
t.sum("age")                     // 90
t.avg("age")                     // 30
t.min("age")                     // 25
t.max("age")                     // 35

Access Methods

t.rowCount()                     // 3
t.columnCount()                  // 3
t.column("name")                 // ["Alice", "Bob", "Carol"]

Tables also support indexing and iteration:

t[0]                             // {name: "Alice", age: 30, dept: "Eng"}

for (row in t) {
    row.name + ": " + row.dept
}

Mutation Methods

All mutation methods return a new table (the original is unchanged).

let t2 = t.appendRow({name: "Dave", age: 28, dept: "Eng"})
t2.count()                       // 4

let t3 = t.appendCol("active", [true, true, false])
t3.columnCount()                 // 4

let t4 = t.renameCol("dept", "department")
t4.column("department")          // ["Eng", "Sales", "Eng"]

let t5 = t.dropCol("dept")
t5.columnCount()                 // 2

Functional Methods

let names = t.map(fn(row) { {name: row.name.toUpper()} })

let alice = t.find(fn(row) { row.name == "Alice" })
alice.age                        // 30

t.any(fn(row) { row.age > 30 })  // true
t.all(fn(row) { row.age > 20 })  // true

let byDept = t.groupBy("dept")
byDept.Eng.count()               // 2

Export Methods

t.toCSV()
// "age,dept,name\n30,Eng,Alice\n25,Sales,Bob\n35,Eng,Carol\n"

t.toMarkdown()
// "| age | dept | name |\n|---|---|---|\n| 30 | Eng | Alice |..."

t.toJSON()
// '[{"age":30,"dept":"Eng","name":"Alice"},...]'

Box Table

toBox() renders an ASCII table suitable for terminal output. Pass an options dictionary to customize:

t.toBox()
// ┌─────┬───────┬───────┐
// │ age │ dept  │ name  │
// ├─────┼───────┼───────┤
// │ 30  │ Eng   │ Alice │
// │ 25  │ Sales │ Bob   │
// │ 35  │ Eng   │ Carol │
// └─────┴───────┴───────┘

t.toBox({title: "Team", style: "rounded"})

Validation Methods

Tables created from schemas support validation:

@schema User {
    name: string(required)
    age: integer
}

let t = table.table([
    {name: "Alice", age: 30},
    {name: "", age: 25},
    {name: "Carol", age: 35}
])

let typed = t.as(User)
typed.isValid()                  // false (empty name on row 2)
typed.validRows().count()        // 2
typed.invalidRows().count()      // 1

Key Differences from Other Languages

• Immutable — every operation returns a new table. The original is never modified.
• SQL-like methods — .where(), .orderBy(), .select(), .groupBy() mirror SQL semantics but use function predicates.
• Multiple export formats — tables can render to CSV, JSON, Markdown, HTML, or ASCII box drawings with a single method call.
• Schema validation — attach a schema with .as() and validate all rows at once.

See Also

• Data Formats — CSV parsing returns tables
• Data Model — schemas, records, and table types
• Query DSL — database queries that return tables
• @std/math — statistical functions on arrays