maybe.hpp

Go to the documentation of this file.

/*
Copyright© 2014 Akihiro Nishimura

This software is released under the MIT License.
http://opensource.org/licenses/mit-license.php
*/

#ifndef _SIG_UTIL_MAYBE_HPP
#define _SIG_UTIL_MAYBE_HPP

#include "../sigutil.hpp"
#include "eval.hpp"
#include "type_convert.hpp"
#include "container_traits.hpp"

#if SIG_ENABLE_BOOST && SIG_USE_OPTIONAL
#include <boost/optional.hpp>
#endif


namespace sig
{
    
// Maybe(boost.optional)の有効・無効に関係なくコードを統一的に記述するための処理
#if SIG_ENABLE_BOOST && SIG_USE_OPTIONAL
    template <class T> using Maybe = boost::optional<T>;


    template <class T, class R = typename sig::impl::remove_const_reference<T>::type>
    Maybe<R> Just(T&& v){ return Maybe<R>(std::forward<T>(v)); }

    template <class T>
    Maybe<T> Just(T const& v){ return Maybe<T>(v); }        // T is given explicitly


    template <class T = void>
    auto Nothing()-> typename impl::SameIf<T, void, typename boost::none_t, Maybe<T>>::type
    {
        return boost::none;
    }


    template <class T> auto Nothing(T const& dummy)-> Maybe<T>{ return boost::none; }


    template <class T> bool isJust(Maybe<T> const& m){ return static_cast<bool>(m); }
    constexpr bool isJust(boost::none_t m){ return false; }
    

    template <class T> bool isNothing(Maybe<T> const& m){ return !static_cast<bool>(m); }
    constexpr bool isNothing(boost::none_t m){ return true; }



    template <class T> T& fromJust(Maybe<T>& m){ return *m; }
    template <class T> T const& fromJust(Maybe<T> const& m){ return *m; }
    template <class T> T&& fromJust(Maybe<T>&& m){ return std::move(*m); }



    template <class T> T& operator*(Maybe<T>& m){ return *m; }
    template <class T> T const& operator*(Maybe<T> const& m){ return *m; }
    template <class T> T&& operator*(Maybe<T>&& m){ return *std::move(m); }



    template <class T> T& fromMaybe(T& def, Maybe<T>& m){ return m ? *m : def; }
    template <class T> T const& fromMaybe(T const& def, Maybe<T> const& m){ return m ? *m : def; }
    template <class T> T&& fromMaybe(T&& def, Maybe<T>&& m){ return m ? std::move(*m) : std::move(def); }
    template <class T> T&& fromMaybe(T&& def, boost::none_t m){ return std::move(def); }



    template <class F, class C> auto mapMaybe(F const& f, C const& list)
        ->typename impl::container_traits<C>::template rebind<
            typename std::remove_reference<decltype(*(impl::eval(
                f, 
                std::declval<typename impl::container_traits<C>::value_type>()
            )))>::type
        >
    {
        using R = typename impl::container_traits<C>::template rebind<typename std::remove_reference<decltype(*(impl::eval(f, std::declval<typename impl::container_traits<C>::value_type>())))>::type>;

        R result;

        for (auto const& e : list){
            auto r = f(e);
            if (r) impl::container_traits<R>::add_element(result, *r);
        }

        return result;
    }



    template <class T, class F>
    auto operator>>=(Maybe<T> const& m, F const& f) ->decltype(impl::eval(f, std::declval<T>()))
    {
        if (m) return f(*m);
        else return boost::none;
    }


    template <class F, class T>
    auto operator<<=(F const& f, Maybe<T> const& m) ->decltype(impl::eval(f, std::declval<T>()))
    {
        if (m) return f(*m);
        else return boost::none;
    }



    template <class T1, class T2>
    auto operator<<=(Maybe<T1>& m, T2 const& v) ->Maybe<T1>&
    {
        if (m) *m = v;
        else m = Maybe<T1>(static_cast<T1>(v));
        return m;
    }
    
#else
    // optionalが使えない場合の代替処理
    // 当ライブラリコードを統一的に記述するために用いているため、ユーザコードでの使用は非推奨

    template <class I, class D = void> using Maybe = std::tuple<I, bool>;

    template <class I> Maybe<I> Just(I v){ return std::make_tuple(v, true); }

    template <class I> Maybe<I> Nothing(I&& dummy){ return std::make_tuple(dummy, false); }
    template <class I> Maybe<I> Nothing(I const& dummy){ return std::make_tuple(dummy, false); }

    template <class I> bool isJust(Maybe<I> const& m){ return std::get<1>(m); }

    template <class I> bool isNothing(Maybe<I> const& m){ return !std::get<1>(m); }

    template <class T> T& fromJust(Maybe<T>& m){ return *m; }
    template <class T> T const& fromJust(Maybe<T> const& m){ return *m; }
    template <class T> T&& fromJust(Maybe<T>&& m){ return *std::move(m); }

    template <class T> T& operator*(Maybe<T>& m){
        if (!std::get<1>(m)) std::abort();
        return std::get<0>(m);
    }
    template <class T> T const& operator*(Maybe<T> const& m){
        if (!std::get<1>(m)) std::abort();
        return std::get<0>(m);
    }
    template <class T> T&& operator*(Maybe<T>&& m){
        if (!std::get<1>(m)) std::abort();
        return std::move(std::get<0>(m));
    }


    template <class T1, class T2>
    auto operator<<=(Maybe<T1>& m, T2 const& v) ->Maybe<T1>&
    {
        std::get<0>(m) = v;
        std::get<1>(m) = true;
        return m;
    }
    
#endif


}   // sig
#endif