Проблема экосистемы C++

Зачем мне это делать?

Упрятать unsafe под капот, раз уж вы так unsafe боитесь.

а чем же tagged union лучше variant-а с полноценным визитом?

Это называется бутстраппинг, осталось в истории коммитов найти того прораба, который ещё не зависел бы от прораба.

Менять 5-10 строк за коммит - это грамотный подход к декомпозиции, автору зачет, сетующим на 500 (или сколько их там, 800?) коммитов - терпения.

Оставшиеся 3 страницы не читал, но могу сказать точно, что основная проблема экосистемы С++ - это тыеё отсутствие - тут речь идет об инструменте а-ля asdf[-install] или cabal[-install], чтобы она была одна единственная и все пользовались только ею. Остальные проблемы - со сборкой, велосипедизмом, етц - во многом вытекают из этого.

Всем.

Значит ничем, чтд. Не, ну правда, что, вообще ничем? Я не знаю просто, что там в расте с ними сделали, но основываясь на хаскельном опыте сам для себя явных плюсов пока выделить не могу.

бутстраппинг

Make можно собрать скриптами. CMake можно собрать Make'ом.

https://bitbashing.io/std-visit.html

Т.е. с хаскелем разница конечно же есть (даже если отбросить аспекты ленивости), но чтобы был прям явный разрыв, хз.

Я-то думал, там будет какое-нибудь Откровение, а там чувак просто сетует на то, что «не как в моём растике!!1»

match (theSetting) {
    Setting::Str(s) =>
        println!("A string: {}", s),
    Setting::Int(n) =>
        println!("An integer: {}", n),
    Setting::Bool(b) =>
        println!("A boolean: {}", b),
};

К слову вот такая фигня при наличии index_of<T>() делается через банальный свич.

gcc можно собрать as-ом?

а чем же tagged union лучше variant-а с полноценным визитом?

Полноценный - это какой, из C++66? Пример можно?

Можно попробовать собрать clang'ом.

Просто автор топика переживает, что нет в жизни совершенства и винит в этом плюсы :)

Есть люди, у которых всегда кто-то виноват :)

Если для xml делать лесопед слегка извращение, имхо. То уже для json можно и запилить.

Парсер json пишется достаточно просто и быстро, но уже есть готовый - jsoncpp ;)

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

Похоже ТС считает, что должен быть один универсальный способ логирования.

Скорее всего, ТС просто обиделся на разработчика сабжевой библиотеки за то, что не смог ее собрать. Но все равно для меня загадка, при чем тут C++?

Оно использует cairo

Это плохо?

и тонну своих велосипедов.

Не вижу там тонны велосипедов.

Да взять хотя бы вот этот: http://en.cppreference.com/w/cpp/utility/variant/visit

Даже множественная диспетчеризация заявлена, о как!

За гранью моего понимания остаётся только это:

Return value

The value returned by the selected invocation of the visitor.

Хо-хо-хо!

Хотя, если все перегрузки Callable должны иметь один и тот же тип возвращаемого значения, тоже ничего сложного.

Спасибо за ответ, но вопрос снимается. Если кому-то годится index_of, ему безнадежно объяснять про pattern matching.

Я давно привык к твоим постам(тупняку и провокации в них), но настолько очевидного не ожидал.

То что ты нашёл откровенно плохой код не значит, что всё плохо вообще везде. С таким же успехом можно сказать про любой язык — достаточно найти кучку говнокода.

В том же tinyxml2 есть ifdef для андроида, что как бы намекает.

И если зрение позволяет, то можно увидеть ifdef, используемый исключительно для ассерта - __android_log_assert.

Если кому-то годится index_of, ему безнадежно объяснять про pattern matching.

Громкое заявление, но всё же, если бы была огромная разница, на неё бы уже указали, правда?

Конечно, вместо этого лучше сохранять Ореол Тайны, загадочно перемигиваясь с собратьями по сектеразуму, и хранить Тайну Божественного Профита Паттерн Матчинга в строжайшем секрете. Только вот пока получается, что тезис «вариант говно потому что не паттерн матчинг» подкреплен только вкусовыми предпочтениями.

Ладно, попытаюсь сам найти ответ. Берем уже засвеченный тут пример, реализуем как умеем:

data Setting = SStr String
             | SInt Integer
             | SBool Bool
             deriving (Eq, Show)

godlikePrint :: Setting -> IO ()
godlikePrint (SStr s)  = putStrLn $ "String " ++ s
godlikePrint (SInt i)  = putStrLn $ "Integer " ++ show i
godlikePrint (SBool b) = putStrLn $ "Boolean " ++ show b

Ну да, получили сразу доступ к потрошкам данных, можно щупать поля. В плюсах пришлось бы под case: написать std::get<T> - это и есть тот сверхпрофит?

Ладно, можно матчить не только по самой структуре, но и по значениям полей:

data Setting = SStr String
             | SInt Integer
             | SBool Bool
             deriving (Eq, Show)

godlikePrint :: Setting -> IO ()
godlikePrint (SStr "Vasya")  = putStrLn $ "Vasia is krasavtchik"
godlikePrint (SStr "Kolya")  = putStrLn $ "Kolian tozhe norm patcan"
godlikePrint (SStr s)        = putStrLn $ "String " ++ s
godlikePrint (SInt 42)       = putStrLn $ "Don't panik!"
godlikePrint (SInt i)        = putStrLn $ "Integer " ++ show i
godlikePrint (SBool b)       = putStrLn $ "Boolean " ++ show b

имеем

*Main> mapM_ godlikePrint [SStr "Foo", SStr "Vasya", SBool False, SInt 42]
String Foo
Vasia is krasavtchik
Boolean False
Don't panik!

Может в этом сверхпрофит? Но он напрямую к вопросу variant/tagged union уже не относится, да и выигрывают от него обычно хелловорлды и прочие примеры.

Так в чем же сверхпрофит? Может в том, что при отсутствии нужного паттерна компилятор может выдать ворнинг? Может в том, что при добавлении нового поля в SStr надо будет переписать все матчи/кейсы в коде?

всё же, если бы была огромная разница, на неё бы уже указали, правда?

Нет. «Огромность» разницы зависит от меры, с которой ты подходишь. Свою меру ты показал фразой про index_of.

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

...но гораздо лучше разоблачать и срывать покровы.

Может в этом сверхпрофит?

В том, что программист на Си++ сможет написать программу на Си++ даже на Хаскеле?

Так в чем же сверхпрофит? Может в том, что при отсутствии нужного паттерна компилятор может выдать ворнинг? Может в том, что при добавлении нового поля в SStr надо будет переписать все матчи/кейсы в коде?

Что заставило тебя подозревать в этом профит или даже сверхпрофит? Разве это лучше if по типам, как в «полноценном визите»?

Разве это лучше if по типам, как в «полноценном визите»?

Иф по типам там только один из вариантов использования (в том случае, когда сам визитор шаблонный). По приведенной ссылке были и другие примеры, последний (с overloaded) например

всё же, если бы была огромная разница, на неё бы уже указали, правда?

Нет. «Огромность» разницы зависит от меры, с которой ты подходишь. Свою меру ты показал фразой про index_of.

О, классика.

Нужно решить задачу - взять sum type и в завсимости от его тега обработать его тем или иным образом. Даже в текущих реалиях задача вполне себе решается не самыми уродливыми средствами. Но нет, сектантам не нужно решать задачи, сектантам нужно, чтоб pattern matching.

Иф по типам там только один из вариантов использования

И... что? Ты дал ссылку на это как на «полноценный визит». Он полноценный или нет?

«Огромность» разницы зависит от меры, с которой ты подходишь. Свою меру ты показал фразой про index_of.

О, классика.

Как что-то плохое.

Нужно решить задачу - взять sum type и в завсимости от его тега обработать его тем или иным образом

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

в текущих реалиях задача

Не ты один живешь в реалиях. Но в данном случае речь не о них.

Впрочем да, последний абзац и есть моя мера как прагматика. Собственно, всё, что я тут и хочу - узнать, какие есть ещё «меры».

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

Пахнет расширением (если не сменой) скоупа, так что давай конкретизируем. Разговор изначально пошёл из сравнения вариантов против нативных sum types.

В каком разрезе мы на это смотрим?

- variant<Ts...> как альтернатива ADT в языке, где оба варианта возможны - естественно вариант хуже.

- variant<Ts...> как реализация ADT для бедных там, где нет нативных ADT - ну, в С++ в этом плане лучше варианта ничего вроде не придумали.

Либа - просто яркий пример.

Смотрите сообщение на котрое я отвечал.

Смотрите сорцы, там половина зависимостей от самого автора.

Плохой?! На фоне того, что я обычно нахожу это очень даже ничего.

В каком разрезе мы на это смотрим?

Вот в этом:

yoghurt> чем же tagged union лучше variant-а с полноценным визитом?

Т.е. не ограничиваемся рамками одного языка.

variant<Ts...> как реализация ADT для бедных там, где нет нативных ADT - ну, в С++ в этом плане лучше варианта ничего вроде не придумали.

Я думаю, что даже в Си++ можно было сделать лучше - хотя бы с предупреждением на неиспользуемый кейс. Впрочем, вопрос «а почему не придумали ничего лучше» - тоже хороший вопрос.

Есть одна копипаста, в которой её главный герой каждый день выходит на улицу и собирает дерьмо в пакет. Потом приходит домой, обмазывается и онанирует.

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

В каком разрезе мы на это смотрим?=

Вот в этом:
yoghurt> чем же tagged union лучше variant-а с полноценным визитом?

Таки анроллить надо до конца

Да и вообще все фичи раста можно сделать в C++, ведь std::variant ничем не хуже tagged union с паттерн матчингом.

И вот в этом контексте вариант в плюсах вполне себе замена матчингу в умеющих в него языках, каких-то сверхспособностей второго так и не обнаружено.

А визитор кстати вполне полноценный, я даже приятно удивлен тем, что там не обязательно выписывать руками все теги, а можно делать заглушки по типу _ / otherwise - поигрался

#include <variant>
#include <iostream>
#include <string>

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

int main() {
    using V = std::variant<int, double, std::string>;
    V v1{"hello"}, v2{42}, v3{3.14}; 
    
    auto visitor1 = overloaded {
        [](const std::string& arg) { std::cout << arg << std::endl; },
        [](auto)                   { std::cout << "<something else>" << std::endl; },
    };
    
    std::visit(visitor1, v1);
    std::visit(visitor1, v2);
    std::visit(visitor1, v3);
}

hello
<something else>
<something else>

https://wandbox.org/permlink/1ubzWL7CZuGjF6Cf

не понял отчего ТС так завёлся, что даже насрал в issue чужого проекта, где автор был вынужден довольно корректно отвечать..

не нравится чужой проект, так не бери его..или улучши если умеешь

Да и вообще все фичи раста можно сделать в C++

Вообще все? Сделай мне лайфтаймы или модули. Все, относящиеся к паттерн матчингу? Сделай мне предупреждения компилятора о non-exhaustiveness или destructuring (только нормально, а не как в Mach7).

Из Си++ можно сделать эрзац-Rust. Но это будет именно эрзац.

https://cs8.pikabu.ru/images/previews_comm/2018-01_6/151699969113842462.jpg

Проблема экосистемы C++ (комментарий)

ЯННП.

Я к тому, что исходная фраза про «все фичи раста» не является моей, а касательно её части о С++ variant vs ADT (и только её!) помимо мною же упомянутых

предупреждения компилятора о non-exhaustiveness или destructuring

Какой-то дополнительной супер-магии в данном вопросе паттерн матчинг не привносит, так что да, С++ variant в плюсах действительно не хуже ADT в $your_favorite_language, чтд.

За сим точки над и предлагаю считать расставленными, пойду в честь этого накачу винчика и заем блинчиком.

накачу винчика

Похоже, ты накатил еще до прихода сюда.

Вы сорцы stl видели?

Единственная проблема в сорцах STL — это stateless memory allocator в виде шаблонах.

vs

#[derive(Debug)]
enum V {
    Int(i32),
    Double(f64),
    String(String),
}

fn main() {
    let v1 = V::Int(1);
    let v2 = V::Double(1.0);
    let v3 = V::String("text".to_owned());
    
    println!("{:?}", v1);
    println!("{:?}", v2);
    println!("{:?}", v3);
}

Если вы не видите проблемы - это не значит что её нет.

Проспитесь и прочтите внимательно весь пост.

А где тут визитор?

В том-то и дело, что он не нужен.

Слишком толсто, чтобы быть правдой. А без derive Debug?

Трей дописать и всё.

Проблема в том, что в повседневных задачах нужно что-то типа:

#[derive(Debug)]
enum V {
    Int(i32),
    Double(f64),
    String(String),
}

fn main() {
    let v1 = V::Int(1);
    
    if let V::Int(v) = v1 {
        println!("{:?}", v);
    }
}

А изобразить такое на плюсах - боль.

Делаю карманной compile-time рефлексией, никакой боли нет, кроме как написать карманную ct рефлексию.

Мне проще взять готовый язык, чем изобретать костыли на каждый чих.

А я вот наоборот плюсы выбрал как язык, который позволяет выбрать нужный уровень абсоакции(то есть можно подключить gc, функциональщину, safe(gsl) и.т.д.) чем брать готовое и уже вручную вырубать вещи которые не нужны(unsafe, raw pointers в шарпах и.т.д.). Я эти кресты тоже не люблю, но это лучшее из худших. Опять же имхо, субъективщина и.т.д.