Guarda (ciência da computação) - Guard (computer science)

Em programação de computador, um guarda é uma expressão booleana que deve ser avaliada como verdadeira se a execução do programa deve continuar no ramo em questão.

Independentemente de qual linguagem de programação é usada, uma cláusula de proteção , código de proteção ou instrução de proteção é uma verificação das pré-condições de integridade usada para evitar erros durante a execução. Um exemplo típico é verificar se uma referência prestes a ser processada não é nula, o que evita falhas de ponteiro nulo. Outros usos incluem o uso de um campo booleano para idempotência (portanto, as chamadas subsequentes são nops), como no padrão dispose . O guarda fornece uma saída antecipada de uma sub - rotina e é um desvio comumente usado da programação estruturada , removendo um nível de aninhamento e resultando em um código mais simples: substituir if guard { ... }por if not guard: return; ....

O termo é usado com significado específico nas linguagens de programação APL , Haskell , Clean , Erlang , occam , Promela , OCaml , Swift , Python da versão 3.10 e Scala . No Mathematica , os guardas são chamados de restrições . Guardas são o conceito fundamental da Guarded Command Language , uma linguagem em métodos formais . Os guardas podem ser usados ​​para aumentar a correspondência de padrões com a possibilidade de pular um padrão, mesmo se a estrutura corresponder. Expressões booleanas em declarações condicionais geralmente também se enquadram nessa definição de guarda, embora sejam chamadas de condições .

No exemplo de Haskell a seguir, os guardas ocorrem entre cada par de "|" e "=": 

f x
 | x > 0 = 1
 | otherwise = 0

Isso é semelhante à respectiva notação matemática:

Neste caso, os protetores estão nas cláusulas "if" e "else".

Se houver vários protetores paralelos, como no exemplo acima, eles são normalmente experimentados em uma ordem de cima para baixo, e o ramal do primeiro a passar é escolhido. Os guardas em uma lista de casos são normalmente paralelos.

No entanto, nas compreensões de lista de Haskell, os guardas estão em série e, se algum deles falhar, o elemento de lista não é produzido. Isso seria o mesmo que combinar as proteções separadas com E lógico , exceto que pode haver outras cláusulas de compreensão de lista entre as proteções.

Evolução

Uma expressão condicional simples, já presente na CPL em 1963, tem um guarda na primeira subexpressão, e outra subexpressão para usar caso a primeira não possa ser usada. Algumas maneiras comuns de escrever isso: 

(x>0) -> 1/x; 0
x>0 ? 1/x : 0

Se a segunda subexpressão pode ser uma expressão condicional simples adicional, podemos fornecer mais alternativas para tentar antes do último fall-through : 

(x>0) -> 1/x; (x<0) -> -1/x; 0

Em 1966, ISWIM tinha uma forma de expressão condicional sem um caso de falha obrigatório, separando guarda do conceito de escolher um ou outro. No caso do ISWIM, se nenhuma das alternativas pudesse ser usada, o valor deveria ser indefinido , que foi definido para nunca ser computado em um valor.

KRC , uma "versão miniaturizada" de SASL (1976), foi uma das primeiras linguagens de programação a usar o termo "guarda". Suas definições de função podem ter várias cláusulas, e aquela a ser aplicada foi escolhida com base nas proteções que seguiram cada cláusula: 

 fac n = 1,               n = 0
       = n * fac (n-1),   n > 0

O uso de cláusulas de proteção e o termo "cláusula de proteção" datam pelo menos da prática de Smalltalk na década de 1990, conforme codificado por Kent Beck .

Em 1996, o Dyalog APL adotou um estilo alternativo puramente funcional no qual a proteção é a única estrutura de controle. Este exemplo, em APL, calcula a paridade do número de entrada:

parity←{
        2∣⍵ : 'odd'
              'even'
        }

Guarda padrão

Além de uma proteção anexada a um padrão, a proteção de padrão pode se referir ao uso de correspondência de padrão no contexto de uma proteção. Com efeito, uma correspondência do padrão significa aprovação. Esse significado foi introduzido em uma proposta para Haskell por Simon Peyton Jones intitulada Uma nova visão dos guardas em abril de 1997 e foi usado na implementação da proposta. O recurso fornece a capacidade de usar padrões nas proteções de um padrão.

Um exemplo em Haskell estendido: 

 clunky env var1 var2
 | Just val1 <- lookup env var1
 , Just val2 <- lookup env var2
 = val1 + val2
 -- ...other equations for clunky...

Isso seria: "Clunky para um ambiente e duas variáveis, no caso de as pesquisas das variáveis ​​do ambiente produzirem valores , é a soma dos valores. ..." Como nas compreensões de lista , os guardas estão em série, e se qualquer um deles falha o ramo não é levado.

Exemplo

public string Foo(string username) {
    if (username == null) {
        throw new ArgumentNullException(nameof(username));
    }
    // Rest of the method code follows here...
}

Veja também

Referências

links externos