An Intuitive Use-Case for Monadic Bind and Kleisli Composition

An Intuitive Use-Case for Monadic Bind and Kleisli Composition(daniel-j-h.github.io)

16 points by danieljh 11 years ago | 4 comments

dons 11 years ago |

> First let us switch to Haskell for pseudocode as I don’t want to show you the C++ that is required for this.

Hehe, but that's actual code.

> we may go back to our C++14 code base and implement the ideas there. I’m not going to show you how this can be done here, as it requires some more boilerplate code to make the compiler happy – as usual.

People are going to want to see the code, otherwise, what's the point?

danieljh 11 years ago | |

The reason I did not show code is that there is 1/ no notion of a monad type class in C++ 2/ no std::optional in the current C++14 standard and 3/ you have to work around side effects, making an actual implementation highly dependent on your environment and so on.

I'm playing around with what is now my second iteration of Monadic Bind and Kleisli Composition for boost::optional, which looks something like this right now:

    // tag dispatch work around for void returning functions (that make no sense in a purely functional world)
    namespace detail {
        template <typename A, typename Fn>
        auto monadicBindImpl(const boost::optional<A>& a, Fn f, std::false_type) -> decltype(f(*a)) {
            if (a) return f(*a); else return {};
        }
   
        template <typename A, typename Fn>
        auto monadicBindImpl(const boost::optional<A>& a, Fn f, std::true_type) -> void {
            if (a) f(*a);
        }
     }

    template <typename A>  
    auto pure(A&& a) { return boost::optional<A>(std::forward<A>(a)); }  

    template <typename A, typename Fn>  
    auto operator>>=(const boost::optional<A>& a, Fn f) -> decltype(f(*a)) {
        return detail::monadicBindImpl(a, f, typename std::is_same<decltype(f(*a)), void>{});
    }

Kleisli Composition can then be build with C++14's generic polymorphic lambdas exactly like the Haskell implementation does it: https://hackage.haskell.org/package/base-4.6.0.1/docs/src/Co...

There are other articles on the web for Monads in C++, that probably do a better job at an actual implementation. Please see this as my personal playground code :)

rollo 11 years ago | | |

The way the C++ code looks makes me think that the language wasn't designed with this in mind. Modern programming concepts are really stretching the syntax of older languages to the point that there is just too much noise that is distracting from what is actually being done which makes simple things look confusing and complicated. I guess there is a reason Haskell code was used to demonstrate the concept.

// tag dispatch work around for void returning functions (that make no sense in a purely functional world) namespace detail { template <typename A, typename Fn> auto monadicBindImpl(const boost::optional<A>& a, Fn f, std::false_type) -> decltype(f(*a)) { if (a) return f(*a); else return {}; } template <typename A, typename Fn> auto monadicBindImpl(const boost::optional<A>& a, Fn f, std::true_type) -> void { if (a) f(*a); } } template <typename A> auto pure(A&& a) { return boost::optional<A>(std::forward<A>(a)); } template <typename A, typename Fn> auto operator>>=(const boost::optional<A>& a, Fn f) -> decltype(f(*a)) { return detail::monadicBindImpl(a, f, typename std::is_same<decltype(f(*a)), void>{}); }