Casando vetores e strings

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

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 — o menor primeiro buraco
	}
	if "/users/42/extra" is "/users/{id}" {
		echo id                           // 42/extra — um último buraco pega o resto
	}
	if "/users/42/extra" is "/users/{id is (\d+)}" {
		echo "nunca: só dígitos, e o modelo cobre a string inteira"
	}
}

func rota(caminho: Str): Str {
	// Só dígitos chegam em id, então /usuarios/ninguem cai para
	// o próximo ramo em vez de casar com este.
	if caminho is "/usuarios/{id is (\d+)}" {
		return "usuário #{id}"
	}
	// Os dois tipos de buraco se misturam à vontade — são uma
	// construção só.
	if caminho is "/api/v{versao is (\d+)}/{resto}" {
		return "v{versao}, depois {resto}"
	}
	// Chaves dentro dos parênteses são da própria regex: isto são
	// quatro dígitos, não uma interpolação.
	if caminho is "/logs/{ano is (\d{4})}" {
		return "logs de {ano}"
	}
	return "sem correspondência"
}

proc main(): void {
	echo rota("/usuarios/42")        // usuário #42
	echo rota("/usuarios/ninguem")   // sem correspondência
	echo rota("/api/v2/coisas")      // v2, depois coisas
	echo rota("/logs/2026")          // logs de 2026
}

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

	// Cada um destes é recusado antes de o programa ser construído:
	// if path is "/users/{id}{name}" { }        // dois buracos abertos lado a lado
	// if path is "/users/{len(path)}" { }       // um buraco vincula, não calcula
	// if path is "{a is (a{2,1})}" { }          // {2,1} conta para trás
	// if path is "{a is ((?=b)c)}" { }          // sem lookaround
	// if path is "{a is ((b)\1)}" { }           // e sem retrorreferência

	// Vale: o primeiro buraco diz onde termina.
	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("vazio")
	}
	return Result.Ok(Route.Page(split(path, ",")))
}

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

	// Um Result com uma Page, com um vetor cujo primeiro elemento
	// é uma string com um buraco: um padrão só.
	if resolve(path) is Result.Ok(Route.Page(["foo/{padding}/bar", ...rest])) {
		echo "{padding}, depois mais {len(rest)}"    // abc, depois mais 2
	}

	// O mesmo casamento, escrito como a cadeia que ele abrevia.
	if resolve(path) is Result.Ok(route) && route is Route.Page(parts) && parts is [head, ...rest] && head is "foo/{padding}/bar" {
		echo "{padding}, depois mais {len(rest)}"
	}

	// Um literal fica onde ficaria um nome: o campo precisa ser igual a ele.
	if resolve("") is Result.Error("vazio") {
		echo "nada para resolver"
	}
}