Programming is Dead.
Long Live Programming.

#include <assert.h>
#include <math.h>

// Var holds different kinds of values.
Var count = 42, ratio = 2.5, name = "Ada";

// Ordinary operators work on Vars.
Var next = count + 1, full = name + " Lovelace";

// Vars format themselves with %s.
printf("%s %s %s\n", next, ratio, full);

// Test Var properties at runtime.
assert(count is int && ratio is double && name is String);

// Types are checked statically and dynamically as needed.
int whole = count; double part = ratio;

// %d and %f also convert Vars.
printf("%d %f %f\n", count, ratio, sin(ratio));

#include <assert.h>
#include <string.h>

// Transform and slice values; keep the original input.
String raw = "  tea:42  ", row = raw.strip(NULL);
String name = row[:3].upper(), title = name + " ORDER";

// Equal contents compare in constant time, however they were built.
assert(title == %"tea order".upper());

// Parse a sliced field and interpolate the result.
long quantity;
if (row[4:].try_long(&quantity))
  puts(%"$title: ${quantity + 1}");

// Iterate bytes directly, or use ordinary C string functions.
assert(strcmp(raw, "  tea:42  ") == 0);
foreach (char ch, name)
  putchar(ch);
printf(" has %zu letters; original: [%s]\n", strlen(name), raw);

#include <assert.h>

// Names are values, without declaring enum constants.
Symbol running = <running>, state = <queued>;

// Symbol literals are constants, so ordinary C switch works.
switch (state) {
  case <queued>:  puts(%"$state: waiting for a worker"); break;
  case <running>: puts(%"$state: doing the work"); break;
  default:        puts(%"$state: no work left");
}

// An ordered vocabulary, built entirely at compile time.
SymbolSet stages = %<<queued running done>>;
assert(stages.contains(state) && !stages.contains(<failed>));
state = stages[stages.index(state) + 1];
assert(state == running);

// Iterate in declared order and recover each name's text.
foreach (Symbol stage, stages)
  printf("%d: %s\n", stages.index(stage), stage.str());

#include <assert.h>

// Prepend in constant time, sharing the original tail.
List prices = %(3 5 8), extended = cons(2, prices);
assert(extended.cdr() == prices && extended == %(2 3 5 8));

// Compose transformations without changing either input.
List totals = extended.map(%!(price) => price * 2);
List selected = totals.filter(%!(total) => total >= 10);

// Unpack values, then fold them into a single result.
Var (first, second) = selected;
Var sum = selected.foldl(0, %!(a, b) => a + b);
printf("selected: %s + %s = %s\n", first, second, sum);

// A literal can combine names, computed values, and nested Lists.
puts(%(total $sum items $selected).repr());
puts(%"original: $prices; extended: $extended");

// car gets the first value; cdr gets the rest, spliced with @.
List parts = %((first ${selected.car()}) (rest @{selected.cdr()}));
puts(parts.repr());

#include <assert.h>

// Grow and update a sequence in place.
Array scores = %[7, 3, 9];
scores.push(5); scores[1] += 1;

// Sorting mutates; copy first to keep the original order.
Array ranked = scores.copy().sort().reverse();
assert(scores == %[7, 4, 9, 5] && scores !== ranked);

// Slices and map create new Arrays.
Array top = ranked[:2];
Array boosted = top.map(%!(score) => score + 1);
Var total = boosted.reduce(%!(a, b) => a + b);
printf("scores: %s; ranked: %s\n", scores.repr(), ranked.repr());

// Use indexed access or iterate over the resulting values.
foreach (Var score, boosted)
  printf("%s ", score);
printf("=> total %s, best %s\n", total, boosted[0]);

// Start with named items and their stock quantities.
Map stock = %{"tea": 12, "coffee": 8, "milk": 6, "sugar": 0};

// Update existing entries or add new ones with the same syntax.
stock["tea"] -= 2;
stock["coffee"] += 5;
stock["cocoa"] = 4;

// Fetch a value directly, or supply a fallback without inserting.
printf("tea: %s; biscuits: %s\n",
  stock["tea"],
  stock.getdefault("biscuits", 0));

// A stored zero is different from an absent key.
Var sugar;
if (stock.try_get("sugar", &sugar))
  puts(%"sugar is stocked: $sugar remaining");

// Visit each key and value; traversal order is unspecified.
foreach (Var (item, quantity), stock)
  puts(%"$item: $quantity");

Map workshop = %{
  title: "Make a tiny game",
  topics: (graphics sound games),
  venue: {
    name: "The Maker House", room: "Studio 2", seats: 24,
    address: {street: "12 Garden Lane", city: "Bristol"}
  },
  hosts: [
    {name: "Ada", role: instructor, skills: (graphics games)},
    {name: "Sam", role: mentor, skills: (music sound)}
  ],
  pricing: {currency: "GBP", standard: 35.0, student: 15.0},
  bring: ["A laptop", "Headphones", "An unfinished idea"],
  sessions: [
    {title: "Draw a world", minutes: 45,
     project: {width: 320, height: 240, colors: 16}},
    {title: "Make it move", minutes: 60,
     controls: {left: a, right: d, jump: space}},
    {title: "Add some sound", minutes: 30,
     audio: {channels: 2, volume: 0.75, rate: 44100}}
  ]
};

#include <stdlib.h>

String path = "quantities.txt";

// Read the whole text file and close it in one expression.
String text = path.open("r").string_close();
printf("whole file (%d bytes):\n%s", text.len(), text);

// Or stream lines, keeping the close beside the open.
File input = path.open("r");
defer input.close();
long total = 0;

// Skip blank lines; each remaining row has three valid longs.
foreach (String line, input) {
  if (!line.strip(NULL)) continue;
  String (a, b, c) = line.words().iter().list();
  long x = atol(a), y = atol(b), z = atol(c);
  total += x + y + z;
}
printf("total: %ld\n", total);

// Define a type with its own named methods.
typedef struct Point { int x, y; } *Point;

// Allocate a Point in the current Scope.
Point Point.new(int x, int y) {
  Point point = Scope.malloc(sizeof(struct Point));
  point.x = x; point.y = y;
  return point;
}

// Fields and methods both use dot notation.
void Point.move(Point point, int dx, int dy) {
  point.x += dx; point.y += dy;
}

// Create and move a Point with compact dot calls.
Point point = Point.new(1, 2);
point.move(3, 4);

// Reuse Map storage: its keys are the set members.
typedef Map Set;

Set Set.new(List keys) => keys.foldl(%{},
  %!(Map set, Var key) => set.update_n(1, key, 1));
Set Set.add(Set left, Set right) => left.copy().merge(right);
Set Set.mul(Set left, Set right) => Set.new(left.keys()
  .filter(%!(Var key) => right.contains(key)));

// Connect add and mul to the + and * operators.
protocol Map(T) { T T.add(T, T); T T.mul(T, T); }
protocol Map(Set);

// Create two sets, then take their union and intersection.
Set fruit = Set.new(%(apple pear));
Set lunch = Set.new(%(pear bread));
Set set_union = fruit + lunch;
Set intersection = fruit * lunch;

macro Statement $swap(Expr $left, Expr $right)
  using $temporary => {
    $(x2c.syntax.type $left) $temporary = $left;
    $left = $right;
    $right = $temporary;
}

// The same macro works with different types.
int left = 20, right = 22;
$swap(left, right);

String first = %"hello", last = %"world";
$swap(first, last);
printf("%d %d; %s %s\n", left, right, first, last);

macro Decorator $trace(Function $function) => {
  printf("enter %s\n",
    $(x2c.literal.string (x2c.function.name $function)));
  defer printf("leave %s\n",
    $(x2c.literal.string (x2c.function.name $function)));
  $(x2c.function.body $function)...
}

$trace()
int answer(void) => 42;

// Prints "enter answer", then "leave answer".
int result = answer();

macro Decorator $control.with_lock(Block $body, Expr $lock)
  using $held => { {
    Mutex $held = $lock;
    $held.lock();
    defer $held.unlock();
    $body
  } }

keyword with_lock $control.with_lock;

Mutex mutex = Mutex.new();
defer mutex.free();
try with_lock(mutex) { raise %(oops); }
catch %(oops):
  puts("caught, and the lock is already free");

// One table supplies both wire codes and readable labels.
$(defun responses ()
  '((200 "OK") (404 "Not Found") (503 "Unavailable")))

static const int codes[] = $(x2c.expr.composite
  (map (lambda (row) (x2c.literal.int (car row)))
       (responses)));

String labels[] = $(x2c.expr.composite
  (map (lambda (row) (x2c.literal.string (cadr row)))
       (responses)));

// The generated program uses ordinary C arrays.
for (size_t i = 0; i < sizeof(codes) / sizeof(*codes); i++)
  printf("%d: %s\n", codes[i], labels[i]);

int seats_left(String plan) => plan == %"pro" ? 25 : 2;

// Expose an ordinary typed function to the runtime interpreter.
Lisp lisp = Lisp.new();
defer lisp.destroy();
$lisp.bind(lisp, "seats-left", seats_left);

// Keep the party together, or admit as many people as fit.
List together = %(lambda (plan n)
  (if (<= n (seats-left plan)) n 0));
List split = %(lambda (plan n)
  (if (<= n (seats-left plan)) n (seats-left plan)));

// Supply either policy as data to the same evaluator.
int whole = lisp.eval(%($together "free" 12));
int partial = lisp.eval(%($split "free" 12));
printf("together: %d; split: %d\n", whole, partial);

# Build normally, or rebuild from the checked-in bootstrap C.
make build
make safely

# Let the compiler build successive versions of itself.
make stresstest
make rebootstrap       # Refresh the checked-in bootstrap C.
make stage-diff-all    # Compare generated C and headers.

# Inspect parsed syntax and the compiler's transformations.
./builds/0/x2c translate --dump-ast examples/foreach.x
./builds/0/x2c translate --dump-transforms examples/foreach.x

# Build a portable executable that carries its own source.
make ape-build
./dist/x2c.com bootstrap --prefix ~/.local/x2c