Как понять асинхонщину в Rust?

Для начинающих — как в любом другом языке: при объявлении асинхронной функции пишешь async fn, при вызове асинхронной функции пишешь await.

async fn foo() -> i32 {
    68
}

async fn bar() -> i32 {
    let f = foo().await;
    f.await
}

fn main() {
    let x = bar();
    println!("{}", x);
}

Не-а, не работает. Если бы.

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

Ты давай от темы не увиливай: как с «сахарком» эту твою монаду вскрыть в случае острой необходимости?

Ну что, продолжишь изучать Rust?

После высеров Царёчка - обязательно!

Ну и кто будить фьючу будет? Это же push асинхронность, когда что-то случилось, надо запушить уведомление

Взять Tokio и не лезть в низкоуровневые примитивы пока не врубаешься.

Вот я и пытаюсь врубиться, не мешай.

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

К примеру, у меня есть входной поток сообщений, куда в рандомное время прилетают новые, которые надо парсить, обрабатывать и продолжать вести наблюдение. Сюда бы идеально подошли сигналы/слоты GTK/Qt, но они медленные даже по заверениям их разработчиков. У меня таких событий может быть до сотни в секунду по самым скромным подсчётам, а скорее, значительно больше. Всё это расчитано не на серверное железо, а на обычный десктоп/лэптоп. Поэтому я и ищу более производительное решение, которое бы реализовало тот же кейс.

В принципе, у меня есть опыт работы с асинхронными функциями в GTK/GIO, они примерно так и работают - даётся задание, выполняющееся асинхронно, в конце вызывается коллбэк, обрабатывающий результат работы асинхронной функции. В С++ тоже всё проще, там из футуры можно достать результат одним методом. Здесь всё как-то намного сложнее, а учебник даёт очень мало инфы.

С этим кодом много проблем.

async это такой сахар чтобы обозначить что функция или блок возвращает что-то что реализует трейт Future. Его есть смысл писать только если внутри есть await.

let mut j = &self.i; здесь ссылка неизменяемая, нужно let mut j = &mut self.i;

Ничего не делает потому что фючи ничего не делают если их не полить. Вот это вот выражение

    async {
        let mut c = Counter::new();
        block_on(c);
        c.count();
    };

Возвращает значение, реализующее Future. Ты с ним ничего не делаешь.

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

Спасибо.

То есть я правильно понимаю, что простого способа вытащить результат из футуры нет? Вот тут чувак на несколько десяток строк расписал обработчик футур, как я понимаю, без этого вообще никак? https://github.com/spacejam/extreme

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

[tokio::main]
async fn main() {
    // ...
}

Он разворачивается во что-то типа

fn main() {
    tokio::runtime::Runtime::new().unwrap().spawn(async {
        // ...
    });
}

Если прямо нужно понять как можно было бы подождать, то попробуй

let mut f = async {
    // code
};
let mut f = unsafe { Pin::new_unchecked(&mut f) };

loop {
    match f.poll() {
        Poll::Pending => (),
        Poll::Ready(x) => break x,
    }
}

Этот цикл вернет x – то, что возвращает тот асинк блок.

Я сам когда-то писал рантайм-планировщик для обучения. Но забросил, когда понял что также оптимально как tokio сделать очень трудно.

Статья в тему https://tokio.rs/blog/2019-10-scheduler

Увы, вот это работать не будет:

f.poll()

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

Спасибо. Один из немногих здесь стоящих ответов.

Хорошо объясняется тема - The Talk You’ve Been Await-ing for.