C++ templates are used for two different features in Rust: generics, and a more broad "metaprogramming."

The other threads talk a bit about general metaprogramming, so let's talk about the other bit. On the generics side, here's an illustrative example, taken from http://en.cppreference.com/w/cpp/language/function_template

  #include <iostream>
   
  template<typename T>
  void f(T s)
  {
      std::cout << s << '\n';
  }
   
  int main()
  {
      f(7);
  }

Here, the function f will take any type T, and print it out. in this case, 7 is an int, so T is int.

In Rust, here's the same function:

  fn f<T>(s: T) {
      println!("{}", s);
  }

  fn main() {
      f(7);
  }

here, 7 is an i32, so T is i32. But, we get a compilation error in Rust:

  error[E0277]: the trait bound `T: std::fmt::Display` is not satisfied
   --> src/main.rs:2:22
    |
  2 |       println!("{}", s);
    |                      ^ `T` cannot be formatted with the default formatter; try using `:?` instead if you are using a format string
    |
    = help: the trait `std::fmt::Display` is not implemented for `T`
    = help: consider adding a `where T: std::fmt::Display` bound
    = note: required by `std::fmt::Display::fmt`

  error: aborting due to previous error

This illuminates a core difference between Rust's generics and C++'s templates: in the C++ case, the code is typechecked after the code is expanded. So it works. However, we don't even need that `main` to cause a compilation error in Rust; it only checks the body of the function. In this case, Rust says "Hey, you accept any T, but you try to print it out. What if a type isn't printable? That wouldn't work!"

The fix is:

  use std::fmt::Display;

  fn f<T: Display>(s: T)

  // or in near-future Rust, a slightly nicer syntax, still needs the 'use' line too:

  fn f(s: impl Display)

This changes the signature to say "we take any type T that implements the Display trait." Now we know that the body of the function works properly.

There are advantages and disadvantages to both approaches. In some senses, the tradeoffs are the same as any duck typed vs not situation: the C++ approach is far more flexible, but the Rust approach has stronger guarantees. We also chose the style we did because we prefer the nicer errors; C++ template errors are notoriously complex, though many say they get used to how to read them over time.

Additionally, neither languages' story is complete here. C++20 has a new feature called "Concepts" that gives you some degree of similar features here, but it's complex and I haven't read the version that was merged into the draft of C++20, so maybe someone else can elaborate on it. Rust is also adding a 'const fn' feature that gives you access to similar tricks to constexpr in C++, as well as more features for our bounded generics.