Язык D включен в коллекцию компиляторов GNU (gcc 9)

Преимущества D перед Rust:

- чистый синтаксис

Довольно спорное преимущестов. Нет, синтаксис, конечно, несколько чище, но по опыту предыдущих поколений, это так себе преимущество.

- развитые, удобные, безопасные типы

Только вот ADT нет, печаль. И чем типы D безопаснее типов Rust?

возможность писать скрипты на D

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

развитые, удобные, безопасные типы

Разверните мысль. Насколько я знаю, в Rust система типов мощнее.

это стоит рассматривать вкупе с легкостью взаимодействия D + C, и вызова D из C

Как будто в Rust с этим есть проблемы. Скорее даже проще.

возможность писать скрипты на D

Ненужно.

- возможность писать скрипты на D

Для раст есть интерпретатор miri.

я был во вьетнаме

поверю, туда даже виза не нужна при въезде на срок до 15 дней

Если макаке вручат гладильную доску, она быстрее сломает себе пальцы, чем что-то погладит. То же и с null - незачем вообще соваться в программирование, если ты настолько бестолков, что не понимаешь, что везде нужен контроль и порядок. Сотни программ работают без падения, хотя ни в одной не было специальных языковых средств «вот это не null». Как так? Магия или КВАЛИФИЦИРОВАННЫЙ КОД?

Те же обезьяны добрались и до C# со своими «мы не можем - у нас лапки! сделайте нам так, чтобы пишешь-пишешь и даже мозг не применяешь!».

Магия или КВАЛИФИЦИРОВАННЫЙ КОД?

Не понял, у Iron_Bug есть родной брат?

Сотни программ работают без падения, хотя ни в одной не было специальных языковых средств «вот это не null».

И ни у одной из них в багтрекере нет ничего про segfault?

И ни у одной из них в багтрекере нет ничего про segfault?

Ты не понимаешь. У них нет багтрекеров - это же КВАЛИФИЦИРОВАННЫЙ КОД.

GC непосредственно не нужен. Но если нужно автоматическое управление памятью, то получить его можно с GC.

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

Быстрого по сравнению с чем? С питоном?

С Си. Ясно, что со слабостями в некоторых сценариях.

Это такая проблема?

А что, кто-то предпочитает больше зависимостей чем меньше? И потяжелее?

Сишка тоже быстро компилируется. Угадайте почему.

Да и код читается быстро, что и хорошо.

С Си.

Ох лол.

Ясно, что со слабостями в некоторых сценариях.

Он в бенчах на уровне джавы, если что.

А что, кто-то предпочитает больше зависимостей чем меньше?

У Go бинари весят по 10 метров, если что.

Да и код читается быстро, что и хорошо.

10 уязвимостей из 10.

Между прочим, программу на D можно запускать именно как классический скрипт, с компиляцией на лету.

На Rust тоже. Но зачем?

Что-то я в практикабельности сомневаюсь. Жаль, тут https://benchmarksgame-team.pages.debian.net/benchmarksgame/ нет D, так что с ним не сравнить. В остальном, Rust компилирует где-то в 10+ раз медленнее Go и даже в несколько раз медленнее C++.

С точностью до наоборот. Если прога собралась - значит всё ок. И не нужно пердолиться с санитайзерами как в сишке и её старшем брате (сестре?).

А у кого, кто старше Си, есть санитайзеры, у Фортрана что-ли?

Rust компилирует где-то в 10+ раз медленнее Go и даже в несколько раз медленнее C++

И у тебя, конечно, есть факты, чтобы это доказать?

Ссылка в посте.

Rust компилирует где-то в 10+ раз медленнее Go

Я вам уже намекнул почему.

в несколько раз медленнее C++

Нет.

А у кого, кто старше Си, есть санитайзеры, у Фортрана что-ли?

Имелся ввиду C++. Старший не в плане возраста, а фич. Криво сформулировал.

раст ценен как язык не дающий удалить массив за пределами границ памяти, что автоматически на уровне языка ликвидирует многие уязвимости

стесняюсь спросить, какой современный компиялятор какого современного языка, этого НЕ поддерживает?

также в rust решена turing bus stop problem, что позволяет еще безопаснее эксплуатировать приложения на нем, поэтому за ним будущее

о как. а ещё он выводит бородавки, да?

биткоины были как пример того, что в то, во что многие не верят, на самом деле и есть будущее человечества

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

Между прочим, программу на D можно запускать именно как классический скрипт, с компиляцией на лету.

На Rust тоже. Но зачем?

ну, например, у меня была тупая задачка пару раз в месяц анализировать некую статистику. тупо написанный скрипт на питоне отрабатывает, примерно, минут 15 - 30. Практически буквально (1:1) перекатанный на D, тот же скрипт отрабатывает, примерно, за 20 - 30 секунд (включая компиляцию на лету и собственно отработку). Запускается именно через #!/usr/bin/rdmd. Исходный код всегда перед глазами, исправляется на лету. Так что, почему бы и нет?

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

криптостиле

А по-русски? Ну и пример бы не помешал.

Я не копенгаген в Расте, знающий человек сразу выдаст список претензий. Поэтому то, что сразу вызывает некоторый холодок прямо в процессе тура по языку:

let x = (let y = 6); зачем многословность? а ведь при постоянном использовании это не мелочь. иммутабельность идентификатора по умолчанию, также ведёт к многословности, а итоговая «безопасность» при этом сомнительна.

Using the Field Init Shorthand when Variables and Fields Have the Same Name --- ну умолчание, ничего страшного. но читательность текста в результате резко снижается.

аналогичные умолчания в Creating Instances From Other Instances With Struct Update Syntax --- затруднения при чтении и потенциальный источник ошибок.

аннотации типа #[derive(... это не «шифровка», сбивающая с толку? в любой реальной программе кода МНОГО. И если читается чужой код, а тут опс, какая интересная аннотация, а раскручивать надо.

а указания типа struct Context<'a>(&'a str); ладно, постоянно пишущий на Расте человек считает запись самоочевидной. А пишущий непостоянно, время от времени? fn parse<'a>(&'a self) -> Result<(), &'a str> { весьма самоочевидная сигнатура, ага.

ну и правила по времени жизни, просто верх самоочевидности.

макросы. спасибо, что на стероидах. но макросы?! да ещё можно делать #[derive смотрим в интернете приеры кода, мама дорогая. ну это смотрится, как шифровка, для понимания которой нужно раскрутить всё вверх, да по сути и является шифровкой.

.. и ... какова вероятность случайной ошибки?

смотрим https://rosettacode.org/wiki/Identity_matrix#Rust

прямо сходу,

impl<T> Matrix<T> where T: num::Num + Clone + Copy, { fn new(size: usize) -> Self { Self { data: vec![T::zero(); size * size], size: size,

что СХОДУ скажет человек, первый раз увидевший этот код? Правильно, криптограмма.

вообще, удивительно. *костыль*, подсказка компилятору

Подсказка - это в плюсах. В Rust - это гарантия компилятора.

вопрос простой. Это ВООБЩЕ, нужно? Обойти эту гарантию, можно. Да, явно указав небезопасность, но можно. Значит, просто удобная подсказка.

Вот это хорошо, да. Но какой ценой? Имхо, увеличения головной боли программиста и снижения скорости разработки.

про безопасность по памяти:

С точностью до наоборот. Если прога собралась - значит всё ок. И не нужно >пердолиться с санитайзерами как в сишке и её старшем брате (сестре?).

это, имхо, очень упрощенный подход. любой просчёт при начальном проектировании, либо исходно заложенные упрощения, и ценность этой фичи резко снижается. Не говоря о том, что заборчик вокруг области памяти, сам по себе, гарантией ПРАВИЛЬНОСТИ программы не является и не может ей быть.

Про тредовую безопасность:

реклама. Все этого хотят. D тоже обещает. Вопрос в цене.

Нет. Это гарантия языка.

Мы не на базаре. Растом клянусь дорогой, слюшай, да?! Каким образом компилятор это гарантирует и какой ценой? Например, в D, это сделано ценой того, что переменные (по умолчанию), являются локальными в треде и при необходимости, неявно и автоматически задействуются семафоры. Но в реальном коде это ведёт к неудобствам и снижению производительности.

Чем это лучше шаблонов D?

Тем, что это не шаблоны.

О да. Тем, что происходит откат к существенно менее совершенной структуре, которую осилили компиляторостроители.

Тем, что существующие языки содержат GC, а значит нужны доп. пляски.

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

Чем это лучше выноса на уровень библиотеки (с возможностью расширения без исправлений в компиляторе)?

Вы точно понимаете что такое pattern matching?

А Вы? Или считаете, что сопоставление с образцом, это в точности (и ТОЛЬКО) то, что написано в the Rust book?

Только вот драйвера на Rust никто не пишет.

Что весьма печально. Впрочем, понятно, почему. Чтобы писать по линь, нужно прилично адаптировать минимальный растовый рантайм. А чтобы делать под вин, нужно пилить совместимость растового кода с апи (уж какой есть) c++.

Люди пишут прикладной софт, который можно было бы писать на D, но он не взлетел.

А это тоже правда. Только дело не во взлёте, а в эффекте хайпа. Под D появились очень интересные вещи, которых под Растом нет и в обозримой перспективе, не будет. Впрочем, обратное тоже верно.

У D есть ниша? =)

Есть. Я рассматриваю D как «строгий Питон». Кстати, скорость распространения Питона на ранних стадиях, была весьма невелика. А это язык сильно проще D. Так что по мере появления учебной литературы по D и расширении экосистемы, надежда есть.

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

А Rust значит пилят обезьяны?

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

Я пол темы пытаюсь выбить у фанбоев D список его преимуществ перед Rust, а получаю лишь мутные ответы.

Ну нет возможности пересказать книгу Александреску, например. Сильная сторона D --- шаблоны, подстановка кода, интроспекция (из чего следует мощная стандартная библиотека, которая тоже неотъемлемая часть языка), синт. сахар. Ну не расскажешь это всё в двух словах.

а указания типа struct Context<'a>(&'a str); ладно, постоянно пишущий на Расте человек считает запись самоочевидной. А пишущий непостоянно, время от времени? fn parse<'a>(&'a self) -> Result<(), &'a str> { весьма самоочевидная сигнатура, ага.

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

Например, в D, это сделано ценой того, что переменные (по умолчанию), являются локальными в треде и при необходимости, неявно и автоматически задействуются семафоры. Но в реальном коде это ведёт к неудобствам и снижению производительности.

Очередная победа D над Rust.

А Вы? Или считаете, что сопоставление с образцом, это в точности (и ТОЛЬКО) то, что написано в the Rust book?

Сопоставление с образцов существует не только в Rust.

Ну так раз на D пишут только мега-спецы - где же рассвет крутых либ? Я слышал только про vibe.d и какую-то либу для json. Но не уверен что они сильно лучше actix-web и serde.

насчёт МЕГА спецов, никто не говорил. Говорилось о очень опытных и признанных специалистах.

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

libmir.

Уточню: консольные утилиты. Почему-то в этой сфере сейчас доминируют

Rust

да?!

и Go,

хайп — эффект. конечно, имхо.

а D даже не слышно. Хотя по-логике он лучше подходит для этой задачи. Как же так?

а сколько людей у нас знакомы с D?

Только вот ADT нет, печаль.

как нет? я пугаюсь.

И чем типы D безопаснее типов Rust?

не безопаснее. гибче при сохранении достаточной безопасности при разумных умолчаниях.

Разверните мысль. Насколько я знаю, в Rust система типов мощнее.

за счёт чего мощнее (оставляем время жизни за скобками, концепция вообще сомнительна (на уровне человека)) ?

GC непосредственно не нужен. Но если нужно автоматическое управление памятью, то получить его можно с GC

смелое утверждение. СМ появился (за пределами интерпретируемых языков) вместе с ООП и концепцией компонентного прогр-ия. Нет?

Жаль, тут https://benchmarksgame-team.pages.debian.net/benchmarksgame/ нет D,

с бенчмарками на D нужно быть осторожнее, очень сильно зависит от компилятора (dmd, скорее всего, медленный код, ldc2, gdc — скорее всего, очень быстрый. да ещё ldc2 до последнего времени умудрялся код с тригонометрией для линукса делать чуть ли не вдвое более медленный, чем тот-же код под виндоус).

с другой стороны, dmd очень быстро компилирует и запуск программы а-ля скрипт имеет смысл.

а указания типа struct Context<'a>(&'a str); ладно,
&'a str> { весьма самоочевидная сигнатура, ага.

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

Дело не в базовости концепций. Очевидно-же, приведён очень простой код из туториала. Как только эта простая запись начинает усложняться до реальности, появляются самые натуральные криптограммы. В чём легко убедиться простым сёрфингом по гитхабу.

Это проблема базового дизайна, как ни крути.

Например, в D, это сделано ценой того, что переменные (по умолчанию), являются локальными в

Очередная победа D над Rust.

речь шла о том, что Раст автомагически обеспечивает тредобезопасность. Вот я и хочу ЗНАТЬ, КАК. Статического анализа тут недостаточно. Должны быть механизмы времени исполнения. Как это сделано в D, я рассказал. Теперь я хочу услышать не базарные гарантии «мамой клянусь», а точное описание, как это СДЕЛАНО в Расте и за счёт чего есть магическая гарантия с, как можно понять предыдущего восторженного оратора, нулевой стоимости.

А Вы? Или считаете, что сопоставление с образцом, это в точности (и ТОЛЬКО) то, что написано в the Rust book?

Сопоставление с образцов существует не только в Rust.

кто-то спорит?

Речь шла о вынесении функционала в библиотеку (с сомнениями, нужно ли выносить эту задачу на уровень компилятора, учитывая трудоёмкость задачи).

И как пример я утверждал, что классические регекспы являются ЧАСТНЫМ случаем сопоставления с образцом и задача в общем случае тоже может требовать генерации автомата.

Я неправ?

PS: а вот в Rust book границы применимости понятия довольно сужены.

В чём легко убедиться простым сёрфингом по гитхабу.

Ну вот например?

Это проблема базового дизайна, как ни крути.

Как представление времени жизни сделано в языках от «опытных и признанных специалистов»?

речь шла о том, что Раст автомагически обеспечивает тредобезопасность. Вот я и хочу ЗНАТЬ, КАК. Статического анализа тут недостаточно.

Исключительно на уровне типов, том самом, который якобы менее гибок, чем в D.

И как пример я утверждал, что классические регекспы являются ЧАСТНЫМ случаем сопоставления с образцом и задача в общем случае тоже может требовать генерации автомата.

И какой автомат генерируется в других языках на сопоставление с образцом?

И какой автомат генерируется в других языках на сопоставление с образцом?

не имею понятия.

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

Ну вот например?

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

Как представление времени жизни сделано в языках от «опытных и признанных специалистов»?

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

Исключительно на уровне типов, том самом, который якобы менее гибок, чем в D.

каким образом анализ на уровне типов поможет сгенерировать «бесплатный» код, гарантирующий тредобезопасность во время исполнения? Запретить взаимодействие тредов вообще? ну, в общем-то, тоже решение. только вот тривиальное до рези в глазах.

неявно, за счёт деятельности компилятора.

И примером будет?

каким образом анализ на уровне типов поможет сгенерировать «бесплатный» код, гарантирующий тредобезопасность во время исполнения?

Типы существуют только при компиляции, в исполняемом файле уже всё проверено.

И примером будет?

любая программа. как ни странно, концепция границ (scope), вполне достаточна.

каким образом анализ на уровне типов поможет сгенерировать «бесплатный» код, гарантирующий тредобезопасность во время исполнения?

Типы существуют только при компиляции, в исполняемом файле уже всё проверено.

Шерлок, но как?!

Если вы не запрещаете взаимодействие тредов вообще, хоть какой-то механизм синхронизации ВО ВРЕМЯ ИСПОЛНЕНИЯ придётся вводить в любом случае. Статический анализ может помочь автоматически сгенерировать оптимальный механизм синхронизации для данного случая, но не более того. Бесплатно это не будет.

Речь шла о вынесении функционала в библиотеку (с сомнениями, нужно ли выносить эту задачу на уровень компилятора, учитывая трудоёмкость задачи).

Библиотечный паттерн матчинг (пм) обычно неудобная и страшная вырвиглазная вещь, как пример можно посмотреть std::variant (boost::variant). Это штука без сахара (то есть уровня компилятора ну или реализации на синтаксических макросах) практически бесполезна.

И как пример я утверждал, что классические регекспы являются ЧАСТНЫМ случаем сопоставления с образцом и задача в общем случае тоже может требовать генерации автомата.

Я неправ?

Неправ. Не знаю как в русте но в языке с которого содран ПМ для него, то есть на OCaml ПМ это switch на стероидах, для его реализации там не нужны никакие сложные автоматы. Все же мощь и полезность ПМ реализуется только в симбиозе с алгебраическими типами данных, без них ПМ малополезная безделушка.

А что? Грамотно всё разложил. Тьюринг еще и гей был - эксцентричнее некуда!

Лол.

Библиотечный паттерн матчинг (пм) обычно неудобная и страшная вырвиглазная вещь, как пример можно посмотреть std::variant (boost::variant).

в D это не (обязательно) так. Чем D и интересен, собственно.

Неправ.
то есть на OCaml ПМ это switch на стероидах, для его реализации там не нужны никакие сложные автоматы.

ok. значит, я учился по другим учебникам :) . впрочем, я ит-дилетант, хоббист, так что простительно :)

в D это не (обязательно) так. Чем D и интересен, собственно.

В D https://dlang.org/phobos/std_variant.html#.visit только чуть менее вырвиглазно чем в современном C++ https://en.cppreference.com/w/cpp/utility/variant/visit Но что там, что там, лишь куцые возможности по сравнению с языками с нормальным ПМ. Условий в ветках нет, гарантий компилятора что выбраны все ветки тоже нет, распаковки стандартных типов данных вроде списков не видно.

Ничего не понимаю. Каким образом в теме про D появилось обсуждение Rust? Это рекламная акция такая? Казалось бы, про Rust есть отдельная достаточно свежая новость.

Ты это серьезно спрашиваешь? Просто наслаждайся. Уже выяснилось, например, что в Rust решили проблему останова.

Ничего не понимаю.

Все просто: раньше свидетели Rust-а срались с C++никами. Со временем C++никами это надоело и срачи Rust vs С++ сошли на нет. Но свидетелям Rust-а недостает новых адептов, вот они и приходят с проповедями в любую, как им кажется, подходящую тему.

Все просто: раньше грязные свидетели C++ срались с рыцарями Rust в сияющих доспехах. Со временем C++никам это надоело, и срачи Rust vs С++ естественным образом сошли на нет.

Fixed FGG.

Ничего, ничего. Тут на носу публикация нового стандарта Fortran (2018). Только как об этом новость писать не представляю. Уж очень там много нововведений касающихся распараллеливания и взаимодействия с Си.

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

Фанбоев тут только два. И я не в их числе.

Я не знаю сколько их тут. Но вы то как раз фанбой Раста. Иначе чего бы вам тут доказывать, в теме про включение Ди в гцц, что Ди хуже Раста?

Уточню: консольные утилиты. Почему-то в этой сфере сейчас доминируют Rust и Go, а D даже не слышно. Хотя по-логике он лучше подходит для этой задачи. Как же так?

А говорите не фанбой. Если утилиты на го я еще встречаю изредка, то на расте вообще ничего не встречал. На Ди например встречал терминал Tilix, но мне даже в голову не придет сказать, что в утилитах доминируют какие либо языки. Уж точно не Го и не Раст.

Только вот ADT нет, печаль.

как нет?

Просто нет.

И чем типы D безопаснее типов Rust?

не безопаснее. гибче

Прекрасно. Чем именно они гибче?

Только вот ADT нет, печаль.

как нет?

Просто нет.

Разверните мысль, пожалуйста. Возможно, мы с Вами имеем в виду разные сущности?

И чем типы D безопаснее типов Rust?

не безопаснее. гибче

Прекрасно. Чем именно они гибче?

свойства (включая .stringof). полная интроспекция для любого типа. явный тип делегата. интерфейсы (у производных пользовательских типов). пользовательские атрибуты (UDA). применимость квалификаторов типов (const, immutable, (inout) (shared)) к любому типу. преобразование типов и возможность преобразования immutable/mutable shared/non-shared только при строгом выполнении безопасных условий.

Просто нет.

Они есть в стандартной библиотеке и в виде сторонних пакетов. Тот taggedalbebraic. Этот пакет очень активно используется. И оценить выразительность Ди вы можете заглянув в код. Там 1366 строк, из них практически половина это юниттесты, плюс комментарии да пустые строки. Недавно появился еще sumtype - тут еще меньше строк, меньше 1000 и также большая часть этих строк это юниттесты и комментарии.

Конечно поддержка языком была бы элегантнее, но говорить что в Ди просто нет ADT это неверно.

раньше свидетели Rust-а срались с C++никами

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

Если вы не запрещаете взаимодействие тредов вообще, хоть какой-то механизм синхронизации ВО ВРЕМЯ ИСПОЛНЕНИЯ придётся вводить в любом случае.

Придется. И что? Вопрос ведь в том, как гарантировать корректность использования этого механизма.

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

Статический анализ не поможет «сгенерировать оптимальный механизм синхронизации» (что это вообще такое?), по крайней мере - не поможет сделатиь это в Rust. Но статический анализ _гарантирует_, что у двух нитей нет общих изменяемых данных, если они не сделаны общими явным указанием программиста.

Бесплатно это не будет.

...и на этапе исполнения это будет именно бесплатно.

Они есть в стандартной библиотеке и в виде сторонних пакетов.

Это не в счет (ADT библиотечными средствами можно сделать и в Си++, но оператор match сделать уже невозможно). Вот это:

        return expr.match!(
            (double num) => "%g".format(num),
            (string var) => var,
            (BinOp bop) => "(%s %s %s)".format(
                pprint(*bop.lhs),
                bop.op,
                pprint(*bop.rhs)
            )
        );

оператором match не является - это switch по типу. Нет destructuring, нет guards. Для сравнения, Rust: https://doc.rust-lang.org/book/second-edition/ch18-03-pattern-syntax.html Как первые два примера сделать на D? Я подозреваю, что это невозможно, но просто на всякий случай спрашиваю.

Конечно поддержка языком была бы элегантнее, но говорить что в Ди просто нет ADT это неверно.

Только так и верно. Потому что в D _нет_ ADT. Средствами D можно изобразить что-то похожее.

Кстати:

Они есть в стандартной библиотеке и в виде сторонних пакетов. Тот taggedalbebraic. Этот пакет очень активно используется.

То, что их много (больше одного) разных делает их гораздо менее полезными, чем один, но стандартный.

let x = (let y = 6); зачем многословность?

error: expected expression, found statement (`let`)
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^ expected expression
  |
  = note: variable declaration using `let` is a statement

.

иммутабельность идентификатора по умолчанию, также ведёт к многословности, а итоговая «безопасность» при этом сомнительна.

Вкусовщина. У меня 90% «переменных» - константы. let mut пишу очень редко.

.

Using the Field Init Shorthand when Variables and Fields Have the Same Name

Я молюсь на эту фичу. В том же C++, инициализация структур - боль.

.

аналогичные умолчания в Creating Instances From Other Instances With Struct Update Syntax --- затруднения при чтении и потенциальный источник ошибок.

Не менее божественная фича. Какие тут могут быть ошибки - не ясно.

.

аннотации типа #[derive(... это не «шифровка», сбивающая с толку? в любой реальной программе кода МНОГО. И если читается чужой код, а тут опс, какая интересная аннотация, а раскручивать надо.

Они убирают копипасту, которая и сбивает с толку (привет Go). Да и в D тоже есть атрибуты.

.

а указания типа struct Context<'a>(&'a str); ладно, постоянно пишущий на Расте человек считает запись самоочевидной. А пишущий непостоянно, время от времени?

1. В этом примере лайфтамы вообще не нужны. 2. Если человек не знаком с языком - для него всё будет непонятно. У D тут нет ни каких преимуществ.

.

макросы. спасибо, что на стероидах. но макросы?!

А в чём проблема? Предлагаете работать за компилятор, как в Go?

.

да по сути и является шифровкой

Вкусовщина. Дальше.

.

.. и ... какова вероятность случайной ошибки?

Какой ещё ошибки?

.

что СХОДУ скажет человек, первый раз увидевший этот код? Правильно, криптограмма.

Покажите аналог на D, а ещё лучше на C++.

.

первый раз увидевший этот код

А что «скажет человек, первый раз увидевший этот код?»:

template GenStruct(string Name, string M1)
{
    const char[] GenStruct = "struct " ~ Name ~ "{ int " ~ M1 ~ "; }";
}

.

вопрос простой. Это ВООБЩЕ, нужно? Обойти эту гарантию, можно. Да, явно указав небезопасность, но можно. Значит, просто удобная подсказка.
Вот это хорошо, да. Но какой ценой? Имхо, увеличения головной боли программиста и снижения скорости разработки.

Аргументация уровня ЛОР. Мне не понятно - значит не надо.

.

Не говоря о том, что заборчик вокруг области памяти, сам по себе, гарантией ПРАВИЛЬНОСТИ программы не является и не может ей быть.

А кто-то об этом говорил? Не вижу ничего плохого в том, что язык позволят фактически забыть про целый класс проблем. При этом бесплатно для рантайма.

.

Мы не на базаре. Растом клянусь дорогой, слюшай, да?! Каким образом компилятор это гарантирует и какой ценой?

Представьте себе - гарантирует. Естественно через unsafe абстракцию, но без затрат в рантайме. zero cost, в который вы тут не верите.

.

Но в реальном коде это ведёт к неудобствам и снижению производительности.

Отучайтесь говорить за всех. Вы только в этом посте это раза три написали. Ваши личные предпочтения никого не волнуют.

.

Тем, что происходит откат к существенно менее совершенной структуре, которую осилили компиляторостроители.

Ох лол. Царь сишки - это ты? Ну да, куда расту до «совершенной структуры» D. Такого даже от лора не ожидал. И эти люди называют меня фанбоем.

.

мусорщик --- цена дружественности к разработчику — человеку при сохранении гибкости и достаточной безопасности кода.

Не надо юлить. Вопрос был про простоту написания биндингов.

.

особо быстром коде или в драйвере
драйвере

У вас пунктик?

.

Или считаете, что сопоставление с образцом, это в точности (и ТОЛЬКО) то, что написано в the Rust book?

Покажите мне как вы сделает это в виде либы:

    let v: (Option<i32>, Option<i32>) = (Some(5), None);
    let value = match v {
        (Some(..), Some(..)) => 1,
        (Some(..), None) => 2,
        (None, Some(..)) => 3,
        (None, None) => 4,
    };
    println!("{}", value);

.

Чтобы писать по линь, нужно прилично адаптировать минимальный растовый рантайм.
А чтобы делать под вин, нужно пилить совместимость растового кода с апи (уж какой есть) c++.

Чушь.

.

Под D появились очень интересные вещи, которых под Растом нет и в обозримой перспективе, не будет.

Жду список.

.

Есть. Я рассматриваю D как «строгий Питон».

И снова здрасте. Я не про ваше мнение, а про реальный мир. Go захватил место «строго Питона» даже не заметив существование D.

.

надежда есть

Главное верить. (с)

Но то, что опыта поменьше, тоже очевидно. Если бы это было не так, некоторых пятнышек в подходе, практически идентичных дрючкам, характерным для ранних стадий развития старых ЯП, не было-бы.

Примеры в студию. А то авторы-мудрецы из D взяли и переписали всю std. Вот это планирование. Вот это да.

А потом ещё и GC сделали опционально, через одно место, тоже прекрасно.

Про betterC вообще молчу.

.

Сильная сторона D --- шаблоны, подстановка кода, интроспекция (из чего следует мощная стандартная библиотека, которая тоже неотъемлемая часть языка), синт. сахар.

Это всё и в Rust есть. Только лучше.

.

Говорилось о очень опытных и признанных специалистах.

Признанных кем?

.

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

А в Rust значит баги на каждом шагу? Но вот std в раст ещё не переписали с нуля. Вот те на.

.

хайп — эффект. конечно, имхо.

Да хоть борщ-эффект. Не нужно бежать от реальности.

.

речь шла о том, что Раст автомагически обеспечивает тредобезопасность. Вот я и хочу ЗНАТЬ, КАК. Статического анализа тут недостаточно. Должны быть механизмы времени исполнения.

Погуглите. Много нового узнаете.