numfmt

https://docs.rs/numfmt/latest/numfmt/
Admin
numfmt is a fast and friendly number formatting library for Rust that provides customizable...
Tokens:19,846
Snippets:184
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Using expect with Environment Variable

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Shows a common use case for `expect` where an environment variable is expected to be set. The message guides the user on what to check if the variable is missing.

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

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

### Collecting Results from Iterators

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Examples of using FromIterator to collect Results, demonstrating short-circuiting behavior on Err.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

```rust
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);
```

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

### Get the set units

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

Returns a slice of the unit strings configured for the scale.

```rust
pub fn units(&self) -> &[&'static str]
```

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

### Get the set base

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

Returns the base value configured for the scale.

```rust
pub fn base(&self) -> u16
```

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

### Get Reference to Ok Value

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Converts a `&Result<T, E>` to `Result<&T, &E>`, providing a reference to the contained value without consuming the original `Result`.

```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"));
```

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

### Customize Formatter options

Source: https://docs.rs/numfmt/latest/numfmt/index.html

Demonstrates creating a currency formatter by chaining configuration methods like separator, prefix, and precision.

```rust
let mut f = Formatter::new() // start with blank representation
    .separator(',').unwrap()
    .prefix("AU$").unwrap()
    .precision(Precision::Decimals(2));

assert_eq!(f.fmt(0.52), "AU$0.52");
assert_eq!(f.fmt(1234.567), "AU$1,234.56");
assert_eq!(f.fmt(12345678900.0), "AU$12,345,678,900.0");
```

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

### Create a file size formatter

Source: https://docs.rs/numfmt/latest/numfmt/index.html

Combines binary scaling, significant figure precision, and a suffix to format file sizes.

```rust
let mut f = Formatter::new()
                .scales(Scales::binary())
                .precision(Precision::Significance(3))
                .suffix("B").unwrap();

assert_eq!(f.fmt(123_f64), "123 B");
assert_eq!(f.fmt(1234_f64), "1.20 kiB");
assert_eq!(f.fmt(1_048_576_f64), "1.0 MiB");
assert_eq!(f.fmt(123456789876543_f64), "112 TiB");
```

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

### Using unwrap on Ok Result

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Demonstrates the basic usage of the `unwrap` method when the Result is an Ok. It safely returns the contained value.

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

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

### Get Mutable Reference to Value

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Converts a `&mut Result<T, E>` to `Result<&mut T, &mut E>`, allowing in-place modification of the contained value or error.

```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);
```

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

### Formatter Configuration Methods

Source: https://docs.rs/numfmt/latest/numfmt/struct.Formatter.html

Methods to configure the behavior of the Formatter, such as precision, scaling, separators, and prefixes/suffixes.

```APIDOC
#### pub fn convert(self, f: fn(f64) -> f64) -> Self
Set the value converter.
Use a converter to transform the input number into another number. This is done before all steps and the number follows the same procedure as normal. A good example of a use of a converter is to make a percentage number by _always_ multiplying by 100.

#### pub fn precision(self, precision: Precision) -> Self
Set the precision.

#### pub fn scales(self, scales: Scales) -> Self
Set the scaling.

#### pub fn build_scales(self, base: u16, units: Vec<&'static str>) -> Result
Set the scaling via `Scales::new`.

#### pub fn separator<S: Into<Option<char>>>(self, sep: S) -> Result
Set the thousands separator.
If separator is not a single byte, an error is returned. If the separator is a period `.`, this signals to use a comma for the decimal marker.
##### §Example
```rust
let mut f = Formatter::new().separator(',').unwrap(); // use a comma
assert_eq!(f.fmt(12345.67), "12,345.67");

f = f.separator(' ').unwrap(); // use a space
assert_eq!(f.fmt(12345.67), "12 345.67");

f = f.separator(None).unwrap(); // no separator
assert_eq!(f.fmt(12345.67), "12345.67");

f = f.separator('.').unwrap(); // use a period separator and comma for decimal
assert_eq!(f.fmt(12345.67), "12.345,67");
```

#### pub fn comma(self, comma: bool) -> Self
Set the comma option.
If set to true it will use a comma instead of a period. If a comma is the separator, a period will be used instead.
##### §Example
```rust
let mut f = Formatter::new();
assert_eq!(f.fmt(12345.67), "12345.67");
f = f.comma(true);
assert_eq!(f.fmt(12345.67), "12345,67");

f = f.separator('.').unwrap();
assert_eq!(f.fmt(12345.67), "12.345,67");
```

#### pub fn prefix(self, prefix: &str) -> Result
Sets the prefix.
If the prefix is longer than the supported length, an error is returned.

#### pub fn suffix(self, suffix: &str) -> Result
Set the suffix.
If the suffix is longer than the supported length, an error is returned.
```

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

### Format as percentage

Source: https://docs.rs/numfmt/latest/numfmt/struct.Formatter.html

Creates a formatter for percentage output, supporting precision adjustments.

```rust
let mut f = Formatter::percentage();
assert_eq!(f.fmt(0.678912), "67.8912%");
assert_eq!(f.fmt(1.23), "123.0%");
assert_eq!(f.fmt(1.2), "120.0%");

f = f.precision(Precision::Decimals(2));
assert_eq!(f.fmt(0.01234), "1.23%");
```

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

### Format as currency

Source: https://docs.rs/numfmt/latest/numfmt/struct.Formatter.html

Creates a formatter configured for currency output with a specified prefix.

```rust
let mut f = Formatter::currency("$").unwrap();
assert_eq!(f.fmt(12345.6789), "$12,345.67");
assert_eq!(f.fmt(1234_f64), "$1,234.0");
```

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

### Formatter Constructors

Source: https://docs.rs/numfmt/latest/numfmt/struct.Formatter.html

Methods for creating new Formatter instances with default or specific configurations.

```APIDOC
## Implementations§
### impl Formatter
#### pub fn new() -> Self
Construct a new formatter.
No scaling is set, so this is only does a single allocation for the buffer.
##### §Example
```rust
let mut f = Formatter::new();
assert_eq!(f.fmt(12345.6789), "12345.6789");
```

#### pub fn currency(prefix: &str) -> Result
Create a formatter that formats numbers as a currency.
##### §Example
```rust
let mut f = Formatter::currency("$").unwrap();
assert_eq!(f.fmt(12345.6789), "$12,345.67");
assert_eq!(f.fmt(1234_f64), "$1,234.0");
```

#### pub fn percentage() -> Self
Create a formatter that formats numbers as a percentage.
##### §Example
```rust
let mut f = Formatter::percentage();
assert_eq!(f.fmt(0.678912), "67.8912%");
assert_eq!(f.fmt(1.23), "123.0%");
assert_eq!(f.fmt(1.2), "120.0%");

f = f.precision(Precision::Decimals(2));
assert_eq!(f.fmt(0.01234), "1.23%");
```
```

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

### CloneToUninit Trait Implementation (Nightly)

Source: https://docs.rs/numfmt/latest/numfmt/enum.Precision.html

This nightly-only experimental API allows copying data to uninitialized memory.

```rust
impl<T> CloneToUninit for T
where T: Clone,
```

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

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

### Apply Scaling to Number Formatting

Source: https://docs.rs/numfmt/latest/numfmt/index.html

Configures how numbers are scaled using predefined characters: `s` for SI, `%` for percentage, `m` for metric, `b` for binary, and `n` for no scaling. Default is SI scaling.

```rust
let mut f: Formatter;
f = "".parse().unwrap(); // default si scaling used
assert_eq!(f.fmt(12345.0), "12.345 K");
```

```rust
f = "[n]".parse().unwrap(); // turn off scaling
assert_eq!(f.fmt(12345.0), "12,345.0");
```

```rust
f = "[%.2]".parse().unwrap(); // format as percentages with 2 decimal places
assert_eq!(f.fmt(0.234), "23.40%");
```

```rust
f = "[b]".parse().unwrap(); // use a binary scaler
assert_eq!(f.fmt(3.14 * 1024.0 * 1024.0), "3.14 Mi");
```

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

### Set Decimal Precision for Number Formatting

Source: https://docs.rs/numfmt/latest/numfmt/index.html

Demonstrates how to set the number of decimal places or use arbitrary precision for formatting. Use `.` for decimal places and `.*` for arbitrary precision.

```rust
let mut f: Formatter;
f = "[.2]".parse().unwrap(); // use two decimal places
assert_eq!(f.fmt(1.2345), "1.23");
```

```rust
f = "[,2]".parse().unwrap(); // use two decimal places with comma
assert_eq!(f.fmt(1.2345), "1,23");
```

```rust
f = "[.0]".parse().unwrap(); // use zero decimal places
assert_eq!(f.fmt(10.234), "10");
```

```rust
f = "[.*]".parse().unwrap(); // arbitrary precision
assert_eq!(f.fmt(1.234), "1.234");
assert_eq!(f.fmt(12.2), "12.2");
```

```rust
f = "[,*]".parse().unwrap(); // arbitrary precision with comma
assert_eq!(f.fmt(1.234), "1,234");
```

```rust
f = "[~3]".parse().unwrap(); // 3 significant figures
assert_eq!(f.fmt(1.234), "1.23");
assert_eq!(f.fmt(10.234), "10.2");
```

```rust
f = "[~3/.]".parse().unwrap(); // 3 significant figures with comma
assert_eq!(f.fmt(1.234), "1,23");
```

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

### Construct a new Formatter

Source: https://docs.rs/numfmt/latest/numfmt/struct.Formatter.html

Initializes a default formatter with no scaling.

```rust
let mut f = Formatter::new();
assert_eq!(f.fmt(12345.6789), "12345.6789");
```

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

### Using into_ok for Infallible Results

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Demonstrates `into_ok`, an experimental nightly-only feature, which returns the Ok value from a Result that is guaranteed not to panic. This is a compile-time safeguard against future Result type changes.

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

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

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

### into_ok

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Returns the contained `Ok` value, but never panics. This is a nightly-only experimental API. It's known to never panic on the result types it is implemented for, making it a maintainability safeguard.

```APIDOC
## POST /api/upload

### Description
Handles file uploads. This endpoint is typically used to upload files to the server.

### Method
POST

### Endpoint
/api/upload

### Parameters
#### Request Body
- **file** (file) - Required - The file to be uploaded.
- **userId** (string) - Optional - The ID of the user associated with the upload.

### Request Example
(Multipart form data containing the file and optional userId)

### Response
#### Success Response (201)
- **fileId** (string) - The unique identifier for the uploaded file.
- **url** (string) - The URL where the uploaded file can be accessed.

#### Response Example
```json
{
  "fileId": "file-abcde",
  "url": "https://example.com/uploads/file-abcde.jpg"
}
```
```

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

### Create a dummy scale

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

This function creates a scale that does not perform any scaling. It's useful for cases where no scaling is desired.

```rust
pub fn none() -> Self
```

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

### Implement From<T> for T

Source: https://docs.rs/numfmt/latest/numfmt/enum.ParseError.html

A trivial implementation of From<T> for T, returning the argument unchanged.

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

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

### Configure precision settings

Source: https://docs.rs/numfmt/latest/numfmt/index.html

Shows how to switch between decimal places and significant figures using the Precision enum.

```rust
let mut f = Formatter::new();
assert_eq!(f.fmt(1234.56789), "1234.56789");

f = f.precision(Precision::Decimals(2));
assert_eq!(f.fmt(1234.56789), "1234.56");

f = f.precision(Precision::Significance(5));
assert_eq!(f.fmt(1234.56789), "1234.5");
```

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

### Default scaling with short scale

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

The default scaling method uses a base of 1000. Units denote magnitude, with the empty base representing the base value.

```rust
pub fn short() -> Self
```

```rust
let mut f = Formatter::default()
            .scales(Scales::short())
            .precision(Precision::Decimals(1));
assert_eq!(f.fmt(12.34e0), "12.3");
assert_eq!(f.fmt(12.34e3), "12.3 K");
assert_eq!(f.fmt(12.34e6), "12.3 M");
assert_eq!(f.fmt(12.34e9), "12.3 B");
assert_eq!(f.fmt(12.34e12), "12.3 T");
assert_eq!(f.fmt(12.34e15), "12.3 P");
assert_eq!(f.fmt(12.34e18), "12.3 E");
assert_eq!(f.fmt(12.34e21), "12.3 Z");
assert_eq!(f.fmt(12.34e24), "12.3 Y");
assert_eq!(f.fmt(12.34e27), "12,339.9 Y");
```

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

### Format numbers with default settings

Source: https://docs.rs/numfmt/latest/numfmt/index.html

Uses the default Formatter configuration which includes short scaling, comma separators, and 3 decimal places.

```rust
let mut f = Formatter::default();
assert_eq!(f.fmt(0.0), "0");
assert_eq!(f.fmt(12345.6789), "12.345 K");
assert_eq!(f.fmt(0.00012345), "1.234e-4");
assert_eq!(f.fmt(123456e22), "1,234.559 Y");
```

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

### Using unwrap_or_default for Parsing

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Shows how `unwrap_or_default` can be used to parse a string into a number, providing a default value (0 for integers) if the string is not a valid number.

```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);
```

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

### Formatter Equality and Hashing

Source: https://docs.rs/numfmt/latest/numfmt/struct.Formatter.html

Methods for testing equality and generating hash values for Formatter instances.

```APIDOC
## Equality and Hashing Methods

### Methods
- **eq(&self, other: &Self) -> bool**: Tests for equality between two Formatter instances.
- **ne(&self, other: &Rhs) -> bool**: Tests for inequality between two Formatter instances.
- **hash<H: Hasher>(&self, hasher: &mut H)**: Feeds the Formatter value into the provided Hasher.
- **hash_slice<H>(data: &[Self], state: &mut H)**: Feeds a slice of Formatter values into the provided Hasher.
```

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

### Providing a default with unwrap_or

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Returns the contained Ok value or a provided default value. 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);
```

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

### Compose Number Formatting Options

Source: https://docs.rs/numfmt/latest/numfmt/index.html

Combines various formatting options like precision, scaling, and separators in a single format string. The order within the number format is arbitrary, but consistency is recommended.

```rust
let mut f: Formatter;

// Percentages to two decimal places
f = "[.2%]".parse().unwrap();
assert_eq!(f.fmt(0.012345), "1.23%");
```

```rust
// Currency to zero decimal places
// notice the `n` for no scaling
f = "$[.0n] USD".parse().unwrap();
assert_eq!(f.fmt(123_456_789.12345), "$123,456,789 USD");
```

```rust
// Formatting file sizes
f = "[~3b]B".parse().unwrap();
assert_eq!(f.fmt(123_456_789.0), "117 MiB");
```

```rust
// Units to 1 decimal place
f = "[.1n] m/s".parse().unwrap();
assert_eq!(f.fmt(12345.68), "12,345.6 m/s");
```

```rust
// Using custom separator and period for decimals
f = "[,1n/_]".parse().unwrap();
assert_eq!(f.fmt(12345.68), "12_345,6");
```

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

### Define formatter grammar

Source: https://docs.rs/numfmt/latest/numfmt/index.html

Displays the syntax structure for parsing a string into a Formatter configuration.

```text
prefix[[.#|,#|~#|.*|,*][%|s|b|n][/<char>]]suffix
^----^ ^--------------^^-------^^-------^ ^----^
prefix precision scale    separator suffix
```

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

### Fallback with or

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Returns the provided Result if the current one is Err, otherwise returns the Ok value. Arguments are eagerly evaluated.

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

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

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

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

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

### Formatter::from_str

Source: https://docs.rs/numfmt/latest/numfmt/struct.Formatter.html

Parses a string into a Formatter instance.

```APIDOC
## fn from_str(s: &str) -> Result<Self, ParseError>

### Description
Parses a string `s` to return a value of this type.

### Parameters
#### Request Body
- **s** (str) - Required - The string to parse into a Formatter.
```

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

### Parse formatter from string

Source: https://docs.rs/numfmt/latest/numfmt/index.html

Uses string parsing to define formatter behavior, including handling of prefixes, suffixes, and special bracket characters.

```rust
let mut f: Formatter;
f = "".parse().unwrap();
assert_eq!(f.fmt(1.234), "1.234");

f = "prefix ".parse().unwrap();
assert_eq!(f.fmt(1.234), "prefix 1.234");

f = "[] suffix".parse().unwrap();
assert_eq!(f.fmt(1.234), "1.234 suffix");

f = "[[prefix [] suffix]]".parse().unwrap();
assert_eq!(f.fmt(1.234), "[prefix 1.234 suffix]");
```

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

### Clone Scales from source

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

Performs copy-assignment from a source Scales instance to self.

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

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

### Formatting Methods

Source: https://docs.rs/numfmt/latest/numfmt/struct.Formatter.html

Methods used to format numeric values into strings.

```APIDOC
#### pub fn fmt(&mut self, num: f64) -> &str
👎Deprecated: consider using Formatter::fmt2 instead
Format the number!

#### pub fn fmt2<N: Numeric>(&mut self, num: N) -> &str
Format any number implementing `Numeric`.

#### pub fn fmt_into<N: Numeric>(&self, buf: &mut String, num: N)
Format any number implementing `Numeric`, appending to the supplied `buf`.
This is functionally the same as `Self::fmt2`, however it does not use the backing buffer, instead extending the supplied string. Useful when the receiver is shared.

#### pub fn fmt_string<N: Numeric>(&self, num: N) -> String
Format any number implementing `Numeric`, returning an owned `String`.
This is functionally the same as `Self::fmt2`, however it does not use the backing buffer, instead allocating a new string to write into. Useful when the receiver is shared.
```

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

### Trait Implementations

Source: https://docs.rs/numfmt/latest/numfmt/struct.Formatter.html

Standard trait implementations for the Formatter struct.

```APIDOC
## Trait Implementations§
### impl Clone for Formatter
#### fn clone(&self) -> Formatter
Returns a duplicate of the value. Read more
1.0.0 · Source§
#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`. Read more
Source§
### impl Debug for Formatter
#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Source§
### impl Default for Formatter
#### fn default() -> Self
Returns the “default value” for a type. Read more
Source§
### impl FromStr for Formatter
#### type Err = ParseError
The associated error which can be returned from parsing.
Source§
```

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

### Implement StructuralPartialEq for ParseError

Source: https://docs.rs/numfmt/latest/numfmt/enum.ParseError.html

Provides structural partial equality comparison for ParseError.

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

### Scales API Methods

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

Methods for creating and interacting with the Scales struct.

```APIDOC
## Scales::new

### Description
Creates a new scale with a specified base and units.

### Parameters
- **base** (u16) - Required - The base value for scaling.
- **units** (Vec<&'static str>) - Required - A list of unit strings.

## Scales::none

### Description
Creates a dummy scale that does not perform any scaling.

## Scales::short

### Description
Creates the default short scale using base 1000.

## Scales::metric

### Description
Creates a metric SI scale using base 1000, intended for unit prefixes.

## Scales::binary

### Description
Creates a binary scale using base 1024, intended for unit prefixes.

## Scales::scale

### Description
Scales a given number and returns the scaled value along with its unit.

### Parameters
- **num** (f64) - Required - The number to scale.

### Response
- **(f64, &'static str)** - The scaled number and the corresponding unit.
```

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

### Create a new scale with custom units

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

Use this function to create a new scale with a specified base and a vector of unit strings. An error is returned if any unit string exceeds the supported length.

```rust
pub fn new(base: u16, units: Vec<&'static str>) -> Result<Self, Error>
```

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

### Clone Scales to uninitialized memory (Nightly)

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

Nightly-only experimental API. Performs copy-assignment from self to uninitialized memory.

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

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

### Product Implementation for Result

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Calculates the product of an iterator of Results, returning the first Err encountered or the product of all Ok values.

```APIDOC
## fn product<I>(iter: I) -> Result<T, E>

### Description
Takes each element in the Iterator: if it is an Err, no further elements are taken, and the Err is returned. Should no Err occur, the product of all elements is returned.

### Parameters
- **iter** (Iterator<Item = Result<U, E>>) - Required - The iterator of Result values to multiply.
```

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

### TryFrom Trait

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

Details the `TryFrom` trait implementation for type conversions.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Provides a way to perform fallible conversions from one type to another.

### Method
`try_from`

### Endpoint
None

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **T** (type) - The successfully converted value.

#### Error Response
- **Error** (type) - The error type returned upon conversion failure.

#### Response Example
None
```

```APIDOC
## type Error = Infallible

### Description
The type returned in the event of a conversion error. `Infallible` indicates that this conversion cannot fail.
```

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

### Description
Performs the conversion from type `U` to type `T`.

### Method
`try_from`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **T** (type) - The successfully converted value.

#### Response Example
None
```

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

### Implement PartialEq for ParseError

Source: https://docs.rs/numfmt/latest/numfmt/enum.ParseError.html

Enables equality comparison between ParseError instances.

```rust
fn eq(&self, other: &ParseError) -> bool
```

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

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

### Clone Into Trait

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

Details the `clone_into` method within the `CloneInto` trait.

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

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

### Method
`clone_into`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
None

#### Success Response (200)
None

#### Response Example
None
```

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

### Implement TryInto<U> for T

Source: https://docs.rs/numfmt/latest/numfmt/enum.ParseError.html

Attempts to convert a type T into a type U, returning a Result.

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

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

### Check if Result is Ok

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Demonstrates how to check if a `Result` instance is the `Ok` variant. This is useful for conditional logic based on operation success.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

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

### Trait Implementations for Precision

Source: https://docs.rs/numfmt/latest/numfmt/enum.Precision.html

Details the standard Rust trait implementations available for the Precision enum, enabling common operations and comparisons.

```APIDOC
## Trait Implementations for Precision

### `Clone` and `Copy`

- `impl Clone for Precision`: Allows creating a copy of a `Precision` value.
- `impl Copy for Precision`: Indicates that `Precision` values can be copied implicitly.

### `Debug`

- `impl Debug for Precision`: Enables formatting `Precision` values for debugging purposes.

### `PartialEq` and `Eq`

- `impl PartialEq for Precision`: Allows comparing two `Precision` values for equality.
- `impl Eq for Precision`: Marks `Precision` as having a total equivalence relation.

### `Hash`

- `impl Hash for Precision`: Enables hashing `Precision` values, useful for collections like `HashMap`.

### Other Implementations

- `Send`, `Sync`, `Freeze`, `RefUnwindSafe`, `Unpin`, `UnwindSafe`: Auto trait implementations indicating thread safety and memory safety characteristics.
- Blanket implementations for `Any`, `Borrow`, `BorrowMut`, `CloneToUninit`, `From`, `Into`, `ToOwned`, `TryFrom`, `TryInto` provide further interoperability and conversion capabilities.
```

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

### is_zero Method Implementation

Source: https://docs.rs/numfmt/latest/numfmt/trait.Numeric.html

Checks if a number is zero. The default implementation converts to f64 and performs the test.

```rust
fn is_zero(&self) -> bool { ... }
```

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

### Binary scale

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

This function creates a binary scale with a base of 1024. It's intended for unit prefixes, and the empty base includes a space.

```rust
pub fn binary() -> Self
```

```rust
let mut f = Formatter::new().scales(Scales::binary());
assert_eq!(f.fmt(1024.0 * 1024.0), "1.0 Mi");
assert_eq!(f.fmt(3.14 * 1024.0 * 1024.0), "3.14 Mi");
```

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

### TryInto Trait

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

Details the `TryInto` trait implementation for type conversions.

```APIDOC
## impl<T, U> TryInto<U> for T

### Description
Provides a way to attempt a conversion from one type to another, which may fail.

### Method
`try_into`

### Endpoint
None

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **U** (type) - The successfully converted value.

#### Error Response
- **Error** (type) - The error type returned upon conversion failure.

#### Response Example
None
```

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

### Description
The type returned in the event of a conversion error. This is determined by the `Error` type of the corresponding `TryFrom` implementation.
```

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

### Description
Performs the conversion from the current type `T` to type `U`.

### Method
`try_into`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **U** (type) - The successfully converted value.

#### Response Example
None
```

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

### Implement TryFrom<U> for T

Source: https://docs.rs/numfmt/latest/numfmt/enum.ParseError.html

Attempts to convert a type U into a type T, returning a Result.

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

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

### Implement ToString for Display types

Source: https://docs.rs/numfmt/latest/numfmt/enum.ParseError.html

Converts any type implementing the Display trait into a String.

```rust
fn to_string(&self) -> String
```

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

### Using unwrap on Err Result

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Illustrates the use of the `unwrap` method when the Result is an Err. This will cause a panic with the error message.

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

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

### Metric SI scale

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

This function creates a scale using the SI standard with a base of 1000. It's intended for unit prefixes, and the empty base includes a space.

```rust
pub fn metric() -> Self
```

```rust
let mut f = Formatter::new().scales(Scales::metric());
assert_eq!(f.fmt(123456.0), "123.456 k");
assert_eq!(f.fmt(123456789.0), "123.456789 M");
```

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

### Using expect on Err Result

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Illustrates the use of the `expect` method when the Result is an Err. This will cause a panic with a custom message.

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

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

### Convert Result to Option (Ok value)

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Converts a `Result<T, E>` into an `Option<T>`, consuming the `Result` and discarding any error. Returns `Some(T)` if the result was `Ok`, otherwise `None`.

```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);
```

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

### Result Methods

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

A collection of methods for manipulating and inspecting Result<T, E> types.

```APIDOC
## map_or

### Description
Returns the provided default if the result is Err, or applies a function to the contained value if Ok.

## map_or_else

### Description
Maps a Result<T, E> to U by applying a fallback function to an Err value, or a function to an Ok value.

## map_or_default

### Description
Maps a Result<T, E> to a U by applying a function to the contained value if Ok, otherwise returns the default value for U.

## map_err

### Description
Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value, leaving Ok untouched.

## inspect

### Description
Calls a function with a reference to the contained value if Ok. Returns the original result.

## inspect_err

### Description
Calls a function with a reference to the contained value if Err. Returns the original result.

## as_deref

### Description
Converts from Result<T, E> to Result<&<T as Deref>::Target, &E>.

## as_deref_mut

### Description
Converts from Result<T, E> to Result<&mut <T as DerefMut>::Target, &mut E>.

## iter

### Description
Returns an iterator over the possibly contained value. Yields one value if Ok, otherwise none.

## iter_mut

### Description
Returns a mutable iterator over the possibly contained value. Yields one value if Ok, otherwise none.
```

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

### Result IntoIterator Implementation

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Demonstrates converting a Result into an iterator that yields the contained value if Ok, or nothing if Err.

```rust
let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);

let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
```

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

### Compare Scales for equality

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

Tests if two Scales values are equal.

```rust
fn eq(&self, other: &Scales) -> bool
```

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

### is_negative Method Implementation

Source: https://docs.rs/numfmt/latest/numfmt/trait.Numeric.html

Checks if a number is negative. The default implementation converts to f64 and performs the test.

```rust
fn is_negative(&self) -> bool { ... }
```

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

### Result Trait Implementations

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Standard trait implementations for the Result type.

```APIDOC
## FromIterator Implementation

### Description
Takes each element in the Iterator: if it is an `Err`, no further elements are taken, and the `Err` is returned. Should no `Err` occur, a container with the values of each `Result` is returned.

## IntoIterator Implementation

### Description
Returns a consuming iterator over the possibly contained value. The iterator yields one value if the result is `Result::Ok`, otherwise none.
```

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

### Configure comma usage

Source: https://docs.rs/numfmt/latest/numfmt/struct.Formatter.html

Toggles the use of a comma as a decimal marker instead of a period.

```rust
let mut f = Formatter::new();
assert_eq!(f.fmt(12345.67), "12345.67");
f = f.comma(true);
assert_eq!(f.fmt(12345.67), "12345,67");

f = f.separator('.').unwrap();
assert_eq!(f.fmt(12345.67), "12.345,67");
```

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

### Compare Scales for inequality

Source: https://docs.rs/numfmt/latest/numfmt/struct.Scales.html

Tests if two Scales values are not equal.

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

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

### TryFrom and TryInto Trait Implementations

Source: https://docs.rs/numfmt/latest/numfmt/enum.Precision.html

These traits provide fallible conversion methods between types, returning a `Result`.

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

```rust
type Error = Infallible
```

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

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

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

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

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

### is_infinite Method Implementation

Source: https://docs.rs/numfmt/latest/numfmt/trait.Numeric.html

Checks if a number is infinite. The default implementation converts to f64 and performs the test.

```rust
fn is_infinite(&self) -> bool { ... }
```

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

### unwrap

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Returns the contained `Ok` value, consuming the `self` value. Panics if the value is an `Err`, with a panic message provided by the `Err`’s value. This is generally discouraged in favor of safer methods like pattern matching or the `?` operator.

```APIDOC
## GET /api/users/{userId}

### Description
Retrieves details for a specific user by their ID.

### Method
GET

### Endpoint
/api/users/{userId}

### Parameters
#### Path Parameters
- **userId** (string) - Required - The unique identifier of the user to retrieve.

#### Query Parameters
- **fields** (string) - Optional - Comma-separated list of fields to include in the response.

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the user.
- **username** (string) - The username of the user.
- **email** (string) - The email address of the user.
- **createdAt** (string) - The timestamp when the user account was created.

#### Response Example
```json
{
  "id": "user-12345",
  "username": "johndoe",
  "email": "john.doe@example.com",
  "createdAt": "2023-10-27T10:00:00Z"
}
```
```

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

### Implement Debug for ParseError

Source: https://docs.rs/numfmt/latest/numfmt/enum.ParseError.html

Provides a Debug implementation for the ParseError enum, allowing it to be formatted for debugging purposes.

```rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

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

### Product for Result<T, E>

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Multiplies numbers from an iterator, returning Err if any string fails to parse.

```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());
```

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

### Type Conversion Implementations

Source: https://docs.rs/numfmt/latest/numfmt/enum.Error.html

Details on how the Error enum can be converted to other types, such as ParseError, and how it participates in generic conversions.

```APIDOC
### impl From<Error> for ParseError

#### fn from(err: Error) -> Self
Converts to this type from the input type.
```

```APIDOC
### impl PartialEq for Error

#### fn eq(&self, other: &Error) -> bool
Tests for `self` and `other` values to be equal, and is used by `==`.

#### fn ne(&self, other: &Rhs) -> bool
Tests for `!=`.
```

```APIDOC
### impl StructuralPartialEq for Error
```

```APIDOC
### impl<T> Any for T

#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.
```

```APIDOC
### impl<T> Borrow<T> for T

#### fn borrow(&self) -> &T
Immutably borrows from an owned value.
```

```APIDOC
### impl<T> BorrowMut<T> for T

#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.
```

```APIDOC
### impl<T> From<T> for T

#### fn from(t: T) -> T
Returns the argument unchanged.
```

```APIDOC
### impl<T, U> Into<U> for T

#### fn into(self) -> U
Calls `U::from(self)`.
```

```APIDOC
### impl<T> ToString for T

#### fn to_string(&self) -> String
Converts the given value to a `String`.
```

```APIDOC
### impl<T, U> TryFrom<U> for T

#### type Error = Infallible

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

```APIDOC
### impl<T, U> TryInto<U> for T

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

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

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

### Implement Any for generic types

Source: https://docs.rs/numfmt/latest/numfmt/enum.ParseError.html

Provides the `type_id` method for any type that is 'static and Send + Sync + 'static.

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

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

### Using expect_err on Ok Result

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Demonstrates the use of `expect_err` when the Result is an Ok. This will cause a panic with a custom message including the Ok value.

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

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

### Formatter Struct

Source: https://docs.rs/numfmt/latest/numfmt/struct.Formatter.html

The Formatter struct holds the configuration for number formatting.

```APIDOC
## Struct Formatter

### Description
The number formatter configurations. See the module documentation for use.
`Formatter` has a `FromStr` implementation that can parse a string into a formatter using a specific grammar. Please consult the parsing section in the module documentation.
```

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

### Map Result to Value with map_or_default

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Maps Ok to a value using a function, or returns the default value for the type if Err. Requires the result_option_map_or_default feature.

```rust
#![feature(result_option_map_or_default)]

let x: Result<_, &str> = Ok("foo");
let y: Result<&str, _> = Err("bar");

assert_eq!(x.map_or_default(|x| x.len()), 3);
assert_eq!(y.map_or_default(|y| y.len()), 0);
```

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

### Computing a default with unwrap_or_else

Source: https://docs.rs/numfmt/latest/numfmt/type.Result.html

Returns the contained Ok value or computes it from a closure if the result is Err.

```rust
fn count(x: &str) -> usize { x.len() }

assert_eq!(Ok(2).unwrap_or_else(count), 2);
assert_eq!(Err("foo").unwrap_or_else(count), 3);
```

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

### Numeric Trait Implementation for u64

Source: https://docs.rs/numfmt/latest/numfmt/trait.Numeric.html

Provides implementations of the Numeric trait methods for the u64 type.

```rust
impl Numeric for u64
```

```rust
fn to_f64(&self) -> f64
```

```rust
fn is_nan(&self) -> bool
```

```rust
fn is_negative(&self) -> bool
```

```rust
fn is_infinite(&self) -> bool
```

```rust
fn is_zero(&self) -> bool
```

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

### Numeric Trait Implementation for i64

Source: https://docs.rs/numfmt/latest/numfmt/trait.Numeric.html

Provides implementations of the Numeric trait methods for the i64 type.

```rust
impl Numeric for i64
```

```rust
fn to_f64(&self) -> f64
```

```rust
fn is_nan(&self) -> bool
```

```rust
fn is_negative(&self) -> bool
```

```rust
fn is_infinite(&self) -> bool
```

```rust
fn is_zero(&self) -> bool
```
Tokens:
Raw