Why can't I add a blanket impl on a trait with a type parameter?












3















Consider these two traits:



pub trait Foo {
fn new(arg: u32) -> Self;
}

pub trait Bar<P>: Foo {
fn with_parameter(arg: u32, parameter: P) -> Self;
}


I'd like to add the blanket impl:



impl<T: Bar<P>, P: Default> Foo for T {
fn new(arg: u32) -> Self {
Self::with_parameter(arg, P::default())
}
}


But I get the compiler error:



error[E0207]: the type parameter `P` is not constrained by the impl trait, self type, or predicates


I think I get this error because I'm violating trait coherence rules, but I don't understand exactly what rule this would break. Why is this pattern not allowed? And, more importantly, can I achieve what I want without getting an error?










share|improve this question





























    3















    Consider these two traits:



    pub trait Foo {
    fn new(arg: u32) -> Self;
    }

    pub trait Bar<P>: Foo {
    fn with_parameter(arg: u32, parameter: P) -> Self;
    }


    I'd like to add the blanket impl:



    impl<T: Bar<P>, P: Default> Foo for T {
    fn new(arg: u32) -> Self {
    Self::with_parameter(arg, P::default())
    }
    }


    But I get the compiler error:



    error[E0207]: the type parameter `P` is not constrained by the impl trait, self type, or predicates


    I think I get this error because I'm violating trait coherence rules, but I don't understand exactly what rule this would break. Why is this pattern not allowed? And, more importantly, can I achieve what I want without getting an error?










    share|improve this question



























      3












      3








      3








      Consider these two traits:



      pub trait Foo {
      fn new(arg: u32) -> Self;
      }

      pub trait Bar<P>: Foo {
      fn with_parameter(arg: u32, parameter: P) -> Self;
      }


      I'd like to add the blanket impl:



      impl<T: Bar<P>, P: Default> Foo for T {
      fn new(arg: u32) -> Self {
      Self::with_parameter(arg, P::default())
      }
      }


      But I get the compiler error:



      error[E0207]: the type parameter `P` is not constrained by the impl trait, self type, or predicates


      I think I get this error because I'm violating trait coherence rules, but I don't understand exactly what rule this would break. Why is this pattern not allowed? And, more importantly, can I achieve what I want without getting an error?










      share|improve this question
















      Consider these two traits:



      pub trait Foo {
      fn new(arg: u32) -> Self;
      }

      pub trait Bar<P>: Foo {
      fn with_parameter(arg: u32, parameter: P) -> Self;
      }


      I'd like to add the blanket impl:



      impl<T: Bar<P>, P: Default> Foo for T {
      fn new(arg: u32) -> Self {
      Self::with_parameter(arg, P::default())
      }
      }


      But I get the compiler error:



      error[E0207]: the type parameter `P` is not constrained by the impl trait, self type, or predicates


      I think I get this error because I'm violating trait coherence rules, but I don't understand exactly what rule this would break. Why is this pattern not allowed? And, more importantly, can I achieve what I want without getting an error?







      generics rust traits type-parameter






      share|improve this question















      share|improve this question













      share|improve this question




      share|improve this question








      edited Mar 5 '17 at 21:52









      Shepmaster

      153k14301439




      153k14301439










      asked Mar 5 '17 at 21:03









      OthersOthers

      1,3871939




      1,3871939
























          1 Answer
          1






          active

          oldest

          votes


















          6














          The problem is that a single type could implement Bar<P> for multiple values of P. If you had a struct Baz that implemented Bar<i32> and Bar<String>, which type should Foo::new use for P?



          The only solution is to ensure that a single type cannot implement Bar more than once (if that's not what you want, then you have a flaw in your design!). To do so, we must replace the P type parameter with an associated type.



          pub trait Bar: Foo {
          type Parameter;

          fn with_parameter(arg: u32, parameter: Self::Parameter) -> Self;
          }

          impl<T> Foo for T
          where T: Bar, T::Parameter: Default
          {
          fn new(arg: u32) -> Self {
          Self::with_parameter(arg, T::Parameter::default())
          }
          }


          An implementation of Bar would look like this:



          struct Baz;

          impl Bar for Baz {
          type Parameter = i32;

          fn with_parameter(arg: u32, parameter: Self::Parameter) -> Self {
          unimplemented!()
          }
          }





          share|improve this answer























            Your Answer






            StackExchange.ifUsing("editor", function () {
            StackExchange.using("externalEditor", function () {
            StackExchange.using("snippets", function () {
            StackExchange.snippets.init();
            });
            });
            }, "code-snippets");

            StackExchange.ready(function() {
            var channelOptions = {
            tags: "".split(" "),
            id: "1"
            };
            initTagRenderer("".split(" "), "".split(" "), channelOptions);

            StackExchange.using("externalEditor", function() {
            // Have to fire editor after snippets, if snippets enabled
            if (StackExchange.settings.snippets.snippetsEnabled) {
            StackExchange.using("snippets", function() {
            createEditor();
            });
            }
            else {
            createEditor();
            }
            });

            function createEditor() {
            StackExchange.prepareEditor({
            heartbeatType: 'answer',
            autoActivateHeartbeat: false,
            convertImagesToLinks: true,
            noModals: true,
            showLowRepImageUploadWarning: true,
            reputationToPostImages: 10,
            bindNavPrevention: true,
            postfix: "",
            imageUploader: {
            brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
            contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
            allowUrls: true
            },
            onDemand: true,
            discardSelector: ".discard-answer"
            ,immediatelyShowMarkdownHelp:true
            });


            }
            });














            draft saved

            draft discarded


















            StackExchange.ready(
            function () {
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f42613974%2fwhy-cant-i-add-a-blanket-impl-on-a-trait-with-a-type-parameter%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown

























            1 Answer
            1






            active

            oldest

            votes








            1 Answer
            1






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes









            6














            The problem is that a single type could implement Bar<P> for multiple values of P. If you had a struct Baz that implemented Bar<i32> and Bar<String>, which type should Foo::new use for P?



            The only solution is to ensure that a single type cannot implement Bar more than once (if that's not what you want, then you have a flaw in your design!). To do so, we must replace the P type parameter with an associated type.



            pub trait Bar: Foo {
            type Parameter;

            fn with_parameter(arg: u32, parameter: Self::Parameter) -> Self;
            }

            impl<T> Foo for T
            where T: Bar, T::Parameter: Default
            {
            fn new(arg: u32) -> Self {
            Self::with_parameter(arg, T::Parameter::default())
            }
            }


            An implementation of Bar would look like this:



            struct Baz;

            impl Bar for Baz {
            type Parameter = i32;

            fn with_parameter(arg: u32, parameter: Self::Parameter) -> Self {
            unimplemented!()
            }
            }





            share|improve this answer




























              6














              The problem is that a single type could implement Bar<P> for multiple values of P. If you had a struct Baz that implemented Bar<i32> and Bar<String>, which type should Foo::new use for P?



              The only solution is to ensure that a single type cannot implement Bar more than once (if that's not what you want, then you have a flaw in your design!). To do so, we must replace the P type parameter with an associated type.



              pub trait Bar: Foo {
              type Parameter;

              fn with_parameter(arg: u32, parameter: Self::Parameter) -> Self;
              }

              impl<T> Foo for T
              where T: Bar, T::Parameter: Default
              {
              fn new(arg: u32) -> Self {
              Self::with_parameter(arg, T::Parameter::default())
              }
              }


              An implementation of Bar would look like this:



              struct Baz;

              impl Bar for Baz {
              type Parameter = i32;

              fn with_parameter(arg: u32, parameter: Self::Parameter) -> Self {
              unimplemented!()
              }
              }





              share|improve this answer


























                6












                6








                6







                The problem is that a single type could implement Bar<P> for multiple values of P. If you had a struct Baz that implemented Bar<i32> and Bar<String>, which type should Foo::new use for P?



                The only solution is to ensure that a single type cannot implement Bar more than once (if that's not what you want, then you have a flaw in your design!). To do so, we must replace the P type parameter with an associated type.



                pub trait Bar: Foo {
                type Parameter;

                fn with_parameter(arg: u32, parameter: Self::Parameter) -> Self;
                }

                impl<T> Foo for T
                where T: Bar, T::Parameter: Default
                {
                fn new(arg: u32) -> Self {
                Self::with_parameter(arg, T::Parameter::default())
                }
                }


                An implementation of Bar would look like this:



                struct Baz;

                impl Bar for Baz {
                type Parameter = i32;

                fn with_parameter(arg: u32, parameter: Self::Parameter) -> Self {
                unimplemented!()
                }
                }





                share|improve this answer













                The problem is that a single type could implement Bar<P> for multiple values of P. If you had a struct Baz that implemented Bar<i32> and Bar<String>, which type should Foo::new use for P?



                The only solution is to ensure that a single type cannot implement Bar more than once (if that's not what you want, then you have a flaw in your design!). To do so, we must replace the P type parameter with an associated type.



                pub trait Bar: Foo {
                type Parameter;

                fn with_parameter(arg: u32, parameter: Self::Parameter) -> Self;
                }

                impl<T> Foo for T
                where T: Bar, T::Parameter: Default
                {
                fn new(arg: u32) -> Self {
                Self::with_parameter(arg, T::Parameter::default())
                }
                }


                An implementation of Bar would look like this:



                struct Baz;

                impl Bar for Baz {
                type Parameter = i32;

                fn with_parameter(arg: u32, parameter: Self::Parameter) -> Self {
                unimplemented!()
                }
                }






                share|improve this answer












                share|improve this answer



                share|improve this answer










                answered Mar 5 '17 at 22:09









                Francis GagnéFrancis Gagné

                32.6k26981




                32.6k26981






























                    draft saved

                    draft discarded




















































                    Thanks for contributing an answer to Stack Overflow!


                    • Please be sure to answer the question. Provide details and share your research!

                    But avoid



                    • Asking for help, clarification, or responding to other answers.

                    • Making statements based on opinion; back them up with references or personal experience.


                    To learn more, see our tips on writing great answers.




                    draft saved


                    draft discarded














                    StackExchange.ready(
                    function () {
                    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f42613974%2fwhy-cant-i-add-a-blanket-impl-on-a-trait-with-a-type-parameter%23new-answer', 'question_page');
                    }
                    );

                    Post as a guest















                    Required, but never shown





















































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown

































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown







                    這個網誌中的熱門文章

                    Hercules Kyvelos

                    Tangent Lines Diagram Along Smooth Curve

                    Yusuf al-Mu'taman ibn Hud