Rust Decimal

https://docs.rs/rust_decimal/latest/
Admin
Rust Decimal is a Decimal number implementation written in pure Rust suitable for financial...
Tokens:459,789
Snippets:3,495
Trust Score:9.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### fract example

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

Shows how to get the fractional part of a Decimal using the fract method.

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

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

### on_bright() example

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

Returns self with the quirk() set to Quirk::OnBright. Example prints the value with on_bright styling.

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

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

### bright() example

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

Returns self with the quirk() set to Quirk::Bright. Example prints the value with bright styling.

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

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

### Test reading very small numeric type (connection setup)

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

Starts a test for reading a very small numeric type by connecting to PostgreSQL. The snippet is incomplete in the source, showing only the connection setup.

```rust
#[test]
fn read_very_small_numeric_type() {
    let mut client = match Client::connect(&get_postgres_url(), NoTls) {
        Ok(x) => x,
        Err(err) => panic!("{:#?}", err),
    };
```

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

### resetting() example

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

Returns self with the quirk() set to Quirk::Resetting. Example prints the value with resetting styling.

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

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

### wrap() example

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

Returns self with the quirk() set to Quirk::Wrap. Example prints the value with wrap styling.

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

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

### Use Decimal::min to get the minimum of two numbers

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

Shows how to use the `min` method to get the smaller of two `Decimal` values. The example creates two decimals and asserts that the minimum is the first one.

```rust
# use rust_decimal::Decimal;
#
let x = Decimal::new(1, 0);
let y = Decimal::new(2, 0);
assert_eq!(x, x.min(y));
```

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

### Get mantissa and scale of a Decimal

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

Shows how to retrieve the mantissa and scale of a Decimal using the `mantissa()` and `scale()` methods. The example uses the `dec!` macro to create a decimal and asserts the expected values.

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

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

### expect recommended message style example

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

Shows the recommended message style for `expect`: describe the reason you expect the `Result` to be `Ok`. The example reads an environment variable and expects it to be set by a wrapper script.

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

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

### iter example

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

Demonstrates `iter` to get an iterator over the possibly contained value. The iterator yields one value for `Ok` and none for `Err`.

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

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

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

### whenever() example

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

Conditionally enable styling based on whether the Condition value applies. Replaces any previous condition. Example enables styling only when both stdout and stderr are TTYs.

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

painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);
```

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

### map example

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

Demonstrates Result::map, which applies a function to the Ok value, leaving Err untouched. The example parses lines and multiplies by two.

```rust
let line = "1\n2\n3\n4\n";

for num in line.lines() {
    match num.parse::<i32>().map(|i| i * 2) {
        Ok(n) => println!("{n}"),
        Err(..) => {}
    }
}
```

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

### Decimal::from_scientific_lossy example

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

Example usage of Decimal::from_scientific_lossy showing conversion of scientific notation with rounding when the exponent exceeds MAX_SCALE.

```rust
/// # use rust_decimal::Decimal;
/// # use rust_decimal::Error;
/// #
/// # fn main() -> Result<(), rust_decimal::Error> {
/// let value = Decimal::from_scientific_lossy("2.710505431213761e-20")?;
/// assert_eq!(value.to_string(), "0.0000000000000000000271050543");
///
/// let value = Decimal::from_scientific_lossy("2.5e-28")?;
/// assert_eq!(value.to_string(), "0.0000000000000000000000000003");
///
/// let value = Decimal::from_scientific_lossy("-2.5e-28")?;
/// assert_eq!(value.to_string(), "-0.0000000000000000000000000003");
///
/// let err = Decimal::from_scientific_lossy("2e-29").unwrap_err();
/// assert_eq!(err, Error::ScaleExceedsMaximumPrecision(29));
/// #     Ok(())
/// # }
/// ```
```

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

### rescale method example

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

Example usage of the rescale method. Rescaling to a higher scale preserves the value, while rescaling to a lower scale rounds using MidpointAwayFromZero. The function never fails; if the requested scale cannot be represented, the maximum possible scale is used.

```rust
/// # use rust_decimal::prelude::*;
/// # use rust_decimal_macros::dec;
///
/// // Rescaling to a higher scale preserves the value
/// let mut number = dec!(1.123);
/// assert_eq!(number.scale(), 3);
/// number.rescale(6);
/// assert_eq!(number.to_string(), "1.123000");
/// assert_eq!(number.scale(), 6);
///
/// // Rescaling to a lower scale forces the number to be rounded
/// let mut number = dec!(1.45);
/// assert_eq!(number.scale(), 2);
/// number.rescale(1);
/// assert_eq!(number.to_string(), "1.5");
/// assert_eq!(number.scale(), 1);
///
/// // This function never fails. Consequently, if a scale is provided that is unable to be
/// // represented using the given mantissa, then the maximum possible scale is used.
/// let mut number = dec!(11.76470588235294);
/// assert_eq!(number.scale(), 14);
/// number.rescale(28);
/// // A scale of 28 cannot be represented given this mantissa, however it was able to represent
/// // a number with a scale of 27
/// assert_eq!(number.to_string(), "11.764705882352940000000000000");
/// assert_eq!(number.scale(), 27);
```

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

### Decimal::from_scientific example

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

Example usage of Decimal::from_scientific showing conversion of scientific notation to a Decimal string representation.

```rust
/// assert_eq!(value.to_string(), "0.00000097");
/// #     Ok(())
/// # }
/// ```
```

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

### Buf48 upper_word method start

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

Starts the implementation of Buf48 with an upper_word method that initializes an index to 11. The snippet is incomplete as shown.

```rust
impl Buf48 {
    const fn upper_word(&self) -> usize {
        let mut i = 11;
```

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

### inspect example

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

Demonstrates `inspect` to print the contained value when the result is `Ok`, then continues with `map` and `expect`. The example parses a string literal and prints the original value before cubing it.

```rust
let x: u8 = "4"
    .parse::<u8>()
    .inspect(|x| println!("original: {x}"))
    .map(|x| x.pow(3))
    .expect("literal `4` should parse as a `u8`");
```

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

### is_err_and example

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

Shows how to use Result::is_err_and to check if the result is an Err and the error value matches a predicate. The example uses std::io::Error and demonstrates true/false cases, including a case with String error and as_ref.

```rust
use std::io::{Error, ErrorKind};

let x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, "!"));
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);

let x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, "!"));
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);

let x: Result<u32, Error> = Ok(123);
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);

let x: Result<u32, String> = Err("ownership".to_string());
assert_eq!(x.as_ref().is_err_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

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

### and_then chaining example

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

Shows how to chain fallible operations that may return Err using and_then. The example uses a function sq_then_to_string that is not defined in the snippet.

```rust
assert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));
assert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err("overflowed"));
assert_eq!(Err("not a number").and_then(sq_then_to_string), Err("not a number"));
```

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

### Truncate decimal examples with dec! macro

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

Example for `trunc` showing that it truncates positive and negative decimals without rounding. Uses `dec!` macro and `Decimal::NEGATIVE_ONE`.

```rust
# use rust_decimal::Decimal;
# use rust_decimal_macros::dec;
#
let pi = dec!(3.141);
assert_eq!(pi.trunc(), dec!(3));

// Negative numbers are similarly truncated without rounding
let neg = dec!(-1.98765);
assert_eq!(neg.trunc(), Decimal::NEGATIVE_ONE);
```

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

### iter_mut example

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

Shows `iter_mut` to get a mutable iterator over the possibly contained value. The example modifies the `Ok` value to 40 and checks that `Err` yields no items.

```rust
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

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

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

### ok example

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

Demonstrates Result::ok, which converts a Result into an Option, returning Some for Ok and None for Err.

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

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

### bold() example

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

Makes text bold using the pithier bold() method. Requires importing yansi::Paint.

```rust
use yansi::Paint;

painted.bold();
```

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

### as_ref example

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

Demonstrates Result::as_ref, which converts a Result into a Result with references, leaving the original in place.

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

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

### Get scale of a Decimal with scale()

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

Shows how to retrieve the scale of a Decimal value using the `scale()` method. The example uses the `dec!` macro to create a decimal and asserts the scale is 3.

```rust
let num = dec!(-1.2345678);
assert_eq!(num.scale(), 3u32);
```

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

### wrap() example

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

Enables wrapping using wrap(). This is a quirk-specific builder method that is preferred over quirk().

```rust
use yansi::Paint;

painted.wrap();
```

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

### Get mantissa of a Decimal with mantissa()

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

Shows how to retrieve the mantissa of a Decimal using the `mantissa()` method. The example uses the `dec!` macro to create a Decimal and asserts the mantissa and scale values.

```rust
# use rust_decimal::prelude::*;
# use rust_decimal_macros::dec;

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

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

### float_option module example for Option<Decimal> serialization

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

Example usage of the `float_option` module for serializing/deserializing `Option<Decimal>` as floats. Requires the `serde-with-float` feature. The example shows a `Some` value serialized as a float with trailing zeros removed.

```rust
/// Serialize/deserialize optional Decimals as floats.
///
/// ```
/// # use serde::{Serialize, Deserialize};
/// # use rust_decimal::Decimal;
/// # use std::str::FromStr;
///
/// #[derive(Serialize, Deserialize)]
/// pub struct FloatExample {
///     #[serde(with = "rust_decimal::serde::float_option")]
///     value: Option<Decimal>,
/// }
///
/// let value = FloatExample { value: Some(Decimal::from_str("123.400").unwrap()) };
/// assert_eq!(
///     &serde_json::to_string(&value).unwrap(),
///     r#"{"value":123.4}"#
/// );
/// ```
```

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

### 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

Demonstrates various ways to create Decimal numbers: from integer with scale, from 128-bit integer, from string, from string in a different base, from scientific notation, using the Into trait, and from raw parts.

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

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

### linger() example

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

Returns self with the quirk() set to Quirk::Linger. Example prints the value with linger styling.

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

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

### as_mut example

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

Demonstrates Result::as_mut, which converts a mutable Result into a Result with mutable references, allowing mutation of the contained value.

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

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

### and method examples

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

Shows how the and method returns res if the result is Ok, otherwise returns the Err value of self.

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

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

### mask() example

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

Returns self with the quirk() set to Quirk::Mask. Example prints the value with mask styling.

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

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

### strike() example

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

Returns self with the attr() set to Attribute::Strike. Example prints the value with strike styling.

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

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

### conceal() example

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

Returns self with the attr() set to Attribute::Conceal. Example prints the value with concealed styling.

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

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

### Test module with test data and MySQL connection helper

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

Defines test structs Test and NullableTest, a static array TEST_DECIMALS with precision, scale, sent, and expected string values, and a helper get_mysql_url that reads the MYSQL_URL environment variable, defaulting to 'mysql://root@127.0.0.1/mysql'.

```rust
#[cfg(test)]
mod tests {
    use super::*;

    struct Test {
        value: Decimal,
    }

    struct NullableTest {
        value: Option<Decimal>,
    }

    pub static TEST_DECIMALS: &[(u32, u32, &str, &str)] = &[
        // precision, scale, sent, expected
        (1, 0, "1", "1"),
        (6, 2, "1", "1.00"),
        (6, 2, "9999.99", "9999.99"),
        (35, 6, "3950.123456", "3950.123456"),
        (10, 2, "3950.123456", "3950.12"),
        (35, 6, "3950", "3950.000000"),
        (4, 0, "3950", "3950"),
        (35, 6, "0.1", "0.100000"),
        (35, 6, "0.01", "0.010000"),
        (35, 6, "0.001", "0.001000"),
        (35, 6, "0.0001", "0.000100"),
        (35, 6, "0.00001", "0.000010"),
        (35, 6, "0.000001", "0.000001"),
        (35, 6, "1", "1.000000"),
        (35, 6, "-100", "-100.000000"),
        (35, 6, "-123.456", "-123.456000"),
        (35, 6, "119996.25", "119996.250000"),
        (35, 6, "1000000", "1000000.000000"),
        (35, 6, "9999999.99999", "9999999.999990"),
        (35, 6, "12340.56789", "12340.567890"),
    ];

    /// Gets the URL for connecting to MySQL for testing. Set the MYSQL_URL
    /// environment variable to change from the default of "mysql://root@localhost/mysql".
    fn get_mysql_url() -> String {
        if let Ok(url) = std::env::var("MYSQL_URL") {
            return url;
        }
        "mysql://root@127.0.0.1/mysql".to_string()
    }
}
```

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

### invert() example

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

Returns self with the attr() set to Attribute::Invert. Example prints the value with inverted styling.

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

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

### or method examples

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

Shows the behavior of or: returns res if self is Err, otherwise returns the Ok value of self. 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));
```

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

### blink() example

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

Returns self with the attr() set to Attribute::Blink. Example prints the value with blink styling.

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

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

### rapid_blink() example

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

Returns self with the attr() set to Attribute::RapidBlink. Example prints the value with rapid blink styling.

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

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

### and_then with Path metadata example

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

Demonstrates and_then with Result from metadata() and modified(). On Windows, "/" maps to "C:\". The second path is expected to fail with ErrorKind::NotFound.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

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

### Create Decimal numbers using convenience functions

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

Shows various ways to create Decimal numbers: from integers with scale, from 128-bit integers, from strings, from strings in different bases, from scientific notation, via the Into trait, from raw parts, and using the dec! macro.

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

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

### unwrap_err_unchecked undefined behavior example

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

Shows undefined behavior when calling unwrap_err_unchecked on an Ok value. This example is for demonstration only and should not be used in practice.

```rust
let x: Result<u32, &str> = Ok(2);
unsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
```
Tokens:
Raw