fn not<'t, I>(self, patterns: I) -> Result<Not<Self>, BuildError>
    where
        Self: Sized,
        I: IntoIterator,
        I::Item: Pattern<'t>,
    {
        FilterAny::any(patterns).map(|filter| Not {
            input: self,
            filter,
        })
    }
Filters file entries against negated glob expressions.

This function constructs a combinator that discards files with paths
that match **any** of the given glob expressions. When matching a
[`Glob`] against a directory tree, this allows for broad negations
that cannot be achieved using a positive glob expression alone.

The combinator does **not** read directory trees from the file system
when a directory matches an [exhaustive glob
expression][`Program::is_exhaustive`] such as `**/private/**`
or `hidden/<<?>/>*`.

**Prefer this combinator over matching each file entry against
[`Program`]s, since it avoids potentially large and unnecessary
reads.**

# Errors

Returns an error if any of the inputs fail to build. If the inputs are a
compiled [`Program`] type such as [`Glob`], then this only occurs if
the compiled program is too large (i.e., there are too many
component patterns).

# Examples

Because glob expressions do not support general negations, it is
sometimes impossible to express patterns that deny particular paths.
In such cases, `not` can be used to apply additional patterns as a
filter.

```rust,no_run
use wax::walk::FileIterator;
use wax::Glob;

// Find image files, but not if they are beneath a directory with a name that suggests that
// they are private.
let glob = Glob::new("**/*.(?i){jpg,jpeg,png}").unwrap();
for entry in glob.walk(".").not(["**/(?i)<.:0,1>private/**"]).unwrap() {
let entry = entry.unwrap();
// ...
}
```

[`Glob`]: crate::Glob
[`Iterator::filter`]: std::iter::Iterator::filter
[`Program`]: crate::Program
[`Program::is_exhaustive`]: crate::Program::is_exhaustive
crates/turborepo-wax/src/walk/mod.rs