Módulos, testes e leis
Slide 43 de 85
43lawMódulos, testes e leis

Leis

Gramática: law-decl
lawIDENT(params)blocktable-law
law-decl = "law" IDENT "(" [ params ] ")" ( block | table-law ) ;

Uma lei é uma afirmação que o compilador prova enquanto compila: law nome(parâmetros) { … }. Os parâmetros assumem todo valor dos seus tipos, e todo assert que o corpo alcança tem de valer para todos eles. Uma lei que ele não consegue provar é um erro de compilação, e nada deixa um programa aceitá-la mesmo assim. Uma lei nunca é emitida e nunca roda.

  • Um assert dentro de um if afirma algo só onde o if vale, e nada que a lei alcança pode entrar em pânico — então uma lei sem assert afirma exatamente isso.
  • Int dá a volta como em tempo de execução, então a + 1 > a é recusada com a = 9223372036854775807.
  • Uma lei só pode alcançar código que termina e responde o mesmo toda vez: nenhuma chamada hive.*, nenhum async, nenhum laço além do for each e de um laço de contagem em que a checagem de limites confia.

Só uma lei pode chamar uma lei. Chamar outra entrega o que ela afirma para aqueles argumentos; chamar a si mesma, sobre uma parte que um padrão tirou de um parâmetro, é uma indução. A maioria das leis não precisa de nenhuma das duas: o compilador tenta valores de borda primeiro, depois todo valor de um tipo pequeno, depois incógnitas divididas em casos, e então uma indução em cada parâmetro vetor, tudo antes de qualquer coisa ser escrita. Uma recusa nomeia os valores que quebram a lei, ou o objetivo que não alcançou, o caso em que estava e o que sabia ali.

Uma lei escrita dentro de um tipo, com um parâmetro desse tipo, é o que todo valor do tipo mantém. Cada lugar que constrói um ou escreve um campo de um tem de mantê-la, provado a partir do que aquela função sabe ali: suas guardas, seus retornos antecipados e as leis dos valores que ela tem. Onde quer que um valor seja lido, suas leis são conhecidas, então uma lei de função pode contar com elas e um índice que elas garantem não precisa de guarda. Um decodificador as verifica enquanto roda, já que nada que o compilador viu construiu o que ele leu, e recusa como Broken um valor que quebra uma delas.

Uma lei também pode ser sobre uma tabela de banco de dados, e toda query nela precisa carregar o que a lei diz. Essa vem depois do SQL, em “Leis sobre uma tabela”.

Uma reserva cancelada continua cancelada
type Status {
	Requested
	Confirmed
	Cancelled
}

type Event {
	Confirm
	Cancel
}

func apply(status: Status, event: Event): Status {
	if status is Status.Cancelled {
		return status
	}
	if event is Event.Cancel {
		return Status.Cancelled()
	}
	return Status.Confirmed()
}

law cancelledIsFinal(status: Status, event: Event) {
	if status is Status.Cancelled {
		assert apply(status, event) == status
	}
}

proc main(): void {
	echo apply(Status.Requested(), Event.Confirm()) == Status.Confirmed()
}
nights.hive, errado de propósito
func nights(checkIn: Int, checkOut: Int): Int {
	return checkOut - checkIn
}

law aStayHasNights(checkIn: Int, checkOut: Int) {
	if checkIn < checkOut {
		assert nights(checkIn, checkOut) > 0
	}
}

proc main(): void {
	echo nights(4, 6)
}
Uma reserva sempre tem uma noite
type Booking {
	room: Str
	checkInDay: Int
	checkOutDay: Int

	law atLeastOneNight(b: Booking) {
		assert b.checkInDay >= 0 && b.checkInDay < b.checkOutDay
	}

}

func book(room: Str, firstDay: Int, nights: Int): Result<Booking, Str> {
	if firstDay < 0 || firstDay > 100000 || nights < 1 || nights > 365 {
		return Result.Error("essas datas não são uma estadia")
	}
	return Result.Ok(Booking(room, firstDay, firstDay + nights))
}

proc main(): void {
	echo book("12", 4, 3)
	echo book("14", 9, 0)
}
Como uma recusa aparece
$ hive check nights.hive
nights.hive:7: in law `aStayHasNights`: it does not hold for checkIn = -9223372036854775808, checkOut = 0: `nights(checkIn, checkOut) > 0` is false