All streams
Search
Write a publication
Pull to refresh
88
0
Александр Мещеряков @freecoder_xx

Rust разработчик

Send message

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

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


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

Вот так будет на Rust (просто для справки):


fn max3<T>(a: T, b: T, c: T) -> T
where
    T: PartialOrd
{
    if b > a {
        if b < c {c} else {b}
    } else {
        if a < c {c} else {a}
    }
}

Ломает компиляцию программы — и что с того? Переставьте как надо и все скомпилируется. Компилятор сам переставить не может, потому что не знает, что ваши функции без побочных эффектов.

В Rust нет "процедур", то есть функций, которые не возвращают значения. Когда такая нужна — пишется функция, которая возвращает значение типа "пусто". Но пустое значение при этом она-таки должна вернуть! Вот пример:


fn foo() {
}

Это то же самое, что


fn foo() -> () {
    ()
}

Или


fn foo() -> () {
    return ();
}

Или


fn foo() -> () {
    ;
}

Так что вы можете написать:


fn foo() {
    statementA;
    statementB;
}

Что на самом деле будет означать:


fn foo() -> () {
    statementA;
    statementB;
    ()
}

Ну если наличие в программе GC или UB (на выбор) вам не мешает, то, наверное, и нет особой надобности использовать именно Rust. Синтаксис тут вряд ли играет какую-то существенную роль.


Я в свое время перешел на Rust потому, что мне понадобился статически типизированный язык без GC и с хорошей системой управления зависимостями. Синтаксис поначалу не нравился, но потом перестал испытывать с ним какие-либо неудобства. И так было со многими моими знакомыми: синтаксис нормальный, просто сначала он может быть непривычен.

Сейчас уже очевидно следующее:


  1. IT захватывает старую индустрию и финансовый сектор;
  2. IT-компании становятся новыми топ-корпорациями, которые выпихнут всех старичков (если те сами не переделаются в IT-компании);
  3. IT-корпорации станут лоббировать свои интересы в политике, все будут вынуждены с ними считаться;
  4. IT поработит всех и все, в ширину и в глубину;
  5. Внутри IT-сектора набирает силу движение СПО… но это уже совсем другая история :)

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


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

Да, я имел ввиду, что далеко не все, что могут делать шаблоны можно "типизировать", то есть выразить в системе типов (Раста). Кое что с помощью обобщенных типов нельзя сделать, что можно с помощью шаблонов.

  • Вас удивляют правила заимствования в языке, вокруг которых он фактически и выстроен;
  • Вы не можете отличить вызов функции от вызова макроса;
  • Вы не понимаете как работает println! и испытываете трудности с расстановкой mut.

А вы точно книгу-то читали? Или это из разряда "смотрю в книгу — вижу фигу" у вас?

Ставите запятую, потом точку с запятой, потом компилятор предлагает вам убрать точку с запятой, потом ваша программа компилируется.

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


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

И что страшного произошло? Компилятор вам сказал:


error[E0308]: mismatched types
 --> src/main.rs:1:19
  |
1 | fn foo(a: i32) -> i32 {
  |    ---            ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
2 |     a;
  |      - help: consider removing this semicolon

Так сложно прочитать сообщение об ошибке и убрать ;? Вот честное слово, детский сад какой-то.

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

А где вы видите функцию? println! — это макрос, который заимствует переданные параметры.

Отчасти вы правы. Поэтому я для себя сформулировал такое правило: "Rust упрощает сложное, но усложняет простое". Если вы пишите скрипт в пару строк — Rust для этой цели будет не лучшим выбором. А вот если ваше ПО достаточно сложное или предполагается его усложнение в будущем — то тут издержки Раста со временем окупятся сполна.

как правило (намеренно?) забывают приложить к этому утверждению сносочку "*в safe подмножестве языка", в результате (намеренно?) создают ложное впечатление

Вам везде мерещатся заговоры. Автор говорит о том, что в тех местах, где его коллеги допускали UB, используя Rust они бы UB не допустили. Очевидно, что речь идет о safe Rust, потому что в unsafe допустить UB можно. Вы занимаетесь каким-то буквоедством и выискиваете в тексе то, чего там нет: где сказано, что используя Rust в принципе невозможно получить UB? Зачем вы додумываете за автора то, чего он не говорит? Проблема C++ именно в том, что в нем легко можно получить UB на ровном месте, по невнимательности, не ожидая вообще, что тут может быть UB. С Rust такое уже не прокатит.

То, что такая ошибка происходит в unsafe блоке — слабое утешение.

Это не утешение, это — принципиальный момент, о котором я уже сказал в комментарии выше.

Наверное это потому, что вы не программируете. Тогда вообще не понятно, что вы делаете в данном обсуждении. Зашли поругаться?

Конечно, в unsafe-коде вы всегда сможете допустить UB. Но речь же в статье именно о тех местах, где разработчики C++ допускают по невнимательности UB, тогда как в Rust этого бы не произошло. Автор говорит, что ловит коллег на ошибках, которые они не допустили бы в Rust — очевидно, что это про те места, которые покрывает безопасный Rust.


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

Вот честно, где вы видите агрессию от людей, защищающих Rust? Вот хотя бы в данных комментариях, перечитайте. Вся агрессия идет как раз от противников Раста.

Information

Rating
Does not participate
Location
Санкт-Петербург, Санкт-Петербург и область, Россия
Registered
Activity