kiszug Namespace Reference

Classes
struct	empty_t

Variables
constexpr auto	foreach_arg
constexpr auto	foreach_tuple
template<typename T >
constexpr auto	map_equal = [] (T value) { return zug::map([value](auto&& x) { return x == value; }); }
template<>
constexpr auto	map_equal< qreal > = [] (qreal value) { return zug::map([value](auto&& x) { return qFuzzyCompare(x, value); }); }
template<typename T >
constexpr auto	map_greater = [] (T value) { return zug::map([value](auto&& x) { return x > value; }); }
template<typename T >
constexpr auto	map_greater_equal = [] (T value) { return zug::map([value](auto&& x) { return x >= value; }); }
template<>
constexpr auto	map_greater_equal< qreal > = [] (qreal value) { return zug::map([value](auto&& x) { return x >= value || qFuzzyCompare(x, value); }); }
template<typename T >
constexpr auto	map_less = [] (T value) { return zug::map([value](auto&& x) { return x < value; }); }
template<typename T >
constexpr auto	map_less_equal = [] (T value) { return zug::map([value](auto&& x) { return x <= value; }); }
template<>
constexpr auto	map_less_equal< qreal > = [] (qreal value) { return zug::map([value](auto&& x) { return x <= value || qFuzzyCompare(x, value); }); }
template<typename T >
constexpr auto	map_multiply = [] (T coeff) { return zug::map([coeff](auto&& x) { return x * coeff; }); }
template<typename T >
constexpr auto	map_not_equal = [] (T value) { return zug::map([value](auto&& x) { return x != value; }); }
template<>
constexpr auto	map_not_equal< qreal > = [] (qreal value) { return zug::map([value](auto&& x) { return !qFuzzyCompare(x, value); }); }
constexpr auto	map_round = zug::map([](qreal x) -> int { return qRound(x); })
template<typename T >
constexpr auto	map_static_cast = zug::map([](auto&& x) { return static_cast<T>(x); })
constexpr auto	to_functor

Detailed Description

kiszug is a namespace extending the functionality of zug library. It contains transducers, lenses and other tools that are not present in zug itself.

Naming convention exception:

The namespace follows naming convention of zug library, that is, all entities should be named in "snake_case" manner.

Variable Documentation

foreach_arg

constexpr auto kiszug::foreach_arg

constexpr

Initial value:

=
    [] (auto mapping) {
        return zug::map([=] (auto&&... t) {
            return std::make_tuple(zug::compat::invoke(to_functor(mapping), ZUG_FWD(t))...);
        });
    }

Definition at line 84 of file KisZug.h.

                      {
        return zug::map([=] (auto&&... t) {
            return std::make_tuple(zug::compat::invoke(to_functor(mapping), ZUG_FWD(t))...);
        });
    };

foreach_tuple

constexpr auto kiszug::foreach_tuple

constexpr

Initial value:

=
    [] (auto mapping) {
        return zug::map([=] (auto &&t) {
            return kismpl::apply_to_tuple(to_functor(mapping), ZUG_FWD(t));
        });
    }

Definition at line 77 of file KisZug.h.

                      {
        return zug::map([=] (auto &&t) {
            return kismpl::apply_to_tuple(to_functor(mapping), ZUG_FWD(t));
        });
    };

map_equal

template<typename T >

constexpr auto kiszug::map_equal = [] (T value) { return zug::map([value](auto&& x) { return x == value; }); }

constexpr

Definition at line 36 of file KisZug.h.

{ return zug::map([value](auto&& x) { return x == value; }); };

map_equal< qreal >

template<>

constexpr auto kiszug::map_equal< qreal > = [] (qreal value) { return zug::map([value](auto&& x) { return qFuzzyCompare(x, value); }); }

inlineconstexpr

Definition at line 53 of file KisZug.h.

{ return zug::map([value](auto&& x) { return qFuzzyCompare(x, value); }); };

map_greater

template<typename T >

constexpr auto kiszug::map_greater = [] (T value) { return zug::map([value](auto&& x) { return x > value; }); }

constexpr

Definition at line 42 of file KisZug.h.

{ return zug::map([value](auto&& x) { return x > value; }); };

map_greater_equal

template<typename T >

constexpr auto kiszug::map_greater_equal = [] (T value) { return zug::map([value](auto&& x) { return x >= value; }); }

constexpr

Definition at line 44 of file KisZug.h.

{ return zug::map([value](auto&& x) { return x >= value; }); };

map_greater_equal< qreal >

template<>

constexpr auto kiszug::map_greater_equal< qreal > = [] (qreal value) { return zug::map([value](auto&& x) { return x >= value || qFuzzyCompare(x, value); }); }

inlineconstexpr

Definition at line 59 of file KisZug.h.

{ return zug::map([value](auto&& x) { return x >= value || qFuzzyCompare(x, value); }); };

map_less

template<typename T >

constexpr auto kiszug::map_less = [] (T value) { return zug::map([value](auto&& x) { return x < value; }); }

constexpr

Definition at line 47 of file KisZug.h.

{ return zug::map([value](auto&& x) { return x < value; }); };

map_less_equal

template<typename T >

constexpr auto kiszug::map_less_equal = [] (T value) { return zug::map([value](auto&& x) { return x <= value; }); }

constexpr

Definition at line 50 of file KisZug.h.

{ return zug::map([value](auto&& x) { return x <= value; }); };

map_less_equal< qreal >

template<>

constexpr auto kiszug::map_less_equal< qreal > = [] (qreal value) { return zug::map([value](auto&& x) { return x <= value || qFuzzyCompare(x, value); }); }

inlineconstexpr

Definition at line 62 of file KisZug.h.

{ return zug::map([value](auto&& x) { return x <= value || qFuzzyCompare(x, value); }); };

map_multiply

template<typename T >

constexpr auto kiszug::map_multiply = [] (T coeff) { return zug::map([coeff](auto&& x) { return x * coeff; }); }

constexpr

Definition at line 33 of file KisZug.h.

{ return zug::map([coeff](auto&& x) { return x * coeff; }); };

map_not_equal

template<typename T >

constexpr auto kiszug::map_not_equal = [] (T value) { return zug::map([value](auto&& x) { return x != value; }); }

constexpr

Definition at line 39 of file KisZug.h.

{ return zug::map([value](auto&& x) { return x != value; }); };

map_not_equal< qreal >

template<>

constexpr auto kiszug::map_not_equal< qreal > = [] (qreal value) { return zug::map([value](auto&& x) { return !qFuzzyCompare(x, value); }); }

inlineconstexpr

Definition at line 56 of file KisZug.h.

{ return zug::map([value](auto&& x) { return !qFuzzyCompare(x, value); }); };

map_round

constexpr auto kiszug::map_round = zug::map([](qreal x) -> int { return qRound(x); })

constexpr

Definition at line 64 of file KisZug.h.

map_static_cast

template<typename T >

constexpr auto kiszug::map_static_cast = zug::map([](auto&& x) { return static_cast<T>(x); })

constexpr

Definition at line 30 of file KisZug.h.

to_functor

constexpr auto kiszug::to_functor

constexpr

Initial value:

= [] (auto f) {
    return
        [=] (auto &&x) {
            return f(zug::last)(empty_t{}, ZUG_FWD(x));
        };
}

Definition at line 70 of file KisZug.h.

                                        {
    return
        [=] (auto &&x) {
            return f(zug::last)(empty_t{}, ZUG_FWD(x));
        };
};