How to implement trait default implementation with parameter - rust

Question

I want to implement getter and setter into the trait. For example:
trait StringValue {
value: String;
fn setValue(&self, value: String) {
self.value = value;
}
fn getValue(&self) -> String {
return self.value;
}
}
struct S;
impl StringValue for S {}
fn main() {
let s: S = S {};
s.setValue(String::from("test"));
println!("{}", s.getValue());
}
cargo build:
error: missing `fn`, `type`, or `const` for trait-item declaration
--> src/main.rs:1:20
|
1 | trait StringValue {
| ____________________^
2 | | value: String;
| |____^ missing `fn`, `type`, or `const`
error[E0609]: no field `value` on type `&Self`
--> src/main.rs:5:14
|
5 | self.value = value;
| ^^^^^
error[E0609]: no field `value` on type `&Self`
--> src/main.rs:9:21
|
9 | return self.value;
| ^^^^^
error: aborting due to 3 previous errors
Questions:
Can I use parameters into traits?
How can I fix the code?
If I want to use getter and setter into two different classes, how to implement it?

Answer 1

There is no way to do this in Rust (Currently). However, it's very likely that an alternative, similar, solution is enough for you. If you're interested in progress in that feature, you can check out https://github.com/rust-lang/rfcs/pull/1546 and https://github.com/nikomatsakis/fields-in-traits-rfc.
As for alternative solutions, simply leaving the implementation of the getter/setter to the struct is one option:
trait StringValue {
fn setValue(&mut self, value: String);
fn getValue(&self) -> &String;
}
struct S {
value: String,
}
impl StringValue for S {
fn setValue(&mut self, value: String) {
self.value = value;
}
fn getValue(&self) -> &String {
return &self.value;
}
}
fn main() {
let mut s: S = S {
value: String::from(""),
};
s.setValue(String::from("test"));
println!("{}", s.getValue());
}
But that might get slightly repetitive, specially if you have many such methods. You could try putting them in a separate state struct, add a getter for that state struct and use it to get the fields in the trait's default impl for all the getters/setters, and then just leave an impl of the getter for the state struct up to the containing one to define. However, it should be noted that if you expect these getter/setters to be flexible and be "overriden" (Not use the default), adding the intermediate State struct will make it so a struct overriding the default impl (For, say, get_value in the example with a constant string) needs/has an unused field in the State struct.Example:
trait StringValue {
fn get_state(&self) -> &State;
fn get_state_mut(&mut self) -> &mut State;
fn set_value(&mut self, value: String) {
self.get_state_mut().value = value
}
fn get_value(&self) -> &str {
self.get_state().value.as_str()
}
fn set_value2(&mut self, value: String) {
self.get_state_mut().value2 = value
}
fn get_value2(&self) -> &str {
self.get_state().value2.as_str()
}
}
struct State {
value: String,
value2: String,
}
struct OtherStruct {
state: State,
}
impl StringValue for OtherStruct {
fn get_state_mut(&mut self) -> &mut State {
&mut self.state
}
fn get_state(&self) -> &State {
&self.state
}
}
fn main() {
let mut s = OtherStruct {
state: State {
value: String::from(""),
value2: String::from(""),
},
};
s.set_value(String::from("test"));
dbg!(s.get_value());
s.set_value2(String::from("test2"));
dbg!(s.get_value2());
}
As mentioned by Ömer Erden, the https://crates.io/crates/getset crate might be useful.

Answer 2

From my experiment, getset crate doesn't work, because one has to implement the getter and setters in the impl Trait for Struct block, instead of the Struct block.
To get rid of the repetitive getter/setting implementation, you can use a macro. It is the easiest type of macro to write because you don't even need to process any tokens.
Say you have a struct and trait like below:
trait Test {
fn get_a(&self) -> i32;
fn get_b(&self) -> i32;
}
struct TT {
a: i32,
b: i32,
}
All you need to do is this:
macro_rules! getters {
{} => {
fn get_a(&self) -> i32 {
self.a
}
fn get_b(&self) -> i32 {
self.b
}
}
}
Then you can spam the getters!(); macro inside the impl block for any struct implementing Test trait.
Playground link: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=d897baa26b8c32e5e7bde6c596714353