Tipos, padrões e valores
Slide 34 de 85
34:= elseTipos, padrões e valores

Vinculando com um padrão

Gramática: pattern-decl, arm, position
pattern:=expressionelse{armarm}
pattern-decl = pattern ":=" expression "else" "{" arm { arm } "}" ;
position,positionblock
arm = position { "," position } block ;
_pattern-INTFLOATATOMtruefalse
position = "_" | pattern | [ "-" ] INT | FLOAT | ATOM | "true" | "false" ;

Um padrão à esquerda de := vincula o que aceita do valor à direita pelo resto do bloco, e o else depois dele traz um braço para cada valor que o padrão não aceita. Os braços são os de um switch, com uma posição cada — um padrão, um literal ou _ — e o primeiro que casa é executado.

Todo braço precisa sair do bloco: ele termina em return, panic, break ou continue, ou num if ou num switch cujos ramos todos terminam assim, e um braço que pudesse chegar ao fim é um erro de compilação. Então nada depois do vínculo é executado sem o que ele vinculou, e um erro é tratado ali mesmo, nos braços ao lado da chamada que o produziu — não existe caminho mais curto até o valor que o adie.

Ele obedece a tudo que um switch obedece:

  • o valor é avaliado uma vez, então uma chamada serve tão bem quanto uma variável;
  • o padrão e os braços, juntos, aceitam todo valor possível, e a mensagem nomeia um que eles deixam de fora — Result.Ok(Shape.Rectangle(_, _));
  • um braço que nunca pode ser executado, porque o padrão ou os braços acima dele já aceitam o que ele aceitaria, também é um erro.

O que o padrão vincula é imutável e pertence ao bloco em que está escrito, então um nome que o bloco já tem é um erro, como é para um := simples.

Tratando o erro onde ele acontece
type Order {
	Placed { item: Str, quantity: Int }
	Cancelled
}

func find(orders: Order[], index: Int): Result<Order, Str> {
	if orders bounds index {
		return Result.Ok(orders[index])
	}
	return Result.Error("não há pedido {index}")
}

// Depois de cada else o padrão casou, já que todo braço sai antes.
func describe(orders: Order[], index: Int): Str {
	Result.Ok(order) := find(orders, index) else {
		Result.Error(why) { return why }
	}
	Order.Placed(item, quantity) := order else {
		Order.Cancelled { return "o pedido {index} foi cancelado" }
	}
	return "{quantity} de {item}"
}

proc main(): void {
	orders := [Order.Placed("abelhas", 3), Order.Cancelled()]
	echo describe(orders, 0)   // 3 de abelhas
	echo describe(orders, 1)   // o pedido 1 foi cancelado
	echo describe(orders, 7)   // não há pedido 7
}
Qualquer padrão, e saindo de um laço
// Um padrão de vetor, com o vetor vazio como o único outro caso.
func total(prices: Int[]): Int {
	[first, ...rest] := prices else {
		[] { return 0 }
	}
	return first + total(rest)
}

proc main(): void {
	echo total([3, 4, 5])   // 12
	for each line in ["andar 3", "", "virar esquerda"] {
		// continue sai do bloco tão certamente quanto return.
		"{verb} {argument}" := line else {
			_ { continue }
		}
		echo "{verb}: {argument}"
	}
}