Tipos, padrões e valores
Slide 33 de 85
33switchTipos, padrões e valores

Casando com switch

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

switch casa um ou mais valores, os seus sujeitos, com uma lista de braços, e executa o primeiro braço que casa com todos eles. Cada sujeito é avaliado uma vez, da esquerda para a direita, antes de qualquer braço ser testado, então uma chamada serve de sujeito tão bem quanto uma variável.

Um braço tem uma posição por sujeito, separadas por vírgulas, e uma posição é:

  • um padrão, exatamente como seria depois de is: Shape.Circle(r), Result.Ok([first, ...rest]), "/users/{id}";
  • um literal ao qual o valor precisa ser igual: 0, -1, #Ready, true;
  • _, que aceita qualquer valor.

Um braço é o if que as suas posições formam, então o que ele vincula está no escopo do seu corpo e em nenhum outro lugar, e ele vincula um nome uma única vez entre todas as suas posições. Nada cai para o braço seguinte: só o primeiro braço que casa é executado, e break e continue agem sobre o laço em volta do switch.

Duas coisas são erros de compilação. Uma combinação de valores que nenhum braço aceita é uma, e a mensagem a nomeia — Shape.Circle(_), Fill.Empty —, então um switch é sempre exaustivo: a cobertura funciona como no slide anterior, sobre todos os sujeitos de uma vez, e um número, um átomo ou uma string precisa de um _. Um braço que nunca pode ser executado, porque os braços acima dele já aceitam tudo o que ele aceitaria, é a outra. Então um switch cujos braços todos retornam encerra uma função, sem nada depois dele.

Vários valores de uma vez
type Shape {
	Circle { radius: Int }
	Point
}

type Fill {
	Solid { color: Str }
	Empty
}

// Toda forma com todo preenchimento tem um braço, então o switch encerra a função.
func describe(shape: Shape, fill: Fill): Str {
	switch shape, fill {
		Shape.Circle(r), Fill.Solid(color) { return "um círculo {color} de {r}" }
		Shape.Circle(r), Fill.Empty        { return "um círculo vazio de {r}" }
		Shape.Point, _                     { return "um ponto" }
	}
}

proc main(): void {
	echo describe(Shape.Circle(2), Fill.Solid("vermelho"))   // um círculo vermelho de 2
	echo describe(Shape.Circle(5), Fill.Empty())             // um círculo vazio de 5
	echo describe(Shape.Point(), Fill.Solid("azul"))         // um ponto
}
Literais, e os dois erros
// Sem o último braço isto é um erro de compilação, já que nenhum conjunto
// finito de números cobre um Int; e um braço abaixo dele nunca poderia ser
// executado, o que também é um erro de compilação.
func size(n: Int, loud: Bool): Str {
	switch n, loud {
		0, _     { return "nenhum" }
		1, true  { return "UM" }
		1, false { return "um" }
		_, _     { return "muitos" }
	}
}

proc main(): void {
	echo size(0, true)    // nenhum
	echo size(1, true)    // UM
	echo size(7, false)   // muitos
}
Uma chamada como sujeito
proc main(): void {
	names := ["ada", "bob"]
	for each wanted in ["bob", "eve"] {
		// A chamada é feita uma vez, antes de qualquer braço ser testado.
		switch indexOf(names, wanted) {
			Result.Ok(i)    { echo "{wanted} está na posição {i}" }
			Result.Error(_) { echo "nenhum {wanted}" }
		}
	}
}