Add examples directory with runnable code samples

Create the /examples directory referenced in README with runnable
code examples from various chapters of the book.

Includes:
- Basic Hello World and Todo List (Chapter 2)
- Prototype inheritance demonstrations (Chapter 4)
- Closure and functional programming examples (Chapter 9)
- Metaprogramming and dynamic method creation (Chapter 11)
- Concurrency with coroutines and futures (Chapter 12)
- HTML DSL implementation (Chapter 13)

Each example is a standalone, runnable Io program that demonstrates
key concepts from the corresponding chapter.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: DavidLiedle

examples/README.md

@@ -0,0 +1,28 @@
+# Code Examples
+
+This directory contains runnable code examples from the book, organized by chapter.
+
+## Running Examples
+
+To run any example:
+
+```bash
+io examples/chapter-02/hello.io
+```
+
+## Organization
+
+- `chapter-02/` - Getting Started examples
+- `chapter-03/` - Everything is an Object examples
+- `chapter-04/` - Prototypes examples
+- `chapter-05/` - Messages and Slots examples
+- `chapter-07/` - Control Flow examples
+- `chapter-08/` - Collections examples
+- `chapter-09/` - Blocks and Closures examples
+- `chapter-11/` - Metaprogramming examples
+- `chapter-12/` - Concurrency examples
+- `chapter-13/` - DSL examples
+- `chapter-15/` - Pattern examples
+- `chapter-16/` - Case study code
+
+Each directory contains standalone examples that demonstrate the concepts from that chapter.

examples/chapter-02/hello.io

@@ -0,0 +1,3 @@
+#!/usr/bin/env io
+# Basic Hello World
+"Hello, World!" println

examples/chapter-02/todo-list.io

@@ -0,0 +1,42 @@
+#!/usr/bin/env io
+# Simple To-Do List Manager from Chapter 2
+
+TodoList := Object clone
+TodoList items := list()
+
+TodoList add := method(task,
+    items append(task)
+    self
+)
+
+TodoList show := method(
+    if(items size == 0,
+        "No tasks!" println,
+        items foreach(i, task,
+            ("  " .. (i + 1) .. ". " .. task) println
+        )
+    )
+    self
+)
+
+TodoList complete := method(index,
+    if(index > 0 and index <= items size,
+        task := items at(index - 1)
+        items removeAt(index - 1)
+        ("Completed: " .. task) println,
+        "Invalid task number" println
+    )
+    self
+)
+
+# Usage
+todo := TodoList clone
+todo add("Learn Io") add("Build something cool") add("Share with friends")
+
+"=== My Todo List ===" println
+todo show
+
+todo complete(1)
+
+"=== Updated List ===" println
+todo show

examples/chapter-04/prototypes.io

@@ -0,0 +1,40 @@
+#!/usr/bin/env io
+# Prototype-based inheritance examples from Chapter 4
+
+# Create a prototype chain
+Animal := Object clone
+Animal species := "Unknown"
+Animal speak := method("Some sound" println)
+
+Dog := Animal clone
+Dog species = "Canis familiaris"
+Dog speak := method("Woof!" println)
+Dog wagTail := method("*wagging tail*" println)
+
+fido := Dog clone
+fido name := "Fido"
+
+# Demonstrate inheritance
+"=== Prototype Chain Demo ===" println
+("fido's name: " .. fido name) println
+("fido's species: " .. fido species) println
+"fido speaks: " print
+fido speak
+"fido wags: " print
+fido wagTail
+
+# Show the prototype chain
+"\n=== Prototype Chain ===" println
+obj := fido
+while(obj != Object,
+    ("  " .. obj type) println
+    obj = obj proto
+)
+
+# Dynamic prototype modification
+"\n=== Dynamic Modification ===" println
+"Adding 'fetch' method to Dog prototype..." println
+Dog fetch := method("*fetching ball*" println)
+
+"Now fido can fetch:" print
+fido fetch  # Works even though fido was created before we added fetch!

examples/chapter-09/closures.io

@@ -0,0 +1,71 @@
+#!/usr/bin/env io
+# Closure examples from Chapter 9
+
+# Counter using closures
+makeCounter := method(start,
+    count := start
+    block(
+        count = count + 1
+        count
+    )
+)
+
+"\n=== Counter Example ===" println
+counter1 := makeCounter(0)
+counter2 := makeCounter(100)
+
+"Counter1: " print
+3 repeat(counter1 call print; " " print)
+"" println
+
+"Counter2: " print
+3 repeat(counter2 call print; " " print)
+"" println
+
+# Function composition
+"\n=== Function Composition ===" println
+compose := method(f, g,
+    block(x, f call(g call(x)))
+)
+
+double := block(x, x * 2)
+addFive := block(x, x + 5)
+doubleThenAddFive := compose(addFive, double)
+
+("10 doubled then plus 5 = " .. doubleThenAddFive call(10)) println
+
+# Partial application
+"\n=== Partial Application ===" println
+add := block(a, b, a + b)
+addTen := block(x, add call(10, x))
+
+("15 + 10 = " .. addTen call(15)) println
+
+# Memoization
+"\n=== Memoization ===" println
+memoize := method(f,
+    cache := Map clone
+    block(n,
+        if(cache hasKey(n asString),
+            "Cache hit!" println
+            cache at(n asString),
+            "Computing..." println
+            result := f call(n)
+            cache atPut(n asString, result)
+            result
+        )
+    )
+)
+
+slowSquare := block(n,
+    wait(0.1)  # Simulate expensive computation
+    n * n
+)
+
+fastSquare := memoize(slowSquare)
+
+"First call to fastSquare(5):" println
+fastSquare call(5) println
+
+"Second call to fastSquare(5):" println
+fastSquare call(5) println

examples/chapter-11/metaprogramming.io

@@ -0,0 +1,100 @@
+#!/usr/bin/env io
+# Metaprogramming examples from Chapter 11
+
+"\n=== Dynamic Method Creation ===" println
+
+# Create getters and setters dynamically
+Object addProperty := method(name, defaultValue,
+    # Create storage slot
+    self setSlot("_" .. name, defaultValue)
+    
+    # Create getter
+    self setSlot(name, 
+        method(self getSlot("_" .. call message name))
+    )
+    
+    # Create setter
+    self setSlot("set" .. name asCapitalized,
+        method(value,
+            propName := call message name afterSeq("set") asLowercase
+            self setSlot("_" .. propName, value)
+            self
+        )
+    )
+)
+
+Person := Object clone
+Person addProperty("name", "Unknown")
+Person addProperty("age", 0)
+
+john := Person clone
+john setName("John") setAge(25)
+("Name: " .. john name) println
+("Age: " .. john age) println
+
+"\n=== Method Missing Pattern ===" println
+
+DynamicObject := Object clone
+DynamicObject forward := method(
+    messageName := call message name
+    args := call message arguments
+    
+    ("Intercepted unknown method: " .. messageName) println
+    
+    if(messageName beginsWithSeq("get"),
+        property := messageName afterSeq("get") asLowercase
+        return self getSlot(property)
+    )
+    
+    if(messageName beginsWithSeq("set"),
+        property := messageName afterSeq("set") asLowercase
+        value := call evalArgAt(0)
+        return self setSlot(property, value)
+    )
+    
+    "Method not handled" println
+)
+
+obj := DynamicObject clone
+obj setColor("blue")
+obj setSize(42)
+("Color: " .. obj getColor) println
+("Size: " .. obj getSize) println
+
+"\n=== Message Inspection ===" println
+
+# Build and inspect messages
+msg := message(2 + 3 * 4)
+("Message: " .. msg) println
+("Message name: " .. msg name) println
+("Message arguments: " .. msg arguments) println
+
+# Evaluate message
+result := msg doInContext(Lobby)
+("Result: " .. result) println
+
+# Modify message
+msg setName("*")
+newResult := msg doInContext(Lobby)
+("Modified result (now multiplication): " .. newResult) println
+
+"\n=== Self-Modifying Code ===" println
+
+Counter := Object clone
+Counter count := 0
+Counter increment := method(
+    count = count + 1
+    ("Count: " .. count) println
+    
+    # Self-modify after 3 calls
+    if(count >= 3,
+        "Limit reached! Disabling increment..." println
+        self increment = method(
+            "Counter is disabled!" println
+        )
+    )
+    count
+)
+
+c := Counter clone
+5 repeat(c increment)