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 &&...);
  }
}

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();
    }
  }
}

BOOST_NO_CONSTEXPR_IF

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 &&);
  }
}

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

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)