Чё ей надо?

lambda vs std::function<...>

Спасибо. Говно собачье ваш C++.

Почему наш-то? Такой же ваш, как наш.

https://www.anekdot.ru/id/921393/

А собственно: есть ли какие-то осмысленные причины, почему так сделали, что у каждой лямбды свой тип != std::function<…>?

std::function - это тип-обертка, которая нужна, только если указатель на функцию предполагается хранить

Уже и сам вспомнил, что к std::function что только не приводится – и обычные функции, и функции-члены… Блин, ну и бардак. Что-то не прёт у меня сегодня вообще.

Это не бардак, это ровно то, для чего std::function предназначена - унифицированный тип переменной, в которой можно сохранить любую вызываемую сущность подходящей сигнатуры

Если тебя интересует вызов конкретного типа функтора, используй template<class F> void f(F) {}

По твоей первой ссылке это есть, со static_assert(), и если мне от функтора нужно проверять только тип возвращаемого значения, наверное можно найти какие-нибудь type-traits чтобы избежать <class F, class...PP>. Потому что эта дрянь даже такое не хочет: void f(std::function<R(auto...)>) {}.

Но я по-прежнему не втыкаю, почему второй вариант в ТС с явным указанием f<P> не работает, да ещё какую-то дикую сигнатуру function<R(P, PP)> выводит.

С первым пунктом действительно не спорю. Сам давно сбежал на D для личных проектов.

Ты не удосужился на осиливание базовых правил, при этом находишь возможным набрасывать кучи дерьма постоянно.

Но я по-прежнему не втыкаю, почему второй вариант в ТС с явным указанием f не работает, да ещё какую-то дикую сигнатуру function<R(P, PP)> выводит.

   // правильно так
   f(std::function([&](P) -> R { return R{}; }));

Во время поиска подходящего шаблона никакие приведения типов не допускаются, здесь всё строже. Потом все подходящие шаблоны + не шаблоны попадают в общий overload set и вызывается самый подходящий со всеми обычными кастами. Блин, букварь, первый класс.

// правильно так
f(std::function([&](P) -> R { return R{}; }));

Громоздкое уродство. На таком «шикарном» синтаксисе хоть сколько-нибудь юзабельный DSL не сделать.

Осиль концепты, включай шаблон только когда аргумент соответствует критериям, никакого std::function при вызове тогда писать не придется.

Местами использую. Но в данном кейсе это будет по сути примерно то же, что и static_assert() по ссылке в первом каменте, и секса будет не намного меньше. Пока что пробую другой финт ушами.

На таком «шикарном» синтаксисе хоть сколько-нибудь юзабельный DSL не сделать.

Вот тебе DSL #1:

#define FUN std::function

int main() {
    f(FUN([&](P) { return R{}; }));
}

Вот тебе DSL #2:

#define FUN(...) std::function([&](P) { __VA_ARGS__ })

int main() {
    f(FUN(return R{};));
}

И т.д., на сколько фантазии хватит

1. На препроцессор душа категорически не лежит.

2. А вот эквивалентный вызов на скале (ЕМНИП, давно не юзал): f(p -> R()).

На препроцессор душа категорически не лежит.

Без препроцессора про eDLS в C++ можно даже не думать

А вот эквивалентный вызов на скале (ЕМНИП, давно не юзал)

С++ не проектировался как функциональный ЯП, да и заменить ФП-языки вроде Scala и Haskell в их нише он все равно никогда не сможет из-за отсутствия GC.

Без препроцессора про eDLS в C++ можно даже не думать

С чего бы это? https://github.com/foonathan/lexy

namespace dsl = lexy::dsl;

// Parse an IPv4 address into a `std::uint32_t`.
struct ipv4_address
{
    // What is being matched.
    static constexpr auto rule = []{
        // Match a sequence of (decimal) digits and convert it into a std::uint8_t.
        auto octet = dsl::integer<std::uint8_t>;

        // Match four of them separated by periods.
        return dsl::times<4>(octet, dsl::sep(dsl::period)) + dsl::eof;
    }();

    // How the matched output is being stored.
    static constexpr auto value
        = lexy::callback<std::uint32_t>([](std::uint8_t a, std::uint8_t b, std::uint8_t c, std::uint8_t d) {
            return (a << 24) | (b << 16) | (c << 8) | d;
        });
};

Секса тут не много, тривиальная конструкция, программиста на плюсах такое не должно пугать.

template <typename T> struct Check;
template <typename Rt, typename... A>
struct Check<function<Rt(A...)>> {	
	static constexpr bool v = is_same_v<Rt, R>;
};

template<class PP> 
requires Check<decltype(function(declval<PP>()))>::v
void f(PP &&) {}

При том, что function заюзана лишь в компайл тайме, а не как у тебя. std::function не юзается в норме в параметрах шаблонных функций.

Кресты прекрасны, не кроши батон на святое

Спасибо, заюзал и даже понял, и в concept завернул. Хотя если это

тривиальная конструкция

то я балерина Большого театра (UPD: у которой ноги не сходятся).