2x1=10

I just start­ed learn­ing Rust some days ago and, com­ing from a C/C++/C# back­ground, imme­di­ate­ly stubbed my toe on the type sys­tem. The notion of traits, how­ev­er, is some­thing I real­ly like and allows for a stunt that is impos­si­ble in C# and ugly in C++: adding things, where by things I mean all the things.

The key is to con­strain a gener­ic type para­me­ter with the Add<T> trait. In this exam­ple, I’m con­strain­ing a gener­ic type T1 to be Add<T2>, that is, to be able to add a T2 to itself. The result of such an oper­a­tion is obvi­ous­ly gener­ic as well, <T1 as Add<T2>>::Output (with Output being the type), allow­ing for the fol­low­ing code:

fn add<T1, T2>(a:T1, b:T2) -> <T1 as Add<T2>>::Output
    where T1: Add<T2>
{
    a+b
}

While this func­tion does noth­ing more than adding two val­ues of arbi­trary types (try that in C# with prim­i­tive types), the under­ly­ing mech­a­nism allows for inter­est­ing oper­a­tions such as vec­tor-matrix mul­ti­pli­ca­tion with­out hav­ing to resort to a con­crete type. A Complex would work as well as a prim­i­tive f32 (i.e. float), f64 (i.e. double), etc.
You can do this in C++, but instead of hav­ing the com­pil­er check the traits (like rustc does), you rather have to hope that some­one imple­ment­ed that spe­cif­ic oper­a­tor over­load or else you’d be in tem­plate error mes­sage hell.