Matching vectors and strings

proc main(): void {
	command := ["move", "north", "2"]
	if command is ["move", dir, ...steps] {
		echo "{dir}, {len(steps)} more"
	} else if command is ["stop"] {
		echo "halt"
	}
}

proc main(): void {
	if "/users/42/posts/7" is "/users/{id}/posts/{postId}" {
		echo "{id} / {postId}"            // 42 / 7
	}
	if "a/b/c" is "{x}/{y}" {
		echo "{x} | {y}"                  // a | b/c — the shortest first hole
	}
	if "/users/42/extra" is "/users/{id}" {
		echo id                           // 42/extra — a last hole takes the rest
	}
	if "/users/42/extra" is "/users/{id is (\d+)}" {
		echo "never: digits only, and the template covers the whole string"
	}
}

func route(path: Str): Str {
	// Only digits reach id, so /users/nobody falls through
	// to the next branch instead of matching this one.
	if path is "/users/{id is (\d+)}" {
		return "user #{id}"
	}
	// The two kinds of hole mix freely — they are one construct.
	if path is "/api/v{version is (\d+)}/{rest}" {
		return "v{version}, then {rest}"
	}
	// Braces inside the parentheses are the regex's own: this is
	// four digits, not an interpolation.
	if path is "/logs/{year is (\d{4})}" {
		return "logs for {year}"
	}
	return "no match"
}

proc main(): void {
	echo route("/users/42")        // user #42
	echo route("/users/nobody")    // no match
	echo route("/api/v2/things")   // v2, then things
	echo route("/logs/2026")       // logs for 2026
}

proc main(): void {
	path := "/users/42"

	// Each of these is refused before the program is built:
	// if path is "/users/{id}{name}" { }        // two open holes side by side
	// if path is "/users/{len(path)}" { }       // a hole binds, it does not compute
	// if path is "{a is (a{2,1})}" { }          // {2,1} counts down
	// if path is "{a is ((?=b)c)}" { }          // no lookaround
	// if path is "{a is ((b)\1)}" { }           // and no backreference

	// Fine: the first hole says where it ends.
	if path is "/users/{id is (\d+)}{rest}" {
		echo "{id}[{rest}]"
	}
}

type Route {
	Page { segments: Str[dyn] }
	Missing
}

func resolve(path: Str): Result<Route, Str> {
	if path == "" {
		return Result.Error("empty")
	}
	return Result.Ok(Route.Page(split(path, ",")))
}

proc main(): void {
	path := "foo/abc/bar,x,y"

	// A Result holding a Page, holding a vector whose first element
	// is a string with a hole in it: one pattern.
	if resolve(path) is Result.Ok(Route.Page(["foo/{padding}/bar", ...rest])) {
		echo "{padding}, then {len(rest)} more"      // abc, then 2 more
	}

	// The very same match, written out as the chain it abbreviates.
	if resolve(path) is Result.Ok(route) && route is Route.Page(parts) && parts is [head, ...rest] && head is "foo/{padding}/bar" {
		echo "{padding}, then {len(rest)} more"
	}

	// A literal stands where a name would: the field has to equal it.
	if resolve("") is Result.Error("empty") {
		echo "nothing to resolve"
	}
}