Rust also supports it, and it's actually very commonly used. For example, the function `Default::default()`, where Default is a trait that you can easily implement for your own types, too.
I am a bit confused here, are you talking about something that would require templates in C++?
template <T>
auto func(T t) { return t; }
y = func<int>(5);Here is the gist of it. Inferring types in C++ (and languages with type deduction) basically looks like this:
auto a = something;
In Rust (and languages with type inference), inferring types can look like that:
let a = something;
let a = 5;
let b: u64 = a;
To see how this plays out in your parent's comment, I adapted the code from: https://docs.microsoft.com/en-us/cpp/cpp/auto-cpp?view=vs-20...
#include<vector>
void func(std::vector<int> &vect)
{
vect.push_back(30);
}
int main()
{
std::vector<int> vect;
vect.push_back(10);
vect.push_back(20);
func(vect);
return 0;
}
But in Rust, you can write:
fn func(vect: &mut Vec<i32>) {
vect.push(30);
}
fn main() {
let mut vect = Vec::new();
vect.push(10);
vect.push(20);
func(&mut vect);
}
use std::collections::HashMap;
fn main() {
let mut foo = HashMap::new();
foo.insert("bar", 42);
}
fn Default<T>::default() -> T
fn main() {
foo((42));
foo((12.0, 13.0));
}
pub fn foo(args: impl FooArgs) { args.exec() }
pub trait FooArgs { fn exec(self); }
impl FooArgs for u32 { fn exec(self) { println!("A number: {}", self) } }
impl FooArgs for (f32, f32) { fn exec(self) { println!("{} x {} = {}", self.0, self.1, self.0 * self.1) } }
A number: 42
12 x 13 = 156
[1]: https://medium.com/@jreem/advanced-rust-using-traits-for-arg...