Is `x >> pure y` equivalent to `liftM (const y) x`












11















The two expressions



y >> pure x
liftM (const x) y


have the same type signature in Haskell.
I was curious whether they were equivalent, but I could neither produce a proof of the fact nor a counter example against it.



If we rewrite the two expressions so that we can eliminate the x and y then the question becomes whether the two following functions are equivalent



flip (>>) . pure
liftM . const


Note that both these functions have type Monad m => a -> m b -> m a.



I used the laws that Haskell gives for monad, applicatives, and functors to transform both statements into various equivalent forms, but I was not able to produce a sequence of equivalences between the two.



For instance I found that y >> pure x can be rewritten as follows



y >>= const (pure x)
y *> pure x
(id <$ y) <*> pure x
fmap (const id) y <*> pure x


and liftM (const x) y can be rewritten as follows



fmap (const x) y
pure (const x) <*> y


None of these spring out to me as necessarily equivalent, but I cannot think of any cases where they would not be equivalent.










share|improve this question





























    11















    The two expressions



    y >> pure x
    liftM (const x) y


    have the same type signature in Haskell.
    I was curious whether they were equivalent, but I could neither produce a proof of the fact nor a counter example against it.



    If we rewrite the two expressions so that we can eliminate the x and y then the question becomes whether the two following functions are equivalent



    flip (>>) . pure
    liftM . const


    Note that both these functions have type Monad m => a -> m b -> m a.



    I used the laws that Haskell gives for monad, applicatives, and functors to transform both statements into various equivalent forms, but I was not able to produce a sequence of equivalences between the two.



    For instance I found that y >> pure x can be rewritten as follows



    y >>= const (pure x)
    y *> pure x
    (id <$ y) <*> pure x
    fmap (const id) y <*> pure x


    and liftM (const x) y can be rewritten as follows



    fmap (const x) y
    pure (const x) <*> y


    None of these spring out to me as necessarily equivalent, but I cannot think of any cases where they would not be equivalent.










    share|improve this question



























      11












      11








      11








      The two expressions



      y >> pure x
      liftM (const x) y


      have the same type signature in Haskell.
      I was curious whether they were equivalent, but I could neither produce a proof of the fact nor a counter example against it.



      If we rewrite the two expressions so that we can eliminate the x and y then the question becomes whether the two following functions are equivalent



      flip (>>) . pure
      liftM . const


      Note that both these functions have type Monad m => a -> m b -> m a.



      I used the laws that Haskell gives for monad, applicatives, and functors to transform both statements into various equivalent forms, but I was not able to produce a sequence of equivalences between the two.



      For instance I found that y >> pure x can be rewritten as follows



      y >>= const (pure x)
      y *> pure x
      (id <$ y) <*> pure x
      fmap (const id) y <*> pure x


      and liftM (const x) y can be rewritten as follows



      fmap (const x) y
      pure (const x) <*> y


      None of these spring out to me as necessarily equivalent, but I cannot think of any cases where they would not be equivalent.










      share|improve this question
















      The two expressions



      y >> pure x
      liftM (const x) y


      have the same type signature in Haskell.
      I was curious whether they were equivalent, but I could neither produce a proof of the fact nor a counter example against it.



      If we rewrite the two expressions so that we can eliminate the x and y then the question becomes whether the two following functions are equivalent



      flip (>>) . pure
      liftM . const


      Note that both these functions have type Monad m => a -> m b -> m a.



      I used the laws that Haskell gives for monad, applicatives, and functors to transform both statements into various equivalent forms, but I was not able to produce a sequence of equivalences between the two.



      For instance I found that y >> pure x can be rewritten as follows



      y >>= const (pure x)
      y *> pure x
      (id <$ y) <*> pure x
      fmap (const id) y <*> pure x


      and liftM (const x) y can be rewritten as follows



      fmap (const x) y
      pure (const x) <*> y


      None of these spring out to me as necessarily equivalent, but I cannot think of any cases where they would not be equivalent.







      haskell monads functor applicative






      share|improve this question















      share|improve this question













      share|improve this question




      share|improve this question








      edited 4 hours ago









      duplode

      23.1k44987




      23.1k44987










      asked 6 hours ago









      10000000001000000000

      469214




      469214
























          3 Answers
          3






          active

          oldest

          votes


















          12














          The other answer gets there eventually, but it takes a long-winded route. All that is actually needed are the definitions of liftM, const, and a single monad law: m1 >> m2 and m1 >>= _ -> m2 must be semantically identical. (Indeed, this is the default implementation of (>>), and it is rare to override it.) Then:



          liftM (const x) y
          = { definition of liftM* }
          y >>= z -> pure (const x z)
          = { definition of const }
          y >>= z -> pure x
          = { monad law }
          y >> pure x


          * Okay, okay, so the actual definition of liftM uses return instead of pure. Whatever.






          share|improve this answer


























          • Interesting. For some reason I thought that the standard definition was liftM = fmap, with the more restrictive type. With the real definition above, the wanted equation is much simpler to obtain :)

            – chi
            4 hours ago






          • 1





            @chi Even without it things aren't too bad: fmap f m = m >>= return . f is also a monad law (one of the oft-forgotten ones).

            – Daniel Wagner
            4 hours ago








          • 3





            That law itself follows from parametricity and the monad law m >>= pure = m.

            – dfeuer
            3 hours ago



















          10














          Yes they are the same



          Let's start with flip (>>) . pure, which is the pointfree version of x >> pure y you provide:



          flip (>>) . pure


          It is the case that flip (>>) is just (=<<) . const so we can rewrite this as:



          ((=<<) . const) . pure


          Since function composition ((.)) is associative we can write this as:



          (=<<) . (const . pure)


          Now we would like to rewrite const . pure. We can notice that const is just pure on (a ->), that means since pure . pure is fmap pure . pure, const . pure is (.) pure . const, ((.) is fmap for the functor (a ->)).



          (=<<) . ((.) pure . const)


          Now we associate again:



          ((=<<) . (.) pure) . const


          ((=<<) . (.) pure) is the definition for liftM1 so we can substitute:



          liftM . const


          And that is the goal. The two are the same.





          1: The definition of liftM is liftM f m1 = do { x1 <- m1; return (f x1) }, we can desugar the do into liftM f m1 = m1 >>= return . f. We can flip the (>>=) for liftM f m1 = return . f =<< m1 and elide the m1 to get liftM f = (return . f =<<) a little pointfree magic and we get liftM = (=<<) . (.) return






          share|improve this answer





















          • 1





            Can you please add how you get from const . pure to fmap pure . const? Btw it might have been easier to start with (.) right away instead of writing fmap (and later explaining (figuring out?) what Functor instance it belongs to).

            – Bergi
            2 hours ago








          • 1





            @Bergi Actually you are right, doing it earlier makes things simpler.

            – Sriotchilism O'Zaic
            2 hours ago



















          4














          One more possible route, exploiting the applicative laws:




          For instance I found that y >> pure x can be rewritten as follows [...]



          fmap (const id) y <*> pure x



          That amounts to...



          fmap (const id) y <*> pure x
          pure ($ x) <*> fmap (const id) y -- interchange law of applicatives
          fmap ($ x) (fmap (const id) y) -- fmap in terms of <*>
          fmap (($ x) . const id) y -- composition law of functors
          fmap (const x) y


          ... which, as you noted, is the same as liftM (const x) y.



          That this route requires only applicative laws and not monad ones reflects how (*>) (another name for (>>)) is an Applicative method.






          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%2f55384267%2fis-x-pure-y-equivalent-to-liftm-const-y-x%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown

























            3 Answers
            3






            active

            oldest

            votes








            3 Answers
            3






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes









            12














            The other answer gets there eventually, but it takes a long-winded route. All that is actually needed are the definitions of liftM, const, and a single monad law: m1 >> m2 and m1 >>= _ -> m2 must be semantically identical. (Indeed, this is the default implementation of (>>), and it is rare to override it.) Then:



            liftM (const x) y
            = { definition of liftM* }
            y >>= z -> pure (const x z)
            = { definition of const }
            y >>= z -> pure x
            = { monad law }
            y >> pure x


            * Okay, okay, so the actual definition of liftM uses return instead of pure. Whatever.






            share|improve this answer


























            • Interesting. For some reason I thought that the standard definition was liftM = fmap, with the more restrictive type. With the real definition above, the wanted equation is much simpler to obtain :)

              – chi
              4 hours ago






            • 1





              @chi Even without it things aren't too bad: fmap f m = m >>= return . f is also a monad law (one of the oft-forgotten ones).

              – Daniel Wagner
              4 hours ago








            • 3





              That law itself follows from parametricity and the monad law m >>= pure = m.

              – dfeuer
              3 hours ago
















            12














            The other answer gets there eventually, but it takes a long-winded route. All that is actually needed are the definitions of liftM, const, and a single monad law: m1 >> m2 and m1 >>= _ -> m2 must be semantically identical. (Indeed, this is the default implementation of (>>), and it is rare to override it.) Then:



            liftM (const x) y
            = { definition of liftM* }
            y >>= z -> pure (const x z)
            = { definition of const }
            y >>= z -> pure x
            = { monad law }
            y >> pure x


            * Okay, okay, so the actual definition of liftM uses return instead of pure. Whatever.






            share|improve this answer


























            • Interesting. For some reason I thought that the standard definition was liftM = fmap, with the more restrictive type. With the real definition above, the wanted equation is much simpler to obtain :)

              – chi
              4 hours ago






            • 1





              @chi Even without it things aren't too bad: fmap f m = m >>= return . f is also a monad law (one of the oft-forgotten ones).

              – Daniel Wagner
              4 hours ago








            • 3





              That law itself follows from parametricity and the monad law m >>= pure = m.

              – dfeuer
              3 hours ago














            12












            12








            12







            The other answer gets there eventually, but it takes a long-winded route. All that is actually needed are the definitions of liftM, const, and a single monad law: m1 >> m2 and m1 >>= _ -> m2 must be semantically identical. (Indeed, this is the default implementation of (>>), and it is rare to override it.) Then:



            liftM (const x) y
            = { definition of liftM* }
            y >>= z -> pure (const x z)
            = { definition of const }
            y >>= z -> pure x
            = { monad law }
            y >> pure x


            * Okay, okay, so the actual definition of liftM uses return instead of pure. Whatever.






            share|improve this answer















            The other answer gets there eventually, but it takes a long-winded route. All that is actually needed are the definitions of liftM, const, and a single monad law: m1 >> m2 and m1 >>= _ -> m2 must be semantically identical. (Indeed, this is the default implementation of (>>), and it is rare to override it.) Then:



            liftM (const x) y
            = { definition of liftM* }
            y >>= z -> pure (const x z)
            = { definition of const }
            y >>= z -> pure x
            = { monad law }
            y >> pure x


            * Okay, okay, so the actual definition of liftM uses return instead of pure. Whatever.







            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited 5 hours ago

























            answered 6 hours ago









            Daniel WagnerDaniel Wagner

            103k7161284




            103k7161284













            • Interesting. For some reason I thought that the standard definition was liftM = fmap, with the more restrictive type. With the real definition above, the wanted equation is much simpler to obtain :)

              – chi
              4 hours ago






            • 1





              @chi Even without it things aren't too bad: fmap f m = m >>= return . f is also a monad law (one of the oft-forgotten ones).

              – Daniel Wagner
              4 hours ago








            • 3





              That law itself follows from parametricity and the monad law m >>= pure = m.

              – dfeuer
              3 hours ago



















            • Interesting. For some reason I thought that the standard definition was liftM = fmap, with the more restrictive type. With the real definition above, the wanted equation is much simpler to obtain :)

              – chi
              4 hours ago






            • 1





              @chi Even without it things aren't too bad: fmap f m = m >>= return . f is also a monad law (one of the oft-forgotten ones).

              – Daniel Wagner
              4 hours ago








            • 3





              That law itself follows from parametricity and the monad law m >>= pure = m.

              – dfeuer
              3 hours ago

















            Interesting. For some reason I thought that the standard definition was liftM = fmap, with the more restrictive type. With the real definition above, the wanted equation is much simpler to obtain :)

            – chi
            4 hours ago





            Interesting. For some reason I thought that the standard definition was liftM = fmap, with the more restrictive type. With the real definition above, the wanted equation is much simpler to obtain :)

            – chi
            4 hours ago




            1




            1





            @chi Even without it things aren't too bad: fmap f m = m >>= return . f is also a monad law (one of the oft-forgotten ones).

            – Daniel Wagner
            4 hours ago







            @chi Even without it things aren't too bad: fmap f m = m >>= return . f is also a monad law (one of the oft-forgotten ones).

            – Daniel Wagner
            4 hours ago






            3




            3





            That law itself follows from parametricity and the monad law m >>= pure = m.

            – dfeuer
            3 hours ago





            That law itself follows from parametricity and the monad law m >>= pure = m.

            – dfeuer
            3 hours ago













            10














            Yes they are the same



            Let's start with flip (>>) . pure, which is the pointfree version of x >> pure y you provide:



            flip (>>) . pure


            It is the case that flip (>>) is just (=<<) . const so we can rewrite this as:



            ((=<<) . const) . pure


            Since function composition ((.)) is associative we can write this as:



            (=<<) . (const . pure)


            Now we would like to rewrite const . pure. We can notice that const is just pure on (a ->), that means since pure . pure is fmap pure . pure, const . pure is (.) pure . const, ((.) is fmap for the functor (a ->)).



            (=<<) . ((.) pure . const)


            Now we associate again:



            ((=<<) . (.) pure) . const


            ((=<<) . (.) pure) is the definition for liftM1 so we can substitute:



            liftM . const


            And that is the goal. The two are the same.





            1: The definition of liftM is liftM f m1 = do { x1 <- m1; return (f x1) }, we can desugar the do into liftM f m1 = m1 >>= return . f. We can flip the (>>=) for liftM f m1 = return . f =<< m1 and elide the m1 to get liftM f = (return . f =<<) a little pointfree magic and we get liftM = (=<<) . (.) return






            share|improve this answer





















            • 1





              Can you please add how you get from const . pure to fmap pure . const? Btw it might have been easier to start with (.) right away instead of writing fmap (and later explaining (figuring out?) what Functor instance it belongs to).

              – Bergi
              2 hours ago








            • 1





              @Bergi Actually you are right, doing it earlier makes things simpler.

              – Sriotchilism O'Zaic
              2 hours ago
















            10














            Yes they are the same



            Let's start with flip (>>) . pure, which is the pointfree version of x >> pure y you provide:



            flip (>>) . pure


            It is the case that flip (>>) is just (=<<) . const so we can rewrite this as:



            ((=<<) . const) . pure


            Since function composition ((.)) is associative we can write this as:



            (=<<) . (const . pure)


            Now we would like to rewrite const . pure. We can notice that const is just pure on (a ->), that means since pure . pure is fmap pure . pure, const . pure is (.) pure . const, ((.) is fmap for the functor (a ->)).



            (=<<) . ((.) pure . const)


            Now we associate again:



            ((=<<) . (.) pure) . const


            ((=<<) . (.) pure) is the definition for liftM1 so we can substitute:



            liftM . const


            And that is the goal. The two are the same.





            1: The definition of liftM is liftM f m1 = do { x1 <- m1; return (f x1) }, we can desugar the do into liftM f m1 = m1 >>= return . f. We can flip the (>>=) for liftM f m1 = return . f =<< m1 and elide the m1 to get liftM f = (return . f =<<) a little pointfree magic and we get liftM = (=<<) . (.) return






            share|improve this answer





















            • 1





              Can you please add how you get from const . pure to fmap pure . const? Btw it might have been easier to start with (.) right away instead of writing fmap (and later explaining (figuring out?) what Functor instance it belongs to).

              – Bergi
              2 hours ago








            • 1





              @Bergi Actually you are right, doing it earlier makes things simpler.

              – Sriotchilism O'Zaic
              2 hours ago














            10












            10








            10







            Yes they are the same



            Let's start with flip (>>) . pure, which is the pointfree version of x >> pure y you provide:



            flip (>>) . pure


            It is the case that flip (>>) is just (=<<) . const so we can rewrite this as:



            ((=<<) . const) . pure


            Since function composition ((.)) is associative we can write this as:



            (=<<) . (const . pure)


            Now we would like to rewrite const . pure. We can notice that const is just pure on (a ->), that means since pure . pure is fmap pure . pure, const . pure is (.) pure . const, ((.) is fmap for the functor (a ->)).



            (=<<) . ((.) pure . const)


            Now we associate again:



            ((=<<) . (.) pure) . const


            ((=<<) . (.) pure) is the definition for liftM1 so we can substitute:



            liftM . const


            And that is the goal. The two are the same.





            1: The definition of liftM is liftM f m1 = do { x1 <- m1; return (f x1) }, we can desugar the do into liftM f m1 = m1 >>= return . f. We can flip the (>>=) for liftM f m1 = return . f =<< m1 and elide the m1 to get liftM f = (return . f =<<) a little pointfree magic and we get liftM = (=<<) . (.) return






            share|improve this answer















            Yes they are the same



            Let's start with flip (>>) . pure, which is the pointfree version of x >> pure y you provide:



            flip (>>) . pure


            It is the case that flip (>>) is just (=<<) . const so we can rewrite this as:



            ((=<<) . const) . pure


            Since function composition ((.)) is associative we can write this as:



            (=<<) . (const . pure)


            Now we would like to rewrite const . pure. We can notice that const is just pure on (a ->), that means since pure . pure is fmap pure . pure, const . pure is (.) pure . const, ((.) is fmap for the functor (a ->)).



            (=<<) . ((.) pure . const)


            Now we associate again:



            ((=<<) . (.) pure) . const


            ((=<<) . (.) pure) is the definition for liftM1 so we can substitute:



            liftM . const


            And that is the goal. The two are the same.





            1: The definition of liftM is liftM f m1 = do { x1 <- m1; return (f x1) }, we can desugar the do into liftM f m1 = m1 >>= return . f. We can flip the (>>=) for liftM f m1 = return . f =<< m1 and elide the m1 to get liftM f = (return . f =<<) a little pointfree magic and we get liftM = (=<<) . (.) return







            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited 2 hours ago

























            answered 6 hours ago









            Sriotchilism O'ZaicSriotchilism O'Zaic

            823620




            823620








            • 1





              Can you please add how you get from const . pure to fmap pure . const? Btw it might have been easier to start with (.) right away instead of writing fmap (and later explaining (figuring out?) what Functor instance it belongs to).

              – Bergi
              2 hours ago








            • 1





              @Bergi Actually you are right, doing it earlier makes things simpler.

              – Sriotchilism O'Zaic
              2 hours ago














            • 1





              Can you please add how you get from const . pure to fmap pure . const? Btw it might have been easier to start with (.) right away instead of writing fmap (and later explaining (figuring out?) what Functor instance it belongs to).

              – Bergi
              2 hours ago








            • 1





              @Bergi Actually you are right, doing it earlier makes things simpler.

              – Sriotchilism O'Zaic
              2 hours ago








            1




            1





            Can you please add how you get from const . pure to fmap pure . const? Btw it might have been easier to start with (.) right away instead of writing fmap (and later explaining (figuring out?) what Functor instance it belongs to).

            – Bergi
            2 hours ago







            Can you please add how you get from const . pure to fmap pure . const? Btw it might have been easier to start with (.) right away instead of writing fmap (and later explaining (figuring out?) what Functor instance it belongs to).

            – Bergi
            2 hours ago






            1




            1





            @Bergi Actually you are right, doing it earlier makes things simpler.

            – Sriotchilism O'Zaic
            2 hours ago





            @Bergi Actually you are right, doing it earlier makes things simpler.

            – Sriotchilism O'Zaic
            2 hours ago











            4














            One more possible route, exploiting the applicative laws:




            For instance I found that y >> pure x can be rewritten as follows [...]



            fmap (const id) y <*> pure x



            That amounts to...



            fmap (const id) y <*> pure x
            pure ($ x) <*> fmap (const id) y -- interchange law of applicatives
            fmap ($ x) (fmap (const id) y) -- fmap in terms of <*>
            fmap (($ x) . const id) y -- composition law of functors
            fmap (const x) y


            ... which, as you noted, is the same as liftM (const x) y.



            That this route requires only applicative laws and not monad ones reflects how (*>) (another name for (>>)) is an Applicative method.






            share|improve this answer






























              4














              One more possible route, exploiting the applicative laws:




              For instance I found that y >> pure x can be rewritten as follows [...]



              fmap (const id) y <*> pure x



              That amounts to...



              fmap (const id) y <*> pure x
              pure ($ x) <*> fmap (const id) y -- interchange law of applicatives
              fmap ($ x) (fmap (const id) y) -- fmap in terms of <*>
              fmap (($ x) . const id) y -- composition law of functors
              fmap (const x) y


              ... which, as you noted, is the same as liftM (const x) y.



              That this route requires only applicative laws and not monad ones reflects how (*>) (another name for (>>)) is an Applicative method.






              share|improve this answer




























                4












                4








                4







                One more possible route, exploiting the applicative laws:




                For instance I found that y >> pure x can be rewritten as follows [...]



                fmap (const id) y <*> pure x



                That amounts to...



                fmap (const id) y <*> pure x
                pure ($ x) <*> fmap (const id) y -- interchange law of applicatives
                fmap ($ x) (fmap (const id) y) -- fmap in terms of <*>
                fmap (($ x) . const id) y -- composition law of functors
                fmap (const x) y


                ... which, as you noted, is the same as liftM (const x) y.



                That this route requires only applicative laws and not monad ones reflects how (*>) (another name for (>>)) is an Applicative method.






                share|improve this answer















                One more possible route, exploiting the applicative laws:




                For instance I found that y >> pure x can be rewritten as follows [...]



                fmap (const id) y <*> pure x



                That amounts to...



                fmap (const id) y <*> pure x
                pure ($ x) <*> fmap (const id) y -- interchange law of applicatives
                fmap ($ x) (fmap (const id) y) -- fmap in terms of <*>
                fmap (($ x) . const id) y -- composition law of functors
                fmap (const x) y


                ... which, as you noted, is the same as liftM (const x) y.



                That this route requires only applicative laws and not monad ones reflects how (*>) (another name for (>>)) is an Applicative method.







                share|improve this answer














                share|improve this answer



                share|improve this answer








                edited 2 hours ago

























                answered 4 hours ago









                duplodeduplode

                23.1k44987




                23.1k44987






























                    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%2f55384267%2fis-x-pure-y-equivalent-to-liftm-const-y-x%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







                    Popular posts from this blog

                    A CLEAN and SIMPLE way to add appendices to Table of Contents and bookmarks

                    Calculate evaluation metrics using cross_val_predict sklearn

                    Insert data from modal to MySQL (multiple modal on website)