dynfmt2

https://docs.rs/dynfmt2
Admin
dynfmt2 is a Rust crate for formatting strings dynamically with support for multiple format...
Tokens:61,255
Snippets:549
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Implementing a Custom Format (HashFormat)

Source: https://docs.rs/dynfmt2/latest/dynfmt2

Provides an example of how to implement a custom format by creating a new struct that derives the `Format` trait. This example shows a `HashFormat` that replaces '#' characters with arguments.

```APIDOC
## Extensibility Example

```rust
use std::str::MatchIndices;
use dynfmt2::{ArgumentSpec, Format, Error};

struct HashFormat;

impl<'f> Format<'f> for HashFormat {
    type Iter = HashIter<'f>;

    fn iter_args(&self, format: &'f str) -> Result<Self::Iter, Error<'f>> {
        Ok(HashIter(format.match_indices('#')))
    }
}

struct HashIter<'f>(MatchIndices<'f, char>);

impl<'f> Iterator for HashIter<'f> {
    type Item = Result<ArgumentSpec<'f>, Error<'f>>;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(|(index, _)| Ok(ArgumentSpec::new(index, index + 1)))
    }
}

let formatted = HashFormat.format("hello, #", &["world"]);
assert_eq!("hello, world", formatted.expect("formatting failed"));
```
```

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

### Get Start Index

Source: https://docs.rs/dynfmt2/latest/dynfmt2/struct.ArgumentSpec.html

Returns the starting index of this argument specification within the original format string.

```rust
pub const fn start(&self) -> usize
```

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

### Example Usage of PythonFormat

Source: https://docs.rs/dynfmt2/latest/dynfmt2/python/struct.PythonFormat.html

Demonstrates how to use the PythonFormat struct to format a string with arguments. Ensure the necessary imports are included.

```rust
use dynfmt2::{Format, PythonFormat};

let formatted = PythonFormat.format("hello, %s", &["world"]);
assert_eq!("hello, world", formatted.expect("formatting failed"));
```

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

### Implementing a Custom Format with HashFormat

Source: https://docs.rs/dynfmt2

Shows how to implement the `Format` trait to create a custom formatting behavior. This example defines `HashFormat` which replaces '#' with arguments.

```rust
use std::str::MatchIndices;
use dynfmt2::{ArgumentSpec, Format, Error};

struct HashFormat;

impl<'f> Format<'f> for HashFormat {
    type Iter = HashIter<'f>;

    fn iter_args(&self, format: &'f str) -> Result<Self::Iter, Error<'f>> {
        Ok(HashIter(format.match_indices('#')))
    }
}

struct HashIter<'f>(MatchIndices<'f, char>);

impl<'f> Iterator for HashIter<'f> {
    type Item = Result<ArgumentSpec<'f>, Error<'f>>;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(|(index, _)| Ok(ArgumentSpec::new(index, index + 1)))
    }
}

let formatted = HashFormat.format("hello, #", &["world"]);
assert_eq!("hello, world", formatted.expect("formatting failed"));
```

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

### ArgumentSpec::start

Source: https://docs.rs/dynfmt2/latest/dynfmt2/struct.ArgumentSpec.html

Returns the start index of the ArgumentSpec in the format string.

```APIDOC
## ArgumentSpec::start

### Description
The start index of this specification in the format string.

### Signature
```rust
pub const fn start(&self) -> usize
```
```

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

### ArgumentSpec::new

Source: https://docs.rs/dynfmt2/latest/dynfmt2/struct.ArgumentSpec.html

Creates a new ArgumentSpec with specified start and end indices in the format string.

```APIDOC
## ArgumentSpec::new

### Description
Creates a new argument specification with default values. The `start` and `end` parameters denote the exclusive range of this specification in the format string. E.g. for a format string `"{}"`, the range is _[0, 2)_.

### Signature
```rust
pub fn new(start: usize, end: usize) -> Self
```
```

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

### Format Specification Methods

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/lib.rs.html

Provides access to the start and end indices of a format specification within the format string.

```APIDOC
## Format Specification Methods

### Description
These methods provide access to the start and end indices of a format specification within the format string.

### Methods
- `start()`: Returns the starting index of the specification.
- `end()`: Returns the ending index of the specification.

### Usage
```rust
// Assuming 'spec' is an instance of a format specification
let start_index = spec.start();
let end_index = spec.end();
```
```

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

### Using unwrap to Get Ok Value or Panic

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Retrieves the contained Ok value. This method will panic if the Result is an Err, so it should be used with caution. Prefer pattern matching or other methods like unwrap_or.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`
```

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

### Basic Usage with NoopFormat

Source: https://docs.rs/dynfmt2/latest/dynfmt2

Demonstrates the basic usage of the `dynfmt2` crate with the `NoopFormat` implementation, which performs no actual formatting.

```APIDOC
## Usage Example

```rust
use dynfmt2::{Format, NoopFormat};

let formatted = NoopFormat.format("hello, world", &["unused"]);
assert_eq!("hello, world", formatted.expect("formatting failed"));
```

See the `Format` trait for more methods.
```

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

### Basic Usage of NoopFormat

Source: https://docs.rs/dynfmt2

Demonstrates the basic usage of the `NoopFormat` for simple string formatting. This format does not perform any actual formatting.

```rust
use dynfmt2::{Format, NoopFormat};

let formatted = NoopFormat.format("hello, world", &["unused"]);
assert_eq!("hello, world", formatted.expect("formatting failed"));
```

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

### FormatType::type_id() Method

Source: https://docs.rs/dynfmt2/latest/dynfmt2/enum.FormatType.html

Gets the TypeId of the FormatType. This is part of the Any trait implementation.

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

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

### Basic Usage of NoopFormat

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/lib.rs.html

Demonstrates the basic usage of the `Format` trait with `NoopFormat` for simple string formatting without argument substitution.

```rust
use dynfmt2::{Format, NoopFormat};

let formatted = NoopFormat.format("hello, world", &["unused"]);
assert_eq!("hello, world", formatted.expect("formatting failed"));

```

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

### Get End Index

Source: https://docs.rs/dynfmt2/latest/dynfmt2/struct.ArgumentSpec.html

Returns the ending index (exclusive) of this argument specification within the original format string.

```rust
pub const fn end(&self) -> usize
```

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

### Formatter::new

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Creates a new Formatter instance with default settings. It takes a writer that implements `io::Write`.

```APIDOC
## Formatter::new

### Description
Creates a new `Formatter` instance. This is the primary constructor for the `Formatter` struct.

### Method
```rust
pub fn new(write: W) -> Self
```

### Parameters
* `write`: A type `W` that implements `std::io::Write`, which will be the output destination for the formatted data.

### Returns
A new `Formatter` instance configured for default display formatting.
```

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

### Iterate Over Result Ok Value

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Use `iter` to get an iterator that yields the `Ok` value once if present, otherwise yields nothing.

```rust
let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));
```

```rust
let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);
```

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

### clone_to_uninit

Source: https://docs.rs/dynfmt2/latest/dynfmt2/enum.Position.html

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

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

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

### Method
`clone_to_uninit`

### Parameters
#### Path Parameters
- **self** (*self*) - Required - Reference to the object
- **dest** (**mut u8*) - Required - Mutable pointer to the destination buffer

### Note
This is a nightly-only experimental API.
```

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

### Formatter `format` Method

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

The main entry point for formatting an argument. It delegates serialization to the `Argument` trait.

```rust
pub fn format(&mut self, value: Argument<'_>) -> Result<(), FormatError> {
        // TODO: Serde calls erased_serialize here, which always passes the error through
        // Error::custom. In this process we lose the original error.
        value.serialize(self)
    }
```

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

### Get Value or Default with unwrap_or

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

The `unwrap_or` method returns the contained `Ok` value or a provided default if the result is `Err`. Arguments are eagerly evaluated.

```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```

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

### into_ok

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Returns the contained `Ok` value, but never panics. This is a nightly-only experimental API.

```APIDOC
## pub const fn into_ok(self) -> T

### Description
Returns the contained `Ok` value, but never panics.
Unlike `unwrap`, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of `unwrap` as a maintainability safeguard that will fail to compile if the error type of the `Result` is later changed to an error that can actually occur.

### Examples
```

fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```
```

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

### Create ArgumentSpec with Range

Source: https://docs.rs/dynfmt2/latest/dynfmt2/struct.ArgumentSpec.html

Creates a new argument specification, defining its start and end position within the format string. The range is exclusive of the end index.

```rust
pub fn new(start: usize, end: usize) -> Self
```

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

### Formatter Initialization

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Initializes a new Formatter with a given writer, setting the default format type to Display and alternate flag to false. This is the entry point for creating a formatter instance.

```rust
pub struct Formatter<W> {
    target: FormatterTarget<W>,
    ty: FormatType,
    alternate: bool,
}

impl<W>
where
    W: io::Write,
{
    pub fn new(write: W) -> Self {
        Formatter {
            target: FormatterTarget::new(write),
            ty: FormatType::Display,
            alternate: false,
        }
    }
}
```

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

### Unsafe Unwrap of Err Value - Rust Result

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Use `unwrap_err_unchecked` to get the contained Err value without checking for errors. Calling this on an Ok is undefined behavior.

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
```

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

### Unsafe Unwrap of Ok Value - Rust Result

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Use `unwrap_unchecked` to get the contained Ok value without checking for errors. Calling this on an Err is undefined behavior.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
```

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

### Formatter Builder Methods

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Methods for configuring the formatter's behavior, such as setting the format type and alternate formatting.

```rust
pub const fn with_type(mut self, ty: FormatType) -> Self {
        self.ty = ty;
        self
    }

    pub const fn with_alternate(mut self, alternate: bool) -> Self {
        self.alternate = alternate;
        self
    }
```

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

### ArgumentAccess::new

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/lib.rs.html

Creates a new `ArgumentAccess` instance with the provided `FormatArgs`.

```rust
pub const fn new(args: A) -> Self {
    ArgumentAccess { args, index: 0 }
}
```

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

### Using unwrap_err to Get Err Value or Panic

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Retrieves the contained Err value, panicking if the Result is Ok. This is useful for asserting that an operation failed and extracting the error.

```rust
let x: Result<u32, &str> = Ok(2);
x.unwrap_err(); // panics with `2`
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");
```

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

### Using unwrap_or_default to Get Ok Value or Default

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Returns the contained Ok value or the default value for the type if the Result is an Err. This is useful for providing fallback values.

```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

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

### fold<B, F>(self, init: B, f: F)

Source: https://docs.rs/dynfmt2/latest/dynfmt2/python/struct.PythonIter.html

Folds every element into an accumulator by applying an operation, returning the final result.

```APIDOC
## fold<B, F>(self, init: B, f: F)

### Description
Applies a function to each element, accumulating a result.

### Parameters
- **init** (B) - The initial value for the accumulator.
- **f** (F) - A closure that takes the accumulator and the current item, returning the updated accumulator.
```

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

### take

Source: https://docs.rs/dynfmt2/latest/dynfmt2/curly/struct.SimpleCurlyIter.html

Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

```APIDOC
## take

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Signature
`fn take(self, n: usize) -> Take<Self>`

### Type Parameters
- `Self`: The type of the iterator being taken from.
```

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

### Iterate Mutably Over Result Ok Value

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Use `iter_mut` to get a mutable iterator that yields a mutable reference to the `Ok` value once if present, otherwise yields nothing.

```rust
let mut x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter_mut().next(), Some(&mut 7));
```

```rust
let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);
```

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

### FormatType::clone_to_uninit() Method

Source: https://docs.rs/dynfmt2/latest/dynfmt2/enum.FormatType.html

Performs copy-assignment from self to uninitialized memory. This is a nightly-only experimental API.

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

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

### Get Mutable Reference to Result Content

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Use `as_mut` to obtain a Result containing mutable references to the contained values. This allows in-place modification of the Ok or Err values.

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

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

### Product Aggregation with Result

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Demonstrates how to use the `product` method on an iterator of Results. If any element fails to parse, the entire operation returns an Err. Otherwise, it returns the Ok value of the accumulated product.

```rust
let nums = vec!["5", "10", "1", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert_eq!(total, Ok(100));
```

```rust
let nums = vec!["5", "10", "one", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert!(total.is_err());
```

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

### Using expect_err to Get Err Value with Custom Panic Message

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Retrieves the contained Err value, panicking with a custom message if the Result is Ok. This is useful for asserting that an operation failed.

```rust
let x: Result<u32, &str> = Ok(10);
x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`
```

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

### Format String with SimpleCurlyFormat

Source: https://docs.rs/dynfmt2/latest/dynfmt2/curly/struct.SimpleCurlyFormat.html

Demonstrates how to use SimpleCurlyFormat to format a string with a positional argument. Ensure the arguments provided match the placeholders in the format string.

```rust
use dynfmt2::{Format, SimpleCurlyFormat};

let formatted = SimpleCurlyFormat.format("hello, {}", &["world"]);
assert_eq!("hello, world", formatted.expect("formatting failed"));
```

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

### Get Reference to Result Content

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Use `as_ref` to obtain a Result containing references to the contained values, without consuming the original Result. This is useful for inspecting values without taking ownership.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

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

### Implement Debug for NoopFormat

Source: https://docs.rs/dynfmt2/latest/dynfmt2/struct.NoopFormat.html

Provides a Debug implementation for NoopFormat, allowing it to be formatted for debugging purposes. The actual formatting logic is handled by the Formatter.

```rust
impl Debug for NoopFormat {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
}
```

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

### partition

Source: https://docs.rs/dynfmt2/latest/dynfmt2/curly/struct.SimpleCurlyIter.html

Consumes an iterator, creating two collections from it.

```APIDOC
## partition

### Description
Consumes an iterator, creating two collections from it.

### Signature
`fn partition<B, F>(self, f: F) -> (B, B)`

### Type Parameters
- `B`: The type of the collections to create, which must implement `Default + Extend<Self::Item>`.
- `F`: The type of the predicate closure used for partitioning.
```

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

### partition<B, F>(self, f: F)

Source: https://docs.rs/dynfmt2/latest/dynfmt2/python/struct.PythonIter.html

Consumes an iterator, creating two collections from it.

```APIDOC
## partition<B, F>(self, f: F)

### Description
Consumes the iterator and partitions its elements into two collections based on a predicate.

### Parameters
- **f** (F) - A closure that takes an item and returns a boolean.

### Type Parameters
- **B**: Must implement `Default` and `Extend<Self::Item>`.
```

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

### Binary Formatting

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Formats a value using its `Binary` implementation.

```rust
fn binary<D: fmt::Binary>(&mut self, value: &D) -> Result<(), FormatError> {
        self.fmt_internal(value, fmt::Binary::fmt)
    }
```

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

### Display Formatting

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Formats a value using its `Display` implementation.

```rust
fn display<D: fmt::Display>(&mut self, value: &D) -> Result<(), FormatError> {
        self.fmt_internal(value, fmt::Display::fmt)
    }
```

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

### Convert Result to Option (Ok value)

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

Use the `ok` method to convert a Result into an Option, discarding any error value. This is useful when you only care about the success value.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

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

### by_ref

Source: https://docs.rs/dynfmt2/latest/dynfmt2/curly/struct.SimpleCurlyIter.html

Creates a “by reference” adapter for this instance of `Iterator`.

```APIDOC
## by_ref

### Description
Creates a “by reference” adapter for this instance of `Iterator`.

### Signature
`fn by_ref(&mut self) -> &mut Self`

### Type Parameters
- `Self`: The type of the iterator to create a by-reference adapter for.
```

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

### FormatArgs Implementation for &A

Source: https://docs.rs/dynfmt2/latest/dynfmt2/trait.FormatArgs.html

Provides a blanket implementation of FormatArgs for references to types that already implement FormatArgs.

```rust
impl<A> FormatArgs for &A
where A: FormatArgs,
```

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

### FormatArgs Implementation for BTreeMap<S, T>

Source: https://docs.rs/dynfmt2/latest/dynfmt2/trait.FormatArgs.html

Implements FormatArgs for BTreeMap, allowing retrieval of arguments by key. Requires keys to be borrowable as strings and values to be serializable.

```rust
impl<S, T> FormatArgs for BTreeMap<S, T>
where S: Borrow<str> + Ord,
      T: Serialize,
```

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

### product

Source: https://docs.rs/dynfmt2/latest/dynfmt2/curly/struct.SimpleCurlyIter.html

Iterates over the entire iterator, multiplying all the elements.

```APIDOC
## product<P>(self) -> P

### Description
Iterates over the entire iterator, multiplying all the elements.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Method Signature
`fn product<P>(self) -> P where Self: Sized, P: Product<Self::Item>`
```

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

### take(self, n: usize)

Source: https://docs.rs/dynfmt2/latest/dynfmt2/python/struct.PythonIter.html

Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

```APIDOC
## take(self, n: usize)

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Parameters
- **n** (usize) - The maximum number of elements to yield.
```

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

### by_ref(&mut self)

Source: https://docs.rs/dynfmt2/latest/dynfmt2/python/struct.PythonIter.html

Creates a “by reference” adapter for this instance of `Iterator`.

```APIDOC
## by_ref(&mut self)

### Description
Creates a mutable reference adapter for the iterator, allowing operations on the iterator without consuming it.
```

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

### NoopFormat Implementation

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/lib.rs.html

A basic implementation of the `Format` trait that does nothing. It returns an empty iterator for arguments, effectively passing the format string through unchanged.

```rust
impl<'f> Format<'f> for NoopFormat {
    type Iter = std::iter::Empty<ArgumentResult<'f>>;

    fn iter_args(&self, _format: &'f str) -> Result<Self::Iter, Error<'f>> {
        Ok(Default::default())
    }
}

```

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

### Formatter Serializer Implementation

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Implements the Serde Serializer trait for the Formatter, enabling serialization of various data types.

```APIDOC
## Formatter Serializer

### Description
This implementation allows the `Formatter` to act as a Serde Serializer, supporting different formatting types like Display, Object, Octal, Hexadecimal, and Binary.

### Methods

#### `serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>`
Serializes a boolean value.

#### `serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>`
Serializes an 8-bit integer value, supporting various formats based on the formatter's type.

#### `serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>`
Serializes a 16-bit integer value, supporting various formats based on the formatter's type.

### Associated Types
- `Ok`: `()`
- `Error`: `FormatError`

### Supported Serialization Types (Conditional)
- `SerializeSeq`
- `SerializeTuple`
- `SerializeTupleStruct`
- `SerializeTupleVariant`
- `SerializeMap`
- `SerializeStruct`
- `SerializeStructVariant`

*Note: These types are only available when the `json` feature is enabled.*
```

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

### SimpleCurlyIter for Format Arguments

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/curly.rs.html

An iterator for extracting arguments from simple curly brace format strings. It uses a pre-compiled regex to find all matches.

```rust
pub struct SimpleCurlyIter<'f> {
    captures: CaptureMatches<'static, 'f>,
}

impl<'f> SimpleCurlyIter<'f> {
    fn new(format: &'f str) -> Self {
        SimpleCurlyIter {
            captures: get_curly_regex().captures_iter(format),
        }
    }
}

impl<'f> Iterator for SimpleCurlyIter<'f> {
    type Item = ArgumentResult<'f>;

    fn next(&mut self) -> Option<Self::Item> {
        self.captures.next().map(|capture| Ok(parse_next(capture)))
    }
}
```

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

### Format Trait Implementation for NoopFormat

Source: https://docs.rs/dynfmt2/latest/dynfmt2/struct.NoopFormat.html

Details of the Format trait implementation for NoopFormat, including methods for iterating arguments and formatting strings.

```APIDOC
## Trait Implementations

### impl<'f> Format<'f> for NoopFormat

#### type Iter = Empty<Result<ArgumentSpec<'f>, Error<'f>>>

The iterator returned by `iter_args`.

#### fn iter_args(&self, _format: &'f str) -> Result<Self::Iter, Error<'f>>

Returns an iterator over format arguments in the format string.

#### fn format<A>( &self, format: &'f str, arguments: A, ) -> Result<Cow<'f, str>, Error<'f>>
where A: FormatArgs,

Formats the given string with the specified arguments.
```

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

### FormatArgs Implementation for HashMap<S, T>

Source: https://docs.rs/dynfmt2/latest/dynfmt2/trait.FormatArgs.html

Implements FormatArgs for HashMap, enabling argument retrieval by key. Requires keys to be borrowable as strings and values to be serializable.

```rust
impl<S, T> FormatArgs for HashMap<S, T>
where S: Borrow<str> + Hash + Eq,
      T: Serialize,
```

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

### Implement FormatArgs for &A

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/lib.rs.html

Delegates `FormatArgs` calls to the underlying referenced `FormatArgs` implementation.

```rust
impl<A>
where
    A: FormatArgs,
{
    fn get_index(&self, index: usize) -> Result<Option<Argument<'_>>, ()> {
        (*self).get_index(index)
    }

    fn get_key(&self, key: &str) -> Result<Option<Argument<'_>>, ()> {
        (*self).get_key(key)
    }
}
```

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

### fn partial_cmp<I>(self, other: I) -> Option<Ordering>

Source: https://docs.rs/dynfmt2/latest/dynfmt2/python/struct.PythonIter.html

Lexicographically compares elements using partial ordering.

```APIDOC
## fn partial_cmp<I>(self, other: I) -> Option<Ordering>

### Description
Lexicographically compares the `PartialOrd` elements of this `Iterator` with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

### Parameters
- **other** (I) - Another `IntoIterator` to compare against.

### Constraints
- `I` must be convertible into an `Iterator`.
- `Self::Item` must implement `PartialOrd` with the item type of `I`.

### Returns
- Option<Ordering> - `Some(Ordering)` if an order can be determined, `None` if elements are incomparable.
```

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

### ArgumentSpec::with_format

Source: https://docs.rs/dynfmt2/latest/dynfmt2/struct.ArgumentSpec.html

Sets the formatting type for the ArgumentSpec. Defaults to FormatType::Display.

```APIDOC
## ArgumentSpec::with_format

### Description
Sets the formatting type. Defaults to `FormatType::Display`.

### Signature
```rust
pub const fn with_format(self, format: FormatType) -> Self
```
```

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

### Formatter Configuration

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Methods for configuring the formatter's behavior, such as setting the format type and alternate formatting.

```APIDOC
## `with_type`

### Description
Sets the format type for the formatter.

### Method
`pub const fn with_type(mut self, ty: FormatType) -> Self`

### Parameters
- `ty` (FormatType) - The desired format type.
```

```APIDOC
## `with_alternate`

### Description
Enables or disables alternate formatting (e.g., pretty-printing for JSON).

### Method
`pub const fn with_alternate(mut self, alternate: bool) -> Self`

### Parameters
- `alternate` (bool) - `true` to enable alternate formatting, `false` otherwise.
```

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

### Generic Formatting Proxy

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

The FmtProxy allows generic formatting by accepting a data pointer and a function pointer, enabling dynamic dispatch for formatting logic. It uses unsafe code for type casting and transmutation.

```rust
use std::fmt;
use std::io;
use std::mem::{self, MaybeUninit};

use serde::{Serialize, Serializer};
#[cfg(feature = "json")]
use serde_json::Serializer as JsonSerializer;

use crate::{Argument, FormatType};

#[cfg(feature = "json")]
type CompactJsonSerializer<W> = JsonSerializer<W, serde_json::ser::CompactFormatter>;
#[cfg(feature = "json")]
type PrettyJsonSerializer<W> = JsonSerializer<W, serde_json::ser::PrettyFormatter<'static>>;

pub type FormatFn<T> = fn(&T, fmt: &mut fmt::Formatter) -> fmt::Result;

struct FmtProxy<'a> {
    data: &'a (),
    func: FormatFn<()>;
}

impl<'a> FmtProxy<'a> {
    pub fn new<T>(data: &'a T, func: FormatFn<T>) -> Self {
        unsafe {
            FmtProxy {
                data: &*(data as *const T).cast::<()>(),
                func: std::mem::transmute::(
                    for<'b, 'c> fn(&T, &'b mut fmt::Formatter<'c>) -> fmt::Result,
                    for<'b, 'c> fn(&(), &'b mut fmt::Formatter<'c>) -> fmt::Result,
                )(func),
            }
        }
    }
}

impl fmt::Display for FmtProxy<'_> {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        (self.func)(self.data, fmt)
    }
}
```

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

### Initialize Regex for Curly Braces

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/curly.rs.html

Initializes a static Regex for parsing curly brace format strings. It uses `OnceLock` for thread-safe lazy initialization.

```rust
static CURLY_RE: OnceLock<Regex> = OnceLock::new();

#[inline]
fn get_curly_regex() -> &'static Regex {
    CURLY_RE.get_or_init(|| Regex::new(r"\{(?P<key>\w+)?\}").unwrap())
}
```

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

### inspect

Source: https://docs.rs/dynfmt2/latest/dynfmt2/curly/struct.SimpleCurlyIter.html

Does something with each element of an iterator, passing the value on.

```APIDOC
## inspect

### Description
Does something with each element of an iterator, passing the value on.

### Signature
`fn inspect<F>(self, f: F) -> Inspect<Self, F>`

### Type Parameters
- `F`: The type of the closure used for inspection.
```

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

### Set Formatting Type

Source: https://docs.rs/dynfmt2/latest/dynfmt2/struct.ArgumentSpec.html

Specifies the formatting type for the argument. Defaults to `FormatType::Display`.

```rust
pub const fn with_format(self, format: FormatType) -> Self
```

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

### try_into Method

Source: https://docs.rs/dynfmt2/latest/dynfmt2/enum.Count.html

Performs a conversion from the current type to a target type `U`. Returns a Result, which is either the converted value or an error if the conversion fails.

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

Performs the conversion.
```

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

### map_windows

Source: https://docs.rs/dynfmt2/latest/dynfmt2/curly/struct.SimpleCurlyIter.html

Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Like `slice::windows()`, the windows during mapping overlap as well.

```APIDOC
## map_windows

### Description
Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Like `slice::windows()`, the windows during mapping overlap as well.

### Signature
`fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>`

### Type Parameters
- `F`: The type of the closure used for mapping windows.
- `R`: The type of the elements returned by the closure.
- `N`: The size of the sliding window.
```

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

### Implement FormatArgs for BTreeMap<S, T>

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/lib.rs.html

Provides named access to arguments stored in a `BTreeMap<S, T>` where `S` borrows as `str` and `T` implements `Serialize`.

```rust
impl<S, T>
where
    S: std::borrow::Borrow<str> + Ord,
    T: Serialize,
{
    fn get_key(&self, key: &str) -> Result<Option<Argument<'_>>, ()> {
        Ok(self.get(key).map(|arg| arg as Argument<'_>))
    }
}
```

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

### Serialize Map with Dynfmt2

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Handles serialization of map data. It checks the format type and delegates to either pretty or compact serialization based on the 'alternate' flag.

```rust
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        if self.ty != FormatType::Object && self.ty != FormatType::Display {
            return Err(FormatError::Type(self.ty));
        }

        if self.alternate {
            self.target
                .as_pretty()
                .serialize_map(len)
                .map(SerializeMap::Pretty)
                .map_err(Into::into)
        } else {
            self.target
                .as_compact()
                .serialize_map(len)
                .map(SerializeMap::Compact)
                .map_err(Into::into)
        }
    }
```

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

### Octal Formatting

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Formats a value using its `Octal` implementation.

```rust
fn octal<D: fmt::Octal>(&mut self, value: &D) -> Result<(), FormatError> {
        self.fmt_internal(value, fmt::Octal::fmt)
    }
```

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

### JSON Serialization (Enabled)

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Handles JSON serialization, differentiating between pretty and compact output based on the `alternate` flag.

```rust
#[cfg(feature = "json")]
    fn serialize<D: Serialize>(&mut self, value: &D) -> Result<(), FormatError> {
        if self.alternate {
            value.serialize(self.target.as_pretty()).map_err(Into::into)
        } else {
            value
                .serialize(self.target.as_compact())
                .map_err(Into::into)
        }
    }
```

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

### Enable Alternate Formatting

Source: https://docs.rs/dynfmt2/latest/dynfmt2/struct.ArgumentSpec.html

Activates the alternate formatting mode for the argument. This often changes the output for numeric types (e.g., `0x` prefix for hex).

```rust
pub const fn with_alternate(self, alternate: bool) -> Self
```

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

### NoopFormat Struct

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/lib.rs.html

A simple implementation of the `Format` trait that does not perform any formatting. It's useful for testing or when no actual formatting is needed.

```APIDOC
## struct NoopFormat

### Description
A format implementation that does not format anything. Useful for scenarios where no actual string manipulation is required.

### Methods

#### `iter_args(&self, _format: &'f str) -> Result<Self::Iter, Error<'f>>`

Returns an empty iterator, as `NoopFormat` does not process any arguments.

**Parameters**
- `_format` (&'f str): The format string (unused).

**Returns**
- Result<Self::Iter, Error<'f>>: An empty iterator.

#### `format<A>(&self, format: &'f str, arguments: A) -> Result<Cow<'f, str>, Error<'f>>`

Returns the original format string without any modifications, as no formatting is applied.

**Parameters**
- `format` (&'f str): The format string.
- `arguments` (A): The arguments (unused).

**Returns**
- Result<Cow<'f, str>, Error<'f>>: The original, unmodified format string.
```

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

### Enable Sign-Aware Zero Padding

Source: https://docs.rs/dynfmt2/latest/dynfmt2/struct.ArgumentSpec.html

Activates zero padding for numbers, respecting the sign. If `true`, zeros are inserted after the sign but before the digits.

```rust
pub const fn with_zeros(self, pad_zero: bool) -> Self
```

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

### FormatType::clone_from() Method

Source: https://docs.rs/dynfmt2/latest/dynfmt2/enum.FormatType.html

Performs copy-assignment from a source FormatType. This is part of the Clone trait implementation.

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

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

### Implement FormatArgs for HashMap<S, T>

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/lib.rs.html

Provides named access to arguments stored in a `HashMap<S, T>` where `S` borrows as `str` and `T` implements `Serialize`.

```rust
impl<S, T>
where
    S: std::borrow::Borrow<str> + std::hash::Hash + Eq,
    T: Serialize,
{
    fn get_key(&self, key: &str) -> Result<Option<Argument<'_>>, ()> {
        Ok(self.get(key).map(|arg| arg as Argument<'_>))
    }
}
```

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

### Combine Results with and

Source: https://docs.rs/dynfmt2/latest/dynfmt2/type.ArgumentResult.html

The `and` method returns the second result if the first is `Ok`, otherwise returns the `Err` value of the first. Arguments are eagerly evaluated.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));

let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));

let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));
```

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

### Define Python Format String Regex

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/python.rs.html

Initializes a static `OnceLock` with a regex to parse Python-style format specifiers. This regex captures keys, flags, width, precision, and type.

```rust
static PYTHON_RE: OnceLock<Regex> = OnceLock::new();

#[inline]
fn get_python_regex() -> &'static Regex {
    PYTHON_RE.get_or_init(|| {
        Regex::new(
            r"(?x)
            %
            (?:\((?P<key>\w+)\))?         # Mapping key
            (?P<flags>[\#0\- +]*)?        # Conversion flags
            (?P<width>\*|\d+)?            # Minimum field width
            (?:.(?P<precision>\*|\d+))?   # Precision after decimal point
            [hlL]*                        # Ignored length modifier
            (?P<type>[diouxXeEfFgGcrs%])  # Conversion type
        ",
        )
        .unwrap()
    })
}
```

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

### Serialization Methods

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Provides methods for serializing different data types, including units, newtypes, and sequences, with support for different formatting types like Display and Object.

```APIDOC
## `serialize_none()`

### Description
Serializes a null value.

### Method
`serialize_none(self) -> Result<Self::Ok, Self::Error>`

## `serialize_some(value: &T)`

### Description
Serializes an optional value.

### Method
`serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>`
where
    T: Serialize + ?Sized,

## `serialize_unit()`

### Description
Serializes a unit type (e.g., `()`). Handles `FormatType::Display` and `FormatType::Object`.

### Method
`serialize_unit(self) -> Result<Self::Ok, Self::Error>`

## `serialize_unit_struct(name: &'static str)`

### Description
Serializes a unit struct.

### Method
`serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error>`

## `serialize_unit_variant(name: &'static str, variant_index: u32, variant: &'static str)`

### Description
Serializes a unit variant.

### Method
`serialize_unit_variant(
    self,
    _name: &'static str,
    _variant_index: u32,
    variant: &'static str,
) -> Result<Self::Ok, Self::Error>`

## `serialize_newtype_struct(name: &'static str, value: &T)`

### Description
Serializes a newtype struct.

### Method
`serialize_newtype_struct<T>(
    self,
    _name: &'static str,
    value: &T,
) -> Result<Self::Ok, Self::Error>`
where
    T: Serialize + ?Sized,

## `serialize_newtype_variant(name: &'static str, variant_index: u32, variant: &'static str, value: &T)`

### Description
Serializes a newtype variant. Returns an error indicating an unsupported type.

### Method
`serialize_newtype_variant<T>(
    self,
    _name: &'static str,
    _variant_index: u32,
    _variant: &'static str,
    _value: &T,
) -> Result<Self::Ok, Self::Error>`
where
    T: Serialize + ?Sized,

```

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

### name Method

Source: https://docs.rs/dynfmt2/latest/dynfmt2/enum.FormatType.html

Returns the string name of the formatting type.

```APIDOC
## impl FormatType

### pub const fn name(self) -> &'static str

Returns the name of this formatting type.
```

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

### SimpleCurlyFormat

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/curly.rs.html

Implements the Format trait for simple curly brace based format strings. This syntax is a subset of what Python 3, Rust, .NET and many logging libraries use. Each argument is formatted in display mode.

```APIDOC
## SimpleCurlyFormat

### Description
Implements the `Format` trait for simple curly brace based format strings. This syntax is a subset of what Python 3, Rust, .NET and many logging libraries use. Each argument is formatted in display mode.

1. `{}`: Refers to the next positional argument.
2. `{0}`: Refers to the argument at index `0`.
3. `{name}`: Refers to the named argument with key `"name"`.

### Example

```rust
use dynfmt2::{Format, SimpleCurlyFormat};

let formatted = SimpleCurlyFormat.format("hello, {}", &["world"]);
assert_eq!("hello, world", formatted.expect("formatting failed"));
```

### Type

```rust
#[derive(Debug)]
pub struct SimpleCurlyFormat;
```

### Trait Implementations

#### `Format` Trait

```rust
impl<'f> Format<'f> for SimpleCurlyFormat {
    type Iter = SimpleCurlyIter<'f>;

    fn iter_args(&self, format: &'f str) -> Result<Self::Iter, Error<'f>> {
        Ok(SimpleCurlyIter::new(format))
    }
}
```
```

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

### SimpleCurlyFormat::iter_args

Source: https://docs.rs/dynfmt2/latest/dynfmt2/curly/struct.SimpleCurlyFormat.html

Returns an iterator over the format arguments present in the format string. This is useful for analyzing the arguments without performing the actual formatting.

```APIDOC
## SimpleCurlyFormat::iter_args

### Description
Returns an iterator over format arguments in the format string.

### Method
`iter_args(&self, format: &'f str) -> Result<Self::Iter, Error<'f>>`

### Parameters
- `format`: &'f str - The format string to iterate over.

### Returns
- `Result<Self::Iter, Error<'f>>` - An iterator over the format arguments or an `Error` if parsing fails.
```

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

### Internal Formatting Helpers

Source: https://docs.rs/dynfmt2/latest/src/dynfmt2/formatter.rs.html

Internal helper methods for formatting values using different display traits.

```APIDOC
## `fmt_internal`

### Description
An internal method to format a value using a provided formatting function.

### Method
`fn fmt_internal<T>(&mut self, value: &T, fmt: FormatFn<T>) -> Result<(), FormatError>`

### Parameters
- `value` (&T) - The value to format.
- `fmt` (FormatFn<T>) - The formatting function to use (e.g., `fmt::Debug::fmt`).

### Returns
- `Ok(())` on successful formatting.
- `Err(FormatError::Io)` if an I/O error occurs.
```

```APIDOC
## `debug`

### Description
Formats a value using its `Debug` trait implementation.

### Method
`#[allow(unused)] fn debug<D: fmt::Debug>(&mut self, value: &D) -> Result<(), FormatError>`

### Parameters
- `value` (&D) - The value to format, which must implement `fmt::Debug`.
```

```APIDOC
## `display`

### Description
Formats a value using its `Display` trait implementation.

### Method
`fn display<D: fmt::Display>(&mut self, value: &D) -> Result<(), FormatError>`

### Parameters
- `value` (&D) - The value to format, which must implement `fmt::Display`.
```

```APIDOC
## `octal`

### Description
Formats a value as an octal number.

### Method
`fn octal<D: fmt::Octal>(&mut self, value: &D) -> Result<(), FormatError>`

### Parameters
- `value` (&D) - The value to format, which must implement `fmt::Octal`.
```

```APIDOC
## `lower_hex`

### Description
Formats a value as a lowercase hexadecimal number.

### Method
`fn lower_hex<D: fmt::LowerHex>(&mut self, value: &D) -> Result<(), FormatError>`

### Parameters
- `value` (&D) - The value to format, which must implement `fmt::LowerHex`.
```

```APIDOC
## `upper_hex`

### Description
Formats a value as an uppercase hexadecimal number.

### Method
`fn upper_hex<D: fmt::UpperHex>(&mut self, value: &D) -> Result<(), FormatError>`

### Parameters
- `value` (&D) - The value to format, which must implement `fmt::UpperHex`.
```

```APIDOC
## `pointer`

### Description
Formats a value as a pointer.

### Method
`fn pointer<D: fmt::Pointer>(&mut self, value: &D) -> Result<(), FormatError>`

### Parameters
- `value` (&D) - The value to format, which must implement `fmt::Pointer`.
```

```APIDOC
## `binary`

### Description
Formats a value as a binary number.

### Method
`fn binary<D: fmt::Binary>(&mut self, value: &D) -> Result<(), FormatError>`

### Parameters
- `value` (&D) - The value to format, which must implement `fmt::Binary`.
```

```APIDOC
## `lower_exp`

### Description
Formats a value using lowercase scientific notation (e.g., `1.23e-4`).

### Method
`fn lower_exp<D: fmt::LowerExp>(&mut self, value: &D) -> Result<(), FormatError>`

### Parameters
- `value` (&D) - The value to format, which must implement `fmt::LowerExp`.
```

```APIDOC
## `upper_exp`

### Description
Formats a value using uppercase scientific notation (e.g., `1.23E-4`).

### Method
`fn upper_exp<D: fmt::UpperExp>(&mut self, value: &D) -> Result<(), FormatError>`

### Parameters
- `value` (&D) - The value to format, which must implement `fmt::UpperExp`.
```
Tokens:
Raw