FunctionalConcepts.hpp

Go to the documentation of this file.

#pragma once
#include <functional>
#include <concepts>
#include <ranges>
 
namespace fishnet::util{
 
template<typename F, typename T, typename R>
concept UnaryFunction = std::invocable<F, T> && std::convertible_to<std::invoke_result_t<F,T>, R>;
 
template<typename T,typename R>
using UnaryFunction_t = std::function<R(const T &)>;
 
template<typename F, typename T, typename U,typename R>
concept BiFunction = std::invocable<F, T, U> && std::convertible_to<std::invoke_result_t<F,T,U>, R>;
 
template<typename T, typename U, typename R>
using BiFunction_t = std::function<R(const T &, const U &)>;
 
template<typename F, typename T>
concept UnaryOperator = UnaryFunction<F,T,T>;
 
template<typename T>
using UnaryOperator_t = std::function<T(const T &)>;
 
template<typename F, typename T>
concept BiOperator = BiFunction<F,T,T,T>;
 
template<typename T>
using BiOperator_t = std::function<T(const T &, const T &)>;
 
template<typename T>
using BiOperator_t = std::function<T(const T &, const T &)>;
 
template<typename F, typename T>
concept Predicate = UnaryFunction<F,T,bool>;
 
template<typename T>
using Predicate_t = std::function<bool(const T &)>;
 
template<typename F,typename T,typename R= T>
concept BiPredicate = BiFunction<F,T,R,bool>;
 
template<typename T, typename  R = T>
using BiPredicate_t = std::function<bool(const T &, const R &)>;
 
template<typename F, typename T>
concept Producer = std::invocable<F> && std::convertible_to<std::invoke_result_t<F>, T>;
 
template<typename T>
using Producer_t = std::function<T()>;
 
template<typename F, typename T>
concept Consumer = UnaryFunction<F,T,void>;
 
template<typename T>
using Consumer_t = UnaryFunction_t<T,void>;
 
template<typename F>
concept Runnable = std::convertible_to<F,std::function<void()>>;
 
template<typename Hasher,typename Key>
concept HashFunction = UnaryFunction<Hasher,Key,size_t>;
 
template<typename F, typename RangeType, typename ResultType = std::ranges::range_value_t<RangeType>>
concept ReduceFunction = std::ranges::forward_range<RangeType> && UnaryFunction<F,RangeType,ResultType>;
 
template<typename RangeType, typename ResultType = std::ranges::range_value_t<RangeType>>
using ReduceFunction_t = std::function<ResultType(const RangeType &)>;
 
struct TruePredicate{
    constexpr bool inline operator()(const auto & t)const noexcept {
        return true;
    }
};
 
struct FalsePredicate {
    constexpr bool inline operator()(const auto & t) const noexcept {
        return false;
    }
};
 
struct TrueBiPredicate{
    constexpr bool inline operator()(const auto & lhs, const auto & rhs) const noexcept {
        return true;
    }
};
 
struct FalseBiPredicate {
    constexpr bool inline operator()(const auto & lhs, const auto & rhs) const noexcept {
        return false;
    }
};
 
struct Identity{
    template<typename T>
    constexpr T inline operator()(const T & t)const noexcept {
        return t;
    }
};
 
struct NOOP{
    constexpr void inline operator()(const auto & t)const noexcept {
        return;
    }
};
 
class LimitPredicate {
private:
    const size_t limit;
    size_t counter;
public:
    LimitPredicate(size_t limit):limit(limit),counter(0){}
    bool operator()(const auto & t) noexcept {
        return counter++ < limit;
    }
};
}