### Split String by Substring using Pattern Trait

Source: https://docs.rs/jetscii

With the `pattern` feature enabled, `Substring` also implements the `Pattern` trait, enabling its use with string manipulation methods like `split`. This example splits a string using a substring as the delimiter.

```rust
use jetscii::Substring;

let colors = "red, blue, green";
let colors: Vec<_> = colors.split(Substring::new(", ")).collect();
assert_eq!(&colors, &["red", "blue", "green"]);
```

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

### Split String by ASCII Characters using Pattern Trait

Source: https://docs.rs/jetscii

When the `pattern` feature is enabled, `AsciiChars` implements the `Pattern` trait, allowing it to be used with methods like `split`. This example demonstrates splitting a string by a set of delimiter characters.

```rust
#[macro_use]
extern crate jetscii;

fn main() {
    let part_number = "86-J52:rev1";
    let parts: Vec<_> = part_number.split(ascii_chars!('-', ':')).collect();
    assert_eq!(&parts, &["86", "J52", "rev1"]);
}
```

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

### Find Substring in Haystack

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

Searches the provided haystack slice for the first occurrence of the ByteSubstring's needle. Returns an Option<usize> indicating the starting index if found, or None otherwise.

```rust
pub fn find(&self, haystack: &[u8]) -> Option<usize>
```

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

### Type ID Implementation

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

Gets the `TypeId` of `self`. This is part of the Any trait implementation.

```rust
fn type_id(&self) -> TypeId
```

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

### AsciiChars Constructor - Manual

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.AsciiCharsConst.html

Use this manual constructor to create an AsciiChars instance when the `ascii_chars!` macro is not suitable. It requires an array of 16 ASCII bytes, the count of valid bytes, and a fallback closure. The closure must replicate the logic of the provided byte array for character searching.

```rust
pub fn new(chars: [u8; 16], len: i32, fallback: F) -> Self
```

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

### ByteSubstringConst::new

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.ByteSubstringConst.html

Creates a new ByteSubstringConst from a byte slice.

```APIDOC
## pub fn new(needle: &'static [u8]) -> ByteSubstringConst

### Description
Creates a new `ByteSubstringConst` from a byte slice. This is a convenience constructor for creating a `ByteSubstring` that can be used in constant or static contexts.

### Method
`new`

### Parameters
#### Path Parameters
- **needle** (&'static [u8]) - Required - The byte slice to search for.
```

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

### Initialize ByteSubstring

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

Creates a new ByteSubstring instance with the specified needle (the subslice to search for).

```rust
pub fn new(needle: &'a [u8]) -> Self
```

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

### Substring::new Constructor

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.Substring.html

Creates a new Substring instance. The `needle` parameter is the substring to search for.

```rust
pub fn new(needle: &'a str) -> Self
```

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

### Into Implementation

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

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

```rust
fn into(self) -> U
```

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

### BytesConst::new

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.BytesConst.html

Constructs a new BytesConst instance. It's recommended to use the `bytes!` macro instead of this manual constructor. This function takes an array of 16 bytes, the number of valid bytes, and a fallback closure for when SIMD intrinsics are not available. The fallback closure must search for the same bytes as provided in the array.

```APIDOC
## BytesConst::new

### Description
Manual constructor for `BytesConst`; prefer using `bytes!` instead.

### Parameters
- `bytes` ([u8; 16]) - The array of bytes to search for.
- `len` (i32) - The number of valid bytes provided.
- `fallback` (F where F: Fn(u8) -> bool) - A closure to use when SIMD intrinsics are not available. This closure **must** search for the same bytes as in the array.

### Returns
- `Self` - A new `BytesConst` instance.
```

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

### Bytes Constructor

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.Bytes.html

Manually constructs a Bytes struct. It's recommended to use the `bytes!` macro instead. Provide an array of bytes to search for, the number of valid bytes, and a fallback closure that must search for the same bytes.

```rust
pub fn new(bytes: [u8; 16], len: i32, fallback: F) -> Self
```

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

### Construct AsciiChars with Fallback using ascii_chars Macro

Source: https://docs.rs/jetscii/0.5.3/jetscii/macro.ascii_chars.html

Use this macro to create an AsciiChars instance with a fallback. You can provide between 1 and 16 characters. The macro handles the implementation details of the fallback.

```rust
macro_rules! ascii_chars {
    ($b00:expr) => { ... };
    ($b00:expr, $b01:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr, $b11:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr, $b11:expr, $b12:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr, $b11:expr, $b12:expr, $b13:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr, $b11:expr, $b12:expr, $b13:expr, $b14:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr, $b11:expr, $b12:expr, $b13:expr, $b14:expr, $b15:expr) => { ... };
}
```

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

### From Implementation

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

Returns the argument unchanged. This is part of the From trait implementation.

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

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

### ByteSubstring::new

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

Creates a new ByteSubstring instance to search for a given needle.

```APIDOC
## pub fn new(needle: &'a [u8]) -> Self

### Description
Creates a new ByteSubstring instance to search for a given needle.

### Parameters
#### Path Parameters
- **needle** (&'a [u8]) - Required - The byte slice to search for.
```

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

### AsciiChars::new

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.AsciiChars.html

Manually constructs an AsciiChars instance. It's recommended to use the `ascii_chars!` macro instead. This function takes an array of ASCII bytes, the number of valid bytes, and a fallback closure for when SIMD intrinsics are unavailable. The closure must perform the same character search as the array.

```APIDOC
## AsciiChars::new

### Description
Manual constructor; prefer using `ascii_chars!` instead.
Provide an array of ASCII bytes to search for, the number of valid bytes provided, and a closure to use when the SIMD intrinsics are not available. The closure **must** search for the same characters as in the array.

### Parameters
- **chars** ([u8; 16]) - The array of ASCII bytes to search for.
- **len** (i32) - The number of valid bytes provided.
- **fallback** (F where F: Fn(u8) -> bool) - A closure to use when SIMD intrinsics are not available.

### Panics
- If you provide a non-ASCII byte.
```

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

### Bytes::new

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.Bytes.html

Manually constructs a Bytes struct. It's recommended to use the `bytes!` macro instead. This function takes an array of bytes to search for, the number of valid bytes, and a fallback closure.

```APIDOC
## Bytes::new

### Description
Manual constructor; prefer using `bytes!` instead.
Provide an array of bytes to search for, the number of valid bytes provided, and a closure to use when the SIMD intrinsics are not available. The closure **must** search for the same bytes as in the array.

### Signature
```rust
pub fn new(bytes: [u8; 16], len: i32, fallback: F) -> Self
```

### Parameters
- **bytes** ([u8; 16]): An array of up to 16 bytes to search for.
- **len** (i32): The number of valid bytes provided in the `bytes` array.
- **fallback** (F): A closure that takes a `u8` and returns a `bool`, used when SIMD intrinsics are not available. This closure must search for the same bytes as specified in the `bytes` array.
```

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

### Search Substring with Substring::new

Source: https://docs.rs/jetscii

Use the `Substring::new` constructor to search a string for the first occurrence of a specific substring. This method is optimized for performance.

```rust
use jetscii::Substring;

let colors = "red, blue, green";
let first = Substring::new(", ").find(colors);
assert_eq!(first, Some(3));
```

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

### jetscii bytes Macro

Source: https://docs.rs/jetscii/0.5.3/jetscii/macro.bytes.html

Use this macro to construct a `Bytes` object. It supports initializing with 1 to 16 byte expressions, automatically implementing a fallback.

```rust
macro_rules! bytes {
    ($b00:expr) => { ... };
    ($b00:expr, $b01:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr, $b11:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr, $b11:expr, $b12:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr, $b11:expr, $b12:expr, $b13:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr, $b11:expr, $b12:expr, $b13:expr, $b14:expr) => { ... };
    ($b00:expr, $b01:expr, $b02:expr, $b03:expr, $b04:expr, $b05:expr, $b06:expr, $b07:expr, $b08:expr, $b09:expr, $b10:expr, $b11:expr, $b12:expr, $b13:expr, $b14:expr, $b15:expr) => { ... };
}
```

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

### Search Bytes with bytes!

Source: https://docs.rs/jetscii

The `bytes!` macro provides an efficient way to search a byte slice for any byte within a specified set. It includes a fallback for systems where specialized instructions are not available.

```rust
#[macro_use]
extern crate jetscii;

fn main() {
    let raw_data = [0x00, 0x01, 0x10, 0xFF, 0x42];
    let first = bytes!(0x01, 0x10).find(&raw_data);
    assert_eq!(first, Some(1));
}
```

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

### Substring::new

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.Substring.html

Creates a new Substring instance with the specified needle.

```APIDOC
## Substring::new

### Description
Creates a new Substring instance with the specified needle.

### Signature
```rust
pub fn new(needle: &'a str) -> Self
```

### Parameters
* **needle** (&'a str) - The substring to search for.
```

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

### AsciiChars Constructor

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.AsciiChars.html

Manually constructs an AsciiChars instance. Prefer using the ascii_chars! macro. This function panics if a non-ASCII byte is provided.

```rust
pub fn new(chars: [u8; 16], len: i32, fallback: F) -> Self
where
    F: Fn(u8) -> bool;
```

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

### AsciiCharsConst::new

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.AsciiCharsConst.html

Constructs a new AsciiCharsConst instance. It takes an array of 16 ASCII bytes, the number of valid bytes, and a fallback closure for when SIMD intrinsics are not available. The fallback closure must perform the same character search as the provided array.

```APIDOC
## pub fn new(chars: [u8; 16], len: i32, fallback: F) -> Self

### Description
Manual constructor; prefer using `ascii_chars!` instead.
Provide an array of ASCII bytes to search for, the number of valid bytes provided, and a closure to use when the SIMD intrinsics are not available. The closure **must** search for the same characters as in the array.

### Parameters
- **chars** ([u8; 16]) - Required - An array of 16 ASCII bytes to search for.
- **len** (i32) - Required - The number of valid bytes provided.
- **fallback** (F) - Required - A closure to use when the SIMD intrinsics are not available. This closure must search for the same characters as in the array.

### Panics
- If you provide a non-ASCII byte.
```

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

### TryInto Implementation

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

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

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

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

### TryFrom Implementation

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

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

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

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

### Search ASCII Characters with ascii_chars!

Source: https://docs.rs/jetscii

Use the `ascii_chars!` macro to efficiently search a string for any character within a specified set. This macro automatically handles fallback mechanisms for broader compatibility.

```rust
#[macro_use]
extern crate jetscii;

fn main() {
    let part_number = "86-J52:rev1";
    let first = ascii_chars!('-', ':').find(part_number);
    assert_eq!(first, Some(2));
}
```

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

### SubstringConst::find

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.SubstringConst.html

Searches the string for the first occurrence of the substring.

```APIDOC
## SubstringConst::find

### Description
Searches the string for the first occurrence of the substring.

### Method
`find`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Option<usize>** - The starting index of the first occurrence of the substring, or None if not found.

#### Response Example
None
```

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

### SubstringConst Struct Definition

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.SubstringConst.html

Shows the struct definition for SubstringConst. Note that fields are private.

```rust
pub struct SubstringConst(/* private fields */);
```

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

### AsciiChars Find Method

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.AsciiCharsConst.html

Searches a given string slice for the first occurrence of any ASCII byte present in the character set. Returns an Option containing the index of the first match, or None if no match is found.

```rust
pub fn find(&self, haystack: &str) -> Option<usize>
```

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

### TryInto Trait Implementation for Substring

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.Substring.html

Provides the `try_into` method for attempting conversions that might fail. The associated `Error` type is derived from the `TryFrom` implementation.

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

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

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

### SubstringConst::new

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.SubstringConst.html

Creates a new SubstringConst from a string slice. This is a convenience type for use in constants or statics.

```APIDOC
## SubstringConst::new

### Description
Creates a new `SubstringConst` from a string slice. This is a convenience type for use in constants or statics.

### Method
`new`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Self** (`SubstringConst`)

#### Response Example
None
```

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

### TryFrom Trait Implementation for Substring

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.Substring.html

Provides the `try_from` method for attempting conversions that might fail. The associated `Error` type is `Infallible`.

```rust
type Error = Infallible
```

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

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

### AsciiChars::find

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.AsciiChars.html

Searches the provided string for the first occurrence of any ASCII byte present in the AsciiChars set.

```APIDOC
## AsciiChars::find

### Description
Searches the string for the first matching ASCII byte in the set.

### Parameters
- **haystack** (&str) - The string to search within.

### Returns
- **Option<usize>** - An Option containing the byte index of the first match, or None if no match is found.
```

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

### Bytes::find

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.Bytes.html

Searches the provided byte slice (`haystack`) for the first occurrence of any byte present in the `Bytes` set.

```APIDOC
## Bytes::find

### Description
Searches the slice for the first matching byte in the set.

### Signature
```rust
pub fn find(&self, haystack: &[u8]) -> Option<usize>
```

### Parameters
- **haystack** (&[u8]): The byte slice to search within.

### Returns
- **Option<usize>** : Returns `Some(index)` of the first matching byte if found, otherwise returns `None`.
```

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

### Substring::find

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.Substring.html

Searches the haystack string for the first occurrence of the substring.

```APIDOC
## Substring::find

### Description
Searches the string for the first occurence of the substring.

### Signature
```rust
pub fn find(&self, haystack: &str) -> Option<usize>
```

### Parameters
* **haystack** (&str) - The string to search within.

### Returns
* Option<usize> - The starting index of the first occurrence of the substring, or None if not found.
```

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

### Search Subslice with ByteSubstring::new

Source: https://docs.rs/jetscii

Employ `ByteSubstring::new` to efficiently find the first occurrence of a given subslice within a larger byte slice. This is useful for binary data analysis.

```rust
use jetscii::ByteSubstring;

let raw_data = [0x00, 0x01, 0x10, 0xFF, 0x42];
let first = ByteSubstring::new(&[0x10, 0xFF]).find(&raw_data);
assert_eq!(first, Some(2));
```

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

### BytesConst::find

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.BytesConst.html

Searches a given slice (`haystack`) for the first occurrence of any byte present in the `BytesConst` set.

```APIDOC
## BytesConst::find

### Description
Searches the slice for the first matching byte in the set.

### Parameters
- `haystack` (&[u8]) - The slice to search within.

### Returns
- `Option<usize>` - Returns `Some(index)` of the first matching byte if found, otherwise `None`.
```

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

### Bytes Struct Definition

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.Bytes.html

Defines the Bytes struct, which searches a slice for a set of bytes. Up to 16 bytes can be used. It requires a closure for fallback when SIMD intrinsics are unavailable.

```rust
pub struct Bytes<F>
where
    F: Fn(u8) -> bool,
{
    /* private fields */
}

```

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

### Borrow Implementation

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

Immutably borrows from an owned value. This is part of the Borrow trait implementation.

```rust
fn borrow(&self) -> &T
```

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

### ByteSubstring::find

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

Searches a slice for the first occurrence of the subslice.

```APIDOC
## pub fn find(&self, haystack: &[u8]) -> Option<usize>

### Description
Searches the slice for the first occurence of the subslice.

### Parameters
#### Path Parameters
- **haystack** (&[u8]) - Required - The byte slice to search within.

### Response
#### Success Response (Option<usize>)
- **usize** - The starting index of the first occurrence of the needle in the haystack, or None if not found.
```

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

### BytesConst Struct Definition

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.BytesConst.html

Represents the structure of BytesConst, which is a private implementation detail. Use the type alias for creating instances.

```rust
pub struct BytesConst { /* private fields */ }
```

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

### ByteSubstringConst Struct Definition

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.ByteSubstringConst.html

The struct definition for ByteSubstringConst. Note that its fields are private.

```rust
pub struct ByteSubstringConst { /* private fields */ }
```

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

### ByteSubstringConst::find

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.ByteSubstringConst.html

Searches for the first occurrence of a subslice within a given slice.

```APIDOC
## pub fn find(&self, haystack: &[u8]) -> Option<usize>

### Description
Searches the slice for the first occurrence of the subslice.

### Method
`find`

### Parameters
#### Path Parameters
- **haystack** (&[u8]) - Required - The slice to search within.
```

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

### Define ByteSubstring Struct

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

Defines the ByteSubstring struct, which is used for substring searching. It has private fields and is generic over a lifetime 'a.

```rust
pub struct ByteSubstring<'a> { /* private fields */ }
```

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

### Substring Struct Definition

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.Substring.html

Defines the Substring struct, which is used for substring searching. It has private fields.

```rust
pub struct Substring<'a>(/* private fields */);
```

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

### AsciiCharsConst::find

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.AsciiCharsConst.html

Searches the provided string slice for the first occurrence of any ASCII byte that is present in the AsciiCharsConst set.

```APIDOC
## pub fn find(&self, haystack: &str) -> Option<usize>

### Description
Searches the string for the first matching ASCII byte in the set.

### Parameters
- **haystack** (&str) - Required - The string slice to search within.

### Returns
- Option<usize> - Returns the byte index of the first matching ASCII byte if found, otherwise None.
```

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

### BorrowMut Implementation

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.ByteSubstring.html

Mutably borrows from an owned value. This is part of the BorrowMut trait implementation.

```rust
fn borrow_mut(&mut self) -> &mut T
```

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

### AsciiCharsConst Struct Definition

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.AsciiCharsConst.html

This shows the structure of AsciiCharsConst, which is an alias for AsciiChars. It contains private fields and is intended for use with the associated methods.

```rust
pub struct AsciiCharsConst(/* private fields */);
```

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

### Define SubstringConst Type Alias

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.SubstringConst.html

Defines SubstringConst as an alias for Substring<'static>. Use this for constants or statics.

```rust
pub type SubstringConst = Substring<'static>;
```

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

### AsciiChars Struct Definition

Source: https://docs.rs/jetscii/0.5.3/jetscii/struct.AsciiChars.html

Defines the AsciiChars struct, which is generic over a fallback closure F. This struct is used for searching a string for a set of ASCII characters.

```rust
pub struct AsciiChars<F>(/* private fields */)
where
    F: Fn(u8) -> bool;
```

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

### ByteSubstringConst Type Alias

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.ByteSubstringConst.html

Defines ByteSubstringConst as a type alias for ByteSubstring<'static>. This is useful for creating constant or static byte substrings.

```rust
pub type ByteSubstringConst = ByteSubstring<'static>;
```

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

### BytesConst Type Alias Definition

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.BytesConst.html

Defines BytesConst as a type alias for Bytes with a specific fallback function signature. This is useful for creating constant byte sets.

```rust
pub type BytesConst = Bytes<fn(u8) -> bool>;
```

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

### AsciiCharsConst Type Alias Definition

Source: https://docs.rs/jetscii/0.5.3/jetscii/type.AsciiCharsConst.html

This is the type alias definition for AsciiCharsConst. It specifies that AsciiCharsConst is an AsciiChars type with a fallback function that takes a u8 and returns a bool. This allows it to be used in constant contexts.

```rust
pub type AsciiCharsConst = AsciiChars<fn(u8) -> bool>;
```

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