mirror of
https://github.com/bolero-MURAKAMI/Sprout.git
synced 2024-12-23 21:25:49 +00:00
707 lines
22 KiB
C++
707 lines
22 KiB
C++
#ifndef SPROUT_BREED_BREED_FWD_HPP
|
|
#define SPROUT_BREED_BREED_FWD_HPP
|
|
|
|
#include <cstddef>
|
|
#include <climits>
|
|
#include <type_traits>
|
|
#include <sprout/config.hpp>
|
|
|
|
namespace sprout {
|
|
namespace breed {
|
|
namespace detail {
|
|
typedef char yes_type;
|
|
typedef char (&no_type)[2];
|
|
|
|
template<long N>
|
|
struct sized_type {
|
|
public:
|
|
typedef char (&type)[N];
|
|
};
|
|
|
|
struct dont_care;
|
|
struct undefined;
|
|
struct not_a_valid_type;
|
|
|
|
struct private_type_ {
|
|
public:
|
|
SPROUT_CONSTEXPR private_type_ operator,(int) const; //!!!!
|
|
};
|
|
|
|
template<typename T>
|
|
struct uncvref {
|
|
public:
|
|
typedef T type;
|
|
};
|
|
template<typename T>
|
|
struct uncvref<T const> {
|
|
public:
|
|
typedef T type;
|
|
};
|
|
template<typename T>
|
|
struct uncvref<T&> {
|
|
public:
|
|
typedef T type;
|
|
};
|
|
template<typename T>
|
|
struct uncvref<T const&> {
|
|
public:
|
|
typedef T type;
|
|
};
|
|
template<typename T, std::size_t N>
|
|
struct uncvref<T const[N]> {
|
|
public:
|
|
typedef T type[N];
|
|
};
|
|
template<typename T, std::size_t N>
|
|
struct uncvref<T (&)[N]> {
|
|
public:
|
|
typedef T type[N];
|
|
};
|
|
template<typename T, std::size_t N>
|
|
struct uncvref<T const (&)[N]> {
|
|
public:
|
|
typedef T type[N];
|
|
};
|
|
|
|
struct ignore {
|
|
public:
|
|
ignore() = default;
|
|
ignore(ignore const&) = default;
|
|
ignore(ignore&&) = default;
|
|
template<typename T>
|
|
SPROUT_CONSTEXPR ignore(T const&) {}
|
|
};
|
|
|
|
struct _default;
|
|
|
|
struct not_a_domain;
|
|
struct not_a_grammar;
|
|
struct not_a_generator;
|
|
|
|
template<typename T, typename Void = void>
|
|
struct is_transform_;
|
|
|
|
template<typename T, typename Void = void>
|
|
struct is_aggregate_;
|
|
} // namespace detail
|
|
|
|
typedef sprout::breed::detail::ignore const ignore;
|
|
|
|
namespace argsns_ {
|
|
template<typename Arg>
|
|
struct term;
|
|
|
|
template<typename... Args>
|
|
struct list;
|
|
} // namespace argsns_
|
|
using namespace argsns_;
|
|
|
|
namespace tagns_ {
|
|
namespace tag {
|
|
struct terminal;
|
|
struct unary_plus;
|
|
struct negate;
|
|
struct dereference;
|
|
struct complement;
|
|
struct address_of;
|
|
struct logical_not;
|
|
struct pre_inc;
|
|
struct pre_dec;
|
|
struct post_inc;
|
|
struct post_dec;
|
|
|
|
struct shift_left;
|
|
struct shift_right;
|
|
struct multiplies;
|
|
struct divides;
|
|
struct modulus;
|
|
struct plus;
|
|
struct minus;
|
|
struct less;
|
|
struct greater;
|
|
struct less_equal;
|
|
struct greater_equal;
|
|
struct equal_to;
|
|
struct not_equal_to;
|
|
struct logical_or;
|
|
struct logical_and;
|
|
struct bitwise_and;
|
|
struct bitwise_or;
|
|
struct bitwise_xor;
|
|
struct comma;
|
|
struct mem_ptr;
|
|
|
|
struct assign;
|
|
struct shift_left_assign;
|
|
struct shift_right_assign;
|
|
struct multiplies_assign;
|
|
struct divides_assign;
|
|
struct modulus_assign;
|
|
struct plus_assign;
|
|
struct minus_assign;
|
|
struct bitwise_and_assign;
|
|
struct bitwise_or_assign;
|
|
struct bitwise_xor_assign;
|
|
struct subscript;
|
|
struct member;
|
|
struct if_else_;
|
|
struct function;
|
|
|
|
// Fusion tags
|
|
struct breed_expr;
|
|
struct breed_expr_iterator;
|
|
struct breed_flat_view;
|
|
} // namespace tag
|
|
} // namespace tagns_
|
|
using namespace tagns_;
|
|
|
|
template<typename Expr>
|
|
struct tag_of;
|
|
|
|
struct _;
|
|
|
|
struct default_generator;
|
|
|
|
struct basic_default_generator;
|
|
|
|
template<template<typename> class Extends>
|
|
struct generator;
|
|
|
|
template<template<typename> class Extends>
|
|
struct pod_generator;
|
|
|
|
struct by_value_generator;
|
|
|
|
template<typename First, typename Second>
|
|
struct compose_generators;
|
|
|
|
template<typename Generator, typename Void = void>
|
|
struct wants_basic_expr;
|
|
|
|
template<typename Generator>
|
|
struct use_basic_expr;
|
|
|
|
namespace domainns_ {
|
|
typedef sprout::breed::detail::not_a_domain no_super_domain;
|
|
|
|
template<
|
|
typename Generator = sprout::breed::default_generator,
|
|
typename Grammar = sprout::breed::_,
|
|
typename Super = sprout::breed::domainns_::no_super_domain
|
|
>
|
|
struct domain;
|
|
|
|
struct default_domain;
|
|
|
|
struct basic_default_domain;
|
|
|
|
struct deduce_domain;
|
|
|
|
template<
|
|
typename Domain,
|
|
typename Tag,
|
|
typename Args,
|
|
bool WantsBasicExpr = sprout::breed::wants_basic_expr<typename Domain::breed_generator>::value
|
|
>
|
|
struct base_expr;
|
|
} // namespace domainns_
|
|
using namespace domainns_;
|
|
|
|
namespace exprns_ {
|
|
template<typename Tag, typename Args, long Arity = Args::arity>
|
|
struct basic_expr;
|
|
|
|
template<typename Tag, typename Args, long Arity = Args::arity>
|
|
struct expr;
|
|
|
|
template<
|
|
typename Expr,
|
|
typename Derived,
|
|
typename Domain = sprout::breed::default_domain,
|
|
long Arity = Expr::breed_arity_c
|
|
>
|
|
struct extends;
|
|
|
|
template<typename This, typename Fun, typename Domain>
|
|
struct virtual_member;
|
|
|
|
struct is_breed_expr;
|
|
}
|
|
using exprns_::expr;
|
|
using exprns_::basic_expr;
|
|
using exprns_::extends;
|
|
using exprns_::is_breed_expr;
|
|
|
|
template<typename... Args>
|
|
struct or_;
|
|
|
|
template<typename... Args>
|
|
struct and_;
|
|
|
|
template<typename Grammar>
|
|
struct not_;
|
|
|
|
template<
|
|
typename Condition,
|
|
typename Then = sprout::breed::_,
|
|
typename Else = sprout::breed::not_<sprout::breed::_>
|
|
>
|
|
struct if_;
|
|
|
|
template<typename Cases, typename Transform = sprout::breed::tag_of<sprout::breed::_>()>
|
|
struct switch_;
|
|
|
|
template<typename T>
|
|
struct exact;
|
|
|
|
template<typename T>
|
|
struct convertible_to;
|
|
|
|
template<typename Grammar>
|
|
struct vararg;
|
|
|
|
SPROUT_STATIC_CONSTEXPR int N = (INT_MAX >> 10);
|
|
|
|
namespace context {
|
|
struct null_context;
|
|
|
|
template<typename Expr, typename Context, long Arity = Expr::breed_arity_c>
|
|
struct null_eval;
|
|
|
|
struct default_context;
|
|
|
|
template<
|
|
typename Expr,
|
|
typename Context,
|
|
typename Tag = typename Expr::breed_tag,
|
|
long Arity = Expr::breed_arity_c
|
|
>
|
|
struct default_eval;
|
|
|
|
template<typename Derived, typename DefaultCtx = sprout::breed::context::default_context>
|
|
struct callable_context;
|
|
|
|
template<typename Expr, typename Context, long Arity = Expr::breed_arity_c>
|
|
struct callable_eval;
|
|
} // namespace context
|
|
|
|
using context::null_context;
|
|
using context::null_eval;
|
|
using context::default_context;
|
|
using context::default_eval;
|
|
using context::callable_context;
|
|
using context::callable_eval;
|
|
|
|
namespace utility {
|
|
template<typename T, typename Domain = sprout::breed::default_domain>
|
|
struct literal;
|
|
} // namespace context
|
|
|
|
using utility::literal;
|
|
|
|
namespace result_of {
|
|
template<typename T, typename Domain = sprout::breed::default_domain>
|
|
struct as_expr;
|
|
|
|
template<typename T, typename Domain = sprout::breed::default_domain>
|
|
struct as_child;
|
|
|
|
template<typename Expr, typename N = std::integral_constant<long, 0> >
|
|
struct child;
|
|
|
|
template<typename Expr, long N>
|
|
struct child_c;
|
|
|
|
template<typename Expr>
|
|
struct left;
|
|
|
|
template<typename Expr>
|
|
struct right;
|
|
|
|
template<typename Expr>
|
|
struct deep_copy;
|
|
|
|
template<typename Expr, typename Context>
|
|
struct eval;
|
|
|
|
template<
|
|
typename Tag,
|
|
typename DomainOrArg,
|
|
typename... Args
|
|
>
|
|
struct make_expr;
|
|
|
|
template<typename Tag, typename DomainOrSequence, typename SequenceOrVoid = void, typename Void = void>
|
|
struct unpack_expr;
|
|
} // namespace result_of
|
|
|
|
template<typename T, typename Void = void>
|
|
struct is_expr;
|
|
|
|
template<typename T, typename Void = void>
|
|
struct is_domain;
|
|
|
|
template<typename SubDomain, typename SuperDomain>
|
|
struct is_sub_domain_of;
|
|
|
|
template<typename Expr>
|
|
struct arity_of;
|
|
|
|
template<typename T, typename Void = void>
|
|
struct domain_of;
|
|
|
|
template<typename Expr, typename Grammar>
|
|
struct matches;
|
|
|
|
template<typename Tag, typename Arg>
|
|
struct unary_expr;
|
|
|
|
template<typename Tag, typename Left, typename Right>
|
|
struct binary_expr;
|
|
|
|
template<typename Tag, typename... Args>
|
|
struct nary_expr;
|
|
|
|
template<typename T>
|
|
struct terminal;
|
|
template<typename T>
|
|
struct unary_plus;
|
|
template<typename T>
|
|
struct negate;
|
|
template<typename T>
|
|
struct dereference;
|
|
template<typename T>
|
|
struct complement;
|
|
template<typename T>
|
|
struct address_of;
|
|
template<typename T>
|
|
struct logical_not;
|
|
template<typename T>
|
|
struct pre_inc;
|
|
template<typename T>
|
|
struct pre_dec;
|
|
template<typename T>
|
|
struct post_inc;
|
|
template<typename T>
|
|
struct post_dec;
|
|
|
|
template<typename T, typename U>
|
|
struct shift_left;
|
|
template<typename T, typename U>
|
|
struct shift_right;
|
|
template<typename T, typename U>
|
|
struct multiplies;
|
|
template<typename T, typename U>
|
|
struct divides;
|
|
template<typename T, typename U>
|
|
struct modulus;
|
|
template<typename T, typename U>
|
|
struct plus;
|
|
template<typename T, typename U>
|
|
struct minus;
|
|
template<typename T, typename U>
|
|
struct less;
|
|
template<typename T, typename U>
|
|
struct greater;
|
|
template<typename T, typename U>
|
|
struct less_equal;
|
|
template<typename T, typename U>
|
|
struct greater_equal;
|
|
template<typename T, typename U>
|
|
struct equal_to;
|
|
template<typename T, typename U>
|
|
struct not_equal_to;
|
|
template<typename T, typename U>
|
|
struct logical_or;
|
|
template<typename T, typename U>
|
|
struct logical_and;
|
|
template<typename T, typename U>
|
|
struct bitwise_and;
|
|
template<typename T, typename U>
|
|
struct bitwise_or;
|
|
template<typename T, typename U>
|
|
struct bitwise_xor;
|
|
template<typename T, typename U>
|
|
struct comma;
|
|
template<typename T, typename U>
|
|
struct mem_ptr;
|
|
|
|
template<typename T, typename U>
|
|
struct assign;
|
|
template<typename T, typename U>
|
|
struct shift_left_assign;
|
|
template<typename T, typename U>
|
|
struct shift_right_assign;
|
|
template<typename T, typename U>
|
|
struct multiplies_assign;
|
|
template<typename T, typename U>
|
|
struct divides_assign;
|
|
template<typename T, typename U>
|
|
struct modulus_assign;
|
|
template<typename T, typename U>
|
|
struct plus_assign;
|
|
template<typename T, typename U>
|
|
struct minus_assign;
|
|
template<typename T, typename U>
|
|
struct bitwise_and_assign;
|
|
template<typename T, typename U>
|
|
struct bitwise_or_assign;
|
|
template<typename T, typename U>
|
|
struct bitwise_xor_assign;
|
|
template<typename T, typename U>
|
|
struct subscript;
|
|
template<typename T, typename U>
|
|
struct member;
|
|
template<typename T, typename U, typename V>
|
|
struct if_else_;
|
|
|
|
template<typename... Args>
|
|
struct function;
|
|
|
|
namespace functional {
|
|
struct left;
|
|
struct right;
|
|
struct eval;
|
|
struct deep_copy;
|
|
|
|
template<typename Domain = sprout::breed::default_domain>
|
|
struct as_expr;
|
|
|
|
template<typename Domain = sprout::breed::default_domain>
|
|
struct as_child;
|
|
|
|
template<typename N = std::integral_constant<long, 0> >
|
|
struct child;
|
|
|
|
template<long N>
|
|
struct child_c;
|
|
|
|
template<typename Tag, typename Domain = deduce_domain>
|
|
struct make_expr;
|
|
|
|
template<typename Tag, typename Domain = deduce_domain>
|
|
struct unpack_expr;
|
|
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::terminal> make_terminal;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::unary_plus> make_unary_plus;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::negate> make_negate;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::dereference> make_dereference;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::complement> make_complement;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::address_of> make_address_of;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::logical_not> make_logical_not;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::pre_inc> make_pre_inc;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::pre_dec> make_pre_dec;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::post_inc> make_post_inc;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::post_dec> make_post_dec;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::shift_left> make_shift_left;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::shift_right> make_shift_right;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::multiplies> make_multiplies;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::divides> make_divides;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::modulus> make_modulus;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::plus> make_plus;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::minus> make_minus;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::less> make_less;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::greater> make_greater;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::less_equal> make_less_equal;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::greater_equal> make_greater_equal;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::equal_to> make_equal_to;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::not_equal_to> make_not_equal_to;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::logical_or> make_logical_or;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::logical_and> make_logical_and;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_and> make_bitwise_and;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_or> make_bitwise_or;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_xor> make_bitwise_xor;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::comma> make_comma;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::mem_ptr> make_mem_ptr;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::assign> make_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::shift_left_assign> make_shift_left_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::shift_right_assign> make_shift_right_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::multiplies_assign> make_multiplies_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::divides_assign> make_divides_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::modulus_assign> make_modulus_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::plus_assign> make_plus_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::minus_assign> make_minus_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_and_assign> make_bitwise_and_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_or_assign> make_bitwise_or_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_xor_assign> make_bitwise_xor_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::subscript> make_subscript;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::if_else_> make_if_else;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::function> make_function;
|
|
|
|
struct flatten;
|
|
struct make_pair;
|
|
struct first;
|
|
struct second;
|
|
struct at;
|
|
struct pop_front;
|
|
struct push_front;
|
|
struct pop_back;
|
|
struct push_back;
|
|
struct reverse;
|
|
} // namespace functional
|
|
|
|
typedef functional::flatten _flatten;
|
|
typedef functional::make_pair _make_pair;
|
|
typedef functional::first _first;
|
|
typedef functional::second _second;
|
|
typedef functional::pop_front _at;
|
|
typedef functional::pop_front _pop_front;
|
|
typedef functional::push_front _push_front;
|
|
typedef functional::pop_back _pop_back;
|
|
typedef functional::push_back _push_back;
|
|
typedef functional::reverse _reverse;
|
|
typedef functional::eval _eval;
|
|
struct _deep_copy;
|
|
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::terminal> _make_terminal;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::unary_plus> _make_unary_plus;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::negate> _make_negate;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::dereference> _make_dereference;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::complement> _make_complement;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::address_of> _make_address_of;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::logical_not> _make_logical_not;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::pre_inc> _make_pre_inc;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::pre_dec> _make_pre_dec;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::post_inc> _make_post_inc;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::post_dec> _make_post_dec;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::shift_left> _make_shift_left;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::shift_right> _make_shift_right;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::multiplies> _make_multiplies;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::divides> _make_divides;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::modulus> _make_modulus;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::plus> _make_plus;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::minus> _make_minus;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::less> _make_less;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::greater> _make_greater;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::less_equal> _make_less_equal;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::greater_equal> _make_greater_equal;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::equal_to> _make_equal_to;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::not_equal_to> _make_not_equal_to;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::logical_or> _make_logical_or;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::logical_and> _make_logical_and;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_and> _make_bitwise_and;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_or> _make_bitwise_or;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_xor> _make_bitwise_xor;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::comma> _make_comma;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::mem_ptr> _make_mem_ptr;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::assign> _make_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::shift_left_assign> _make_shift_left_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::shift_right_assign> _make_shift_right_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::multiplies_assign> _make_multiplies_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::divides_assign> _make_divides_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::modulus_assign> _make_modulus_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::plus_assign> _make_plus_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::minus_assign> _make_minus_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_and_assign> _make_bitwise_and_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_or_assign> _make_bitwise_or_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::bitwise_xor_assign> _make_bitwise_xor_assign;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::subscript> _make_subscript;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::if_else_> _make_if_else;
|
|
typedef sprout::breed::functional::make_expr<sprout::breed::tag::function> _make_function;
|
|
|
|
template<typename T>
|
|
struct is_callable;
|
|
|
|
template<typename T>
|
|
struct is_transform;
|
|
|
|
template<typename T>
|
|
struct is_aggregate;
|
|
|
|
# define SPROUT_BREED_UNEXPR() typedef int breed_is_expr_;
|
|
# define SPROUT_BREED_CALLABLE() typedef void breed_is_callable_;
|
|
# define SPROUT_BREED_AGGREGATE() typedef void breed_is_aggregate_;
|
|
# define SPROUT_BREED_USE_BASIC_EXPR() typedef void breed_use_basic_expr_;
|
|
|
|
struct callable {
|
|
public:
|
|
SPROUT_BREED_CALLABLE();
|
|
};
|
|
|
|
struct external_transform;
|
|
|
|
template<typename PrimitiveTransform = void, typename X = void>
|
|
struct transform;
|
|
|
|
template<typename Grammar, typename Fun = Grammar>
|
|
struct when;
|
|
|
|
template<typename Fun>
|
|
struct otherwise;
|
|
|
|
template<typename Fun>
|
|
struct call;
|
|
|
|
template<typename Fun>
|
|
struct make;
|
|
|
|
template<typename PrimitiveTransform>
|
|
struct protect;
|
|
|
|
template<typename T>
|
|
struct noinvoke;
|
|
|
|
template<typename Fun>
|
|
struct lazy;
|
|
|
|
template<typename Sequence, typename State, typename Fun>
|
|
struct fold;
|
|
|
|
template<typename Sequence, typename State, typename Fun>
|
|
struct reverse_fold;
|
|
|
|
template<typename Sequence, typename State, typename Fun>
|
|
struct fold_tree;
|
|
|
|
template<typename Sequence, typename State, typename Fun>
|
|
struct reverse_fold_tree;
|
|
|
|
template<typename Grammar>
|
|
struct pass_through;
|
|
|
|
template<typename Grammar = sprout::breed::detail::_default>
|
|
struct _default;
|
|
|
|
struct _expr;
|
|
struct _state;
|
|
struct _data;
|
|
|
|
struct _value;
|
|
|
|
struct _void;
|
|
|
|
template<typename T, T I>
|
|
struct integral_c;
|
|
|
|
template<char I>
|
|
struct char_;
|
|
|
|
template<int I>
|
|
struct int_;
|
|
|
|
template<long I>
|
|
struct long_;
|
|
|
|
template<std::size_t I>
|
|
struct size_t;
|
|
|
|
template<int I>
|
|
struct _child_c;
|
|
|
|
typedef _child_c<0> _child0;
|
|
typedef _child_c<1> _child1;
|
|
typedef _child0 _child;
|
|
typedef _child0 _left;
|
|
typedef _child1 _right;
|
|
|
|
typedef _child_c<2> _child2;
|
|
|
|
struct _byref;
|
|
struct _byval;
|
|
|
|
template<typename T>
|
|
struct is_extension;
|
|
} // namespace breed
|
|
} // namespace sprout
|
|
|
|
#endif // #ifndef SPROUT_BREED_BREED_FWD_HPP
|