Так ли токсичен синтаксис Rust?

А если в конце функции в последнем выражении поставить точку с запятой то это уничтожит значение?

Уничтожит, но вы получите ошибку компиляции, если типы возврата не совпадут:

fn add_two(a: isize) -> isize {
    a + 2;  // error[E0308]: mismatched types, expected `isize`, found `()`
}

Так ли токсичен синтаксис Rust?

Да! Но можно было показать проще:

fn take_equal_types<T>(_: T, _: T) {}

fn main() {
    take_equal_types(|| 10usize, || 10usize);
}

Так ли токсичен синтаксис Rust?

но если считать что; это drop, то зачем мне делать drop на каждый вызов того что и так возвращает ()?

Можно и не делать. Но ; помимо этого превращает выражение в инструкцию, то есть выступает разделителем инструкций.

Так ли токсичен синтаксис Rust?

Нет, их нужно инстанциировать, если необходимо получить объект данного типа. Как и другие структурные типы.

Так ли токсичен синтаксис Rust?

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

Так ли токсичен синтаксис Rust?

Отредактировал свое сообщение.

Так ли токсичен синтаксис Rust?

Затем, что они становятся бесполезными, если не иметь возможности их инстанциировать.

Так ли токсичен синтаксис Rust?

Не вижу отличия от Java.

Где должны храниться значения статических полей в Rust, если после компиляции информация о типе нигде не хранится?

Так ли токсичен синтаксис Rust?

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

a @= 25;

вместо

let a = 25;

Вариант c let выглядит чище и традиционнее. И он как бы намекает, что перед нами все-таки не присваивание (раз он присутствует). Но многие незнакомые с языком думают, что тут именно присваивание, и что поэтому let лишний.

Так ли токсичен синтаксис Rust?

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

Можете уточнить, в каких ситуациях это составляет проблему? Просто посмотреть на последнюю строчку в теле функции.

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

return оправдывается как многословный потому, что он может встретиться в любой строчке внутри функции, вам его придется искать и вы должны хорошо его видеть, ибо он меняет поток выполнения программы. А вот в последней строчке он не нужен, так как явно или неявно присутствует там всегда (в Rust нет процедур) и поток выполнения там он не меняет.

Что же касается просто блоков, то там вообще оказывается не применим return, потому что это именно оператор возврата из функции, а не из текущего блока. Поэтому в блоках можно возвращать только последнее выражение.

Так ли токсичен синтаксис Rust?

Если данный код скомпилировался (или прошел check), то вы точно знаете, что bar возвращает (), так как другая ветка условия возвращает именно это значение благодаря ;, а типы значений веток обязательно должны совпадать.

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

Так ли токсичен синтаксис Rust?

message; — просто частный пример для иллюстрации того, что происходит. В реальном коде будет foo(); с дропом в этом месте значения, которое вернула foo, который может приводить к побочным эффектом, в случае кастомизации Drop'а этого значения.

Так ли токсичен синтаксис Rust?

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

Вот здесь говорилось, что этой информации нет во время выполнения: "Программа, написанная на Rust, не имеет информации о типах во время выполнения, так как при компиляции происходит "стирание типов". ". Мне показалось, что вы спорили с этим утверждением.

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

Вызов через точку можно рассматривать как вызов, при котором неявно передается указатель на предыдущий сегмент, а значение этого указателя определено в рантайме. Тогда как в вызове через :: сегменты являются именами статических пространств имен и не имеют представления во время выполнения. Поэтому структуры в Rust не могут иметь статических полей, в отличии от классов Java, и статические методы в Rust — это просто функции, расположенные в пространстве имен структуры, ничего более.

Так ли токсичен синтаксис Rust?

Rust может и значения элементов массива подставлять во время компиляции, несмотря на [].

Ну это все же относится к оптимизации частных случаев использования и не работает в общем случае.

Так ли токсичен синтаксис Rust?

Какую проблему вы видите в этом коде?

Так ли токсичен синтаксис Rust?

Не знаю как в C#, но в Java с try-with-resources ответственность за корректное освобождение ресурсов перекладывается на вызывающую сторону. К тому же не всегда использование ресурсов настолько локализовано, что безошибочное использование try-with-resources очевидно.

Использование Cleaner улучшает ситуацию и избавляет от необходимости следить за освобождением в тривиальных случаях, но в более сложных — головной боли не избежать. О проблемах освобождения ресурсов в Java подробно рассказывается в докладе Евгения Козлова "Вы все еще используете finalize()? Тогда мы идем к вам".

Так ли токсичен синтаксис Rust?

При желании — да, см. трейт Any.

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

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

Так ли токсичен синтаксис Rust?

Все-таки Rust — это императивный язык, поэтому сравнение с Haskell в этом отношении немного неуместно. Например, в Haskell нет традиционного для императивных языков условия if без else, а в Rust оно есть. Ну и там, где возникает в Haskell необходимость писать императивно, появляются и фигурные скобки, и точка с запятой. Хоть опционально, но ведь почему-то они в языке присутствуют, не так ли?

Так ли токсичен синтаксис Rust?

Доступ к элементу массива по индексу и к значению в хэш-таблице по ключу осуществляется во время выполнения и вообще говоря для этого используется один и тот же оператор (собственные реализации типажа Index). Именно Index управляет возможностью делать доступ [i] в рантайме, это просто сахар для вызова container.index(i), однако в случае обобщенной функции требуется совершенно другая семантика — выбор функции осуществляется на этапе компиляции.

Так ли токсичен синтаксис Rust?

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