field_comparable_derive 0.1.1

Procedural macro to generate struct field comparison methods / Macro procédurale pour générer des méthodes de comparaison de champs de structures
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

# field_comparable_derive

[![Crates.io](https://img.shields.io/crates/v/field_comparable_derive.svg)](https://crates.io/crates/field_comparable_derive)
[![Documentation](https://docs.rs/field_comparable_derive/badge.svg)](https://docs.rs/field_comparable_derive)
[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue.svg)](#license)

---

## English 🇬🇧

### Overview
`field_comparable_derive` is a procedural macro crate that automatically generates **field comparison methods** for Rust structs.  
It is particularly useful when you need fine-grained comparison logic without manually implementing boilerplate code.

### Features
- Derive macros for struct field comparisons.
- Simple integration with existing types.
- Helps reduce repetitive and error-prone code.

### Example
```rust
use field_comparable_derive::Comparable;

#[derive(Comparable)]
struct User {
    id: u32,
    name: String,
    email: String,
}

fn compare_user() {
    let u1 = User { id: 1, name: "Alice".into(), email: "alice@mail.com".into() };
    let u2 = User { id: 1, name: "Bob".into(), email: "alice@mail.com".into() };

    // Example: check field differences
    let diffs: bool = u1.differs_from(&u2);
    println!("{:?}", diffs);
    
    let name_diffs: bool = u1.name_differs_from(u2);
    let name_diffs: bool = u1.name_differs_from_ref(&u2);
    
    let email_diffs: bool = u1.email_differs_from(u2);
}
````

---

## Français 🇫🇷

### Présentation

`field_comparable_derive` est une **macro procédurale** qui génère automatiquement des **méthodes de comparaison de champs** pour vos structures Rust.
Elle est particulièrement utile lorsque vous avez besoin d’une logique de comparaison fine sans écrire du code répétitif.

### Fonctionnalités

* Macros derive pour comparer les champs de structures.
* Intégration simple avec vos types existants.
* Réduit le code répétitif et sujet aux erreurs.

### Exemple

```rust
use field_comparable_derive::Comparable;

#[derive(Comparable)]
struct Utilisateur {
    id: u32,
    nom: String,
    email: String,
}

fn compare_user() {
    let u1 = Utilisateur { id: 1, nom: "Alice".into(), email: "alice@mail.com".into() };
    let u2 = Utilisateur { id: 1, nom: "Bob".into(), email: "alice@mail.com".into() };

    // Exemple : vérifier les différences entre champs
    let diffs = u1.compare_fields(&u2);
    println!("{:?}", diffs);
    
    let name_diffs: bool = u1.name_differs_from(u2);
    let name_diffs: bool = u1.name_differs_from_ref(&u2);
    
    let email_diffs: bool = u1.email_differs_from(u2);
}
```

---

## License

This project is licensed under either:

* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
* Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))

at your option.

---

## Contribution

Contributions, issues and feature requests are welcome!
Feel free to open a PR or an issue in the [GitLab repository](https://gitlab.com/seb.sannac.pro/field-comparable).

---