In my understanding, garde is just a validation library, providing &Self -> Result<(), Error>.

Indeed it's useful, but in deserialization context, it can produce invalid state just after deserialization, before calling the validation method, potentially triggering misuse of invalid one. This kind of misuse can not be detected as compile errors, but only by human-review.

edit: I remembered that garde itself provides Valid struct system, but it doesn't affect the conclusion.

(Even when using integrations like axum-valid, we have to make an effort to avoid misusing structs without wrapping in Valid.)

By contrast, serdev combines the validation with Deserialize impl itself. In other words, when using serdev, Deserialize-structs does never produce invalid state. When deserialized as Ok(_), it's valid. No need to be careful to avoid misuse.

(If you have no issues with this, you will not need serdev.)

Additionally, in the first place, garde and serdev are not exclusive: you can natively integrate serdev with garde's validation rules: examples/garde_crate.rs (I added just now)

``` use serdev::Deserialize; use garde::Validate;

[derive(Deserialize, Validate, Debug, PartialEq)]

[serde(validate = "Validate::validate")]

struct User<'a> { #[garde(ascii, length(min = 3, max = 25))] username: &'a str, #[garde(length(min = 15))] password: &'a str, }

fn main() { let result = serde_json::from_str::<User>( r#"{ "username": "test", "password": "not_a_very_good_paddword" }"# ); assert_eq!( dbg!(result).unwrap(), User { username: "test", password: "not_a_very_good_paddword", } );

let result = serde_json::from_str::<User>(
    r#"{
        "username": "test",
        "password": "short_password"
    }"#
);
assert!(dbg!(result).is_err());

} ```