C++ pattern matching

    Нет нужды описывать чем хорош pattern matching. Так как в любом случае такой конструкции в С++ нет.
    Без него же работа с шаблонами, часто обрастает лесами понятного и полезного кода.
    Итак предлагаю способ некоего подобия pattern matching`а для С++14 (скорее даже type matching'a), который укладывается в 50 строк кода, не использует макросы и вообще кросс-компиляторный.


    Сначала пример использования: http://coliru.stacked-crooked.com/a/6066e8c3d87e31eb


    template<class T>
    decltype(auto) test(T& value) {
        return match(value
            ,[](std::string value)    { cout << "This is string"; return value + " Hi!"; }
            ,[](int i)                { cout << "This is int";    return i * 100; }
            ,[](auto a)               { cout << "This is default";return nullptr; }
        );
    }

    compile-time Условия: http://coliru.stacked-crooked.com/a/ccb13547b04ce6ad


    match(true_type{}
             ,[](bool_constant< T::value == 10 >)                        { cout << "1" ; }
             ,[](bool_constant< (T::value == 20 && sizeof...(Args)>4) >) { cout << "2" ; }
        );

    Возвращаем тип: http://coliru.stacked-crooked.com/a/0a8788d026008b4b


    auto t = match(true_type{}
               ,[](is_same_t<T, int>) -> type_holder<short>  { return{}; }
               ,[](auto)              -> type_holder<T>      { return{}; }
             );
    
    using I = typename decltype(t)::type;             
    I i = 1000000;

    Если вы вообще не понимаете зачем нужен pattern matching (в частности по типу)

    Например вы пишете обертку для вызова java функции из С++ (через jni).
    Обычно это бы выглядело:


    int call_java_helper(int element){
       return  jni->CallIntMethod(....);
    }
    
    float call_java_helper(float element){
       return  jni->CallFloatMethod(....);
    }
    
    void call_java_helper(nullptr_t){
        jni->CallVoidMethod(....);
    }
    
    template<class T>
    auto call_java(T element){
         cout << "Start Java Call";
         return call_java_helper(element);
    }

    C использованием pattern matching:


    template<class T>
    auto call_java(T element){
         cout << "Start Java Call";
         return match(elment, 
             ,[](int element)  { return jni->CallIntMethod(element); }
             ,[](float element){ return jni->CallFloatMethod(element); }
             ,[](auto)         { jni->CallVoidMethod(); }
         );
    }

    Всё собрано и в одном месте.


    Думаю можно провести некую аналогию с Rust pattern matching по enum'ам


    Синтаксис


    match(value                    // <- значение, тип которого сравнивается
         ,[](std::string value)    { /* будет сравниваться с std::string */ }         
         ,[](int i)                { /* можно возвращать значения различных типов  */ return i+100; } 
         ,[](auto a)               { /* Аналог default: в switch */ }     
    ); 

    Принцип работы


    Основная логика:


    namespace details {
        template<class T, class Case, class ...OtherCases>
        decltype(auto) match_call(const Case& _case, T&& value, std::true_type, const OtherCases&...) {
            return _case(std::forward<T>(value));
        }
    
        template<class T, class Case, class ...OtherCases>
        decltype(auto) match_call(const Case& _case, T&& value, std::false_type, const OtherCases&...) {
            return match(std::forward<T>(value), other...);
        }
    }
    
    template<class T, class Case, class ...Cases>
    decltype(auto) match(T&& value, const Case& _case, const Cases&... cases) {
        using namespace std;
        using args = typename FunctionArgs<Case>::args;               // <- Это самое интересное место!
        using arg = tuple_element_t<0, args>;
        using match = is_same<decay_t<arg>, decay_t<T>>;
        return details::match_call(_case, std::forward<T>(value), match{}, cases...);
    }
    
    // это для default
    template<class T, class Case>
    decltype(auto) match(T&& value, const Case& _case) {
        return _case(std::forward<T>(value));
    }

    Функция match принимает на вход сравниваемое значение value и список лямбд (которые служат case'ми). У каждой лямбды должен быть ровно один аргумент. С помощью FunctionArgs мы определяем тип этого аргумента. Затем проходим по всем лямбдам и вызываем ту у которой совпадает тип аргумента.


    Предполагается что последняя лямбда может содержать generic аргумент. Поэтому тип её аргументов не проверяется. Она просто вызывается. Если она не generic, и тип не совпадает компилятор просто выдаст ошибку (правда предварительно попытается привести к типу).


    Можно было бы как то определять generic последняя лямбда или нет, но как это сделать — неизвестно.


    FunctionArgs — модифицированная версия http://stackoverflow.com/a/27867127/1559666 :


    template <typename T>
    struct FunctionArgs : FunctionArgs<decltype(&T::operator())> {};
    
    template <typename R, typename... Args>
    struct FunctionArgsBase{
        using args  = std::tuple<Args...>;
        using arity = std::integral_constant<unsigned, sizeof...(Args)>;
        using result = R;
    };
    
    template <typename R, typename... Args>
    struct FunctionArgs<R(*)(Args...)> : FunctionArgsBase<R, Args...> {};
    template <typename R, typename C, typename... Args>
    struct FunctionArgs<R(C::*)(Args...)> : FunctionArgsBase<R, Args...> {};
    template <typename R, typename C, typename... Args>
    struct FunctionArgs<R(C::*)(Args...) const> : FunctionArgsBase<R, Args...> {};

    P.S.


    Должен заметить, что существует также https://github.com/solodon4/Mach7, которая также реализует pattern matching (можно даже сказать что в более полной мере). Но синтаксис, обилие макросов, её объём, и то что на момент написания статьи она находилась в несколько… разобранном состоянии оттолкнули автора в сторону этого велосипеда…
    Впрочем, будем надеяться на светлое будущее в лице с++23 а может и с++20 с поддержкой pattern matching'a со стороны языка.


    Весь код текстом (для копи-паста)
    /*
    std::string s = "12";
    cout << match(s
        ,[](int& i) { return "int"; }
        ,[](bool& b) { return "bool"; }
        ,[](std::string& s) -> auto& { s += " GAV"; return s; }
        ,[](auto j) { cout << "default one"; return j; }
    );
    */
    
    #include <tuple>
    
    template <typename T>
    struct FunctionArgs : FunctionArgs<decltype(&T::operator())> {};
    
    template <typename R, typename... Args>
    struct FunctionArgsBase{
        using args  = std::tuple<Args...>;
        using arity = std::integral_constant<unsigned, sizeof...(Args)>;
        using result = R;
    };
    
    template <typename R, typename... Args>
    struct FunctionArgs<R(*)(Args...)> : FunctionArgsBase<R, Args...> {};
    template <typename R, typename C, typename... Args>
    struct FunctionArgs<R(C::*)(Args...)> : FunctionArgsBase<R, Args...> {};
    template <typename R, typename C, typename... Args>
    struct FunctionArgs<R(C::*)(Args...) const> : FunctionArgsBase<R, Args...> {};
    
    // forward declarations
    template<class T, class Case, class ...Cases>
    decltype(auto) match(T&& value, const Case& _case, const Cases&... cases);
    template<class T, class Case>
    decltype(auto) match(T&& value, const Case& _case);
    
    namespace details {
        template<class T, class Case, class ...OtherCases>
        decltype(auto) match_call(const Case& _case, T&& value, std::true_type, const OtherCases&... other) {
            return _case(std::forward<T>(value));
        }
    
        template<class T, class Case, class ...OtherCases>
        decltype(auto) match_call(const Case& _case, T&& value, std::false_type, const OtherCases&... other) {
            return match(std::forward<T>(value), other...);
        }
    }
    
    template<class T, class Case, class ...Cases>
    decltype(auto) match(T&& value, const Case& _case, const Cases&... cases) {
        using namespace std;
        using args = typename FunctionArgs<Case>::args;
        using arg = tuple_element_t<0, args>;
        using match = is_same<decay_t<arg>, decay_t<T>>;
        return details::match_call(_case, std::forward<T>(value), match{}, cases...);
    }
    
    // the last one is default
    template<class T, class Case>
    decltype(auto) match(T&& value, const Case& _case) {
        return _case(std::forward<T>(value));
    }



    Update


    В комментариях предложили на мой взгляд более совершенный способ https://habrahabr.ru/post/282630/#comment_8873766.
    С его помощью можно делать сопоставление с образцом сразу по нескольким значениям.
    Даже если вы делаете сопоставление всего по одному значению, вам может понадобится просто передать дополнительные аргументы в функцию. Например в следующем примере в clang необходимо передавать в функцию тип(gcc и VS работают и без этого):


        template<class Out, class ...Args>
        inline Out run(Args&&...args){
            auto in = std::tie(std::forward<Args>(args)...);
            return match(type_holder<Out>()
                    ,[&](type_holder<void>){ command(Parcel(in), Parcel()); }
                    ,[&](auto type)->Out{
                        Out out;    // clang выдаст ошибку : переменная не может быть типа void . 
                        //typename decltype(type)::type out;    // А так работает
                        command(Parcel(in), Parcel(out));
                        return out;
                    }
            );
        }

    Но вот что-то в духе:


    match(
       [&](false_type, auto)      { command(); },
       [&](true_type,  auto type) {
             typename decltype(type)::type out;
             command(Parcel(out));    
       }
    )(is_void{}, type_holder<Out>{});

    Сделать невозможно.


    В случае не нахождения "образца" компилятор выдаёт вполне внятные сообщения.


    http://coliru.stacked-crooked.com/a/1f3723d422ef05ee


    Код
    namespace detail {
        template <class ...> struct match;
    
        template <class Head, class ... Tail>
        struct match<Head, Tail...> : match<Tail...>, Head {
            template <class Head2, class ... Tail2>
            match(Head2&& head, Tail2&& ... tail) : match<Tail...>(std::forward<Tail2>(tail)...), Head(std::forward<Head2>(head)) {}
            using Head::operator();
            using match<Tail...>::operator();
        };
    
        template <class T>
        struct match<T> : T {
            template <class R>
            match(R&& r) : T(std::forward<R>(r)) {}
            using T::operator();
        };
    }
    
    template <class ... Cases>
    auto match(Cases&& ... cases) {
        return detail::match<typename std::decay<Cases>::type...>{std::forward<Cases>(cases)...};
    }
    
    int main() {
        int io = 100;
        int i = 1000;
        match(
            [](int i1 , auto i2) { cout << "int" << i1 << " " << i2; }
            ,[](short, char)     { cout << "short"; }
            ,[&](auto...)        { cout << "auto " << io; }
        )(1,  i);
        return 0;
    }

    P.S. Сколько я не бился, не смог синтаксис привести к виду match(1,2) ( cases...) так чтобы move конструктор не вызывался http://coliru.stacked-crooked.com/a/70d1aec24c26642a

    Поделиться публикацией
    AdBlock похитил этот баннер, но баннеры не зубы — отрастут

    Подробнее
    Реклама

    Комментарии 48

      0
      Выглядит круто. А как по скорости по сравнению с работой через if'ы? Или оно compile-time?
        0
        Это compile-time. Тут плюсы скорее даже не в скорости, а в том что if'ми это сделать невозможно. Попробуйте boost::variant if'ми разобрать.
          0
          Я не самый специалист в этом деле, но компилятор действительно в данном случае может оптимизацией выкинуть объект лямбды и заинлайнить код в ней? Для производительности это критическая штука. Если у кого-то есть возможность, пожалуйста, можете проверить или подсказать?

          А идея крутая и лежит на поверхности. И как я сам не додумался…
            0
            Да, конечно компилятор такие вещи выкидывает. На этом Boost::Hana построена. Собственно описанный тут велосипед — это как раз её кусочек, только чуть менее удобный в использовании.

            Можете почитать — выглядит почти так, как тут.
              0
              А чем менее удобная? Визуально в Hana писанины больше. + Я не пробовал, но почти уверен что если начать тянуть эту часть из Boost'a пара мегабайт (как минимум) кода обеспечена.
                0
                Тем, что вы должны прямо «здесь и сейчас» обработать тип. Передать его дальше для обработки нельзя, обработать список объектов разной природы — тоже. Такой себе маленький кусочек большой системы.

                Вот как, например, у вас обработка списка элементов будет выглядеть? Банальный for_each?

                А что касается «пары мегабайт» — за что конкретно мы боремся? Время компиляции по сравнению со многими другими библиотеками у Boost:Hana уменьшено, там на сайте графики есть — хотя, понятно, тут всегда важен баланс между скоростью и возможностями…
                  0
                  Тем, что вы должны прямо «здесь и сейчас» обработать тип. Передать его дальше для обработки нельзя...

                  Вы имеете ввиду что теряется информация о типе? Если да, то я не понимаю как.


                  Банальный for_each?

                  Извините, но я считаю что это разные вещи. Здесь нужен отдельный алгоритм прохода по кортежу, и он у меня есть. Так же как и Hana'вский он принимает на вход кортеж, и лямбду. В лямбде можно уже использовать pattern matching.
                  Более того — текущий pattern matching можно использовать в Hana::for_each как есть:


                      hana::for_each(hana::make_tuple(0, '1', "234", 5.5), [&](auto x) {
                           match(x
                            ,[](std::string value)    { cout << "This is string";  }
                            ,[](int i)                 { cout << "This is int";    }
                            ,[](auto a)                  { cout << "This is default"; }
                          );
                      });

                  Hana — это библиотека. И мне она не нравится. Прежде всего по тому что там свои кортежи.
                  Здесь же описана конкретная конструкция. Мне кажется это как сравнивать STL и конкретно взятый алгоритм.

                    +2
                    Здесь же описана конкретная конструкция. Мне кажется это как сравнивать STL и конкретно взятый алгоритм.
                    Если под «конкретно взятым алгоритмом» вы понимаете «что-то аналогичное алгоритму из STL'евского <algorithm>а», то да, конечно. Алгоритмы из STL'я удобны не потому, что они реализуют какую-то супермудрость, а потому, что они являются частью большой библиотеки, которые согласованы между собой.

                    То же самое и здесь: да, вы можете использовать ваш матчер с hana::make_tuple, но… зачем?

                    Насчёт что лучше — отдельные «алгоритмы» или целые библиотеки можно спорить, но хочу заметить, что даже ваш матчер не существует в вакууме, а тянет за собой FunctionArgs :-)

                    Практика показывает, что «отдельные маленькие хорошенькие штучки» хороши в теории, но на практике библиотеки — удобнее. До определённого предела, конечно (вряд ли кто захочет использовать библиотеку на терабайт, даже если она будет уметь очень-очень много всего-всего-всего), но в большинстве случаев — это так.
                0

                Hana не об этом. Hana позволяет заменить вырвиглазные и тормозные шаблоны Boost Fusion и MPL на читаемые и относительно быстрые constexpr вычисления. Такой минихаскель построенный на C++ constexpr, где вычисления идут в compile-time над типами и константами C++.


                Заинлайниться же в C++ может почти все что угодно (кроме не tail рекурсии), даже при раздельной компиляции с LTO.


                Паттерн матчинг бывает 2х типов: comile time и run time. Первый — это пример автора и hana (которая позволила бы написать еще короче и понятнее), а так же известный variant. Если же нужен полноценный run time pattern matching почти как в хаскеле (ака dynamic_cast на стероидах, да еще и быстрее), то Mach7 как раз об этом (но десять раз подумайте — может вам просто нужен хаскель?).


                P.S. Я экспериментировал с Boost Hana — и она замечательна, планирую написать статьи о ней.

                0
                Элементарный пример — std::for_each. Переданное лямбда-выражение инлайнится.
                Косвенная проверка:
                https://godbolt.org/g/pNIa8n
                С -O2 или -O3 вообще результат вычисляется в compile-time.
            +12

            Пожалуйста, укажите лицензию на ваш код. Формально, использовать код без указанной лицензии нельзя, ибо по умолчанию лицензия на код проприетарная, т. е. использовать код можете только вы, где бы вы его при этом не публиковали.


            Не обязательно копипастить весь текст лицензии, укажите хотя бы её название и ваш копирайт. Например:


            /* The MIT License (MIT)
             * Copyright (c) 2016 tower120
             */

            Также было бы очень здорово, если бы вы опубликовали код не только в статье на Хабре, но и, скажем, в виде GitHub Gist. Так вашему коду можно поставить звезду и потом не потерять его. А можно форкнуть и дополнить. И все форки будут в одном месте и тоже не потеряются.

              0
              Всегда было интересно, а как можно обнаружить кусок чьего-то кода в большом проекте, если ни авторства, ни лицензии не указано? И кто этим занимается — есть какие-то автоматизированные сервисы, или специально обученные люди? И чем может быть чревато использование такого кода? А если проект с закрытым исходным кодом?
                0
                1. Никому не интересно обнаруживать абстрактный «кусок чьего-то кода». Компаниям интересно обнаружить случайно залитый код с github'а без лецензий — для чего есть тулы типа той же FOSSology, а для владельцев авторских прав интересно отловить свой код — и уж они-то знают обычно, как это сделать.
                2. Есть и специальные сервисы и люди — но обычно это делается тогда, когда с пользователя кода можно денег содрать. Поймать «дядушку Ляо» на использовании чужого кода можно, конечно — но дальше что? Даже затраты на адвокатов не окупите.
                3. А чем чревата продажа пиратских фильмов или аудизаписей? Принцип тот же: до $100'000 за копию в теории, но на практике вряд ли больше нескольких центов. Гораздо более чувствительным может быть требование прекратить новые продажи до того момента пока чужой код не будет изъят — но, опять-таки, «дядушку Ляо» так не остановить.
                4. Что значит «а если проект с закрытым исходным кодом»? А какая вообще разница? Суд не интересует какие там у вас в фирме политики. Незаконное копирование == штраф.
                  0
                  1,2,3. Ну в общих чертах я все это как-то так себе и представлял. Просто подумал, может есть есть какая-то еще специфика, о которой я не знаю, а все знают.
                  4. Это значит, что некая условная корпорация берет из интернета кусок кода, распространяемый, например, под GPL, или вообще без указания лицензии (а значит, по умолчанию она проприетарная), и засовывает его в свой проприетарный же продукт с закрытым кодом. А распространяет она бинарники. Кто и как узнает, что в скомпилированных бинарниках есть кусок чужого кода, вставленный туда без разрешения автора? И какими могут быть реальные последствия этого для корпорации? И как это вообще можно доказать?
                    0
                    Я однажды в книжке серии Библиотечки Квант про двойные прочитал шикарную фразу (цитирую по памяти): «Если вы звёзды имели спектр идеально чёрного тела, то их движение друг относительно друг друга было бы невозможно заметить. К счастью мир не столь совершенен, а потому познаваем.»

                    И вот этот вот «мир не столь совершенен, а потому познаваем» — очень часто играет в подобного рода вещах.

                    Кто и как узнает, что в скомпилированных бинарниках есть кусок чужого кода, вставленный туда без разрешения автора?
                    Можно отловить характерные участки кода, строки и т.п. Обычно автору эо сделать несложно: берётся место, которое «давно стоило бы переписать, да руки не доходят» и проверяется его наличие. Так как это место сделано «шероховато», то очень маловероятно что кто-то сделает его так же криво очень мала (все счастливые семьи счастливы одинаково, каждая несчастливая семья несчастлива по-своему).

                    И как это вообще можно доказать?
                    А как доказывают что Петя убил Васю ледорубом? Следы ищут, «отпечатки пальцев», экспертов привлекают и т.д. и т.п. Потом суд решает — достаточно ли улик. Достаточно должно быть только для того, чтобы заставить код показать экспертам (противной стороне, понятно, его показывать нельзя — секреты фирмы и прочее, но если вы отказываетесь его показать независимым экспертам, ссылаясь на «потерянные флоппи», то вам нужно будет после этого очень сильно постараться, чтобы судья поверил в вашу невиновность).

                    И какими могут быть реальные последствия этого для корпорации?
                    До сих пор самое страшное что случалось — запрещали продажу конкретных устройств. Что само по себе чревато. До «термоядерной опции» (указать что нарушение, скажем, GPL, лишает вас права на использование соответствуещего кода вообще, навсегда) никто пока не добирался.

                    Но это все про крупные проекты. Мелкие куски кода (типа 50 строк приведённых в статье) обычно проще выкинуть и переписать заново, чем разбираться с лицензиями. Когда SCO пыталась всех пользователей Linux засудить спорный кусок кода в Linux'е обнаружили, к примеру. На всякий случай его переписали — просто «на всякий случай»…
              +2
              Можно покороче:
              namespace detail {
              
              template <class ...> struct match;
              
              template <class Head, class ... Tail>
              struct match<Head, Tail...> : match<Tail...>, Head {
                  template <class Head2, class ... Tail2>
                  match(Head2&& head, Tail2&& ... tail) : match<Tail...>(std::forward<Tail2>(tail)...), Head(std::forward<Head2>(head)) {}
                  using Head::operator();
              };
              
              template <> struct match<> {};
              
              }
              
              
              template <class T, class ... Cases>
              decltype(auto) match(T&& value, Cases&& ... cases) {
              	return detail::match<typename std::decay<Cases>::type...>{std::forward<Cases>(cases)...}(std::forward<T>(value));
              }
              
                +2
                Небольшая поправочка:
                namespace detail {
                
                template <class ...> struct match;
                
                template <class Head, class ... Tail>
                struct match<Head, Tail...> : match<Tail...>, Head {
                    template <class Head2, class ... Tail2>
                    match(Head2&& head, Tail2&& ... tail) : match<Tail...>(std::forward<Tail2>(tail)...), Head(std::forward<Head2>(head)) {}
                    using Head::operator();
                    using match<Tail...>::operator();
                };
                
                template <class T>
                struct match<T>: T {
                    template <class R>
                    match(R&& r) : T(std::forward<R>(r)) {}
                    using T::operator();
                };
                
                }
                
                template <class T, class ... Cases>
                decltype(auto) match(T&& value, Cases&& ... cases) {
                    return detail::match<typename std::decay<Cases>::type...>{std::forward<Cases>(cases)...}(std::forward<T>(value));
                }
                
                
                  +1

                  К сожалению, теперь я не могу понять что тут вообще происходит...

                    +2
                    Из всех всех лямбд собирается одна «суперлямбда» в которой живут они все — вместе со всеми своими operator'ами. Дальше вызывается её operator() — и если нам повезло, то он, собственно, и срабатывает.

                    Если не повезло — не срабатывает.

                    Это не совсем эквивалент, так как перебора нет и нельзя передать много «уточняющих» лямб: если будет десколько лямбд, которые, теоретически, могут принять аргумент, то они все будут пытаться примениться и получится ошибка компиляции.
                      0

                      Вангую очень веселое сообщение об ошибке, если что-то не получилось.

                        0
                        overloaded_function.cpp
                        Вы говорите про нечто подобное?
                        А умение читать сообщения об ошибках от компилятора C++ приходит вместе с опытом :-)
                  +2
                  Не понял пример использования. Зачем оно надо?
                    0
                    В основном для всяких JSON'ов и RPC. Когда у вас могут приходить всякие boost:any, а вам это как-то нужно в конкретные типы привератить. Ну или в обратном направлении.
                      –3
                      Вы все еще парсите сетевые данные руками? Тогда мы не идем к вам… работать :)
                      +1
                      Чтобы было удобно пользоваться алгебраическими типами данных.
                      Например, нужно получить из функции структуру, в которой нас интересует только одно поле. Пишем:

                      let MyStruct{field, ..} = my_function();
                      Или вместо

                      std::size_t found = str.find(str2);
                      if (found!=std::string::npos)
                      std::cout
                      +1
                      А зачем такая штука может использоваться? Можно пример прикладного кода с использованием такой конструкции?
                        +3
                        А зачем вообще нужно метапрограммирование — вы понимаете?

                        Это не издевательство, я реально не понимаю как можно практически использовать метапрограммирование и не понимать когда и как вам может пригодиться pattern matching. Я могу у нас в проекте показать сразу пяток мест, где бы это можно было с пользой применить если бы C++14 был разрешён. А так — приходится по старинке, с шаблонами с частичной специализацией…

                        Посмотрите на ваш любимый пример, использующий метапрограммирование с разными типами, и посмотрите сколько там ненужного boilerplate…
                          +1
                          А так — приходится по старинке, с шаблонами с частичной специализацией


                          Так а чем это плохо?

                          Посмотрите на ваш любимый пример, использующий метапрограммирование с разными типами, и посмотрите сколько там ненужного boilerplate…


                          Что вы имеете в виду?
                            +1
                            Так а чем это плохо?
                            Тем что на написание и чтение всего это кода уходит время, очевидно. Ваш К.О.

                            Так-то вообще всё, что можно сделать на C, C++, Haskell'е или там Java можно сделать прямо в машинных кодах… в конце-то-концов ничего больше CPU исполнять не умеет… вопрос только в том, сколько у вас на это времени уйдёт.

                            Что вы имеете в виду?
                            Возьмите любой пример и посмотрите — сколько вам придётся завести лишних trait'ов, шаблонов и прочего, чтобы сделать хоть что-нибудь.

                            Возьмите хотя бы те 8 строк с которых началась статья и превратите их в шаблоны метапрограммирования в стиле C++98 — а дальше подумайте — легко ли там будет допустить ошибку и сколько времени вы будете её искать, если ошибётесь.
                        +7

                        Вот самый очевидный пример который я придумал. В С++17 введена конструкция constexpr if. Она позволяет выполнять ветвления на этапе компиляции. Например:


                        template<class T>
                        auto call_java(T element){
                             cout << "Start Java Call";
                             constexpr if (is_same<T, int>){
                                 return jni->CallIntMethod(....);
                             } else constexpr if (is_same<T, float>) {
                                 return jni->CallFloatMethod(....);
                             } else {
                                 return jni->CallVoidMethod(....);    
                             }
                        }

                        Без constexpr if вам бы пришлось в данном случае три дополнительные функции:


                        int call_java_helper(int element){
                           return  jni->CallIntMethod(....);
                        }
                        
                        float call_java_helper(float element){
                           return  jni->CallFloatMethod(....);
                        }
                        
                        void call_java_helper(nullptr_t){
                            jni->CallVoidMethod(....);
                        }
                        
                        template<class T>
                        auto call_java(T element){
                             cout << "Start Java Call";
                             return call_java_helper(element);
                        }

                        C pattern matching (как реализовано в статье):


                        template<class T>
                        auto call_java(T element){
                             cout << "Start Java Call";
                             return match(elment, 
                                 ,[](int element)  { return jni->CallIntMethod(element); }
                                 ,[](float element){ return jni->CallFloatMethod(element); }
                                 ,[](auto)         { jni->CallVoidMethod(); }
                             );
                        }

                        С увеличением сложности разница ещё более увеличивается. Основной плюс как по мне что код получается не размазанным по всему файлу.

                          +2
                          Вот. Другое дело. Теперь видно, что вещь нужная. Спасибо за конструктивный ответ!
                            +1
                            Кстати, на мой взгляд, в статье стоило именно этот пример привести. Он менее абстрактный и даёт чётко понять красоту придуманного вами механизма на прикладной задаче.
                              0
                              Ещё бы иметь возможность сделать как-нибудь в духе

                              ...
                              [](Vec<float, n> element) { return jni->CallFloatVector(element, n); }
                              ...
                              


                              Но частичная специализация вроде до сих пор только для структур/классов возможна.
                                0
                                Но частичная специализация вроде до сих пор только для структур/классов возможна.
                                Для обычных функций ещё возможна. Для функций членов и лямбд — невозможна. Не знаю — в чём там засада.
                                  0
                                  Не нашёл, как возможна для обычных функций? Везде пишут, что нельзя, можно только полностью специализовать.
                                    0
                                    Сходил почитал доки. Вы правы, конечно. То, что можно делать (и что мы у себя в проекте, в частности) — называется function template overloading — это более общая вещь, в общем-то: вы можете указывать не только «уточнения», как с классами, но и гораздо более общие вещи… и становится немного яснее почему для членов класса она не очень хороша — хотя полного понимания таки нет: почему бы не разрешить это делать хотя бы с описанием в самом классе всех вариантов?
                            +2

                            Всё-таки без полноценных типов-сумм сопоставлению с образцом очень не хватает юзабельности. То есть в таком виде это скорее static visitor от одного параметра.

                              0

                              Возможно можно как-то переделать на матчинг по нескольким параметрам (вас наверное деструктуризация интересует). Но! Рекомендую к ознакомлению http://cppnow2016.sched.org/event/6Sfb (когда появится конечно).

                                0

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

                                  0

                                  Мда действительно, просто то таки посмотрел на эту перегрузку другими глазами.

                              0
                              Я года 2 назад решал схожую задачу. Решил сделать статический маппинг функций на типы. Плюсом решения было свободный вызов любых Callable объектов, даже с одинаковой сигнатурой. Ну и редактор кода по выбранному ключу уже подсказывал типы и количество параметров. Выглядело примерно так:
                              //какие-то функции
                              int test1(float a, double b)
                              {
                              	std::cout << "int test1(float a, double b)\n";
                              	return 1;
                              }
                              
                              void test2(std::string a, int b, const char* c)
                              {
                              	std::cout << "void test2(std::string a, int b, const char* c)\n";
                              }
                              ...
                              //создаем "статическую мапу функций"
                              tagged_functor<
                              		int, decltype(test1),
                              		float, decltype(test2)> 
                              		functor(test1, test2);
                              ....
                              //используем
                              functor.call<int>()(0.0f, 1.0);
                              
                                0

                                To DISaccount:
                                А как вы решали дело с классами? Через указатель на член класса &ClassName::test1?

                                  0
                                  1) Простой bind.
                                  2) Передача указателя на класс в вызове, как дополнительный параметр.
                                0
                                Практически тоже самое описано в комментариях тут http://stackoverflow.com/questions/18432260/lambda-functions-as-base-classes.
                                0

                              Только полноправные пользователи могут оставлять комментарии. Войдите, пожалуйста.

                              Самое читаемое