feat(compiler): infer rectangular arrays and tables

README.md

@@ -31,7 +31,7 @@ Intended for performance-sensitive scripting, numerical work, simulation, and sy
 
 **Purity:** Functions have read-only inputs and writable outputs; structs are raw data with no hidden pointers.
 
-Range-driven auto-vectorization, safe arrays and slices.
+Range-driven auto-vectorization and safe arrays.
 
 Scope-based memory (no nulls, no out-of-bounds, no GC), and concurrency by construction.
 
@@ -42,7 +42,7 @@ Scope-based memory (no nulls, no out-of-bounds, no GC), and concurrency by const
 - Go front-end, LLVM back-end; emits native binaries
 - Template functions in `.pt`: specialized per argument types (generics by use)
 - Range literals with auto-vectorized execution
-- First-class arrays (safe slicing) and link semantics
+- First-class rectangular arrays of any rank, columnar tables, and link semantics
 - Scope-based memory: no nulls, no out-of-bounds, no garbage collector
 - printf-style formatting; arrays/ranges printable
 - Cross-platform (Linux/macOS/Windows)
@@ -197,6 +197,47 @@ y = [1.1 2.2 3.3]
 
 Arrays are safe by construction — out-of-bounds access is not possible. Comparisons like `arr > 2` produce element-wise masks (each element kept where it holds, else 0) that work anywhere an array does.
 
+The same bracket syntax infers higher-rank arrays and tables without a type keyword:
+
+```python
+matrix = [
+    1 2
+    3 4
+]
+
+cube = [
+    [1 2] [3 4]
+    [5 6] [7 8]
+]
+
+scores = [
+  : Name Score
+    "Ada" 10
+    "Lin" 12
+]
+```
+
+Inline literals such as `[1 2 3]` contribute one array axis. A block literal,
+where `[` is followed by a newline, contributes row and column axes even when
+it contains one row. Thus the matrix above is equivalent to
+`[[1 2] [3 4]]`. Use `\` to continue a long inline array across physical
+lines without starting block layout. Array-valued cells stack recursively
+while storage remains flat and row-major. Ragged literals are compile errors.
+
+A header row produces a columnar table, with named columns projected as arrays
+such as `scores.Score`. The shown hanging `:` is the preferred layout because
+the first header aligns with the first value; spacing within header and data
+rows is otherwise non-semantic.
+
+The empty literal `[]` has type `[Empty]`: it prints as `[]`, can be passed to
+functions, and adopts an element type when concatenated with a concrete array.
+Once a variable has a concrete array type, assigning `[]` empties its value but
+preserves that element type. Operations such as indexing or arithmetic still
+require a concrete element type.
+
+See [Pluto Array Semantics](docs/Pluto%20Array%20Semantics.md) for complete
+inference, shape, indexing, empty-value, and table rules.
+
 String-array elements print quoted so boundaries stay unambiguous:
 
 ```python

ast/ast.go

@@ -278,7 +278,7 @@ type StringLiteral struct {
 
 func (sl *StringLiteral) expressionNode()  {}
 func (sl *StringLiteral) Tok() token.Token { return sl.Token }
-func (sl *StringLiteral) String() string   { return sl.Token.Literal }
+func (sl *StringLiteral) String() string   { return `"` + sl.Token.Literal + `"` }
 
 // RangeLiteral represents start:stop[:step]
 type RangeLiteral struct {
@@ -300,7 +300,8 @@ func (rl *RangeLiteral) String() string {
 
 type ArrayLiteral struct {
 	Token   token.Token      // the '[' token
-	Headers []string         // column headers (empty for matrices)
+	Block   bool             // '[' is followed by a newline; source rows form two layout axes
+	Headers []string         // column names; empty for arrays and unnamed tables
 	Rows    [][]Expression   // row data
 	Indices map[string][]int // named row indices like "books": [2,3]
 }
@@ -310,43 +311,51 @@ func (al *ArrayLiteral) Tok() token.Token { return al.Token }
 func (al *ArrayLiteral) String() string {
 	var out bytes.Buffer
 	out.WriteString("[")
+	if len(al.Headers) == 0 && !al.Block {
+		if len(al.Rows) == 1 {
+			writeArrayRow(&out, al.Rows[0])
+		}
+		out.WriteString("]")
+		return out.String()
+	}
 
 	// Print headers if present
 	if len(al.Headers) > 0 {
-		out.WriteString("\n  :  ") // 2 spaces after :
+		out.WriteString("\n  : ")
 		for j, header := range al.Headers {
 			if j > 0 {
 				out.WriteString(" ")
 			}
 			out.WriteString(header)
 		}
-		out.WriteString("\n")
 	}
 
 	// Print rows
 	for _, row := range al.Rows {
-		if len(al.Headers) > 0 {
-			out.WriteString("     ") // 5 spaces for header tables
-		} else {
-			out.WriteString("    ") // 4 spaces for matrices
-		}
-		for j, expr := range row {
-			if j > 0 {
-				out.WriteString(" ")
-			}
-			if expr != nil {
-				out.WriteString(expr.String())
-			} else {
-				out.WriteString("<nil>")
-			}
-		}
-		out.WriteString("\n")
+		out.WriteString("\n    ")
+		writeArrayRow(&out, row)
 	}
 
+	if al.Block || len(al.Headers) > 0 || len(al.Rows) > 0 {
+		out.WriteString("\n")
+	}
 	out.WriteString("]")
 	return out.String()
 }
 
+func writeArrayRow(out *bytes.Buffer, row []Expression) {
+	for i, expr := range row {
+		if i > 0 {
+			out.WriteString(" ")
+		}
+		if expr == nil {
+			out.WriteString("<nil>")
+			continue
+		}
+		out.WriteString(expr.String())
+	}
+}
+
 // StructLiteral represents a struct value declared in .pt code mode.
 // Example:
 // p = Person
@@ -627,6 +636,7 @@ func RewriteExpr(expr Expression, rewrite func(Expression) Expression) Expressio
 		}
 		return &ArrayLiteral{
 			Token:   e.Token,
+			Block:   e.Block,
 			Headers: append([]string(nil), e.Headers...),
 			Rows:    rows,
 			Indices: maps.Clone(e.Indices),