Long term RFC: Associated traits / Trait generics / ConstraintKinds


I’ve started a dedicated repository for preparing, planning, scheming and writing an RFC for {-# LANGUAGE ConstraintKinds #-} which would allow you to parameterize things by traits (trait generics) as well as have associated traits in traits.

What we wish to enable

A Map trait with associated traits

pub trait Map<K: Self::Key, V: Self::Value> {
    trait Key;
    trait Value;

impl<K: Hash, V> Map<K, V> for HashMap<K, V> {
    trait Key = Hash;
    trait Value = ();

A generic trait object type alias

type FooBox<trait Extra = ()> = Box<dyn Foo + Extra>;

Here, = () means that FooBox is the same as Box<dyn Foo> while FooBox<Send> is the same as Box<dyn Foo + Send>. That is, () is the “unit constraint”, see issue 5 for bikeshedding.

ExactSizeIterator passing

We want to have the same “leakage” as we get with auto traits for -> impl Trait.

The output type is Extra if the input type is Extra:

fn foo<trait Extra = ()>
   (iter: impl Iterator + Extra)
       -> impl Iterator + Extra

Schedule: End of 2018

The goal is to write and design the RFC slowly but surely. So the plan is long term. The intent is to have a bullet proof RFC ready by the end of 2018 or at the beginning of 2019 for consideration.

Landing “ConstraintKinds” will largly require the integration of the chalk_engine into rustc to be complete. Then we can have a more rigoruous understanding of what impact this new feature will have and how we preserve soundness and how this interacts with type inference.

I need your help

I would like your help with identifying:

  • use cases and motivations
  • how to teach users about the contents of the RFC
  • corner cases
  • technical problems & implementation concerns
  • how type inference works if at all
  • writing the RFC
  • etc.

To help out, please, if you can, write and file:

Thank you.

What are ConstraintKinds?

Here’s a friendly explanation:

What is a constraint?

A constraint or a bound is a logical requirement on a type. A type satisfies a certain constraint if it satisfies the requirement to for example, have a certain set of methods.

In Rust, a constraint is of the form: MyType: MyTrait where MyType is of the kind type, and MyTrait of the kind type -> constraint. If we apply a type to the kind level function type -> constraint, we get constraint back.

GHC and Haskell

ConstraintKinds are a feature implemented in GHC, the Glasgow Haskell Compiler. Conceptually, they let you talk about bounds or constraints as kinds.