### Example of underline()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the underline() method to apply underline formatting.

```rust
println!("{}", value.underline());
```

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

### Example of bold()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the bold() method to apply bold formatting.

```rust
println!("{}", value.bold());
```

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

### Example of blink()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the blink() method to apply blink formatting.

```rust
println!("{}", value.blink());
```

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

### Example of on_magenta()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_magenta() method to set the background color to magenta.

```rust
println!("{}", value.on_magenta());
```

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

### Examples of Product on Result Iterator

Source: https://docs.rs/rust_decimal/latest/rust_decimal/type.Result.html?search=std%3A%3Avec

Demonstrates using the `product` method on an iterator of `Result`s. The first example shows a successful multiplication, while the second shows an error due to a non-parseable string.

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

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

### Example of rapid_blink()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the rapid_blink() method to apply rapid blink formatting.

```rust
println!("{}", value.rapid_blink());
```

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

### Example of on_cyan()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_cyan() method to set the background color to cyan.

```rust
println!("{}", value.on_cyan());
```

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

### Example of on_bright_white()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_bright_white() method to set the background color to bright white.

```rust
println!("{}", value.on_bright_white());
```

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

### Example of on_bright_cyan()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_bright_cyan() method to set the background color to bright cyan.

```rust
println!("{}", value.on_bright_cyan());
```

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

### Example of on_bright_black()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_bright_black() method to set the background color to bright black.

```rust
println!("{}", value.on_bright_black());
```

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

### Example of Rounding to 2 Decimal Places

Source: https://docs.rs/rust_decimal/latest/src/rust_decimal/decimal.rs.html?search=u32+-%3E+bool

Demonstrates how to use the `round_dp` method to round a Decimal to two decimal places. The example uses the `dec!` macro for easy Decimal creation.

```rust
# use rust_decimal::Decimal;
# use rust_decimal_macros::dec;
# 
let pi = dec!(3.1415926535897932384626433832);
assert_eq!(pi.round_dp(2).to_string(), "3.14");
```

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

### Example of strike()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the strike() method to apply strike-through formatting.

```rust
println!("{}", value.strike());
```

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

### Example of on_bright_red()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_bright_red() method to set the background color to bright red.

```rust
println!("{}", value.on_bright_red());
```

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

### Example of on_white()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_white() method to set the background color to white.

```rust
println!("{}", value.on_white());
```

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

### Example of conceal()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the conceal() method to hide text.

```rust
println!("{}", value.conceal());
```

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

### Example of dim()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the dim() method to apply dim formatting.

```rust
println!("{}", value.dim());
```

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

### Example of on_blue()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_blue() method to set the background color to blue.

```rust
println!("{}", value.on_blue());
```

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

### Example of on_bright_magenta()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_bright_magenta() method to set the background color to bright magenta.

```rust
println!("{}", value.on_bright_magenta());
```

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

### Example of invert()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the invert() method to invert the colors.

```rust
println!("{}", value.invert());
```

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

### Example of on_bright_blue()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_bright_blue() method to set the background color to bright blue.

```rust
println!("{}", value.on_bright_blue());
```

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

### Example of italic()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the italic() method to apply italic formatting.

```rust
println!("{}", value.italic());
```

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

### Create New Painted Example

Source: https://docs.rs/rust_decimal/latest/rust_decimal/serde/struct.DecimalFromString.html?search=u32+-%3E+bool

Creates a new Painted object with a default style.

```rust
Painted::new()
```

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

### Example of on_green()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_green() method to set the background color to green.

```rust
println!("{}", value.on_green());
```

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

### Example of on_bright_green()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_bright_green() method to set the background color to bright green.

```rust
println!("{}", value.on_bright_green());
```

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

### Example of on_yellow()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_yellow() method to set the background color to yellow.

```rust
println!("{}", value.on_yellow());
```

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

### Rust Decimal: Background Color Examples

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

Demonstrates setting background colors using `bg()` and `on_red()`.

```rust
use yansi::{Paint, Color};

painted.bg(Color::Red);
```

```rust
use yansi::Paint;

painted.on_red();
```

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

### Example of on_bright_yellow()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the on_bright_yellow() method to set the background color to bright yellow.

```rust
println!("{}", value.on_bright_yellow());
```

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

### Apply Style Wholesale Example

Source: https://docs.rs/rust_decimal/latest/rust_decimal/serde/struct.DecimalFromString.html?search=u32+-%3E+bool

Applies a given style wholesale to the painted object, replacing any previous style.

```rust
painted.paint(style)
```

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

### AwayFromZero Rounding Example

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html

Demonstrates rounding away from zero, increasing the magnitude of the number.

```rust
e.g. -6.8 -> -7, 6.8 -> 7
```

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

### MidpointAwayFromZero Rounding Example

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html

Demonstrates MidpointAwayFromZero rounding, where halfway cases are rounded to the number furthest from zero.

```rust
e.g. 6.4 -> 6, 6.5 -> 7, -6.5 -> -7
```

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

### Product of Results Example: Successful Multiplication

Source: https://docs.rs/rust_decimal/latest/rust_decimal/type.Result.html?search=u32+-%3E+bool

Demonstrates the `product` method on an iterator of `Result`s where all elements are successfully parsed and multiplied.

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

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

### Bincode Serialization with Optional String Feature

Source: https://docs.rs/rust_decimal/latest/src/rust_decimal/serde.rs.html?search=

Handles bincode serialization and deserialization for a struct containing an optional Decimal using the 'str_option' Serde module. This example is incomplete and only shows the setup.

```rust
#[cfg(feature = "serde-with-str")]
fn with_str_bincode_optional() {
    use bincode::{deserialize, serialize};

    #[derive(Serialize, Deserialize)]
    struct BincodeExample {
        #[serde(with = "crate::serde::str_option")]
        value: Option<Decimal>,
    }

    // Some(value)
}
```

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

### Get Raw Layout

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html?search=std%3A%3Avec

Gets the raw memory layout of the type.

```APIDOC
## fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

### Description
Gets the layout of the type.

### Parameters
- `_`: Metadata related to the pointer.

### Returns
- `Result<Layout, LayoutError>`: Ok containing the `Layout` or Err containing a `LayoutError`.
```

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

### Handle Invalid Decimal Input: Leading Underscore

Source: https://docs.rs/rust_decimal/latest/src/rust_decimal/str.rs.html

Tests parsing a string that starts with an underscore, which is not a valid start for a decimal number. The function should return an error.

```rust
assert_eq!(
            parse_str_radix_10("_"),
            Err(Error::from("Invalid decimal: must start lead with a number"))
        );
```

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

### Convert Rust Decimal to PostgreSQL Positive Numeric (Second Example)

Source: https://docs.rs/rust_decimal/latest/src/rust_decimal/postgres/diesel.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Another example of converting a positive Rust Decimal to PostgreSQL Numeric, demonstrating handling of different digit sequences.

```rust
let expected = Decimal::from_str("1.2345678901234567890123456790").unwrap();
        let pg_numeric = PgNumeric::Positive {
            weight: 0,
            scale: 34,
            digits: vec![1, 2345, 6789, 0123, 4567, 8901, 2345, 6789, 5000, 0],
        };

        let res: Decimal = pg_numeric.try_into().unwrap();
        assert_eq!(res.to_string(), expected.to_string());
```

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

### LayoutRaw Trait

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.Error.html?search=u32+-%3E+bool

Gets the layout of a type.

```APIDOC
## Trait: LayoutRaw

Gets the layout of a type.

### Methods

#### `fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>`
Gets the layout of the type.
```

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

### layout_raw

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html?search=

Gets the raw memory layout of the type.

```APIDOC
## fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

### Description
Gets the layout of the type.

### Parameters
* `_`: Metadata related to the type's pointer.

### Returns
A `Result` containing the `Layout` of the type or a `LayoutError`.
```

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

### Layout Raw

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html

Gets the raw memory layout of the type.

```APIDOC
## fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

### Description
Gets the layout of the type.

### Method
(Method within `LayoutRaw` trait implementation)

### Parameters
- **_**: <T as Pointee>::Metadata - Metadata for the type.

### Returns
- Result<Layout, LayoutError> - The layout of the type or a layout error.
```

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

### LayoutRaw for T

Source: https://docs.rs/rust_decimal/latest/rust_decimal/serde/struct.DecimalFromString.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides a method to get the raw layout of a type `T`.

```APIDOC
## fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

### Description
Gets the raw memory layout of the type `T`. This method requires metadata associated with a pointer to the type.

### Method
`layout_raw`

### Parameters
- `_`: The metadata associated with a pointer to `T`.

### Returns
A `Result` containing the `Layout` of the type on success, or a `LayoutError` on failure.
```

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

### Decimal::declaration

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html?search=std%3A%3Avec

Gets the name of the Decimal type without brackets.

```APIDOC
## declaration

### Description
Get the name of the type without brackets.

### Method
`declaration`

### Returns
- `Declaration` - The declaration of the Decimal type.
```

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

### Get Decimal Scale

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html

Retrieves the scale (exponent) of the Decimal number.

```rust
let num = Decimal::new(1234, 3);
assert_eq!(num.scale(), 3u32);
```

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

### Get the DecWide one value

Source: https://docs.rs/rust_decimal/latest/src/rust_decimal/ops/wide.rs.html?search=std%3A%3Avec

Returns a `DecWide` representation of the number one.

```rust
pub const fn one() -> DecWide {
    DecWide::from_decimal(&Decimal::ONE)
}
```

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

### Get LayoutRaw for Type

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.Error.html?search=

Retrieves the layout information for a type based on its metadata.

```rust
fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

```

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

### Initialization

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new `Painted` object with a default style.

```APIDOC
## `new()`

### Description
Create a new `Painted` with a default `Style`. Read more

### Method
`new()`

### Example
```rust
// Example usage would go here, assuming 'Painted' is constructible
```
```

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

### Initialization

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html?search=u32+-%3E+bool

Method to create a new `Painted` object.

```APIDOC
## fn new(self) -> Painted<Self>

### Description
Create a new `Painted` with a default `Style`. Read more

### Method
`new`

### Example
```rust
// Example usage would go here, assuming 'self' is a type that can be painted.
// For instance, if 'value' is a string or other displayable type:
// let painted_value = value.new();
```
```

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

### Get Decimal Mantissa

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html

Retrieves the mantissa (the integer part before scaling) of the Decimal number.

```rust
let num = dec!(-1.2345678);
assert_eq!(num.mantissa(), -12345678i128);
assert_eq!(num.scale(), 7);
```

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

### init

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html?search=

Initializes and returns the parsing context for `Self`.

```APIDOC
## fn init

### Description
Initializes and returns the parsing context for `Self`.

### Parameters
- `opts`: `Options` - The options for initialization.

### Returns
- `<T as FromForm<'v>>::Context`: The initialized parsing context.
```

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

### Creation and Styling Methods

Source: https://docs.rs/rust_decimal/latest/rust_decimal/serde/struct.DecimalFromString.html?search=

Methods for creating a new Painted instance and applying styles.

```APIDOC
## fn new()

### Description
Create a new `Painted` with a default `Style`.

### Method
(Called as a constructor)

### Example
```rust
// Assuming 'Painted' is in scope
let painted_instance = Painted::new();
```

## fn paint<S>(style: S)

### Description
Apply a style wholesale to `self`. Any previous style is replaced.

### Method
(Implicitly called on a `Painted` object)

### Parameters
#### Path Parameters
- **style** (S: Into<Style>) - Required - The style to apply.

### Example
```rust
// Assuming 'Style' and 'Painted' are in scope
let styled_text = painted_instance.paint(some_style_instance);
```
```

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

### Recommended expect message style for environment variables

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

Provides an example of a recommended `expect` message style for retrieving environment variables, emphasizing clarity on why the variable is expected to be set.

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

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

### Using bold() for Bold

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates the preferred way to enable bold text using the specific bold() builder method.

```rust
use yansi::Paint;

painted.bold();
```

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

### new

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.Error.html?search=u32+-%3E+bool

Creates a new Painted with a default Style.

```APIDOC
## fn new(self) -> Painted<Self>

### Description
Create a new `Painted` with a default `Style`. Read more

### Method
N/A (Constructor)

### Endpoint
N/A

### Parameters
None

### Request Example
```rust
// Assuming 'Self' is a type that can be painted
let painted_value = Self::new();
```

### Response
#### Success Response
Returns a new `Painted<Self>` instance.

#### Response Example
N/A
```

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

### Get &dyn Any from &Trait

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.Error.html?search=

Provides a reference to `Any` from a reference to a trait object, necessary for dynamic dispatch.

```rust
fn as_any(&self) -> &(dyn Any + 'static)

```

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

### Rust Crate Configuration and Module Imports

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

This snippet shows the initial configuration of the rust_decimal crate, including documentation attributes, feature flags, and the import of the 'alloc' crate. It also lists various internal modules that are conditionally compiled based on feature flags.

```rust
#![doc = include_str!(concat!(env!("OUT_DIR"), "/README-lib.md"))]
#![forbid(unsafe_code)]
#![deny(clippy::print_stdout, clippy::print_stderr)]
#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(docsrs, feature(doc_cfg))]
extern crate alloc;

mod constants;
mod decimal;
mod error;
mod ops;
pub mod str;

// We purposely place this here for documentation ordering
mod arithmetic_impls;

#[cfg(feature = "rust-fuzz")]
mod fuzz;
#[cfg(feature = "maths")]
mod maths;
#[cfg(all(feature = "db-diesel-mysql", not(target_arch = "wasm32")))]
mod mysql;
#[cfg(all(
    any(
        feature = "db-tokio-postgres",
        feature = "db-postgres",
        feature = "db-diesel-postgres",
    ),
    not(target_arch = "wasm32")
))]
mod postgres;
#[cfg(feature = "proptest")]
mod proptest;
#[cfg(feature = "rand")]
mod rand;
#[cfg(feature = "rand-0_9")]
mod rand_0_9;
#[cfg(feature = "rocket-traits")]
mod rocket;
#[cfg(all(
    feature = "serde",
    not(any(
        feature = "serde-with-str",
        feature = "serde-with-float",
        feature = "serde-with-arbitrary-precision"
    ))
))]
mod serde;
/// Serde specific functionality to customize how a decimal is serialized/deserialized (`serde_with`)
#[cfg(all(
    feature = "serde",
    any(
        feature = "serde-with-str",
        feature = "serde-with-float",
        feature = "serde-with-arbitrary-precision"
    )
))]
pub mod serde;
#[cfg(all(target_arch = "wasm32", feature = "wasm"))]
pub mod wasm;

pub use decimal::{Decimal, RoundingStrategy};
pub use error::Error;
#[cfg(feature = "maths")]
pub use maths::MathematicalOps;

```

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

### Window Filter Example

Source: https://docs.rs/rust_decimal/latest/rust_decimal/serde/struct.DecimalFromString.html?search=u32+-%3E+bool

Adds a filter to the current window function based on a boolean expression.

```rust
fn window_filter<P>(self, f: P) -> Self::Output;
```

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

### Example Implementation of FromStr

Source: https://docs.rs/rust_decimal/latest/rust_decimal/prelude/trait.FromStr.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates a basic implementation of the `FromStr` trait for a custom `Point` struct, showing both explicit and implicit usage of the `from_str` method.

```APIDOC
## §Examples

Basic implementation of `FromStr` on an example `Point` type:

```rust
use std::str::FromStr;

#[derive(Debug, PartialEq)]
struct Point {
    x: i32,
    y: i32
}

#[derive(Debug, PartialEq, Eq)]
struct ParsePointError;

impl FromStr for Point {
    type Err = ParsePointError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let (x, y) = s
            .strip_prefix('(')
            .and_then(|s| s.strip_suffix(')'))
            .and_then(|s| s.split_once(','))
            .ok_or(ParsePointError)?;

        let x_fromstr = x.parse::<i32>().map_err(|_| ParsePointError)?;
        let y_fromstr = y.parse::<i32>().map_err(|_| ParsePointError)?;

        Ok(Point { x: x_fromstr, y: y_fromstr })
    }
}

let expected = Ok(Point { x: 1, y: 2 });
// Explicit call
assert_eq!(Point::from_str("(1,2)"), expected);
// Implicit calls, through parse
assert_eq!("(1,2)".parse(), expected);
assert_eq!("(1,2)".parse::<Point>(), expected);
// Invalid input string
assert!(Point::from_str("(1 2)").is_err());
```
```

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

### new()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=u32+-%3E+bool

Creates a new Painted object with a default Style.

```APIDOC
## new()

### Description
Create a new `Painted` with a default `Style`.
Read more

### Method
This is a constructor for the `Painted` type.

### Example
```rust
// Assuming `Painted` can be constructed this way, actual usage might vary.
// let painted_text = Painted::new();
```
```

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

### new()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html

Creates a new Painted object with a default Style.

```APIDOC
## new()

### Description
Create a new `Painted` with a default `Style`.
Read more

### Method
This is a static method to create a new `Painted` object.

### Example
```rust
// Assuming `Painted` can be created this way, actual usage might differ.
// let painted_text = Painted::new(); 
```
```

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

### Create New Painted Instance

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html?search=

Creates a new `Painted` instance with a default `Style`. This is the entry point for creating styled text.

```rust
new()
```

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

### FromForm<'v>::init

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html

Initializes and returns the parsing context for `Self`.

```APIDOC
## fn init(opts: Options) -> <T as FromForm<'v>>::Context

### Description
Initializes and returns the parsing context for `Self`.

### Method
`init`

### Parameters
* `opts` (`Options`): The options for initialization.

### Returns
`<T as FromForm<'v>>::Context`: The initialized parsing context.
```

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

### Example: Implementing FromStr for a Point struct

Source: https://docs.rs/rust_decimal/latest/rust_decimal/prelude/trait.FromStr.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates a basic implementation of the FromStr trait for a custom Point struct, including explicit and implicit parsing calls, and handling of invalid input.

```rust
use std::str::FromStr;

#[derive(Debug, PartialEq)]
struct Point {
    x: i32,
    y: i32
}

#[derive(Debug, PartialEq, Eq)]
struct ParsePointError;

impl FromStr for Point {
    type Err = ParsePointError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let (x, y) = s
            .strip_prefix('(')
            .and_then(|s| s.strip_suffix(')'))
            .and_then(|s| s.split_once(','))
            .ok_or(ParsePointError)?;

        let x_fromstr = x.parse::<i32>().map_err(|_| ParsePointError)?;
        let y_fromstr = y.parse::<i32>().map_err(|_| ParsePointError)?;

        Ok(Point { x: x_fromstr, y: y_fromstr })
    }
}

let expected = Ok(Point { x: 1, y: 2 });
// Explicit call
assert_eq!(Point::from_str("(1,2)"), expected);
// Implicit calls, through parse
assert_eq!("(1,2)".parse(), expected);
assert_eq!("(1,2)".parse::<Point>(), expected);
// Invalid input string
assert!(Point::from_str("(1 2)").is_err());
```

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

### FromStr for NonZero<u64>

Source: https://docs.rs/rust_decimal/latest/rust_decimal/prelude/trait.FromStr.html?search=

Implements FromStr for NonZero<u64>.

```APIDOC
## FromStr for NonZero<u64>

### Description
Implements the `FromStr` trait for `NonZero<u64>`, allowing parsing of string representations into non-zero `u64` values.

### Method
`FromStr::from_str`

### Parameters
- **s** (`&str`) - The string slice to parse.

### Response
#### Success Response
- `Ok(NonZero<u64>)` - The parsed non-zero `u64` value.
#### Error Response
- `Err(ParseIntError)` - An error if the string is not a valid representation of a non-zero `u64` number.
```

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

### Blanket Implementations for Any

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Details blanket implementations for the Any trait, providing a method to get the TypeId of a trait object.

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

where T: 'static + ?Sized,

### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
```

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

### FromStr for http::uri::path::PathAndQuery

Source: https://docs.rs/rust_decimal/latest/rust_decimal/prelude/trait.FromStr.html?search=

Implements FromStr for http::uri::path::PathAndQuery.

```APIDOC
## FromStr for http::uri::path::PathAndQuery

### Description
Implements the `FromStr` trait for `http::uri::path::PathAndQuery`, allowing parsing of string representations into `PathAndQuery` objects.

### Method
`FromStr::from_str`

### Parameters
- **s** (`&str`) - The string slice to parse.

### Response
#### Success Response
- `Ok(PathAndQuery)` - The parsed `PathAndQuery` object.
#### Error Response
- `Err(InvalidUri)` - An error if the string is not a valid URI path and query component.
```

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

### Get &mut dyn Any from &mut Trait

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.Error.html?search=

Provides a mutable reference to `Any` from a mutable reference to a trait object.

```rust
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

```

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

### Basic usage with i32

Source: https://docs.rs/rust_decimal/latest/rust_decimal/prelude/trait.FromStr.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use the FromStr trait with the built-in i32 type, demonstrating parsing a string to an integer.

```rust
use std::str::FromStr;

let s = "5";
let x = i32::from_str(s).unwrap();

assert_eq!(5, x);
```

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

### Create Decimal using Convenience Functions

Source: https://docs.rs/rust_decimal/latest/rust_decimal/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Instantiate Decimal numbers using various convenience functions like `new`, `from_i128_with_scale`, `from_str`, `from_str_radix`, `from_scientific`, and `Into` trait.

```rust
// Using the prelude can help importing trait based functions (e.g. core::str::FromStr).
use rust_decimal::prelude::*;

// Using an integer followed by the decimal points
let scaled = Decimal::new(202, 2);
assert_eq!("2.02", scaled.to_string());

// From a 128 bit integer
let balance = Decimal::from_i128_with_scale(5_897_932_384_626_433_832, 2);
assert_eq!("58979323846264338.32", balance.to_string());

// From a string representation
let from_string = Decimal::from_str("2.02").unwrap();
assert_eq!("2.02", from_string.to_string());

// From a string representation in a different base
let from_string_base16 = Decimal::from_str_radix("ffff", 16).unwrap();
assert_eq!("65535", from_string_base16.to_string());

// From scientific notation
let sci = Decimal::from_scientific("9.7e-7").unwrap();
assert_eq!("0.00000097", sci.to_string());

// Using the `Into` trait
let my_int: Decimal = 3_i32.into();
assert_eq!("3", my_int.to_string());

// Using the raw decimal representation
let pi = Decimal::from_parts(1_102_470_952, 185_874_565, 1_703_060_790, false, 28);
assert_eq!("3.1415926535897932384626433832", pi.to_string());

// If the `macros` feature is enabled, it also allows for the `dec!` macro
let amount = dec!(25.12);
assert_eq!("25.12", amount.to_string());
```

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

### ToZero Rounding Example

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html

Illustrates rounding towards zero, truncating the decimal part regardless of the sign.

```rust
e.g. -6.8 -> -6, 6.8 -> 6
```

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

### Set Background Color to Red using on_red()

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates setting the background color to red using the `on_red()` builder method. This is a more concise alternative to `bg(Color::Red)`.

```rust
use yansi::Paint;

painted.on_red();
```

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

### MidpointTowardZero Rounding Example

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.RoundingStrategy.html

Shows MidpointTowardZero rounding, where halfway cases are rounded to the number closest to zero.

```rust
e.g. 6.4 -> 6, 6.5 -> 6, -6.5 -> -6
```

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

### FromStr for NonZero<i64>

Source: https://docs.rs/rust_decimal/latest/rust_decimal/prelude/trait.FromStr.html?search=

Implements FromStr for NonZero<i64>.

```APIDOC
## FromStr for NonZero<i64>

### Description
Implements the `FromStr` trait for `NonZero<i64>`, allowing parsing of string representations into non-zero `i64` values.

### Method
`FromStr::from_str`

### Parameters
- **s** (`&str`) - The string slice to parse.

### Response
#### Success Response
- `Ok(NonZero<i64>)` - The parsed non-zero `i64` value.
#### Error Response
- `Err(ParseIntError)` - An error if the string is not a valid representation of a non-zero `i64` number.
```

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

### Basic usage with i32

Source: https://docs.rs/rust_decimal/latest/rust_decimal/prelude/trait.FromStr.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Illustrates the basic usage of the `from_str` method with `i32`, a primitive type that implements `FromStr`.

```APIDOC
##### §Examples

Basic usage with `i32`, a type that implements `FromStr`:

```rust
use std::str::FromStr;

let s = "5";
let x = i32::from_str(s).unwrap();

assert_eq!(5, x);
```
```

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

### Add rust_decimal with macros to Cargo.toml

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

Install the rust_decimal crate with the 'macros' feature enabled for macro support.

```bash
$ cargo add rust_decimal --features macros
```

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

### Add rust_decimal to Cargo.toml

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

Install the rust_decimal crate using Cargo. Add it to your project's dependencies.

```bash
$ cargo add rust_decimal
```

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

### FromStr for NonZero<usize>

Source: https://docs.rs/rust_decimal/latest/rust_decimal/prelude/trait.FromStr.html?search=

Implements FromStr for NonZero<usize>.

```APIDOC
## FromStr for NonZero<usize>

### Description
Implements the `FromStr` trait for `NonZero<usize>`, allowing parsing of string representations into non-zero `usize` values.

### Method
`FromStr::from_str`

### Parameters
- **s** (`&str`) - The string slice to parse.

### Response
#### Success Response
- `Ok(NonZero<usize>)` - The parsed non-zero `usize` value.
#### Error Response
- `Err(ParseIntError)` - An error if the string is not a valid representation of a non-zero `usize` number.
```

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

### Extract Fractional Part of Decimal

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html

Illustrates how to get the fractional part of a Decimal number. The result is also a Decimal.

```rust
let pi = Decimal::new(3141, 3);
let fract = Decimal::new(141, 3);
// note that it returns a decimal
assert_eq!(pi.fract(), fract);
```

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

### FromStr for NonZero<u32>

Source: https://docs.rs/rust_decimal/latest/rust_decimal/prelude/trait.FromStr.html?search=

Implements FromStr for NonZero<u32>.

```APIDOC
## FromStr for NonZero<u32>

### Description
Implements the `FromStr` trait for `NonZero<u32>`, allowing parsing of string representations into non-zero `u32` values.

### Method
`FromStr::from_str`

### Parameters
- **s** (`&str`) - The string slice to parse.

### Response
#### Success Response
- `Ok(NonZero<u32>)` - The parsed non-zero `u32` value.
#### Error Response
- `Err(ParseIntError)` - An error if the string is not a valid representation of a non-zero `u32` number.
```

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

### Zero for Decimal

Source: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implements the Zero trait for Decimal, providing methods to get, check, and set the zero value.

```APIDOC
## impl Zero for Decimal

### fn zero() -> Decimal

Returns the additive identity element of `Self`, `0`. Read more

### fn is_zero(&self) -> bool

Returns `true` if `self` is equal to the additive identity.

### fn set_zero(&mut self)

Sets `self` to the additive identity element of `Self`, `0`.
```

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

### Get LayoutRaw

Source: https://docs.rs/rust_decimal/latest/rust_decimal/enum.Error.html?search=u32+-%3E+bool

Retrieves the raw memory layout of a type. This is a low-level operation used for memory management and optimization.

```rust
fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>
```