static auto handler = [](BaseComponent* sender, const MouseEventArgs& args) {
         ...
       };
       
       parent->MouseMove() += handler;
       parent->MouseMove() -= handler;

    auto values = rxcpp::observable<>::range(1, 3).
        concat(rxcpp::observable<>::never<int>()).
        finally([](){printf("The final action\n");});
    auto subscription = values.subscribe(
        [](int v){printf("OnNext: %d\n", v);},
        [](){printf("OnCompleted\n");});
    subscription.unsubscribe();
 

            std::vector<int> tmp;
            element->AddHandler(event, [tmp](BaseComponent* sender, const RoutedEventArgs& args) {
            });

    // Utility to get the N-th type from tuple
    // Ref: https://stackoverflow.com/questions/16928669/how-to-get-n-th-type-from-a-tuple
    template <int N, typename... Ts>
    struct get;

    template <int N, typename T, typename... Ts>
    struct get<N, std::tuple<T, Ts...>>
    {
        using type = typename get<N - 1, std::tuple<Ts...>>::type;
    };

    template <typename T, typename... Ts>
    struct get<0, std::tuple<T, Ts...>>
    {
        using type = T;
    };

    // Utility to strip const/ref/pointer from a type
    // Ref https://stackoverflow.com/questions/14522496/remove-reference-with-const-references
    template<class T> struct remove_all { typedef T type; };
    template<class T> struct remove_all<T*> : remove_all<T> {};
    template<class T> struct remove_all<T&> : remove_all<T> {};
    template<class T> struct remove_all<T&&> : remove_all<T> {};
    template<class T> struct remove_all<T const> : remove_all<T> {};
    template<class T> struct remove_all<T volatile> : remove_all<T> {};
    template<class T> struct remove_all<T const volatile> : remove_all<T> {};

    // Wrap a functor and provide a method that can be used for NoesisGUI Delegate
    template<typename Ret, typename ...Args>
    class FunctorToDelegate{
    public:
        FunctorToDelegate(const std::function<Ret(Args...)> & callback) : m_callback(callback) { }
        Ret Invoke(Args... args) { return m_callback(args...); }
    private:
        std::function<Ret(Args...)> m_callback;
    };

    // FromEvent: Convert NoesisGUI events to rxcpp observables
    // When the observable is subscribed   -> add a callback to the NoesisGUI event
    // When the observable is unsubscribed -> remove the callback from the NoesisGUI event
    template<typename Ret, typename ...Args, template<typename Ret, typename ...Args> typename C>
    decltype(auto) FromEvent(C<Delegate<Ret(Args...)>> & _ev)
    {
        // Remove const & from the second Args type
        // e.g. const MouseEventArgs & -> MouseEventArgs
        // this type will be passed as parameter of the returned observable
        using var = std::tuple<Args...> ;
        using type = remove_all<get<1, var>::type>::type;

        return rxcpp::observable<>::create<type>([_ev](auto && subscriber) {
            auto ev = const_cast<C<Delegate<Ret(Args...)>> &>(_ev);
            // NoesisGUI currently cannot handle lambda with object captures
            // Use FunctorToDelegate to workaround it
            auto wrapper = std::make_shared<FunctorToDelegate<Ret, Args...>>([subscriber](Args... args) -> Ret {
                auto t = std::make_tuple(args...);
                auto param = std::get<1>(t);
                subscriber.on_next(param);
            });

            // Register a callback to NoesisGUI event
            ev += MakeDelegate(wrapper.get(), &FunctorToDelegate<Ret, Args...>::Invoke); 

            subscriber.add([_ev, wrapper]() {
                // In the event of unsubscribe, remove the callback from the NoesisGUI event
                auto ev = const_cast<C<Delegate<Ret(Args...)>> &>(_ev);
                ev -= MakeDelegate(wrapper.get(), &FunctorToDelegate<Ret, Args...>::Invoke);
            });
        });
    }

            auto subscription = FromEvent(element->MouseDown()).subscribe([](auto && param) {
                ...
            });
            ...
            subscription.unsubscribe();