fastbloom

https://docs.rs/fastbloom/0.17.0/fastbloom/
Admin
fastbloom is a fast, flexible, and accurate Bloom filter implementation in Rust with full...
Tokens:19,083
Snippets:220
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Initialize BuilderWithBits

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithBits.html

Create a new BuilderWithBits instance with a specified number of bits or from a vector of bits. This is the starting point for configuring a Bloom filter.

```rust
use fastbloom::BloomFilter;

let builder = BloomFilter::with_num_bits(1024);
let builder = BloomFilter::from_vec(vec![0; 8]);
```

--------------------------------

### Create a Bloom filter builder with a false positive rate

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithFalsePositiveRate.html

Initialize a builder for a Bloom filter with a target false positive rate. This is the starting point for configuring a Bloom filter.

```rust
use fastbloom::BloomFilter;

let builder = BloomFilter::with_false_pos(0.01);
```

--------------------------------

### Constructing AtomicBloomFilter from a Bit Vector

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Example of creating an AtomicBloomFilter from an existing bit vector. It involves collecting the iterator of the original filter and then using `from_vec` with the same seed and number of hashes.

```rust
use fastbloom::AtomicBloomFilter;

let orig = AtomicBloomFilter::with_false_pos(0.001).seed(&42).items([1, 2].iter());
let num_hashes = orig.num_hashes();
let new = AtomicBloomFilter::from_vec(orig.iter().collect()).seed(&42).hashes(num_hashes);

assert!(new.contains(&1));
assert!(new.contains(&2));
```

--------------------------------

### Construct a Bloom filter with initial items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithFalsePositiveRate.html

Build a Bloom filter and populate it with an initial set of items. The filter's configuration is optimized based on the number of provided items to meet the false positive rate.

```rust
use fastbloom::BloomFilter;

let bloom = BloomFilter::with_false_pos(0.001).items([1, 2, 3].iter());
```

--------------------------------

### Basic BloomFilter Usage

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Demonstrates basic insertion and containment checks. Initialize with a specific number of bits and hash functions.

```rust
use fastbloom::BloomFilter;

let mut bloom = BloomFilter::with_num_bits(1024).hashes(4);
bloom.insert(&2);
assert!(bloom.contains(&2));
```

--------------------------------

### Create and Use AtomicBloomFilter

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Demonstrates the basic usage of AtomicBloomFilter, including creation, insertion of an element, and checking for its presence. This is useful for general-purpose probabilistic set membership testing.

```rust
use fastbloom::AtomicBloomFilter;

let bloom = AtomicBloomFilter::with_num_bits(1024).hashes(4);
bloom.insert(&2);
assert!(bloom.contains(&2));
```

--------------------------------

### VZip Implementation

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Provides functionality for zipping multiple lanes of data.

```APIDOC
## impl<V, T> VZip<V> for T
where V: MultiLane<T>

### Methods
#### fn vzip(self) -> V
Description: Zips the lanes of data.
```

--------------------------------

### Initialize AtomicBuilderWithBits

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Use AtomicBloomFilter::with_num_bits to create a builder with a specified number of bits. Alternatively, use AtomicBloomFilter::from_vec to initialize from a byte vector.

```rust
use fastbloom::AtomicBloomFilter;

let builder = AtomicBloomFilter::with_num_bits(1024);
let builder = AtomicBloomFilter::from_vec(vec![0; 8]);
```

--------------------------------

### Basic BloomFilter Usage

Source: https://docs.rs/fastbloom

Instantiate a BloomFilter with a specified number of bits and expected items, then insert elements.

```rust
use fastbloom::BloomFilter;

let mut filter = BloomFilter::with_num_bits(1024).expected_items(2);
filter.insert("42");
filter.insert("🦀");
```

--------------------------------

### TryFrom Implementation

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Enables attempting to convert one type into another, returning a Result.

```APIDOC
## impl<T, U> TryFrom<U> for T
where U: Into<T>

### Associated Types
#### type Error = Infallible
Description: The type returned in the event of a conversion error.

### Methods
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Description: Performs the conversion.
```

--------------------------------

### from

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Returns the argument unchanged. This is a standard conversion method.

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged.

### Method
fn

### Parameters
#### Path Parameters
- **t** (T) - Required - The value to convert.
```

--------------------------------

### clone_to_uninit

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`. Read more

### Method
unsafe fn

### Parameters
#### Path Parameters
- **dest** (*mut u8) - Required - The destination pointer.
```

--------------------------------

### TryInto Implementation

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Enables attempting to convert a type into another type, returning a Result.

```APIDOC
## impl<T, U> TryInto<U> for T
where U: TryFrom<T>

### Associated Types
#### type Error = <U as TryFrom<T>>::Error
Description: The type returned in the event of a conversion error.

### Methods
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Description: Performs the conversion.
```

--------------------------------

### Construct AtomicBloomFilter with initial items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithFalsePositiveRate.html

Consumes the builder to create an AtomicBloomFilter pre-populated with the provided items. The filter's capacity and hash count are optimized based on the number of items to meet the false positive rate.

```rust
use fastbloom::AtomicBloomFilter;

let bloom = AtomicBloomFilter::with_false_pos(0.001).items([1, 2, 3].iter());
```

--------------------------------

### into

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Calls `U::from(self)`. The conversion behavior is determined by the `From<T> for U` implementation.

```APIDOC
## fn into(self) -> U

### Description
Calls `U::from(self)`. That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### Method
fn

### Parameters
#### Path Parameters
- **self** (T) - Required - The value to convert.
```

--------------------------------

### Add fastbloom to Cargo.toml

Source: https://docs.rs/fastbloom

To use the fastbloom crate, add the following to your Cargo.toml file.

```toml
# Cargo.toml
[dependencies]
fastbloom = "0.17.0"
```

--------------------------------

### items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithFalsePositiveRate.html

Consumes this builder and constructs a `BloomFilter` containing all values in `items`. The number of hashes per item and underlying memory is optimized based on `items.len()` to meet the desired false positive rate.

```APIDOC
### pub fn items<'a, H: Hash + 'a, I: IntoIterator<IntoIter = impl ExactSizeIterator<Item = &'a H>>>( self, items: I, ) -> BloomFilter<S>

Consumes this builder and constructs a `BloomFilter` containing all values in `items`. The number of hashes per item and underlying memory is optimized based on `items.len()` to meet the desired false positive rate.

#### Examples

```rust
use fastbloom::BloomFilter;

let bloom = BloomFilter::with_false_pos(0.001).items([1, 2, 3].iter());
```
```

--------------------------------

### Construct a Bloom filter with expected items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithFalsePositiveRate.html

Create a Bloom filter by specifying the expected number of items. The filter's size and hash count are optimized for this capacity to maintain the desired false positive rate. If 0 is provided, it defaults to 1.

```rust
use fastbloom::BloomFilter;

let bloom = BloomFilter::with_false_pos(0.001).expected_items(500);
```

--------------------------------

### AtomicBuilderWithBits Methods

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

This section details the methods available on the AtomicBuilderWithBits struct for configuring and building an AtomicBloomFilter.

```APIDOC
## pub fn seed(self, seed: &u128) -> Self

### Description
Sets the seed for this builder. The later constructed Bloom filter will use this seed when hashing items.

### Method
`seed`

### Parameters
- **seed** (`&u128`) - Description: The seed value to use for hashing.

### Returns
`Self` - The builder instance with the seed set.
```

```APIDOC
## pub fn hasher<H: BuildHasher>(self, hasher: H) -> AtomicBuilderWithBits<H>

### Description
Sets the hasher for this builder. The later constructed Bloom filter will use this hasher when inserting and checking items.

### Method
`hasher`

### Parameters
- **hasher** (`H: BuildHasher`) - Description: The hasher to use for the Bloom filter.

### Returns
`AtomicBuilderWithBits<H>` - A new builder instance with the specified hasher.
```

```APIDOC
## pub fn hashes(self, num_hashes: u32) -> AtomicBloomFilter<S>

### Description
Consumes this builder, using the provided `num_hashes` to return an empty `AtomicBloomFilter`. Note: if `num_hashes` is 0, it is treated as 1. Bloom filters with 0 hashes per item are practically useless, and disallowing this case enables further optimizations.

### Method
`hashes`

### Parameters
- **num_hashes** (`u32`) - Description: The number of hash functions to use per item.

### Returns
`AtomicBloomFilter<S>` - An empty AtomicBloomFilter configured with the specified number of hashes.
```

```APIDOC
## pub fn expected_items(self, expected_items: usize) -> AtomicBloomFilter<S>

### Description
Consumes this builder, using the provided `expected_items` to return an empty `AtomicBloomFilter`. The number of hashes is optimized based on `expected_items` to maximize Bloom filter accuracy (minimize false positives chance on `AtomicBloomFilter::contains`). More or less than `expected_items` may be inserted into Bloom filter. Note: `expected_items` will internally be set to 1 if 0 is specified.

### Method
`expected_items`

### Parameters
- **expected_items** (`usize`) - Description: The expected number of items to be inserted into the Bloom filter.

### Returns
`AtomicBloomFilter<S>` - An empty AtomicBloomFilter configured for the expected number of items.
```

```APIDOC
## pub fn items<'a, H: Hash + 'a, I: IntoIterator<IntoIter = impl ExactSizeIterator<Item = &'a H>>>( self, items: I, ) -> AtomicBloomFilter<S>

### Description
Consumes this builder and constructs a `AtomicBloomFilter` containing all values in `items`. The number of hashes per item is optimized based on `items.len()` to maximize Bloom filter accuracy (minimize false positives chance on `AtomicBloomFilter::contains`).

### Method
`items`

### Parameters
- **items** (`I: IntoIterator<IntoIter = impl ExactSizeIterator<Item = &'a H>>`) - Description: An iterator over the items to insert into the Bloom filter.

### Returns
`AtomicBloomFilter<S>` - An AtomicBloomFilter populated with the provided items.
```

--------------------------------

### Create AtomicBuilderWithFalsePositiveRate with false positive rate

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithFalsePositiveRate.html

Initializes a new builder for an AtomicBloomFilter with a desired false positive rate.

```rust
use fastbloom::AtomicBloomFilter;

let builder = AtomicBloomFilter::with_false_pos(0.01);
```

--------------------------------

### BuilderWithBits Methods

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithBits.html

Methods available on the BuilderWithBits struct for configuring BloomFilter construction.

```APIDOC
## BuilderWithBits

### Description
A Bloom filter builder with an immutable number of bits. This type can be used to construct an instance of `BloomFilter` via the builder pattern.

### Methods

#### `seed(self, seed: &u128) -> Self`
Sets the seed for this builder. The later constructed Bloom filter will use this seed when hashing items.

#### `hasher<H: BuildHasher>(self, hasher: H) -> BuilderWithBits<H>`
Sets the hasher for this builder. The later constructed Bloom filter will use this hasher when inserting and checking items.

#### `hashes(self, num_hashes: u32) -> BloomFilter<S>`
Consumes this builder, using the provided `num_hashes` to return an empty `BloomFilter`. Note: if `num_hashes` is 0, it is treated as 1.

#### `expected_items(self, expected_items: usize) -> BloomFilter<S>`
Consumes this builder, using the provided `expected_items` to return an empty `BloomFilter`. The number of hashes is optimized based on `expected_items` to maximize Bloom filter accuracy.

#### `items<'a, H: Hash + 'a, I: IntoIterator<IntoIter = impl ExactSizeIterator<Item = &'a H>>>(self, items: I) -> BloomFilter<S>`
Consumes this builder and constructs a `BloomFilter` containing all values in `items`. The number of hashes per item is optimized based on `items.len()`.
```

--------------------------------

### items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithFalsePositiveRate.html

Consumes this builder and constructs a `AtomicBloomFilter` containing all values in `items`. The number of hashes per item and underlying memory is optimized based on `items.len()` to meet the desired false positive rate.

```APIDOC
## pub fn items<'a, H: Hash + 'a, I: IntoIterator<IntoIter = impl ExactSizeIterator<Item = &'a H>>>( self, items: I, ) -> AtomicBloomFilter<S>

Consumes this builder and constructs a `AtomicBloomFilter` containing all values in `items`. The number of hashes per item and underlying memory is optimized based on `items.len()` to meet the desired false positive rate.

### Examples

```rust
use fastbloom::AtomicBloomFilter;

let bloom = AtomicBloomFilter::with_false_pos(0.001).items([1, 2, 3].iter());
```
```

--------------------------------

### try_from

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Performs the conversion. The `Error` type is `Infallible`.

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion.

### Method
fn

### Parameters
#### Path Parameters
- **value** (U) - Required - The value to convert.
```

--------------------------------

### Construct AtomicBloomFilter with Initial Items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Populate a new AtomicBloomFilter with an initial set of items provided as an iterator. The number of hashes is optimized based on the number of items to maximize accuracy.

```rust
use fastbloom::AtomicBloomFilter;

let bloom = AtomicBloomFilter::with_num_bits(1024).items([1, 2, 3].iter());
```

--------------------------------

### Finalize Builder with Expected Items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithBits.html

Construct a Bloom filter by specifying the expected number of items. The number of hash functions is optimized for accuracy. If 0 is specified, it defaults to 1.

```rust
use fastbloom::BloomFilter;

let bloom = BloomFilter::with_num_bits(1024).expected_items(500);
```

--------------------------------

### AtomicBloomFilter with Custom Hasher

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Illustrates using a custom hasher (RandomState from foldhash) with AtomicBloomFilter. The filter is configured with a specific number of bits and initialized with items.

```rust
use fastbloom::AtomicBloomFilter;
use foldhash::fast::RandomState;

let filter = AtomicBloomFilter::with_num_bits(1024)
    .hasher(RandomState::default())
    .items(["42", "🦀"].iter());
```

--------------------------------

### AtomicBloomFilter::with_false_pos

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Creates a builder for constructing an AtomicBloomFilter with a target false positive rate. The memory size depends on the false positive rate and expected number of items. Panics if the false positive rate is 0.

```APIDOC
## AtomicBloomFilter::with_false_pos

### Description
Creates a new builder instance to construct a `Self` with a target false positive rate of `fp`. The memory size of the underlying bit vector is dependent on the false positive rate and the expected number of items.

### Panics
Panics if the false positive rate, `fp`, is 0.

### Examples
```
use fastbloom::AtomicBloomFilter;
let filter = AtomicBloomFilter::with_false_pos(0.001).expected_items(1000);
```
```

--------------------------------

### clone_into

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Uses borrowed data to replace owned data, usually by cloning.

```APIDOC
## fn clone_into(&self, target: &mut T)

### Description
Uses borrowed data to replace owned data, usually by cloning. Read more

### Method
fn

### Parameters
#### Path Parameters
- **self** (&self) - Required - The borrowed data.
- **target** (&mut T) - Required - The mutable reference to the owned data to be replaced.
```

--------------------------------

### Builder for AtomicBloomFilter with Number of Bits

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Demonstrates creating a builder for AtomicBloomFilter by specifying the exact number of bits for the underlying bit vector. The builder is then used to set the number of hash functions.

```rust
use fastbloom::AtomicBloomFilter;
let filter = AtomicBloomFilter::with_num_bits(1024).hashes(4);
```

--------------------------------

### Construct AtomicBloomFilter with expected items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithFalsePositiveRate.html

Consumes the builder to create an empty AtomicBloomFilter, optimizing hash count based on the expected number of items to maintain the desired false positive rate.

```rust
use fastbloom::AtomicBloomFilter;

let bloom = AtomicBloomFilter::with_false_pos(0.001).expected_items(500);
```

--------------------------------

### Builder for AtomicBloomFilter with False Positive Rate

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Shows how to create a builder for AtomicBloomFilter using a target false positive rate. This builder is then used to specify the expected number of items.

```rust
use fastbloom::AtomicBloomFilter;
let filter = AtomicBloomFilter::with_false_pos(0.001).expected_items(1000);
```

--------------------------------

### Construct AtomicBloomFilter with Expected Items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Create an AtomicBloomFilter optimized for a given number of expected items. The number of hashes is automatically determined to minimize false positives. If 0 is specified for expected items, it's internally set to 1.

```rust
use fastbloom::AtomicBloomFilter;

let bloom = AtomicBloomFilter::with_num_bits(1024).expected_items(500);
```

--------------------------------

### BloomFilter with Custom Hasher

Source: https://docs.rs/fastbloom

Configure a BloomFilter to use a custom hasher, such as `RandomState` from the `foldhash` crate, and initialize it with items.

```rust
use fastbloom::BloomFilter;
use foldhash::fast::RandomState;

let filter = BloomFilter::with_num_bits(1024)
    .hasher(RandomState::default())
    .items(["42", "🦀"].iter());
```

--------------------------------

### Builder for Number of Bits

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Creates a builder for constructing a BloomFilter with a fixed number of bits. Panics if the number of bits is 0.

```rust
use fastbloom::BloomFilter;
let filter = BloomFilter::with_num_bits(1024).hashes(4);
```

--------------------------------

### AtomicBloomFilter::with_num_bits

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Creates a builder for constructing an AtomicBloomFilter with a specified number of bits for tracking item membership. Panics if the number of bits is 0.

```APIDOC
## AtomicBloomFilter::with_num_bits

### Description
Creates a builder instance to construct a `Self` with `num_bits` number of bits for tracking item membership.

### Panics
Panics if the number of bits, `num_bits`, is 0.

### Examples
```
use fastbloom::AtomicBloomFilter;
let filter = AtomicBloomFilter::with_num_bits(1024).hashes(4);
```
```

--------------------------------

### BloomFilter with Target False Positive Rate

Source: https://docs.rs/fastbloom

Instantiate a BloomFilter by providing a target false positive rate and initializing it with an iterator of items. Asserts membership for inserted items.

```rust
use fastbloom::BloomFilter;

let filter = BloomFilter::with_false_pos(0.001).items(["42", "🦀"].iter());
assert!(filter.contains("42"));
assert!(filter.contains("🦀"));
```

--------------------------------

### TryInto<U> for T

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Provides a fallible conversion from type T to type U.

```APIDOC
## type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.

## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.

### Method
`try_into`
```

--------------------------------

### Construct AtomicBloomFilter with Number of Hashes

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Finalize the builder to create an AtomicBloomFilter using a specified number of hash functions. If 0 is provided, it's treated as 1.

```rust
use fastbloom::AtomicBloomFilter;

let bloom = AtomicBloomFilter::with_num_bits(1024).hashes(4);
```

--------------------------------

### Union of AtomicBloomFilters

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Shows how to perform a union operation between two AtomicBloomFilters. Ensure both filters have identical configurations (number of bits and hashes) to avoid panics. This operation merges the set of elements from both filters into the first one.

```rust
use fastbloom::AtomicBloomFilter;

let bloom = AtomicBloomFilter::with_num_bits(4096).seed(&1).hashes(4);
let other = AtomicBloomFilter::with_num_bits(4096).seed(&1).hashes(4);
for x in 0..=1000 {
    bloom.insert(&x);
}
for x in 500..=1500 {
    bloom.insert(&x);
}
bloom.union(&other);

for x in 0..=2000 {
    assert_eq!(bloom.contains(&x), bloom.contains(&x) || other.contains(&x));
}
```

--------------------------------

### Builder for False Positive Rate

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Creates a builder for constructing a BloomFilter with a specific false positive rate. Panics if the rate is 0.

```rust
use fastbloom::BloomFilter;
let filter = BloomFilter::with_false_pos(0.001).expected_items(1000);
```

--------------------------------

### expected_items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithFalsePositiveRate.html

Consumes this builder, using the provided `expected_items` to return an empty `BloomFilter`. The number of hashes is optimized based on `expected_items` to maximize Bloom filter accuracy.

```APIDOC
### pub fn expected_items(self, expected_items: usize) -> BloomFilter<S>

Consumes this builder, using the provided `expected_items` to return an empty `BloomFilter`. The number of hashes is optimized based on `expected_items` to maximize Bloom filter accuracy (minimize false positives chance on `BloomFilter::contains`). More or less than `expected_items` may be inserted into Bloom filter.

Note: `expected_items` will internally be set to 1 if 0 is specified.

#### Examples

```rust
use fastbloom::BloomFilter;

let bloom = BloomFilter::with_false_pos(0.001).expected_items(500);
```
```

--------------------------------

### BloomFilter::with_num_bits

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Creates a builder instance to construct a BloomFilter with a specified number of bits for tracking item membership.

```APIDOC
## BloomFilter::with_num_bits

### Description
Creates a builder instance to construct a `Self` with `num_bits` number of bits for tracking item membership.

### Panics
Panics if the number of bits, `num_bits`, is 0.

### Examples
```rust
use fastbloom::BloomFilter;
let filter = BloomFilter::with_num_bits(1024).hashes(4);
```
```

--------------------------------

### Finalize Builder with Number of Hashes

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithBits.html

Consume the builder to create a Bloom filter with a specified number of hash functions. If 0 is provided, it defaults to 1.

```rust
use fastbloom::BloomFilter;

let bloom = BloomFilter::with_num_bits(1024).hashes(4);
```

--------------------------------

### expected_items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithFalsePositiveRate.html

Consumes this builder, using the provided `expected_items` to return an empty `AtomicBloomFilter`. The number of hashes is optimized based on `expected_items` to maximize Bloom filter accuracy (minimize false positives chance on `AtomicBloomFilter::contains`). More or less than `expected_items` may be inserted into Bloom filter. Note: `expected_items` will internally be set to 1 if 0 is specified.

```APIDOC
## pub fn expected_items(self, expected_items: usize) -> AtomicBloomFilter<S>

Consumes this builder, using the provided `expected_items` to return an empty `AtomicBloomFilter`. The number of hashes is optimized based on `expected_items` to maximize Bloom filter accuracy (minimize false positives chance on `AtomicBloomFilter::contains`). More or less than `expected_items` may be inserted into Bloom filter.

Note: `expected_items` will internally be set to 1 if 0 is specified.

### Examples

```rust
use fastbloom::AtomicBloomFilter;

let bloom = AtomicBloomFilter::with_false_pos(0.001).expected_items(500);
```
```

--------------------------------

### BloomFilter Functions

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/index.html

Utility functions for Bloom filters, including `expected_density`, `expected_false_pos`, `optimal_hashes`, and `optimal_size`. These functions help in calculating and determining optimal parameters for Bloom filter configurations.

```APIDOC
## Functions

### expected_density
 Returns the probability of a “1” bit in the Bloom filter.

### expected_false_pos
 Returns the expected false positive rate of a Bloom filter.

### optimal_hashes
 Returns the optimal (for false positive rate) number of hashes to perform for an item given the expected number of items in the bloom filter.

### optimal_size
 Returns the smallest size in bits of a Bloom filter containing `num_items` items to achieve the target false positive rate.
```

--------------------------------

### AtomicBloomFilter::from_vec

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Creates a builder for constructing an AtomicBloomFilter initialized with a given bit vector. Panics if the bit vector is empty.

```APIDOC
## AtomicBloomFilter::from_vec

### Description
Creates a builder instance to construct a `Self` initialized with bit vector `bit_vec`.

### Panics
Panics if the bit vector, `bit_vec`, is empty.

### Examples
```
use fastbloom::AtomicBloomFilter;

let orig = AtomicBloomFilter::with_false_pos(0.001).seed(&42).items([1, 2].iter());
let num_hashes = orig.num_hashes();
let new = AtomicBloomFilter::from_vec(orig.iter().collect()).seed(&42).hashes(num_hashes);

assert!(new.contains(&1));
assert!(new.contains(&2));
```
```

--------------------------------

### to_owned

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Creates owned data from borrowed data, usually by cloning.

```APIDOC
## fn to_owned(&self) -> T

### Description
Creates owned data from borrowed data, usually by cloning. Read more

### Method
fn

### Parameters
#### Path Parameters
- **self** (&self) - Required - The borrowed data.
```

--------------------------------

### vzip

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Combines lanes into a zipped structure.

```APIDOC
## fn vzip(self) -> V

### Description
Combines lanes into a zipped structure.

### Method
fn

### Parameters
#### Path Parameters
- **self** (T) - Required - The lanes to zip.
```

--------------------------------

### BloomFilter::with_false_pos

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Creates a new builder instance to construct a BloomFilter with a target false positive rate. The memory size of the underlying bit vector is dependent on the false positive rate and the expected number of items.

```APIDOC
## BloomFilter::with_false_pos

### Description
Creates a new builder instance to construct a `Self` with a target false positive rate of `fp`. The memory size of the underlying bit vector is dependent on the false positive rate and the expected number of items.

### Panics
Panics if the false positive rate, `fp`, is 0.

### Examples
```rust
use fastbloom::BloomFilter;
let filter = BloomFilter::with_false_pos(0.001).expected_items(1000);
```
```

--------------------------------

### Calculate Optimal Hashes - Rust

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/fn.optimal_hashes.html

Returns the optimal number of hashes for a bloom filter given the total number of bits and the expected number of items. This is used to achieve the lowest possible false positive rate.

```rust
pub fn optimal_hashes(num_bits: usize, num_items: usize) -> u32
```

--------------------------------

### TryFrom<U> for T

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Provides a fallible conversion from type U to type T.

```APIDOC
## type Error = Infallible

### Description
The type returned in the event of a conversion error.

## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion.

### Method
`try_from`
```

--------------------------------

### Extend

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Enables extending the Bloom filter with items from an iterator.

```APIDOC
## Extend

### Description
Enables extending the Bloom filter with items from an iterator.

### Method
`fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)`
```

--------------------------------

### try_into

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Performs the conversion. The `Error` type is determined by the `TryFrom<T>` implementation for `U`.

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.

### Method
fn

### Parameters
#### Path Parameters
- **self** (T) - Required - The value to convert.
```

--------------------------------

### ToOwned Implementation

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Provides methods for creating owned data from borrowed data.

```APIDOC
## impl<T> ToOwned for T
where T: Clone

### Associated Types
#### type Owned = T
Description: The resulting type after obtaining ownership.

### Methods
#### fn to_owned(&self) -> T
Description: Creates owned data from borrowed data, usually by cloning.

#### fn clone_into(&self, target: &mut T)
Description: Uses borrowed data to replace owned data, usually by cloning.
```

--------------------------------

### Set a custom hasher for the Bloom filter builder

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithFalsePositiveRate.html

Specify a custom hasher for the Bloom filter. This allows using different hashing algorithms or states for better performance or specific requirements.

```rust
use fastbloom::BloomFilter;
use foldhash::fast::RandomState;

let bloom = BloomFilter::with_false_pos(0.001).hasher(RandomState::default()).expected_items(100);
```

--------------------------------

### PartialEq

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Tests for equality between two AtomicBloomFilter instances.

```APIDOC
## PartialEq

### Description
Tests for equality between two AtomicBloomFilter instances.

### Method
`fn eq(&self, other: &Self) -> bool`

### Returns
`true` if `self` and `other` are equal, `false` otherwise.
```

```APIDOC
## ne

### Description
Tests for inequality between two AtomicBloomFilter instances.

### Method
`fn ne(&self, other: &Rhs) -> bool`

### Returns
`true` if `self` and `other` are not equal, `false` otherwise.
```

--------------------------------

### Set Seed for AtomicBuilderWithBits

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithBits.html

Configure the seed for the builder, which will be used by the constructed Bloom filter for hashing items. This method returns the builder itself for further chaining.

```rust
use fastbloom::AtomicBloomFilter;

let bloom = AtomicBloomFilter::with_num_bits(1024).seed(&1).hashes(4);
```

--------------------------------

### TryFrom and TryInto Traits

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithFalsePositiveRate.html

These traits facilitate fallible type conversions. `TryFrom` attempts to convert a source type into a target type, returning a `Result`. `TryInto` is the inverse operation.

```APIDOC
## TryFrom and TryInto Traits

### Description
Facilitates fallible type conversions. `TryFrom` attempts to convert a source type into a target type, returning a `Result`. `TryInto` is the inverse operation.

### TryFrom<U> for T

#### Associated Types
- `type Error = Infallible`: The type returned in the event of a conversion error.

#### Methods
- `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`: Performs the conversion.

### TryInto<U> for T

#### Associated Types
- `type Error = <U as TryFrom<T>>::Error`: The type returned in the event of a conversion error.

#### Methods
- `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`: Performs the conversion.
```

--------------------------------

### BloomFilter Structs

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/index.html

Provides definitions for various Bloom filter structures, including AtomicBloomFilter, AtomicBuilderWithBits, AtomicBuilderWithFalsePositiveRate, BloomFilter, BuilderWithBits, and BuilderWithFalsePositiveRate. These structs represent different ways to implement and build Bloom filters with varying characteristics.

```APIDOC
## Structs

### AtomicBloomFilter
 A space efficient approximate membership set data structure. False positives from `contains` are possible, but false negatives are not, i.e. `contains` for all items in the set is guaranteed to return true, while `contains` for all items not in the set probably return false.

### AtomicBuilderWithBits
 A Bloom filter builder with an immutable number of bits.

### AtomicBuilderWithFalsePositiveRate
 A Bloom filter builder with an immutable false positive rate.

### BloomFilter
 A space efficient approximate membership set data structure. False positives from `contains` are possible, but false negatives are not, i.e. `contains` for all items in the set is guaranteed to return true, while `contains` for all items not in the set probably return false.

### BuilderWithBits
 A Bloom filter builder with an immutable number of bits.

### BuilderWithFalsePositiveRate
 A Bloom filter builder with an immutable false positive rate.
```

--------------------------------

### BloomFilter::from_vec

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Creates a builder instance to construct a BloomFilter initialized with a provided bit vector.

```APIDOC
## BloomFilter::from_vec

### Description
Creates a builder instance to construct a `Self` initialized with bit vector `bit_vec`.

### Panics
Panics if the bit vector, `bit_vec`, is empty.

### Examples
```rust
use fastbloom::BloomFilter;

let orig = BloomFilter::with_false_pos(0.001).seed(&42).items([1, 2].iter());
let num_hashes = orig.num_hashes();
let new = BloomFilter::from_vec(orig.iter().collect()).seed(&42).hashes(num_hashes);

assert!(new.contains(&1));
assert!(new.contains(&2));
```
```

--------------------------------

### Clone

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Provides functionality to create a duplicate of an AtomicBloomFilter.

```APIDOC
## Clone

### Description
Provides functionality to create a duplicate of an AtomicBloomFilter.

### Method
`fn clone(&self) -> AtomicBloomFilter<S>`

### Returns
Returns a duplicate of the value.
```

```APIDOC
## clone_from

### Description
Performs copy-assignment from `source`.

### Method
`fn clone_from(&mut self, source: &Self)`
```

--------------------------------

### Bloom Filter Structures

Source: https://docs.rs/fastbloom

Provides definitions for various Bloom filter structures, including atomic and standard versions, and their builders.

```APIDOC
## Structs

### AtomicBloomFilter
    A space efficient approximate membership set data structure. False positives from `contains` are possible, but false negatives are not, i.e. `contains` for all items in the set is guaranteed to return true, while `contains` for all items not in the set probably return false.

### AtomicBuilderWithBits
    A Bloom filter builder with an immutable number of bits.

### AtomicBuilderWithFalsePositiveRate
    A Bloom filter builder with an immutable false positive rate.

### BloomFilter
    A space efficient approximate membership set data structure. False positives from `contains` are possible, but false negatives are not, i.e. `contains` for all items in the set is guaranteed to return true, while `contains` for all items not in the set probably return false.

### BuilderWithBits
    A Bloom filter builder with an immutable number of bits.

### BuilderWithFalsePositiveRate
    A Bloom filter builder with an immutable false positive rate.
```

--------------------------------

### Finalize Builder with Iterator of Items

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithBits.html

Create a Bloom filter populated with items from an iterator. The number of hash functions is optimized based on the number of items for maximum accuracy.

```rust
use fastbloom::BloomFilter;

let bloom = BloomFilter::with_num_bits(1024).items([1, 2, 3].iter());
```

--------------------------------

### Set Seed for Builder

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithBits.html

Configure the seed for the Bloom filter builder. The constructed Bloom filter will use this seed for hashing items.

```rust
use fastbloom::BloomFilter;

let bloom = BloomFilter::with_num_bits(1024).seed(&1).hashes(4);
```

--------------------------------

### From<T> for T

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithBits.html

Implementation of the From trait for a type T, allowing conversion from T to T. This is a trivial conversion that returns the argument unchanged.

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged.

### Signature
```rust
fn from(t: T) -> T
```
```

--------------------------------

### hasher

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithFalsePositiveRate.html

Sets the hasher for this builder. The later constructed `AtomicBloomFilter` will use this hasher when inserting and checking items.

```APIDOC
## pub fn hasher<H: BuildHasher>( self, hasher: H, ) -> AtomicBuilderWithFalsePositiveRate<H>

Sets the hasher for this builder. The later constructed `AtomicBloomFilter` will use this hasher when inserting and checking items.

### Examples

```rust
use fastbloom::AtomicBloomFilter;
use foldhash::fast::RandomState;

let bloom = AtomicBloomFilter::with_false_pos(0.001).hasher(RandomState::default()).expected_items(100);
```
```

--------------------------------

### BloomFilter from Existing Bit Vector

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Constructs a BloomFilter from an existing vector of u64, representing the bit vector. Panics if the vector is empty. This is useful for serialization and deserialization.

```rust
use fastbloom::BloomFilter;

let orig = BloomFilter::with_false_pos(0.001).seed(&42).items([1, 2].iter());
let num_hashes = orig.num_hashes();
let new = BloomFilter::from_vec(orig.iter().collect()).seed(&42).hashes(num_hashes);

assert!(new.contains(&1));
assert!(new.contains(&2));
```

--------------------------------

### TryInto<U> for T

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithFalsePositiveRate.html

The `TryInto<U>` trait provides a fallible conversion from `T` to `U`, leveraging the `TryFrom<T>` implementation for `U`. It defines an associated `Error` type and a `try_into` method.

```APIDOC
## type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
```

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
```

--------------------------------

### Bloom Filter Functions

Source: https://docs.rs/fastbloom

Utility functions for calculating Bloom filter properties such as expected density, false positive rate, and optimal parameters.

```APIDOC
## Functions

### expected_density
    Returns the probability of a “1” bit in the Bloom filter.

### expected_false_pos
    Returns the expected false positive rate of a Bloom filter.

### optimal_hashes
    Returns the optimal (for false positive rate) number of hashes to perform for an item given the expected number of items in the bloom filter.

### optimal_size
    Returns the smallest size in bits of a Bloom filter containing `num_items` items to achieve the target false positive rate.
```

--------------------------------

### Checking Membership in AtomicBloomFilter

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Shows how to check if an element is possibly present in the AtomicBloomFilter. The filter is initialized with a number of bits and then used to check for inserted items.

```rust
use fastbloom::AtomicBloomFilter;

let bloom = AtomicBloomFilter::with_num_bits(1024).items([1, 2, 3].iter());
assert!(bloom.contains(&1));
```

--------------------------------

### Calculate Optimal Bloom Filter Size

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/fn.optimal_size.html

Returns the smallest size in bits of a Bloom filter containing `num_items` items to achieve the target false positive rate.

```rust
pub fn optimal_size(num_items: usize, fp: f64) -> usize
```

--------------------------------

### expected_density

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/fn.expected_density.html

Calculates the probability of a '1' bit in the Bloom filter given the number of hashes, bits, and items.

```APIDOC
## expected_density

### Description
Returns the probability of a “1” bit in the Bloom filter.

### Signature
```rust
pub fn expected_density(hashes: u32, bits: usize, items: usize) -> f64
```

### Parameters
* `hashes` (u32) - The number of hash functions used.
* `bits` (usize) - The total number of bits in the Bloom filter.
* `items` (usize) - The number of items inserted into the Bloom filter.

### Returns
* `f64` - The probability of a '1' bit.
```

--------------------------------

### TryInto<U> for T

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithBits.html

Implementation of the TryInto trait for a type T, allowing fallible conversion into a type U, provided that U implements TryFrom<T>. This method attempts the conversion and returns a Result.

```APIDOC
## type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.

### Type Alias
```rust
type Error = <U as TryFrom<T>>::Error
```
```

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion from T to U. Returns a Result indicating success or failure.

### Signature
```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```
```

--------------------------------

### hasher

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithFalsePositiveRate.html

Sets the hasher for this builder. The later constructed `BloomFilter` will use this hasher when inserting and checking items.

```APIDOC
## impl<S: BuildHasher> BuilderWithFalsePositiveRate<S>

### pub fn hasher<H: BuildHasher>( self, hasher: H, ) -> BuilderWithFalsePositiveRate<H>

Sets the hasher for this builder. The later constructed `BloomFilter` will use this hasher when inserting and checking items.

#### Examples

```rust
use fastbloom::BloomFilter;
use foldhash::fast::RandomState;

let bloom = BloomFilter::with_false_pos(0.001).hasher(RandomState::default()).expected_items(100);
```
```

--------------------------------

### optimal_hashes

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/fn.optimal_hashes.html

Returns the optimal (for false positive rate) number of hashes to perform for an item given the expected number of items in the bloom filter.

```APIDOC
## optimal_hashes

### Description
Returns the optimal (for false positive rate) number of hashes to perform for an item given the expected number of items in the bloom filter.

### Signature
```rust
pub fn optimal_hashes(num_bits: usize, num_items: usize) -> u32
```

### Parameters
* `num_bits` (usize) - The total number of bits in the Bloom filter.
* `num_items` (usize) - The expected number of items to be inserted into the Bloom filter.
```

--------------------------------

### optimal_size

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/fn.optimal_size.html

Returns the smallest size in bits of a Bloom filter containing `num_items` items to achieve the target false positive rate.

```APIDOC
## optimal_size

### Description
Returns the smallest size in bits of a Bloom filter containing `num_items` items to achieve the target false positive rate.

### Signature
```rust
pub fn optimal_size(num_items: usize, fp: f64) -> usize
```

### Parameters
#### Path Parameters
- **num_items** (usize) - The number of items the Bloom filter is expected to hold.
- **fp** (f64) - The target false positive rate (e.g., 0.01 for 1%).

### Returns
- **usize** - The smallest size in bits for the Bloom filter.
```

--------------------------------

### BloomFilter::insert_all

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BloomFilter.html

Inserts all the items in an iterator into the Bloom filter.

```APIDOC
## BloomFilter::insert_all

### Description
Inserts all the items in `iter` into the `self` Bloom filter.

### Method
`insert_all`

### Parameters
- `iter` (I: IntoIterator<Item = &'a T>) - An iterator yielding elements to be inserted. Each element `T` must implement `Hash`.
```

--------------------------------

### VZip<V> for T

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithFalsePositiveRate.html

The `VZip<V>` trait is implemented for type `T` where `V` is a `MultiLane<T>`. It provides a `vzip` method to create a `V` from `self`.

```APIDOC
## fn vzip(self) -> V


```

--------------------------------

### VZip<V> for T

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithBits.html

Implementation of the VZip trait for a type T, where V is a MultiLane<T>. This provides a method to perform a 'vzip' operation.

```APIDOC
## fn vzip(self) -> V

### Description
Performs the vzip operation, returning a value of type V.

### Signature
```rust
fn vzip(self) -> V
```
```

--------------------------------

### Set custom hasher for AtomicBuilderWithFalsePositiveRate

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBuilderWithFalsePositiveRate.html

Assigns a custom hasher to the builder. The constructed Bloom filter will use this hasher for all hashing operations.

```rust
use fastbloom::AtomicBloomFilter;
use foldhash::fast::RandomState;

let bloom = AtomicBloomFilter::with_false_pos(0.001).hasher(RandomState::default()).expected_items(100);
```

--------------------------------

### Set the seed for the Bloom filter builder

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithFalsePositiveRate.html

Configure the seed for the Bloom filter. The seed is used by the hashing functions when inserting and checking for items.

```rust
use fastbloom::BloomFilter;

let bloom = BloomFilter::with_false_pos(0.001).seed(&1).expected_items(100);
```

--------------------------------

### VZip<V> for T

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.AtomicBloomFilter.html

Provides a zipping operation for types that support MultiLane.

```APIDOC
## fn vzip(self) -> V

### Description
Performs a zipping operation.

### Method
`vzip`
```

--------------------------------

### seeded

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/type.DefaultHasher.html

Creates a new instance of DefaultHasher with a specific seed.

```APIDOC
## impl DefaultHasher

### pub fn seeded(seed: &[u8; 16]) -> Self

Creates a new `DefaultHasher` initialized with the provided 16-byte seed.
```

--------------------------------

### BuilderWithFalsePositiveRate

Source: https://docs.rs/fastbloom/0.17.0/fastbloom/struct.BuilderWithFalsePositiveRate.html

A Bloom filter builder with an immutable false positive rate. This type can be used to construct an instance of `BloomFilter` via the builder pattern.

```APIDOC
## Struct BuilderWithFalsePositiveRate

```rust
pub struct BuilderWithFalsePositiveRate<S = DefaultHasher> { /* private fields */ }
```

A Bloom filter builder with an immutable false positive rate.
This type can be used to construct an instance of `BloomFilter` via the builder pattern.

### Examples

```rust
use fastbloom::BloomFilter;

let builder = BloomFilter::with_false_pos(0.01);
```
```
Tokens:
Raw