# Comparison and Equality

> StringZilla for Rust

`order` and `equal` are SIMD byte comparisons, while `utf8_uncased_order` compares under Unicode case folding.

```rust
pub fn order<A: AsRef<[u8]>, B: AsRef<[u8]>>(a: A, b: B) -> core::cmp::Ordering; // SIMD sz_order_best
pub fn equal<A: AsRef<[u8]>, B: AsRef<[u8]>>(a: A, b: B) -> bool;               // SIMD sz_equal_best
pub fn utf8_uncased_order<A, B>(a: A, b: B) -> core::cmp::Ordering;             // Unicode case-folded
```

```rust
use stringzilla as sz;
use std::cmp::Ordering;

assert_eq!(sz::order("apple", "banana"), Ordering::Less);
assert!(sz::equal("abc", "abc"));
assert_eq!(sz::utf8_uncased_order("Hello", "HELLO"), Ordering::Equal);
```

`use stringzilla::*;`

## order

Lexicographic byte-order comparison of two strings, SIMD-accelerated.

```rust
pub fn order<First, Second>(first: First, second: Second) -> Ordering
where
    First: AsRef<[u8]>,
    Second: AsRef<[u8]>,
```

Mirrors `Ord` on `&[u8]` but uses StringZilla's vectorized `sz_order_best`.

Examples: ```
use std::cmp::Ordering;
use stringzilla as sz;

assert_eq!(sz::order("apple", "banana"), Ordering::Less);
assert_eq!(sz::order("abc", "abc"), Ordering::Equal);
```

## equal

Byte-level equality of two strings, SIMD-accelerated via `sz_equal_best`.

```rust
pub fn equal<First, Second>(first: First, second: Second) -> bool
where
    First: AsRef<[u8]>,
    Second: AsRef<[u8]>,
```

Examples: ```
use stringzilla as sz;

assert!(sz::equal("abc", "abc"));
assert!(!sz::equal("abc", "abd"));
```