Простые вопросы о Rust и проектах его экосистемы.

Чё за щаблоны? Там же должно всё быть сделано Ъ, а не как в плюсах?

Есть unwrap но ты не должен хотеть им пользоваться.

сначала они изобретают optional, а потом способы от него избавиться. Как уже показывает практика говнокода на расте будет даже больше, чем на 50-летнем старичке С.

Ну если конкретно мне допустим нужно достать из Option<i32> это самое i32 значение, это можно сделать через match, но может есть какой-то более приличный способ это сделать?

А вот если бы в Rust были монады...

Ну тебе вон unwrap подсказали выше.

вот спасибо, не должен по причине того, что это ломает самую идею оборачивания в Option?

я понимаю что можно продолжать тянуть option за собой везде, понимаю что это вещь вроде как бы спасает от факта отсутствия значения. Но почему-то для меня уже преложенный unwrap() воспринимался как «шум» (видимо при прочтении растбука на моменте где его показывают я был уже уставшим и прочитал по диагонали..), теперь стало понятней для чего он на самом деле. В общем спасибо ребята :)

map, and_then, unwrap, огромное количество их, смотри доки https://doc.rust-lang.org/std/option/enum.Option.html

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

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

Unwrap всегда потребляет сам объект. x.as_ref().unwrap() вернет тебе иммутабельный &T. Далее зависит от того что ты хочешь с ним сделать, если просто получить какое-то значение из T то приведенного вызова вполне достаточно. Если ты хочешь изменить T то T должен быть объектом интерьерной мутабельности Rc<RefCell<T>> или Arc<Mutex<T>>. В там случае ты можешь сделать так x.as_ref().unwrap().clone() и получишь копию ссылки ну мутируемый объект.

Какой-то мусорный язык.

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

Спасибо за пример.

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

На всякий случай напоминаю, что оператор ? работает не только для Result, но и для Option.

А ну и еще момент. T может не быть интерьеркой, если он сам реализует Clone. Это тоже вариант. Но тут нужно смотреть что за объект, потому что cклонировать Rc это очень дешевая операция, а если у тебя объект с сотней полей типа String, то лучше так не делать.

Если ты уверен что там есть значение, то unwrap. Если нет, то вариантов куча. От unwrap_or.*, до if let.

Либо unwrap_or, либо ты делаешь что-то неправильное

Может тебе просто map нужен для преобразований? В Rust не надо бояться использовать ФП!

Тут же просто элиминатора бы хватило, не?

unwrap, unwrap_or, unwrap_or_else

Это как раз нормальный язык.

Язык нужен, в основном, для чтения кода. Внезапно. И тут он проигрывает даже Си.

Я так понимаю, пруфов не будет?

Ну и пиши честно:

Язык нужен, в основном, для чтения кода. Внезапно. И, к сожалению, я понимаю только что написано на C, а Rust мне не интересен/я не осилил/etc.

Язык нужен, в основном, для чтения кода. Внезапно. И тут он проигрывает даже Си.

Где в Си можно прочитать, кто владеет указателем?

Какое ещё «владеет»? Указатель это просто адрес в памяти! Никаких непонятных извращений как у педеrustoв!

Зачем так толсто? Или это серьезное утверждение?

Эдик-педик, это ты?

Я передаю указатель в функцию, принимающую указатель. Где в «божественной сишечке» прочитать в коде, должен ли я после этого освободить указатель или нет?

В документации.

А зачем тогда «Язык нужен, в основном, для чтения кода.», если всё равно приходится читать на английском языке, а не на С?

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

Да и я не знаю зачем нужно читать код на таком языке:

macro_rules! diagnostic_method {
    ($name:ident, $level:expr) => (
        #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
        pub fn $name<T: Into<String>>(self, message: T) -> Diagnostic {
            Diagnostic::spanned(self, $level, message)
        }
    )
}
pub struct Context<'a> { _marker: PhantomData<fn(&'a ()) -> &'a ()> }

fn arg_local_refs<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
    bx: &mut Bx,
    fx: &FunctionCx<'a, 'tcx, Bx>,
    memory_locals: &BitSet<mir::Local>,
    va_list_ref: &mut Option<PlaceRef<'tcx, Bx::Value>>,
) -> Vec<LocalRef<'tcx, Bx::Value>> {
   let ty = if let (true, &ty::Ref(_, ty, _)) = (by_ref, &ty.sty) {
       ty
   } else {
       ops = &ops[..ops.len() - 1];
       ty
   };
}

В расте тоже знаешь ли нужно документацию к либе прочесть.

Но не для такой банальной вещи, как узнать, кто должен удалять что.

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

Чисто придуманная трабла

На си ничего не писал кроме хелловорлдов? Типичнейшая проблема.

Зависит от либ/проекта.

Раст укурен с точки зрения практически любого языка.

Где в Си можно прочитать, кто владеет указателем?

Указателем не обязательно должен кто-то владеть. Если же мы говорим про ресурсы, то, как правило, есть парный функции для создания/выделения и удаления/освобождения ресурса. Соответственно, клиент и удаляет. Есть другие подходы, с пулами, например. Но это все указано в документации.

А в C++ есть RAII и вообще все ок.

Ужас.

Покажи код.

Не знаю что вас смущает так сильно, это же +- сишечкаджава в чистом виде, просто немного перелопачен синтаксис, и теперь возвращаемое значение сзади через стрелочку + есть немножко мусорных 'foo для маркировки времени жизни в остальном та же сишкаджава почти... определение макроса выше вообще к коду ниже вроде никак не относится, не вижу чтобы оно использовалось тут, в общем-то, вкусовщина на самом деле, субъективно после джавы, с# или с++ с шаблонами и stl, такой синтаксис не должен вызывать какой-то пригар в нежных местах, так как там такой же кучерявый страшненький многословный синтаксис.

Лучше бы в моём коде искал быдлокод. Пользы больше было бы.

Не знаю что вас смущает так сильно, это же +- сишечкаджава в чистом виде

Сможешь показать такой же код на Java? Это выше я взял из rust компилятора наугад тыкнув в файлы, не искал специально.

Для меня после C нечитаемо выглядит...

«Такой же» выполняющий то же самое - нет. Потому что джава в такое не особо умеет, по вполне понятным причинам (да и вообще кусок вырванный из контекста, мало говорит о предназначении того кода, скорее всего что-то функционально идентичное можно и на java сделать). Если же под «такой же» имеется в виду, то, о чем я говорил, а именно что на любом из этих языков более менее сложный код выглядит не очень красиво, то можно брать любой код, ну не знаю... например вот это не самый витиеватый код, бывает куда хуже, но от такой же многословный(многосимвольный). Вы просто утрируете, на С тоже можно, и даже приходится писать так, что тяжело разобраться даже +- зная язык с тем, что кто-то написал, просто с наскоку.

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

«Такой же» выполняющий то же самое - нет.

Почти весь код на Rust такой, не имеет смысла «выполняет тож самое».

например вот

Вполне читаемо, даже очень.

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

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

Почти весь код на Rust такой, не имеет смысла «выполняет тож самое».

Это все-равно сказать что весь код на С++ такой же как потроха boost.