Cannot create a generic function that uses a literal zero

by

The problem is 0. I’m unclear on the exact rules right now, but let’s be general: 0 is of some specific integer type, which may or may not be the same thing as whatever T is. Thus, the compiler can’t work out what the type parameter to range is supposed to be.

You can resolve this by using Zero::zero:

fn positions<T: Integer>(start: T, step: T, len: T) -> Vec<T> {
    (T::zero()..len).map(|i| start + step * i).collect()
}

This gives the compiler enough leeway to infer that the two arguments to range are of the same type. However, that’s still not enough to use Range as an iterator:

error: no method named `map` found for type `std::ops::Range<T>` in the current scope
 --> src/main.rs:8:22
  |
8 |     (T::zero()..len).map(|i| start + step * i).collect()
  |                      ^^^
  |
  = note: the method `map` exists but the following trait bounds were not satisfied: `T : std::iter::Step`, `&'a T : std::ops::Add`, `std::ops::Range<T> : std::iter::Iterator`

Unfortunately, as of Rust 1.17, the Step trait is unstable, so there’s currently no good way to solve this problem using stable Rust.

Using unstable Rust, you can require implementations of Step:

#![feature(step_trait)]

extern crate num;

use num::Integer;

fn positions<T>(start: T, step: T, len: T) -> Vec<T>
    where T: Integer + std::iter::Step + Copy,
          for<'a> &'a T: std::ops::Add<Output = T>
{
    (T::zero()..len).map(|i| start + step * i).collect()
}

fn main() {
    println!("{:?}", positions(10, 2, 10));
}

You also need to require that T can be copied (or cloned, if you like) because the implementation of Add and Mul consumes the operands by value, which would mean that start + step * i could only be called once, except it needs to be called multiple times.

More Related Contents:

  1. What is the difference between iter and into_iter?
  2. How does for syntax differ from a regular lifetime bound?
  3. How to get a reference to a concrete type from a trait object?
  4. Conditionally iterate over one of several possible iterators
  5. Why is this match pattern unreachable when using non-literal patterns?
  6. Is there any way to create a type alias for multiple traits?
  7. Proper way to return a new string in Rust
  8. Double mutable borrow error in a loop happens even with NLL on
  9. How to return a reference to a sub-value of a value that is under a mutex?
  10. Is it possible to make a type only movable and not copyable?
  11. How to use struct self in member method closure
  12. How do I call a function through a member variable?
  13. How do you pass a Rust function as a parameter?
  14. How do I implement a trait with a generic method?
  15. Is there a way to create a function pointer to a method in Rust?
  16. How do I use conditional compilation with `cfg` and Cargo?
  17. When I can use either Cell or RefCell, which should I choose?
  18. Return an async function from a function in Rust
  19. How to implement `serde::Serialize` for a boxed trait object?
  20. How can a Rust program access metadata from its Cargo package?
  21. How can the ref keyword be avoided when pattern matching in a function taking &self or &mut self?
  22. How do I disambiguate traits in Rust?
  23. Expected bound lifetime parameter, found concrete lifetime [E0271]
  24. How do I change a function’s qualifiers via conditional compilation?
  25. How to quiet a warning for a single statement in Rust?
  26. Use of undeclared type or module `std` when used in a separate module
  27. Is there an elegant solution to modifying a structure while iterating?
  28. Can a struct containing a raw pointer implement Send and be FFI safe?
  29. Lazy sequence generation in Rust
  30. Is there a way to get the field names of a struct in a macro?

Leave a Comment