# Guard (computer science) – Wikipedia

In computer programming, a guard is a boolean expression that must evaluate to true if the program execution is to continue in the branch in question.

Regardless of which programming language is used, a guard clause, guard code, or guard statement, is a check of integrity preconditions used to avoid errors during execution. A typical example is checking that a reference about to be processed is not null, which avoids null-pointer failures. Other uses include using a boolean field for idempotence (so subsequent calls are nops), as in the dispose pattern. The guard provides an early exit from a subroutine, and is a commonly used deviation from structured programming, removing one level of nesting and resulting in flatter code:[1] replacing `if guard { ... }` with `if not guard: return; ...`. For example, in Python:

```# This function has no guard clause
def f_noguard(x):
if isinstance(x, int):
return x + 1

# Equivalent function with a guard clause
def f_guard(x):
if not isinstance(x, int):
return None

return x + 1
```

The term is used with specific meaning in APL, Haskell, Clean, Erlang, occam, Promela, OCaml, Swift,[2]Python from version 3.10, and Scala programming languages.[citation needed] In Mathematica, guards are called constraints. Guards are the fundamental concept in Guarded Command Language, a language in formal methods. Guards can be used to augment pattern matching with the possibility to skip a pattern even if the structure matches. Boolean expressions in conditional statements usually also fit this definition of a guard although they are called conditions.

In the following Haskell example, the guards occur between each pair of “|” and “=”:

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

This is similar to the respective mathematical notation:

${displaystyle f(x)=left{{begin{matrix}1&{mbox{if }}x>0�&{mbox{otherwise}}end{matrix}}right.}$

Evolution

A simple conditional expression, already present in CPL in 1963, has a guard on first sub-expression, and another sub-expression to use in case the first one cannot be used. Some common ways to write this:

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

If the second sub-expression can be a further simple conditional expression, we can give more alternatives to try before the last fall-through:

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

In 1966 ISWIM had a form of conditional expression without an obligatory fall-through case, thus separating guard from the concept of choosing either-or. In the case of ISWIM, if none of the alternatives could be used, the value was to be undefined, which was defined to never compute into a value.

KRC, a “miniaturized version”[3] of SASL (1976), was one of the first programming languages to use the term “guard”. Its function definitions could have several clauses, and the one to apply was chosen based on the guards that followed each clause:

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

Use of guard clauses, and the term “guard clause”, dates at least to Smalltalk practice in the 1990s, as codified by Kent Beck.[1]

In 1996, Dyalog APL adopted an alternative pure functional style in which the guard is the only control structure.[4] This example, in APL, computes the parity of the input number:

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

## Pattern guard

In addition to a guard attached to a pattern, pattern guard can refer to the use of pattern matching in the context of a guard. In effect, a match of the pattern is taken to mean pass. This meaning was introduced in a proposal for Haskell by Simon Peyton Jones titled A new view of guards in April 1997 and was used in the implementation of the proposal. The feature provides the ability to use patterns in the guards of a pattern.

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

This would read: “Clunky for an environment and two variables, in case the lookups of the variables from the environment produce values, is the sum of the values. …” As in list comprehensions, the guards are in series, and if any of them fails the branch is not taken.

## Example

```public string Foo(string username)
{
}
// Rest of the method code follows here...
}
```