Experimental autogenerated traits for operations between arbitrary structs (in the same crate).
MIT License
Inter-struct provides various derive macros to implement traits between two structs.
This is useful to, for instance, automatically generate traits such as Into
or PartialEq
between two similar structs.
Please read the known caveats section before using this crate! It's not trivial to implement code for two different structs in a codebase.
Also note that this crate is in an early development phase. The crate is already properly tested, but bugs might still be there and the API might change drastically.
Clone
.From/Into
impl between two structs.From/Into
, but use Default
on the target for unknown fields./// Merge another struct into Self whilst consuming it.
///
/// The other trait is named `StructMergeRef` and merges other structs by reference.
pub trait StructMerge<Src> {
/// Merge the given struct into self.
fn merge(&mut self, src: Src);
}
This following code is an example on how to use the StructMerge
derive macro for implementing the StructMerge
trait between two structs.
use inter_struct::prelude::*;
/// The target struct we'll merge into.
pub struct Target {
pub normal: String,
pub optional: String,
/// This field won't be touched as the macro cannot find a
/// respective `ignored` field in the `Source` struct.
pub ignored: String,
}
/// A struct with both an identical and an optional field type.
/// Note that the path to `Target` must always be fully qualifying.
#[derive(StructMerge)]
#[merge("crate::Target")]
pub struct Source {
pub normal: String,
pub optional: Option<String>,
}
fn main() {
let mut target = Target {
normal: "target".to_string(),
optional: "target".to_string(),
ignored: "target".to_string(),
};
let source = Source {
/// Has the same type as Target::normal
normal: "source".to_string(),
/// Wraps Target::optional in an Option
optional: Some("source".to_string()),
};
// Merge the `Source` struct into target.
target.merge(source);
// You can also call this:
// source.merge_into(target);
assert_eq!(target.normal, "source".to_string());
assert_eq!(target.optional, Some("source".to_string()));
assert_eq!(target.ignored, "target".to_string());
}
This following code is an example on how to use the StructInto
derive macro for implementing Into
between two structs.
use inter_struct::prelude::*;
/// The target struct we'll convert our `Source` struct into.
pub struct Target {
pub normal: String,
pub optional: String,
}
#[derive(StructInto)]
// Note that the path to `Target` must always be fully qualifying.
#[struct_into("crate::Target")]
pub struct Source {
pub normal: String,
pub optional: Option<String>,
/// This field doesn't exist in the target, hence it'll be ignored.
pub ignored: String,
}
fn main() {
let source = Source {
/// Has the same type as Target::normal
normal: "source".to_string(),
/// Wraps Target::optional in an Option
optional: Some("source".to_string()),
ignored: "source".to_string(),
};
// Convert the `Source` struct into `Target`.
let target: Target = source.into();
assert_eq!(target.normal, "source".to_string());
assert_eq!(target.optional, Some("source".to_string()));
}
Inter-struct is designed to work in this environment:
src
folder of the crate. Integration tests and examples aren't supported.The main problems in this crate come from the fact that there's no official way to resolve modules or types in the procedural macro stage.
Due to this limitation, inter-struct isn't capable of ensuring the equality of two types. As a result, it might create false negative compile errors, even though the types might be compatible. This might happen if, for instance, types are obscured via an alias or if a type can be automatically dereferenced into another type.
However, as we're creating safe and valid Rust code, the compiler will thrown an error if any type problems arise.
These are problems that can probably be solved but they're non-trivial.
mod {}
block in file.src
.Cargo.toml
.These are problems that are either impossible to solve or very infeasible. For instance, something infeasible would be to parse all files for a full type resolution of a given crate. That would be a job for the compiler in a later stage.
type test = Option<String>
won't be detected as optional.type AlsoString = String;
won't be detected as a String
;