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.foldl(0, %!(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 = argc > 1 ? argv[1]
                      : "examples/data/love-files/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);

// Files supply lines; each line supplies words.
Map word_count(String path) {
  Map counts = {};
  File input = path.open("r");
  defer input.close();
  foreach (String line, input)
    foreach (String word, line.lower().words())
      counts[word] += 1;
  return counts;
}

// words.txt: "Tea coffee tea" then "Milk coffee tea".
String path = argc > 1 ? argv[1]
                      : "examples/data/power-counting/words.txt";
Map counts = word_count(path);

// Rank by count, breaking ties by word in the same descending order.
Array ranked = counts.enumerate().array().sort_with(
  %!(List left, List right) => {
    int order = right[1].compare(left[1]);
    return order ? order : right[0].compare(left[0]);
  });
foreach (Var (word, n), ranked)
  puts(%"$n $word");

// Store documents once; words refer to them by ID.
typedef struct Index { Array documents; Map words; } *Index;

Index Index.new(void) {
  Index index = Scope.malloc(sizeof(struct Index));
  index.documents = []; index.words = {};
  return index;
}

// Add each word once per document, regardless of case or repetition.
void Index.add(Index index, String name, String text) {
  int id = index.documents.len();
  index.documents.push(name);
  foreach (String word, text.lower().words().iter().unique())
    index.words.setdefault(word, []).array().push(id);
}

// An unknown word has no matches; lookup does not change the index.
Array Index.find(Index index, String word)
  => index.words.getdefault(word.lower(), []);

// Reclaim working storage regularly in a long-running survey.
size_t total = 0;
// Each day's file list lives until that survey finishes.
while (wait_for_day()) $scope() {
  Array files = survey_files();

  // Working data is reclaimed after every file.
  foreach (String path, files) $scope() {
    Map findings = inspect_file(path);
    save_findings(path, findings);
    total++;
  }
}
printf("processed: %zu files\n", total);

// Recognize a nested condition and exchange its branches.
List simplify(List node) {
  match (node) {
    case %(if (not ?condition) ?yes ?no):
      return simplify(%(if $condition $no $yes));
    case %(if true ?yes ?): return simplify(yes);
    case %(if false ? ?no): return simplify(no);
    case %(if ?condition ?yes ?no):
      return %(if $condition ${simplify(yes)} ${simplify(no)});
    // Capture a whole block, transform it, splice it back in.
    case %(block *body):
      return %(block @{body.map(%!(List item) => simplify(item))});
    default: return node;
  }
}

List code = %(block
  (if (not ready) (call wait) (call start))
  (if true (call save) (call discard)));
puts(simplify(code).str());
// ( block ( if ready ( call start ) ( call wait )) ( call save ))

// Each worker squares its values and reduces them to one sum.
static Var sum_squares(const void *input, size_t bytes) {
  const int *values = input;
  double sum = 0;
  for (size_t i = 0; i < bytes / sizeof(int); i++)
    sum += (double) values[i] * values[i];
  return sum;
}

// Split the data; launch both workers before waiting for either.
int values[2][3] = {{1, 2, 3}, {4, 5, 6}};
Thread first = Thread.start(sum_squares,
  values[0], sizeof(values[0]));
Thread second = Thread.start(sum_squares,
  values[1], sizeof(values[1]));

// Combine the partial sums after both workers finish.
double left = first.join(), right = second.join();
first.free(); second.free();
printf("sum of squares: %g\n", left + right);

// Close the file on success or while unwinding from a failed read.
String read_text(String path) {
  File input = path.open("r");
  defer input.close();
  return input.string();
}

// The caller decides how to present content that cannot be text.
String preview(String path) {
  try return read_text(path);
  catch %(bad-arg *):
    return "No text preview: file contains a NUL byte.";
  catch %(not-found *):
    return "No preview: file not found.";
  catch:
    return "No preview: unable to read file.";
}

String directory = argc > 1 ? argv[1]
                           : "examples/data/power-exceptions";
// document.bin contains a NUL byte, which String cannot hold.
puts(preview(%"$directory/document.bin"));

// Opt into the ready-made typed collection families.
#include "typed-array.x"
#include "typed-map.x"
#include "typed-list.x"

// Store native ints and count each response code.
ArrayInt responses = [200, 200, 404, 200, 500, 404];
MapIntInt counts = {};
for (int i = 0, n = responses.len(); i < n; i++)
  counts[responses[i]] += 1;

// A typed List fixes the report order, including absent codes.
ListInt codes = %(200 403 404 500);
for (ListInt rest = codes; rest; rest = rest.cdr()) {
  int code = rest.car();
  printf("%d: %d\n", code, counts.getdefault(code, 0));
}

// Import the package under a name you choose.
import "pcre2" as rx;

// Compile a pattern with named captures; release it on exit.
rx.Regexp request = rx.Regexp.compile(
  "^(?<method>[A-Z]+) (?<path>/[^ ]+)$", 0);
defer request.free();

// Sample requests include lines the pattern will ignore.
String text = %"\
GET /docs
POST /build
-- idle --
DELETE /cache
GET missing-slash
";

foreach (String line, text.lines()) {
  rx.RegexpMatch found = request.match(line);
  if (found)
    puts(%"${found[<method>]} requests ${found[<path>]}");
}

// 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) => key in right));

// 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");

$(import "autodiff.xmacro")

$ad.reverse()
static double energy(double x, double y, int n) {
  double s = 0.0;
  for (int i = 0; i < n; i++) {
    if (i == 2) continue;
    s += x * x * (double) i;
  }
  return sin(s) / x - exp(y);
}

double dx, dy;
double value = energy_grad(1.0, 2.0, 5, &dx, &dy);

// 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);

// Compile-time Lisp can return an actual AST node.
List comptime = $(let ((cons-expr (lambda (n tail)
  `(expr ("List") (cons ,(x2c.literal.int n) ,tail)))))
  (cons-expr 1 (cons-expr 4 (cons-expr 9 '(nil)))));

// A literal compiles to a form similar to the cons cells below.
List literal = %(1 4 9);

// Explicit construction reveals the underlying C functions.
List constructed = cons(int_var(1),
  cons(int_var(4), cons(int_var(9), NULL)));

// Runtime Lisp will build it on the fly.
Lisp lisp = Lisp.new(); defer lisp.destroy();
List runtime = lisp.eval(%(list (* 1 1) (* 2 2) (* 3 3)));

assert(comptime == literal && literal == constructed &&
       constructed == runtime);
puts("All four lists are equal.");

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

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

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

# For fun: build the experimental portable bootstrap.
make ape-build
./dist/x2c.com bootstrap --prefix ~/.local/x2c