What makes `impl Trait` as an argument “universal” and as a return value “existential”?

by

The RFC defines the terms multiple times in multiple manners:

between existential types (where the callee chooses the type) and universal types (where the caller chooses)

There’s been a lot of discussion around universals vs. existentials (in today’s Rust, generics vs impl Trait).

  • Universal quantification, i.e. “for any type T”, i.e. “caller
    chooses”. This is how generics work today. When you write
    fn foo<T>(t: T), you’re saying that the function will work for any
    choice of T, and leaving it to your caller to choose the T.

  • Existential quantification, i.e. “for some type T”, i.e. “callee
    chooses”. This is how impl Trait works today (which is in return
    position only). When you write fn foo() -> impl Iterator, you’re
    saying that the function will produce some type T that implements
    Iterator, but the caller is not allowed to assume anything else
    about that type.

TL;DR:

  • fn take_iter(t: impl Iterator) — the person calling take_iter picks the concrete type. The function has to work for the entire “universe” of types that implement the trait.

  • fn give_iter() -> impl Iterator — the implementation of give_iter picks the concrete type. There is some type which “exists” and implements the trait that will be returned by the function.

More Related Contents:

  1. Why is a trait not implemented for a type that clearly has it implemented?
  2. How can I include a module from another file from the same project?
  3. What does “Sized is not implemented” mean?
  4. Deriving a trait results in unexpected compiler error, but the manual implementation works
  5. How do I implement a trait I don’t own for a type I don’t own?
  6. How do I implement Copy and Clone for a type that contains a String (or any type that doesn’t implement Copy)?
  7. Mutably borrow one struct field while borrowing another in a closure
  8. What makes something a “trait object”?
  9. How to do a binary search on a Vec of floats?
  10. Change enum variant while moving the field to the new variant
  11. When is it useful to define multiple lifetimes in a struct?
  12. Can I write an Iterator that mutates itself and then yields a reference into itself?
  13. How to update-or-insert on a Vec?
  14. How do I include the end value in a range?
  15. How do I specify lifetime parameters in an associated type?
  16. How do I invoke a system command and capture its output?
  17. How to return a string (or similar) from Rust in WebAssembly?
  18. What is the difference between Copy and Clone?
  19. Is it possible to have stack allocated arrays with the size determined at runtime in Rust?
  20. How to format output to a byte array with no_std and no allocator?
  21. What is the right way to allocate data to pass to an FFI call?
  22. Sharing a struct with trait objects as properties across threads
  23. Read large files line by line in Rust [duplicate]
  24. Why is it discouraged to accept a reference &String, &Vec, or &Box as a function argument?
  25. Why does compilation not fail when a member of a moved value is assigned to?
  26. How to switch between Rust toolchains?
  27. What does “missing lifetime specifier” mean when storing a &str in a structure?
  28. Use of undeclared type or module `std` when used in a separate module
  29. Is there an elegant solution to modifying a structure while iterating?
  30. How do I cope with lazy iterators?

Leave a Comment