Can I declare functions and define it later in Rust, like C++? - function

Question

this example grabbed from geeksforgeeks.
// C++ program to demonstrate function
// declaration outside class
#include <bits/stdc++.h>
using namespace std;
class Geeks
{
public:
string geekname;
int id;
// printname is not defined inside class definition
void printname();
// printid is defined inside class definition
void printid()
{
cout << "Geek id is: " << id;
}
};
// Definition of printname using scope resolution operator ::
void Geeks::printname()
{
cout << "Geekname is: " << geekname;
}
int main() {
Geeks obj1;
obj1.geekname = "xyz";
obj1.id=15;
// call printname()
obj1.printname();
cout << endl;
// call printid()
obj1.printid();
return 0;
}
I mean, function like printname in this example.
And in rust..., this example grabbed from exercism and I modified little bit.
// This stub file contains items which aren't used yet; feel free to remove this module attribute
// to enable stricter warnings.
#![allow(unused)]
pub struct User {
name: String,
age: u32,
weight: f32,
}
impl User {
pub fn new(name: String, age: u32, weight: f32) -> Self;
pub fn name(&self) -> &str;
...
...
}
pub fn User::name(&self) -> &str {
unimplemented!()
}
...
...
like this or somewhat difference, but declare first definition later.
Sorry for my bad english, and therefore I included many lines of code and I needed to add some more detail because SO wants that.
There's no way to do this in Rust?

Answer 1

You can do the same thing in Rust. You can implement particular struct methods, from anywhere inside the crate.
This is mostly pointless in Rust, but I'm going to provide an example where this might prove useful.
Soundness concerns leak to the surrounding module, and thus you can reduce the scope of this issue by doing this:
mod a {
pub struct A;
impl A {
pub fn a(&self) {
// here we can't access any unsafe functions specific to A
// unsafe { some_unsafe_helper() }; // compiler error
println!("Called ::crate::a::A::a implemented in ::crate::a");
}
}
mod less_safe {
unsafe fn some_unsafe_helper() {}
impl super::A {
pub fn b(&self) {
// here we have to uphold invariants, in this case, by doing nothing
unsafe { some_unsafe_helper() };
println!("Called ::crate::a::A::b implemented in ::crate::a::less_safe");
}
}
}
}
fn main() {
let example = a::A;
example.a();
example.b();
}
This prints:
Called ::crate::a::A::a implemented in ::crate::a
Called ::crate::a::A::b implemented in ::crate::a::less_safe
Playground