Monads and GATs in Nightly Rust(fpcomplete.com)

  fn foo<T: Copy + Add + Sync>(x: T) {
    ...
  }

    trait TraitA {
     fn foo(&self, x: i32) -> i32;
    }
    
    trait TraitB {
     fn foo(&self, x: i32) -> i32;
    }
    
    struct Foo {
    }
    
    impl TraitA for Foo {
     fn foo(&self, x: i32) -> i32 {
      x + 1
     }
    }
    
    fn requires_b<T: TraitB>(x: T) {
        x.foo(12);
    }
    
    fn main() {
        let f = Foo { };
        requires_b(f);
    }

    error[E0277]: the trait bound `Foo: TraitB` is not satisfied
      --> src/main.rs:25:16
       |
    19 | fn requires_b<T: TraitB>(x: T) {
       |                  ------ required by this bound in `requires_b`
    ...
    25 |     requires_b(f);
       |                ^ the trait `TraitB` is not implemented for `Foo`

    trait Iterator {
        type Out;

        fn next() -> Option<Out>;
    }

    trait Iterator<T> {
        fn next() -> Option<T>;
    }

  type Input<'a>: 'a;

  type Output<'a>: Future + 'a

  fn call<'a>(self, Self::Input<'a>) -> Self::Output<'a>;
}