---
name: boolean logic tutorial
---
# Boolean Logic for Perl Programmers — a tutorial

Almost every line of working Perl is shaped by boolean logic.
`open ... or die`, `$h{$k} //= []`, `unless ($a == $b && $c eq $d)`,
`/^(yes|no)$/`, `$flags & 0x4` — they are all the same handful of
operations applied in different domains. This tutorial walks
through those operations from the bottom up: what truth means in
Perl, what the operators actually return, all sixteen binary truth
functions and how to spell each one in Perl, the two laws that turn
convoluted conditions into simple ones, and the three places that
logic shows up most: bitwise arithmetic, regular expressions, and
control flow.

## Who this is for

You already write working Perl. You use `&&`, `||`, `if`, `unless`
without thinking — but when a condition grows past three or four
clauses you stop trusting it, and you reach for parentheses you
suspect are not needed. This tutorial closes that gap. After
reading it, you will know exactly which logical operation a given
expression performs, why two seemingly different forms are the same
expression, and how to reduce a tangled `unless` to a clean `if`
with confidence rather than by trial and error.

## Scope

Classical two-valued boolean logic — true and false, full stop.
Perl's `undef` introduces a third value (the *unknown*) and a whole
family of three-valued idioms (`defined`, `//`, `//=`). Those are
mentioned where they intersect with two-valued logic, but a proper
treatment of three-valued logic would double the size of this
tutorial without finishing it; that is a separate guide.

## How this tutorial is organised

Each chapter is one concept. Read them in order on the first pass;
jump to the relevant chapter later when you are looking up a fact.

```{toctree}
:maxdepth: 1

truthiness
operators
truth-tables
de-morgan
functional-completeness
applications
```

## What you will be able to do after reading

- Look at any boolean expression in Perl source and name the
  truth function it computes.
- Convert between the four equivalent shapes of an implication
  (`a → b`, `!a || b`, `!(a && !b)`, the contrapositive) without
  having to think.
- Reduce an `unless` with two negated subclauses to a flat `if`
  in one mechanical step.
- Recognise when a regex alternation is a logical OR over sets
  and when a lookaround pair is a logical AND, and use that
  framing to read complicated regexes.
- Use the bitwise operators to set, clear, toggle and test
  individual flags without consulting a reference.
- Pick the right short-circuit idiom (`||`, `//`, `||=`, `//=`,
  `or die`) for the situation, knowing why each one works.