Validar com uma máquina: a entrada como autômato

Ler caractere por caractere através de estados

Imagine validar um código simples: ele precisa começar com uma letra e depois ter só dígitos, como A417. Dá para fazer isso com if empilhados, mas fica confuso e cheio de casos de borda. O autômato oferece um caminho mais organizado. Você define estados que descrevem por onde a leitura está: início, letra lida, dígito lido, formato quebrado. Aí lê o texto um caractere de cada vez. Cada caractere é um evento que dispara uma transição para o estado que corresponde ao que foi visto até ali. Quando o texto acaba, a pergunta é uma só: em que estado paramos? Se for um estado de aceitação, o código é válido.

O que torna isso elegante é que a complexidade fica toda nas transições, e não numa cascata de condições. Estando no estado início, se o caractere for uma letra, vá para letra lida; se for qualquer outra coisa, vá para o estado de rejeição. Estando em letra lida ou em dígito lido, se o caractere for um dígito, vá para dígito lido; senão, rejeite. O estado de rejeição é uma armadilha: uma vez nele, qualquer caractere seguinte o mantém ali, porque o formato já quebrou. No final, aceitar só o estado dígito lido garante que houve uma letra seguida de pelo menos um dígito.

O código do validador

Traduzir o diagrama em código é quase mecânico, e essa é outra vantagem do autômato: o desenho vira o programa quase linha a linha. Você guarda o estado atual numa variável, começa no estado inicial e percorre o texto com um laço. Dentro do laço, um bloco de decisões consulta o estado atual e o caractere da vez para escolher o próximo estado, exatamente a tabela de transições em forma de código. Depois do laço, uma única comparação decide o veredito: o estado final é de aceitação? Repare que não há retorno no meio do laço; a leitura vai até o fim e a decisão fica para depois, o que deixa a lógica previsível.

// valida: uma letra seguida de um ou mais digitos
estado <- 'inicio'
para cada c em texto faça
  se estado = 'inicio' e ehLetra(c) então
    estado <- 'letra'
  senão se estado = 'letra' e ehDigito(c) então
    estado <- 'digito'
  senão se estado = 'digito' e ehDigito(c) então
    estado <- 'digito'
  senão
    estado <- 'rejeicao'
  fim
fim
// aceita apenas se terminou em 'digito'
valido <- (estado = 'digito')
escreva(valido)

O estado atual e o caractere da vez decidem o próximo estado. No fim, só o estado de aceitação (digito) vale como válido.

Aceitação, rejeição e a armadilha

Dois detalhes fazem o validador ser correto de verdade. O primeiro é escolher com cuidado o estado de aceitação. No exemplo, aceitar o estado dígito garante que houve uma letra e ao menos um dígito; se aceitássemos também o estado letra, um texto de uma letra só passaria, o que não é o padrão pedido. O segundo é o estado de rejeição funcionar como armadilha: uma vez que o formato quebrou, nenhum caractere seguinte deve consertar. Sem essa armadilha, uma entrada como A4X7 poderia ser salva pelo 7 no final, mesmo tendo um X no meio. Autômato bem feito é aquele em que o erro, uma vez cometido, não tem volta.