Table Literals as Primary Data Structure

What are Table Literals?

Tables are the only data structure in our language. They serve as objects, arrays, maps, and any other collection type you might need.

/* Tables serve multiple purposes */
/* As objects: {name: "Alice", age: 30} */
/* As arrays: {1, 2, 3, 4, 5} */
/* As maps: {key1: "value1", key2: "value2"} */
/* As nested structures: {user: {name: "Alice", scores: {85, 90, 88}}} */

Why is This Esoteric?

Most languages have separate types for different data structures (arrays, objects, maps, sets, etc.). Our language uses one unified structure for everything.

Basic Table Syntax

Key-Value Pairs (Objects)

/* Create object-like tables */
person : {name: "Alice", age: 30, city: "New York"};
user : {id: 123, email: "alice@example.com", active: true};

/* Access properties */
name : person.name;  /* "Alice" */
age : person.age;    /* 30 */

Array-Like Tables

/* Create array-like tables */
numbers : {1, 2, 3, 4, 5};
names : {"Alice", "Bob", "Charlie"};
mixed : {1, "hello", true, 3.14};

/* Access by index (using bracket notation) */
first_number : numbers[0];  /* 1 */
second_name : names[1];     /* "Bob" */

Mixed Tables

/* Tables can mix key-value pairs and array elements */
mixed_table : {
  name: "Alice",
  scores: {85, 90, 88},
  metadata: {created: "2024-01-01", version: 1.0}
};

Table Operations

Creating Tables

/* Empty table */
empty : {};

/* Single element */
single : {42};

/* Key-value pairs */
config : {debug: true, timeout: 30, retries: 3};

/* Mixed content */
complex : {
  id: 123,
  tags: {"important", "urgent"},
  settings: {theme: "dark", notifications: true}
};

Accessing Values

/* Dot notation for keys */
data : {name: "Alice", age: 30};
name : data.name;  /* "Alice" */

/* Bracket notation for indices or dynamic keys */
numbers : {1, 2, 3, 4, 5};
first : numbers[0];  /* 1 */
second : numbers[1]; /* 2 */

/* Dynamic key access */
key : "name";
value : data[key];  /* "Alice" */

Nested Tables

/* Deeply nested structures */
user_profile : {
  personal: {
    name: "Alice",
    age: 30,
    contact: {
      email: "alice@example.com",
      phone: "555-1234"
    }
  },
  preferences: {
    theme: "dark",
    notifications: true,
    languages: {"English", "Spanish"}
  }
};

/* Access nested values */
email : user_profile.personal.contact.email;  /* "alice@example.com" */
theme : user_profile.preferences.theme;       /* "dark" */
first_language : user_profile.preferences.languages[0];  /* "English" */

Table-Specific Operations

The t. namespace provides table-specific operations:

/* Table operations */
data : {a: 1, b: 2, c: 3};

/* Get keys */
keys : t.keys data;  /* {"a", "b", "c"} */

/* Get values */
values : t.values data;  /* {1, 2, 3} */

/* Get key-value pairs */
pairs : t.pairs data;  /* {{key: "a", value: 1}, {key: "b", value: 2}, {key: "c", value: 3}} */

/* Check if key exists */
has_a : t.has data "a";  /* true */
has_d : t.has data "d";  /* false */

/* Get value by key */
value_a : t.get data "a";  /* 1 */

/* Get table length */
length : t.length data;  /* 3 */

Element-Wise Operations

Tables work seamlessly with element-wise operations:

/* Map over table values - @ operator required for higher-order functions */
numbers : {a: 1, b: 2, c: 3, d: 4, e: 5};
double : x -> x * 2;
doubled : map @double numbers;  /* {a: 2, b: 4, c: 6, d: 8, e: 10} */

/* Filter table values - @ operator required for higher-order functions */
is_even : x -> x % 2 = 0;
evens : filter @is_even numbers;  /* {b: 2, d: 4} */

/* Reduce table values - @ operator required for higher-order functions */
sum : reduce @add 0 numbers;  /* 15 */

Common Patterns

Configuration Objects

/* Build configuration objects */
base_config : {
  timeout: 30,
  retries: 3,
  debug: false
};

/* Environment-specific overrides */
dev_config : t.merge base_config {
  debug: true,
  log_level: "verbose"
};

prod_config : t.merge base_config {
  timeout: 60,
  cache_enabled: true
};

Data Transformation

/* Transform data structures */
raw_data : {
  users: {
    alice: {name: "Alice", age: 30, scores: {85, 90, 88}},
    bob: {name: "Bob", age: 25, scores: {92, 87, 95}}
  }
};

/* Extract and transform user data */
transform_user : user -> {
  name: user.name,
  age: user.age,
  average_score: reduce @add 0 user.scores / 3
};

transformed_users : map @transform_user raw_data.users;
/* Result: {
  alice: {name: "Alice", age: 30, average_score: 87.67},
  bob: {name: "Bob", age: 25, average_score: 91.33}
} */

Nested Data Processing

/* Process nested table structures */
company_data : {
  departments: {
    engineering: {
      employees: {
        alice: {name: "Alice", role: "Developer", salary: 80000},
        bob: {name: "Bob", role: "Manager", salary: 100000}
      }
    },
    marketing: {
      employees: {
        charlie: {name: "Charlie", role: "Designer", salary: 70000}
      }
    }
  }
};

/* Extract all employee names - @ operator required for higher-order functions */
get_names : dept -> map @(emp -> emp.name) dept.employees;
all_names : map @get_names company_data.departments;
/* Result: {
  engineering: {"Alice", "Bob"},
  marketing: {"Charlie"}
} */

When to Use Tables

Use tables when you need:

Objects - key-value pairs for structured data
Arrays - ordered collections of values
Maps - dynamic key-value mappings
Nested structures - complex hierarchical data
Mixed data - combinations of different data types

Tables are perfect for:

Configuration objects
User data and profiles
API responses and requests
Data transformation pipelines
Complex nested structures

Key Takeaways

Unified structure - one data type for all collections
Flexible syntax - supports both key-value pairs and array elements
Nested support - can contain other tables
Element-wise operations - works with map, filter, reduce (using @ operator)
Immutable operations - all operations return new tables

Why This Matters

Table literals as the primary data structure make the language simpler and more unified:

Simplicity - only one data structure to learn
Flexibility - can represent any collection type
Consistency - same operations work on all data
Composability - tables can be nested and combined
Functional style - immutable operations on all data

This feature makes the language feel more like mathematical sets and relations than traditional programming data structures! 🚀

10_Tables_Deep_Dive