| Home | Libraries | People | FAQ | More

## Reference

### Headers

#### Header <boost/yap/algorithm.hpp>

    namespace boost {
      namespace yap {
        template<typename Expr> struct expression_function;
        template<typename Expr> decltype(auto) deref(Expr &&);
        template<typename T> decltype(auto) value(T &&);
        template<typename Expr, typename I> decltype(auto) get(Expr &&, I const &);
        template<long long I, typename Expr> decltype(auto) get_c(Expr &&);
        template<typename Expr> decltype(auto) left(Expr &&);
        template<typename Expr> decltype(auto) right(Expr &&);
        template<typename Expr> decltype(auto) cond(Expr &&);
        template<typename Expr> decltype(auto) then(Expr &&);
        template<typename Expr> decltype(auto) else_(Expr &&);
        template<typename Expr> decltype(auto) callable(Expr &&);
        template<long long I, typename Expr>
          decltype(auto) argument(Expr &&, hana::llong< I >);
        template<template< expr_kind, class > class ExprTemplate, expr_kind Kind,
                 typename... T>
          auto make_expression(T &&...);
        template<template< expr_kind, class > class ExprTemplate, typename T>
          auto make_terminal(T &&);
        template<template< expr_kind, class > class ExprTemplate, typename T>
          decltype(auto) as_expr(T &&);
        template<typename Expr> auto make_expression_function(Expr &&);
        template<typename... T> auto replacements(T &&...);
        template<typename Expr, typename... T>
          decltype(auto) replace_placeholders(Expr &&, T &&...);
        template<typename... T> auto evaluation(T &&...);
        template<typename Expr, typename... T>
          decltype(auto) evaluate(Expr &&, T &&...);
        template<typename Expr, typename Transform, typename... Transforms>
          decltype(auto) constexpr
          transform(Expr &&, Transform &&, Transforms &&...);
        template<typename Expr, typename Transform, typename... Transforms>
          decltype(auto) transform_strict(Expr &&, Transform &&, Transforms &&...);
      }
    }

#### Header <boost/yap/algorithm_fwd.hpp>

    namespace boost {
      namespace yap {
        template<expr_kind Kind> struct expr_tag;
        template<typename Expr> struct is_expr;
        template<expr_kind Kind, typename Tuple> struct minimal_expr;
        template<long long I> struct placeholder;

        enum expr_kind;
        typedef expr_template< expr_kind::terminal, hana::tuple< T > > terminal;
        typedef expr_template< expr_kind::expr_ref, hana::tuple< std::remove_reference_t< T > * > > expression_ref;
        namespace literals {
          template<char... c> constexpr auto operator""_p();
        }
      }
    }

#### Header <boost/yap/config.hpp>

    BOOST_NO_CONSTEXPR_IF

#### Header <boost/yap/expression.hpp>

    namespace boost {
      namespace yap {
        template<expr_kind Kind, typename Tuple> struct expression;

        template<typename T>
          struct expression<expr_kind::terminal, hana::tuple< T >>;
        template<typename Expr> constexpr auto operator+(Expr &&);
        template<typename Expr> constexpr auto operator-(Expr &&);
        template<typename Expr> constexpr auto operator*(Expr &&);
        template<typename Expr> constexpr auto operator~(Expr &&);
        template<typename Expr> constexpr auto operator&(Expr &&);
        template<typename Expr> constexpr auto operator!(Expr &&);
        template<typename Expr> constexpr auto operator++(Expr &&);
        template<typename Expr> constexpr auto operator--(Expr &&);
        template<typename Expr> constexpr auto operator++(Expr &&, int);
        template<typename Expr> constexpr auto operator--(Expr &&, int);
        template<typename LExpr, typename RExpr>
          constexpr auto operator<<(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator>>(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator*(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator/(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator%(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator+(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator-(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator<(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator>(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator<=(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator>=(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator==(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator!=(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator||(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator&&(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator&(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator|(LExpr &&, RExpr &&);
        template<typename LExpr, typename RExpr>
          constexpr auto operator^(LExpr &&, RExpr &&);
        template<typename Expr1, typename Expr2, typename Expr3>
          constexpr auto if_else(Expr1 &&, Expr2 &&, Expr3 &&);
        template<expr_kind Kind, typename... T>
          constexpr auto make_expression(T &&...);
        template<typename T> constexpr auto make_terminal(T &&);
        template<typename T> decltype(auto) constexpr as_expr(T &&);
      }
    }

#### Header <boost/yap/print.hpp>

    namespace boost {
      namespace yap {
        char const  * op_string(expr_kind);
        template<typename Expr> std::ostream & print(std::ostream &, Expr const &);
      }
    }

#### Header <boost/yap/user_macros.hpp>

    BOOST_YAP_USER_UNARY_OPERATOR(op_name, expr_template, result_expr_template)
    BOOST_YAP_USER_BINARY_OPERATOR(op_name, expr_template, result_expr_template)
    BOOST_YAP_USER_ASSIGN_OPERATOR(this_type, expr_template)
    BOOST_YAP_USER_SUBSCRIPT_OPERATOR(expr_template)
    BOOST_YAP_USER_CALL_OPERATOR(expr_template)
    BOOST_YAP_USER_CALL_OPERATOR_N(expr_template, n)
    BOOST_YAP_USER_EXPR_IF_ELSE(expr_template)
    BOOST_YAP_USER_UDT_ANY_IF_ELSE(expr_template, udt_trait)
    BOOST_YAP_USER_UDT_UNARY_OPERATOR(op_name, expr_template, udt_trait)
    BOOST_YAP_USER_UDT_UDT_BINARY_OPERATOR(op_name, expr_template, t_udt_trait, u_udt_trait)
    BOOST_YAP_USER_UDT_ANY_BINARY_OPERATOR(op_name, expr_template, udt_trait)
    BOOST_YAP_USER_LITERAL_PLACEHOLDER_OPERATOR(expr_template)