Rust 1.49

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

Уже это показывает степень глубины твоих познаний.

Ты ещё расскажи что плюсовые темплейты это отдельный язык.

Впрочем чего я жду от хейтеров Rust. Проще от полена внятной аргументации дожатсья.

Разница большая.

int x; // 1
cin >> x;

json j2 = {
  {"pi", x}, // 2
  {"happy", true},
  {"name", "Niels"},
  {"nothing", nullptr},
  {"answer", {
    {"everything", 42}
  }},
  {"list", {1, 0, 2}},
  {"object", {
    {"currency", "USD"},
    {"value", 42.99}
  }}
};

Нельзя.

Сочувствую. Мне казалось что одной извилины достаточно для удаления всех переносов строки.

Построено на стороннем язычке ака препроцессоре, мы о синтаксисе раста говорим.

Во первых он не сторонний. Во вторых нет, не построено. Скролль до «Untyped example» или открой доку как сделать Serialize/Deserialize без #[derive(...)]. Другое дело, что нет никакого смысла каждый раз писать одно и то же руками.

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

Между макросами раста и темплейтами большая разница, если просто прочесть что тут написано - https://doc.rust-lang.org/book/ch19-06-macros.html

То станет ясно что макросы раста это прокаченный препроцессор который работает не с кодом а текстом.

Не имею представления, если честно ¯_(ツ)_/¯ На самом деле этому было обоснование, но там целая телега.

#include <cassert>

void foo() {}

int main() {
    assert(foo == &foo);
}

Сочувствую. Мне казалось что одной извилины достаточно для удаления всех переносов строки.

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

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

Во первых он не сторонний.

Отдельную утилиту вызывать не надо, но это лишь препроцессор который с основным языком не связан, можно взять python-clang и написать все тоже самое для С++, и пишут, примеры наверное сам видел.

Так и в С++ можно, а вот как я выше показал в расте уже нельзя.

https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/macro_scope.hpp

Ой, тоже куча макросов, что теперь петь будешь ?

Ты хреново читал. От слова совсем.

«Смотрю в книгу, вижу фигу» это как раз про тебя.

Там дефайны для разных стандартов и разных компиляторов. Не вижу в растовой либе дефайнов для поддержки разных компиляторов и разных стандартов, наверное потому что их нет, а если бы были - были бы и подобные макросы.

Получается и тут у С++ преимущество.

Там дефайны для разных стандартов и разных компиляторов.

https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/macro_scope.hpp#L143

В глазки долбишся ?

Не совсем. Но что в этом плохого? Вместо того что бы на каждый случай городить какой-то особый синтаксис вроде initializer lists, в Rust просто сделали нормальный препроцессор.

json! это макрос.

Я и не говорил что у раста плохой препроцессор.

Код который я выше показал задействует макросы? - Нет.

Ну вот и все.

Или может ты хотел продемонстрировать как макросы по твоей ссылке заменяются чистым кодом раста? Ну так покажи.

Да. Но ты говоришь, почти буквально, «В C++ впаяны initializer lists и это хорошо, а в Rust такого нет - и это плохо». Я тебя и спрашиваю - почему? Визуально выглядит лучше, ИМХО, так в чём проблема?

Ты пишешь для iOS? Если да, то там реально Objective-C стал полным легаси?

Пописываю на Qt и местами страдаю от того, что нужно писать прослойки на Objective-C, а нагуглить инфу по этому становится сильно сложнее - все свежее в инете на свифте, включая stack overflow.

json! это макрос

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

Уже нет. Они слились.

Я как раз и говорил, что это не убийца С.

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

Как положить макрос в неймспейс?

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

Код который я выше показал задействует макросы? - Нет.

Ты совсем дурочка чтоли ? Если макросы -это половина кода json.hpp, то твой код однозначно их задейтвует.

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

Ну вот и все.

Предлагаю тебе нарисовать либу для Json на С++ без макросов. потом что-то там предлагай другим.

Да-да, в Rust нет никаких коллизий. Можно хоть сотню макросов с одинаковым именем иметь и все их одновременно использовать в коде, просто импортировав под другим именем.

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

И вот именно что в rust макросы - это часть языка, а не препроцессор.

И да, царь - унылый говноед и балабол.

сказав, что там только макросы для компиляторозависимых фичь

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

Предлагаю тебе нарисовать либу для Json на С++ без макросов.

Ты сам с собой споришь? Я сказал что json! это макрос а не встроенная возможность в язык, у С++ инитиализер листс встроен. Доходит?

Смотри, в С++ есть class, virtual, abstract, а еще есть if и for, прямо как в С. И кто-то может сказать что вот эти вот if и for – сторонний язычок. То есть, в С++ даже банальный цикл нельзя написать без стороннего язычка. Или можно, но тогда выходит, что С++овцы – воры, украли конструкции из С и выдают за свои.

И вот именно что в rust макросы - это часть языка, а не препроцессор.

Темплейты работают с языком, макросы с текстом, токенами итд.

Разницу между токенами и языком в студию!

Вернее даже не токенами и языком, а группами токенов и языком. template в C++ - это частный случай macro_rules!, где допустимые типы - только expr и ty.

Коммент vlad9486 хорошо демонстрирует ваше непонимание. for он знает про переменные, неймспейсы, итд. А макросы знают лишь буквы, не могут обратиться внутрь. Они могут только генерировать текст, и получать текст.

Только макросы с for совсем странно сравнивать, тут полностью не раскрывается суть.

Как в json переводить будешь?

сказав, что там только макросы для компиляторозависимых фичь

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

Окей, прям такого что слово в слово ты не говорила. Но тогда изьясняйся яснее.

И вот в этом ключе, хотелось бы от тебя таки внятного коментария почему макросы в json.hpp - это Ок, а макросы в serde_json - не Ок ?

Ты просто придумал свою суть™ и, конечно же, она не раскрывается. Попробуй связаться с реальностью и как-то обосновать чем твоя суть более суть, чем моя.

а макросы в serde_json - не Ок ?

И такого я не говорил. Я хочу код как я дал выше без использования макросов. Пусть они используются где то внутри, я не против.

А макросы знают лишь буквы, не могут обратиться внутрь. Они могут только генерировать текст, и получать текст.

Макросы в расте могут только получать группы токенов и отдавать групы токенов. При этом группы токенов имеют метатип. В частности, из-за этого невозможно вызвать макрос внутри структуры, например.

Metavariables
In the matcher, $ name : fragment-specifier matches a Rust syntax fragment of the kind specified and binds it to the metavariable $name. Valid fragment specifiers are:

item: an Item
block: a BlockExpression
stmt: a Statement without the trailing semicolon (except for item statements that require semicolons)
pat: a Pattern
expr: an Expression
ty: a Type
ident: an IDENTIFIER_OR_KEYWORD
path: a TypePath style path
tt: a TokenTree (a single token or tokens in matching delimiters (), [], or {})
meta: an Attr, the contents of an attribute
lifetime: a LIFETIME_TOKEN
vis: a possibly empty Visibility qualifier
literal: matches -?LiteralExpression
In the transcriber, metavariables are referred to simply by $name, since the fragment kind is specified in the matcher. Metavariables are replaced with the syntax element that matched them. The keyword metavariable $crate can be used to refer to the current crate; see Hygiene below. Metavariables can be transcribed more than once or not at all.

Я знаю, но это все уровень python-clang.

for «знает» про переменные (что бы это ни значило), а virtual не знает. Язык для описания классов, структур и сигнатур функций это тот же язык что и язык для управления потоком выполнения?

Ты просто придумал свою суть

Я просто копирую с википедии и растбука. Не надоедает спорить с очевидным?

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

Разницу между токенами и языком в студию!

fn main() {
    let my_number = 10;
    match my_number {
        10 => println!("You got a ten"),
        _ => 10,
    }
}

It will complain that you want to return () in one case, and i32 in the other.

But a macro doesn't care, because it's just giving an output. It's not a compiler - it's code before code. So you can do this:

macro_rules! six_or_print {
    (6) => {
        6
    };
    () => {
        println!("You didn't give me 6.");
    };
}

fn main() {
    let my_number = six_or_print!(6);
    six_or_print!();
}

So a macro isn't exactly Rust syntax.

// Какая-то книжка по расту, но кто их читает…

// Какая-то книжка по расту, но кто их читает…

https://doc.rust-lang.org/stable/book/ch19-06-macros.html

We’ve used macros like println! throughout this book, but we haven’t fully explored what a macro is and how it works. The term macro refers to a family of features in Rust

Есть и другие книжки.

В контексте обсуждения где у нас уродский синтаксис, в C или Rust ты выбрал

while(*to++ = *src++);
for(int x, y;x < y && x + 10 > z;f1(), y = f2(), x++)
  if(f3() < 100) x--;

facepalm.jpg

Глупее было бы только жаловаться на то, что в Расте нельзя

base* arr = new derived[10];
...
arr[1].foo();

Пусть они используются где то внутри, я не против.

ты вообще понимаешь как работает #include в С/С++ ?

Зачем убивать изящный C если надо убивать уродливый C++?

Только из-за того, что люди - рукожопы, и не умеют пользоваться валгриндом?

да, вопрос стоит именно так:

или С или человеки.