Faça estados inválidos serem irrepresentáveis

Intro

Números. Infinitos itens. Porém, por si só, números não tem sentido (algebra?). Para que façam sentido, definimos unidades à o que se referem. Nisso, temos coisas contáveis que são infinitas, mas também, coisas que são finitas.

Imagine um toca CD de carro do inicio dos anos 2000. Alguns modelos possuem apenas 1 slot, e outros, até 10 slots (talvez mais, mas ai é muito chique).

Descrever essa capacidade (slots) como um number ou Int é um convite para introduzir bugs. Todos os métodos e variáveis que serão declaradas assim, podem ter valores arbitrários em todos os lugares do sistema, ou, todos os lugares que utilizam deverão ter checks de pre e postcondition para saber se o valor está dentro dos constraints específicos a aquele item.

Um aplicação tem vários estados. Se fizéssemos a união de todos os estados possíveis em uma única função, seria praticamente impossível compreender quantos estados a aplicação poderia tomar em um determinado momento.

A quantidade de variáveis seria muito grande para se quer acompanhar mentalmente o que está acontecendo.

A maioria dos estados não precisam estar disponíveis o tempo todo. Essas variáveis precisariam de manutenção do momento em que ela é inicializada, até quando deveria ser descartada - que causa problemas de “stale data” (que pode causar um estado inválido).

Dificilmente, você vai ver um code base que se preocupa com essas coisas (e sempre aparece um bug). Alguns casos podem ser resolvidos com tipos pequenos ou “tipos enumerados”, outros, talvez esteja você olhando o problema de uma única perspectiva.

Dados primitivos e constraints

Number, Int, s64, u64, string, char são primitivos das linguagens. Alguns possuem bounds (limites como signed char que vai de -128 até 127 ou unsigned char que vai de 0 até 255), outros o limite é “mais aberto”.

Números tem limites acordo com o tamanho de storage disponível, mas os infinitos tipos de dados temos varias constraints que são subsets (sub-conjuntos) desses outros conjuntos. Exemplos: E-mail (string com constraint no formato e tamanho - leia a RFC e vai ver que existe um tamanho mínimo - curiosidade), idade (que a constraint varia de acordo com o contexto - se falarmos de idade de uma pessoa, o valor está em entre 0 - idade da última pessoa que bateu o record de longevidade, mas pode ser a idade de uma cidade, que já é outro range aberto, mas pelo menos 0 - infinito).

Uma das soluções é a cada utilização dessa informação adicionar pre-condition (se os valores estão validos para a execução) e post-condition (se depois da operação o valor continua valido).

Existem linguagens como Eiffel que possui a keyword require e ensure - que se referem ao pattern de precondition e postcondition, ou, um pattern comum de algumas linguagens de adicionar assert para verificar que uma determinada propriedade não viola a pre-condition.

Opções

Types

Tipos são um bom começo. Precisamos dar contexto aos tipos de dados primitivos para podermos efetuar operações com mais segurança. Podemos definir o tipo “número de cartão de credito” como

```haskell data CreditCardNumber = CreditCardNumber String – the number Bool – valid or not

validCeditCardNumber _ = False

class From a b where from :: a -> b

instance From String CreditCardNumber where from a = CreditCardNumber a (validCeditCardNumber a)

(from “1111 1111 1111 1111”) :: CreditCardNumber – CreditCardNumber “1111 1111 1111 1111” False ```

Agora temos um contexto. Nem todas as strings vão ser permitidas - no que se refere a validade do número. Ainda sim, existem vários outros tipos para diferentes contextos.

```haskell data ValidCreditCardNumber = ValidCreditCardNumber String – the number

validCeditCardNumber _ = False

class From a b where from :: a -> b

instance From String CreditCardNumber where from a = if not (validCeditCardNumber a) then error “Invalid credit card number.” else ValidCreditCardNumber a

(from “1111 1111 1111 1111”) :: ValidCreditCardNumber – *** Exception: Invalid credit card number. CallStack (from HasCallStack): error, called at :1:1 in interactive ```

Agora somente números validos passaram pelo programa, exceto que você instancie por conta própria (sem utilizar o from). Ai o problema é seu…

Essa é representação visual. De todos o elementos, somente um elemento do conjunto das strings possíveis tem um correspondente, porque só números validos podem ser usados. O ideal é termos funções totais o máximo possível.

Figura 1 indisponível no arquivo.

Sair de valores infinitos e desconhecidos para um único elemento deixa tudo mais fácil.

Figura 2 indisponível no arquivo.

A leitura fica mais precisa: “Com um numeração valida, execute a ação f”. Não existe chamar a função f, vamos imaginar que f é a função comprar algo, com um número de cartão invalido. Toda a informação necessária está embutida no tipo.

Ainda podemos ter casos com validação e “continuação” com erros, mas terá outro exemplo.

Null object pattern

Esse pattern é mais adequado para casos onde temos objetos complexos.

Algumas linguagens permitem declaramos variáveis não incializadas, que recebem o valor null ou undefined.

Ser deixarmos essa variável não inicializada e passarmos para o restante das funções, elas vão ter que verificar (pre-condition) se existe um valor ou não.

Uma das principais utilizações:

Evitar que dispare exceções do tipo “null pointer exception” Disparar um erro quando o valor deveria existir, mas o objeto nulo continuou (erros previsíveis) Objeto cujas as operações não alteram o valor do resultado

```kotlin open class BaseCreditCard { open fun buyStuff() {} }

class NullCreditCard: BaseCreditCard { open fun buyStuff() { thow Error(“Bailing out! No credit card available.”) } }

class CreditCard: BaseCreditCard()

fun findCreditCard(number: String): BaseCreditCard { return NullCreditCard(); }

fun main() { var card: BaseCreditCard = findCreditCard(“1111 1111 1111 1111”); card.buyStuff(); } ```

Esse é um modo de garantir que sempre haverá um objeto concreto, e, ajuda a encontrar edge cases em testes.

Maybe/Option/Either/Result Functors

Maybe ou option, dependendo da linguagem que você está usando, pode servir para casos onde o resultado de uma validação não é importante - somente proibir que valores inválidos sejam utilizados.

```rust struct ValidCreditCardNumber { string_number: String }

fn valid(_value: &str) -> bool { return true; }

impl From<&str> for ValidCreditCardNumber { fn from(value: &str) -> Self { return Self { string_number: value.to_string() }; } }

trait SafeFrom { fn from_safe(value: T) -> Option where Self: Sized; }

impl SafeFrom<&str> for ValidCreditCardNumber { fn from_safe(value: &str) -> Option { if valid(value) { return Some(ValidCreditCardNumber:: from(value)); } return None; } }

fn main() { let pipe = ValidCreditCardNumber::from_safe(“111111111111111111”) .map(|x| x) .map(|x| x); match pipe { Some (x) => printin!(“{}”, x.string_number), None => println!(“meh”) } } ```

Nas figurinhas…

Figura 3 indisponível no arquivo.

Existência do Objeto já é o seu valor (unificação)

Este é mais uma simplificação. Objetos - classes quando possível -, são a definição de algo.

Um dos exemplos mais notórios são GUIs.

Quando navegamos por páginas usamos strings para marcar onde estamos.

```typescript export type Pages = “PAGE_A” | “PAGE_B” | “PAGE_C”

export function getPageComponent (page: Pages) { switch (page) { case “PAGE_A”: return PageA; case “PAGE_B”: return PageB; case “PAGE_C”: return PageC; } } ```

Podemos remover essas strings e utilizar as próprias classes/objetos para formar uma máquina de estado.

```typescript export type Pages = | PageA | PageB | PageC

previousPage(PageA); nextPage(PageC); ```

Identidade de monoids

Monoids possuem um elemento que não influenciam no resultado de uma operação. O elemento identidade.

1 + 0 = 0 + 1 = 1

Ou

“" + “a" = “a” + “" = “a”

Ou

Balde.Empty + Balde(Litro(x)) = Balde(Litro(0) + Litro(x)) = Balde(Litro(0 + x))

🤷‍♂️

Conclusão

Existem várias opções para não deixa informações invalidas causarem problemas no projeto. Cada uma vai ser utilizada de acordo com o contexto da ação que precisa ser feita, e, também de acordo com o tipo de linguagem.

Esse conceito também é responsável por melhora a linguagem do domínio.

Referências

https://www.awwsmm.com/blog/make-invalid-states-unrepresentable https://fsharpforfunandprofit.com/posts/designing-with-types-making-illegal-states-unrepresentable/ https://geeklaunch.io/blog/make-invalid-states-unrepresentable/ https://hugotunius.se/2020/05/16/making-invalid-state-unrepresentable.html