### Serialize and Deserialize with Serde

Source: https://context7.com/ptal/intervallum/llms.txt

Convert intervals and sets to JSON format and back using Serde. Empty intervals are represented as null.

```rust
use interval::prelude::*;
use serde::{Serialize, Deserialize};

// Intervals serialize as tuples [lower, upper]
let interval = Interval::new(10, 20);
let json = serde_json::to_string(&interval).unwrap();
assert_eq!(json, "[10,20]");

// Empty intervals serialize as null
let empty = Interval::<i32>::empty();
let json = serde_json::to_string(&empty).unwrap();
assert_eq!(json, "null");

// Interval sets serialize as arrays of intervals
let set = [(1, 3), (5, 7)].to_interval_set();
let json = serde_json::to_string(&set).unwrap();
// Produces: [[1,3],[5,7]]

// Deserialize back
let parsed: IntervalSet<i32> = serde_json::from_str(&json).unwrap();
assert_eq!(parsed, set);
```

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

### Creating Interval Sets

Source: https://context7.com/ptal/intervallum/llms.txt

Create interval sets to represent discontinuous ranges with exact precision.

```APIDOC
## Creating Interval Sets

### Description
Create interval sets to represent discontinuous ranges with exact precision.

### Methods
- `to_interval_set()` (from array of tuples)
- `IntervalSet::new(lower: T, upper: T)`
- `IntervalSet::singleton(value: T)`
- `IntervalSet::empty()`

### Parameters
#### `to_interval_set`
- **self** (`&[(T, T)]`)

#### `IntervalSet::new`
- **lower** (`T`): The lower bound of the interval.
- **upper** (`T`): The upper bound of the interval.

#### `IntervalSet::singleton`
- **value** (`T`): The single value to create an interval set from.

### Request Example
```rust
use interval::prelude::*

let set_from_tuples = [(1, 2), (6, 10)].to_interval_set();
let set_new = IntervalSet::new(0, 10);
let singleton_set = IntervalSet::singleton(5);
let empty_set = IntervalSet::<i32>::empty();
```

### Response
#### Success Response (IntervalSet)
- **result** (`IntervalSet<T>`)

### Response Example
```json
{
  "result": "{[1, 2], [6, 10]}"
}
```
```

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

### Creating Intervals

Source: https://context7.com/ptal/intervallum/llms.txt

Construct intervals using ranges, singletons, empty states, or the full representable range of an integer type.

```rust
use interval::prelude::*;

// Create an interval from lower to upper bound (inclusive)
let range = Interval::new(3, 8);
assert_eq!(range.lower(), 3);
assert_eq!(range.upper(), 8);
assert!(range.contains(&5));

// Create a singleton interval containing one value
let single = Interval::singleton(5);
assert_eq!(single.size(), 1u32);
assert_eq!(single.lower(), single.upper());

// Create an empty interval
let empty = Interval::<i32>::empty();
assert!(empty.is_empty());
assert_eq!(empty.size(), 0);

// Create the whole representable interval
let whole_u8 = Interval::<u8>::whole();
assert_eq!(whole_u8, Interval::new(0, 254)); // Note: max_value - 1

let whole_i8 = Interval::<i8>::whole();
assert_eq!(whole_i8, Interval::new(-127, 127)); // Note: min_value + 1
```

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

### Perform Interval Arithmetic

Source: https://context7.com/ptal/intervallum/llms.txt

Intervals support addition, subtraction, and multiplication. Addition and subtraction are straightforward, while multiplication may over-approximate the actual resulting range. Empty intervals propagate through operations.

```rust
use interval::prelude::*;

// Addition: adds bounds
let a = Interval::new(5, 9);
let b = Interval::new(-2, 4);
assert_eq!(a + b, Interval::new(3, 13));

// Addition with constant
assert_eq!(Interval::new(5, 9) + 4, Interval::new(9, 13));

// Subtraction: a.lower - b.upper to a.upper - b.lower
let c = Interval::new(5, 9);
let d = Interval::new(-2, 4);
assert_eq!(c - d, Interval::new(1, 11));

// Subtraction with constant
assert_eq!(Interval::new(5, 9) - 4, Interval::new(1, 5));

// Multiplication (may over-approximate)
let e = Interval::new(0, 1);
let f = Interval::new(3, 5);
assert_eq!(e * f, Interval::new(0, 5)); // Only 0,3,4,5 are actual results

// Empty intervals propagate
assert!((Interval::empty() + Interval::new(2, 4)).is_empty());
```

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

### Create Interval Sets

Source: https://context7.com/ptal/intervallum/llms.txt

Construct `IntervalSet` objects to represent discontinuous ranges. Sets can be created from arrays of tuples, single ranges, singletons, or as empty sets. Adjacent intervals in the source data are automatically merged.

```rust
use interval::prelude::*;

// Create from array of tuples
let set = [(1, 2), (6, 10)].to_interval_set();
assert_eq!(set.interval_count(), 2);

// Create from single range
let single = IntervalSet::new(0, 10);
assert!(single.contains(&5));

// Create singleton
let one = IntervalSet::singleton(5);
assert_eq!(one.size(), 1u32);

// Create empty set
let empty = IntervalSet::<i32>::empty();
assert!(empty.is_empty());

// Adjacent intervals are automatically merged
let merged = [(1, 5), (2, 8)].to_interval_set();
assert_eq!(merged.interval_count(), 1);
assert_eq!(merged.lower(), 1);
assert_eq!(merged.upper(), 8);
```

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

### Interval Arithmetic Operations

Source: https://context7.com/ptal/intervallum/llms.txt

Perform addition, subtraction, and multiplication on intervals.

```APIDOC
## Interval Arithmetic Operations

### Description
Perform addition, subtraction, and multiplication on intervals.

### Method
- `+` (addition)
- `-` (subtraction)
- `*` (multiplication)

### Parameters
#### Binary Operations
- **self** (`Interval<T>`)
- **other** (`Interval<T>` or `T`)

### Request Example
```rust
use interval::prelude::*

let a = Interval::new(5, 9);
let b = Interval::new(-2, 4);
let sum = a + b;
let diff = a - b;
let prod = Interval::new(0, 1) * Interval::new(3, 5);
```

### Response
#### Success Response (Interval)
- **result** (`Interval<T>`)

### Response Example
```json
{
  "result": "[3, 13]" 
}
```
```

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

### Perform Interval Set Arithmetic

Source: https://context7.com/ptal/intervallum/llms.txt

Applies arithmetic operations like addition, subtraction, and multiplication to interval sets.

```rust
use interval::prelude::*;

let a = [(1, 2), (5, 6)].to_interval_set();
let b = [(1, 1), (4, 5)].to_interval_set();

// Addition: all pairwise sums
let sum = &a + &b;
assert_eq!(sum, [(2, 3), (5, 7), (9, 11)].to_interval_set());

// Add constant
assert_eq!([(3, 3), (7, 8)].to_interval_set() + 2, [(5, 5), (9, 10)].to_interval_set());

// Subtraction with constant
assert_eq!([(3, 3), (7, 8)].to_interval_set() - 2, [(1, 1), (5, 6)].to_interval_set());

// Multiplication (may over-approximate)
let c = [(1, 2), (5, 6)].to_interval_set();
let d = [(0, 0), (3, 4)].to_interval_set();
assert_eq!(&c * &d, [(0, 0), (3, 8), (15, 24)].to_interval_set());
```

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

### Interval Set Operations Checking

Source: https://context7.com/ptal/intervallum/llms.txt

Check containment, subset relations, and overlap between intervals.

```APIDOC
## Interval Set Operations Checking

### Description
Check containment, subset relations, and overlap between intervals.

### Methods
- `contains(&self, value: &T)`
- `is_subset(&self, other: &Interval<T>)`
- `is_proper_subset(&self, other: &Interval<T>)`
- `overlap(&self, other: &Interval<T>)`
- `is_disjoint(&self, other: &Interval<T>)`

### Parameters
#### `contains`
- **self** (`Interval<T>`)
- **value** (`&T`)

#### `is_subset`, `is_proper_subset`, `overlap`, `is_disjoint`
- **self** (`Interval<T>`)
- **other** (`&Interval<T>`)

### Request Example
```rust
use interval::prelude::*

let interval = Interval::new(1, 4);
interval.contains(&3);

Interval::new(6, 7).is_subset(&Interval::new(3, 7));
Interval::new(1, 5).overlap(&Interval::new(3, 4));
Interval::new(8, 9).is_disjoint(&Interval::new(1, 2));
```

### Response
#### Success Response (Boolean)
- **result** (`bool`)

### Response Example
```json
{
  "result": true
}
```
```

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

### Calculate Interval Set Complement

Source: https://context7.com/ptal/intervallum/llms.txt

Computes the complement of an interval set relative to the whole range.

```rust
use interval::prelude::*;

let neg_inf = IntervalSet::<i32>::whole().lower();
let pos_inf = IntervalSet::<i32>::whole().upper();

// Complement of singleton
let single = IntervalSet::singleton(5);
assert_eq!(single.complement(), [(neg_inf, 4), (6, pos_inf)].to_interval_set());

// Complement of multiple intervals
let multi = [(2, 5), (8, 10)].to_interval_set();
let expected = [(neg_inf, 1), (6, 7), (11, pos_inf)].to_interval_set();
assert_eq!(multi.complement(), expected);

// Complement of empty is whole
assert_eq!(IntervalSet::<i64>::empty().complement(), IntervalSet::whole());
```

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

### Check Interval Set Operations

Source: https://context7.com/ptal/intervallum/llms.txt

Verify containment of values within an interval, check if one interval is a subset (or proper subset) of another, and determine if intervals overlap or are disjoint. These operations are crucial for range comparisons.

```rust
use interval::prelude::*;

// Check if interval contains a value
let interval = Interval::new(1, 4);
assert!(interval.contains(&1));
assert!(interval.contains(&3));
assert!(!interval.contains(&0));
assert!(!interval.contains(&5));

// Check subset relationship
assert!(Interval::new(6, 7).is_subset(&Interval::new(3, 7)));
assert!(Interval::empty().is_subset(&Interval::new(5, 8)));
assert!(!Interval::new(1, 4).is_subset(&Interval::new(2, 6)));

// Check proper subset (subset but not equal)
assert!(Interval::new(6, 7).is_proper_subset(&Interval::new(3, 7)));
assert!(!Interval::new(5, 8).is_proper_subset(&Interval::new(5, 8)));

// Check overlap/disjoint
assert!(Interval::new(1, 5).overlap(&Interval::new(3, 4)));
assert!(Interval::new(3, 5).overlap(&Interval::new(5, 7)));
assert!(Interval::new(8, 9).is_disjoint(&Interval::new(1, 2)));
```

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

### Extend Interval Sets in Rust

Source: https://context7.com/ptal/intervallum/llms.txt

Dynamically add intervals to an existing set. Overlapping intervals are automatically merged.

```rust
use interval::prelude::*;

let mut set = IntervalSet::<u32>::empty();
assert!(set.is_empty());

// Extend with intervals
set.extend([Interval::new(2, 3), Interval::new(6, 7)]);
assert_eq!(set, [(2, 3), (6, 7)].to_interval_set());

// Extending with overlapping intervals merges them
set.extend([Interval::singleton(4), Interval::singleton(5)]);
assert_eq!(set, [(2, 7)].to_interval_set());
```

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

### Check Interval Set Subset and Overlap

Source: https://context7.com/ptal/intervallum/llms.txt

Verifies subset relationships and checks for overlaps or disjoint sets.

```rust
use interval::prelude::*;

let set = [(3, 3), (7, 8)].to_interval_set();

// Subset checks
assert!(set.is_subset(&[(3, 8)].to_interval_set()));
assert!(set.is_subset(&[(3, 4), (7, 9)].to_interval_set()));
assert!(!set.is_subset(&[(3, 3)].to_interval_set()));

// Proper subset (subset but not equal)
assert!(set.is_proper_subset(&[(3, 8)].to_interval_set()));
assert!(!set.is_proper_subset(&set));

// Overlap and disjoint
let a = [(1, 3), (7, 8)].to_interval_set();
let b = [(4, 6)].to_interval_set();
assert!(!a.overlap(&b));
assert!(a.is_disjoint(&b));

let c = [(1, 3)].to_interval_set();
let d = [(3, 4), (8, 10)].to_interval_set();
assert!(c.overlap(&d));
assert!(!c.is_disjoint(&d));
```

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

### Calculate Interval Difference

Source: https://context7.com/ptal/intervallum/llms.txt

Use the `difference` method to find values present in the first interval but not in the second. The result is the smallest interval that covers these unique values. Handles cases like complete subtraction resulting in an empty interval.

```rust
use interval::prelude::*;

// Difference removes overlap
let a = Interval::new(4, 9);
let b = Interval::new(6, 11);
assert_eq!(a.difference(&b), Interval::new(4, 5));

// Difference from boundary
let c = Interval::new(4, 7);
let d = Interval::new(4, 5);
assert_eq!(c.difference(&d), Interval::new(6, 7));

// Complete subtraction yields empty
let e = Interval::new(2, 3);
let f = Interval::new(1, 10);
assert_eq!(e.difference(&f), Interval::empty());

// Difference with a single value
let g = Interval::new(4, 9);
assert_eq!(g.difference(&4), Interval::new(5, 9)); // Remove lower bound
assert_eq!(g.difference(&9), Interval::new(4, 8)); // Remove upper bound
assert_eq!(g.difference(&5), Interval::new(4, 9)); // Middle values: no effect
```

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

### Calculating Interval Hull

Source: https://context7.com/ptal/intervallum/llms.txt

Find the smallest interval containing two input intervals, noting that this may result in an over-approximation.

```rust
use interval::prelude::*;

// Hull of adjacent intervals
let a = Interval::new(1, 3);
let b = Interval::new(5, 8);
assert_eq!(a.hull(&b), Interval::new(1, 8)); // Over-approximation: includes 4

// Hull includes all values between
let c = Interval::new(1, 6);
let d = Interval::new(4, 7);
assert_eq!(c.hull(&d), Interval::new(1, 7));

// Hull with contained interval
let e = Interval::new(3, 9);
let f = Interval::new(5, 6);
assert_eq!(e.hull(&f), Interval::new(3, 9));

// Hull with a single value
let g = Interval::new(5, 8);
assert_eq!(g.hull(&3), Interval::new(3, 8));
assert_eq!(Interval::empty().hull(&5), Interval::singleton(5));
```

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

### Interval Set Union

Source: https://context7.com/ptal/intervallum/llms.txt

Calculate the union of two interval sets, combining all values.

```APIDOC
## Interval Set Union

### Description
Calculate the union of two interval sets, combining all values.

### Methods
- `union(&self, other: &IntervalSet<T>)`
- `union(&self, value: T)`

### Parameters
#### `union` (with IntervalSet)
- **self** (`&IntervalSet<T>`)
- **other** (`&IntervalSet<T>`): The other interval set to union with.

#### `union` (with value)
- **self** (`&IntervalSet<T>`)
- **value** (`T`): The value to add to the interval set.

### Request Example
```rust
use interval::prelude::*

let a = [(1, 2), (6, 10)].to_interval_set();
let b = [(3, 5), (7, 7)].to_interval_set();
let union_sets = a.union(&b);

let set = [(1, 4), (6, 7)].to_interval_set();
let union_with_value_10 = set.union(&10);
let union_with_value_5 = set.union(&5);
```

### Response
#### Success Response (IntervalSet)
- **result** (`IntervalSet<T>`)

### Response Example
```json
{
  "result": "{[1, 5], [6, 10]}"
}
```
```

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

### Shrink Interval Bounds

Source: https://context7.com/ptal/intervallum/llms.txt

Use `shrink_left` to increase the lower bound and `shrink_right` to decrease the upper bound of an interval. If the new bound exceeds the opposite bound, the interval becomes empty. Shrinking with a value smaller than the current bound has no effect.

```rust
use interval::prelude::*;

let a = Interval::new(5, 9);

// Shrink left: increase lower bound
let b = a.shrink_left(7);
assert_eq!(b, Interval::new(7, 9));

// No effect if new bound is smaller
let c = a.shrink_left(4);
assert_eq!(c, a);

// Shrink to empty if bound exceeds upper
let d = a.shrink_left(10);
assert!(d.is_empty());

// Shrink right: decrease upper bound
let e = a.shrink_right(8);
assert_eq!(e, Interval::new(5, 8));

// No effect if new bound is larger
let f = a.shrink_right(12);
assert_eq!(f, a);

// Shrink to empty if bound is below lower
let g = a.shrink_right(3);
assert!(g.is_empty());
```

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

### Converting to Intervals

Source: https://context7.com/ptal/intervallum/llms.txt

Use the ToInterval trait to convert tuples, ranges, and single values into Interval types.

```rust
use interval::prelude::*;

// Convert tuple to interval
let from_tuple = (2, 6).to_interval();
assert_eq!(from_tuple, Interval::new(2, 6));

// Convert single value to singleton interval
let from_value = 8.to_interval();
assert_eq!(from_value, Interval::singleton(8));

// Convert empty tuple to empty interval
let from_empty: Interval<usize> = ().to_interval();
assert_eq!(from_empty, Interval::empty());

// Convert inclusive range to interval
let from_range = (2..=6).to_interval();
assert_eq!(from_range, Interval::new(2, 6));

// Convert range-from to interval (extends to max)
let from_range_from = (23u8..).to_interval();
assert_eq!(from_range_from, Interval::new(23, 254));
```

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

### Interval Shrink Operations

Source: https://context7.com/ptal/intervallum/llms.txt

Narrow interval bounds from either side.

```APIDOC
## Interval Shrink Operations

### Description
Narrow interval bounds from either side.

### Methods
- `shrink_left(self, bound: T)`
- `shrink_right(self, bound: T)`

### Parameters
#### `shrink_left`
- **self** (`Interval<T>`)
- **bound** (`T`): The new lower bound.

#### `shrink_right`
- **self** (`Interval<T>`)
- **bound** (`T`): The new upper bound.

### Request Example
```rust
use interval::prelude::*

let a = Interval::new(5, 9);
let b = a.shrink_left(7);
let e = a.shrink_right(8);
```

### Response
#### Success Response (Interval)
- **result** (`Interval<T>`)

### Response Example
```json
{
  "result": "[7, 9]"
}
```
```

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

### Interval Difference

Source: https://context7.com/ptal/intervallum/llms.txt

Calculate values in the first interval but not in the second. Returns the smallest covering interval.

```APIDOC
## Interval Difference

### Description
Calculate values in the first interval but not in the second. Returns the smallest covering interval.

### Method
`difference` (method on `Interval`)

### Parameters
#### Self
- **self** (`Interval<T>`)
- **other** (`Interval<T>` or `T`)

### Request Example
```rust
use interval::prelude::*

let a = Interval::new(4, 9);
let b = Interval::new(6, 11);
a.difference(&b);

let g = Interval::new(4, 9);
g.difference(&4);
```

### Response
#### Success Response (Interval)
- **result** (`Interval<T>`)

### Response Example
```json
{
  "result": "[4, 5]"
}
```
```

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

### Calculate Interval Set Intersection

Source: https://context7.com/ptal/intervallum/llms.txt

Computes the intersection of two interval sets or a set and a single value.

```rust
use interval::prelude::*;

let a = [(1, 3), (8, 8), (10, 11)].to_interval_set();
let b = [(2, 5), (7, 8), (12, 15)].to_interval_set();

// Intersection keeps only overlapping values
let intersection = a.intersection(&b);
assert_eq!(intersection, [(2, 3), (8, 8)].to_interval_set());

// Intersection with single value
let set = [(1, 4), (6, 7)].to_interval_set();
assert_eq!(set.intersection(&3), IntervalSet::singleton(3));
assert_eq!(set.intersection(&5), IntervalSet::empty());
```

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

### Calculate Interval Set Symmetric Difference

Source: https://context7.com/ptal/intervallum/llms.txt

Computes the symmetric difference of two sets or toggles the inclusion of a single value.

```rust
use interval::prelude::*;

let a = [(1, 3), (8, 8), (10, 11)].to_interval_set();
let b = [(2, 5), (7, 8), (12, 15)].to_interval_set();

// Symmetric difference is commutative
let sym_diff = a.symmetric_difference(&b);
assert_eq!(sym_diff, [(1, 1), (4, 5), (7, 7), (10, 15)].to_interval_set());
assert_eq!(b.symmetric_difference(&a), sym_diff);

// With single value: toggle inclusion
let set = [(1, 3), (5, 9)].to_interval_set();
assert_eq!(set.symmetric_difference(&4), [(1, 9)].to_interval_set()); // Add missing
assert_eq!(set.symmetric_difference(&5), [(1, 3), (6, 9)].to_interval_set()); // Remove existing
```

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

### Iterate Over Interval Sets in Rust

Source: https://context7.com/ptal/intervallum/llms.txt

Traverse intervals within a set by value or reference, and retrieve the total count of intervals.

```rust
use interval::prelude::*;

let set = [(0, 5), (10, 15)].to_interval_set();

// Iterate by value (consumes)
let mut iter = set.clone().into_iter();
assert_eq!(iter.next(), Some(Interval::new(0, 5)));
assert_eq!(iter.next(), Some(Interval::new(10, 15)));
assert_eq!(iter.next(), None);

// Iterate by reference
for interval in &set {
    println!("Interval: [{}, {}]", interval.lower(), interval.upper());
}

// Count intervals
assert_eq!(set.interval_count(), 2);
```

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

### Perform Interval Set Shrink Operations

Source: https://context7.com/ptal/intervallum/llms.txt

Narrows the bounds of an interval set by removing values outside a specified threshold.

```rust
use interval::prelude::*;

let set = [(4, 5), (8, 8)].to_interval_set();

// Shrink left: remove values below threshold
assert_eq!(set.shrink_left(2), set);
assert_eq!(set.shrink_left(4), set);
assert_eq!(set.shrink_left(5), [(5, 5), (8, 8)].to_interval_set());
assert_eq!(set.shrink_left(7), IntervalSet::singleton(8));
assert_eq!(set.shrink_left(9), IntervalSet::empty());

// Shrink right: remove values above threshold
let set2 = [(3, 3), (7, 8)].to_interval_set();
assert_eq!(set2.shrink_right(9), set2);
assert_eq!(set2.shrink_right(8), set2);
assert_eq!(set2.shrink_right(7), [(3, 3), (7, 7)].to_interval_set());
assert_eq!(set2.shrink_right(6), IntervalSet::singleton(3));
assert_eq!(set2.shrink_right(2), IntervalSet::empty());
```

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

### Calculating Interval Intersection

Source: https://context7.com/ptal/intervallum/llms.txt

Compute the overlapping portion between two intervals or an interval and a value.

```rust
use interval::prelude::*;

// Basic intersection
let a = Interval::new(1, 4);
let b = Interval::new(2, 6);
assert_eq!(a.intersection(&b), Interval::new(2, 4));

// Non-overlapping intervals yield empty
let c = Interval::new(8, 9);
let d = Interval::new(1, 2);
assert_eq!(c.intersection(&d), Interval::empty());

// Touching intervals share only the boundary
let e = Interval::new(5, 8);
let f = Interval::new(8, 10);
assert_eq!(e.intersection(&f), Interval::singleton(8));

// Intersection with a value
let g = Interval::new(3, 8);
assert_eq!(g.intersection(&4), Interval::singleton(4));
assert_eq!(g.intersection(&10), Interval::empty());
```

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

### Calculate Interval Set Difference

Source: https://context7.com/ptal/intervallum/llms.txt

Computes the set difference, which is non-symmetric, or removes a single value from a set.

```rust
use interval::prelude::*;

let a = [(1, 3), (8, 8), (10, 11)].to_interval_set();
let b = [(2, 5), (7, 8), (12, 15)].to_interval_set();

// Difference is not symmetric
assert_eq!(a.difference(&b), [(1, 1), (10, 11)].to_interval_set());
assert_eq!(b.difference(&a), [(4, 5), (7, 7), (12, 15)].to_interval_set());

// Remove single value
let set = [(1, 3), (5, 9)].to_interval_set();
assert_eq!(set.difference(&5), [(1, 3), (6, 9)].to_interval_set());
assert_eq!(set.difference(&7), [(1, 3), (5, 6), (8, 9)].to_interval_set());
```

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

### Calculate Interval Set Union

Source: https://context7.com/ptal/intervallum/llms.txt

Compute the union of two `IntervalSet` objects to combine all their constituent intervals. A single value can also be added to an interval set using the union operation, potentially merging existing intervals.

```rust
use interval::prelude::*;

let a = [(1, 2), (6, 10)].to_interval_set();
let b = [(3, 5), (7, 7)].to_interval_set();

// Union combines all values
let union = a.union(&b);
assert_eq!(union, [(1, 5), (6, 10)].to_interval_set());

// Add a single value
let set = [(1, 4), (6, 7)].to_interval_set();
assert_eq!(set.union(&10), [(1, 4), (6, 7), (10, 10)].to_interval_set());
assert_eq!(set.union(&5), [(1, 7)].to_interval_set()); // Merges intervals
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.