null-kane 2.0.1

currency crate with the option to add your own currency localization logic
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

# null-kane

This is a Rust crate designed for currency manipulation. It provides an
interface via a trait for implementing localization methods. The trait enables
retrieval of the currency separator, thousand separator, and currency symbol.

## Features

### Localization Methods

- `get_separator`: Retrieves the separator used for the currency.
- `get_thousand_separator`: Retrieves the thousand separator used for the currency.
- `get_currency_symbol`: Retrieves the currency symbol.

### Arithmetic Operations

The crate implements arithmetic operations for the following types:
- Addition, multiplication, and division among currencies.
- Addition, multiplication, and division between currencies and `usize`.
- Addition, multiplication, and division between currencies and `f32`.
- Addition, multiplication, and division between currencies and `f64`.

### Constructors

`From` implementations for creating instances from `f32` and `f64`.

## Example

```rust
use null_kane::{Currency, CurrencyLocalization};

#[derive(Clone, Default, PartialEq, Eq)]
enum MyLocalization {
    #[default]
    Euro
}

impl CurrencyLocalization for MyLocalization {
    fn get_separator(&self) -> char {
        // Implementation of the separator for Euro
        ','
    }

    fn get_thousand_separator(&self) -> char {
        // Implementation of the thousand separator for Euro
        '.'
    }

    fn get_currency_symbol(&self) -> &'static str {
        // Implementation of the currency symbol for Euro
        "€"
    }
}

fn main() {
    let euro_currency = MyLocalization::default;
    let amount_one = Currency::from(50.25_f32).with_locale(euro_currency.clone());
    let amount_two = Currency::from(30.75_f64).with_locale(euro_currency);

    let sum = amount_one + amount_two;
    let product = amount_one * 2.0;
    let division = amount_two / 3.0;

    println!("Sum: {}", sum);
    println!("Product: {}", product);
    println!("Division: {}", division);
}
```

## TODO

- implement a good solution for failing operations, for example if currency localizations don't match
- consider using num trait


# License

This project is licensed under the MIT License. See the [LICENSE](/LICENSE.md) file for details.