На Rust запилили Coroutine, Go можно выкидывать?

На этот случай есть map, map_err и т.д

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

Хотя если судить на «месиво» (с) из unwrap() в типичном коде на rust, то там просто предпочитают забивать на обработку ошибок.

Так что вот - писать сурьезные игры и подобные по требованиям к быстродействию штуки.

Кроме игр ничего не интересует?

подобные по требованиям к быстродействию штуки

На окамле, эрланге и жабе не пишут всякие сверхнагруженные сервисы? Я что-то пропустил?

Я что-то пропустил?

Да много чего, судя по комментариям.

Ниша у С/С++ есть и это не только игры. Вот на неё раст и претендует.

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

Зачем добавлять вложенность?

let result = accept().map(|client| /*что-то делаем*/).map(...);

Пачка вложенных match будет?

Как напишешь так и будет. Как обойтись без вложенности я показал. Есть ещё макрос try!.

А ты уверен, что в итоге код на rust быстрее будет? Если нет - то все эти размышления ни о чем.

Причём тут вообще быстрее? Я о корректности. В С/С++ ведь тоже можно проверять указатели перед использованием, но бывают ошибки. В статических анализаторах (можно хотя бы посмотреть на PVS благо они любят пиарится результатами) есть как раз проверки на «указатель проверяется после использования» и подобные.

А в расте ты просто не можешь использовать не проверив.

просто предпочитают забивать на обработку ошибок.

Ну передёргивать-то не надо.

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

Ну и unwrap - это далеко не всегда плохо. Случаев когда ошибку непонятно как обрабатывать (на данном уровне) хватает. Другие дело, что растовая паника - не совсем исключение.

let result = accept().map(|client| /*что-то делаем*/).map(...);

Одна из вещей, которые мне не нравятся в Rust - длинный унылый чейнинг.

Как обойтись без вложенности я показал.

Да, длиннее и нечитабельнее чем в Go.

Есть ещё макрос try!.

Есть, только это уже не обработка ошибки, а заметание лишних match под коврик для проброски ошибок.

Я о корректности.

В примере на Go все корректно, нет клиента - сообщаем об этом. Есть - работаем с ним.

А в расте ты просто не можешь использовать не проверив.

Ага, .unwrap().unwrap().unwrap()... С этого вроде обсуждение и началось.

Да, длиннее и нечитабельнее чем в Go.

А покажи, почему в Go не будет пачки вложенных if при проверке ошибок.

А покажи, почему в Go не будет пачки вложенных if при проверке ошибок.

«continue»

длинный унылый чейнинг.

Хочешь как в хаскеле?

А в расте ты просто не можешь использовать не проверив.

И кстати о корректности, я у себя проверил главное - что мне есть с чем работать, а ты на rust проверяешь есть ли ошибка, а вот есть ли с чем после проверки работать - нет. Какой код по-твоему надежнее?

Да, длиннее и нечитабельнее чем в Go.

Ну давай сравним на немного большем примере. Пока что я не уверен.

Есть, только это уже не обработка ошибки, а заметание лишних match под коврик для проброски ошибок.

Почему не обработка? Точно так же как в Го if err != nil return.

В примере на Go все корректно, нет клиента - сообщаем об этом. Есть - работаем с ним.

Издеваешься или правда не понял? В твоём случае (а так же в С/С++) корректность обеспечивается руками. В расте - самим языком.

Ага, .unwrap().unwrap().unwrap()... С этого вроде обсуждение и началось.

Это не игнорирование, unwrap - это паника. Просто быстрый способ залогировать и завершиться.

«continue»

Кинь ссылку где об этом почитать, а то гуглятся только циклы.

Издеваешься или правда не понял? В твоём случае (а так же в С/С++) корректность обеспечивается руками. В расте - самим языком.

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

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

Какой код по-твоему надежнее?

Ещё раз - в расте нельзя использовать значение enum («варианта») без проверки. Я просто изобразил точный аналог твоего кода. Если нам хочет как-то обрабатывать и ошибку и результат, то надо матчить. Ну если ты не захочешь писать if let на каждый вариант.

Так что, разумеется, надежнее вариант раста.

Это не игнорирование, unwrap - это паника.

Так это уже совсем другой вопрос - к чему приводит игнорирование ошибок.

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

Нет, это ты просто не понял. Перечитай и спроси, если останутся вопросы.

Go уже взлетел и уже начинает меня раздражать своей популярностью

Ничё. Тут один человечек уже 4 месяц работу на Ruby ищет (не на саппорт старых, а именно на что-то новое)...а как руби взлетал!

А Go реально взлетит, если НА НЕМ, Б...Ь, АНДРОИД ПЕРЕПИШУТ. Или хотябы позволят ваять на нем свои поделки с гуйней и доступом к системе.

Rust будет игрушкой до тех пор пока не будет серьезных проектов.

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

Так это уже совсем другой вопрос - к чему приводит игнорирование ошибок.

Ну так это не игнорирование. unwrap - это ты говоришь «если тут нет значения, то залогируй и завершись». «Fail fast» - это тоже вид обработки.

Не говоря уже о том, что панику можно и перехватить.

Ещё раз - в расте нельзя использовать значение enum («варианта») без проверки

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

Так что, разумеется, надежнее вариант раста.

Окай.

Это и есть пример «парадокса блаба»? ))

А покажи, почему в Go не будет пачки вложенных if при проверке ошибок.

«continue»

Веско, ага.

Посмотрел исходники net/http - глубокая вложенность if обходится тупым return.

Это и есть пример «парадокса блаба»? ))

Похоже на то. (:

Заявления про то, что модули и карго не нужны из той же оперы.

длинный унылый чейнинг.

Хочешь как в хаскеле?

Я хочу как в шелле :)

Посмотрел исходники net/http - глубокая вложенность if обходится тупым return.

Именно. А теперь попробуй использовать match для return и продолжения вычислений.

Это и есть пример «парадокса блаба»? ))

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

Посмотрел исходники net/http - глубокая вложенность if обходится тупым return.

Именно.

Заметание лишних if под коврик для проброски ошибок. Только разница в том, что проброс ошибок в случае Rust удобнее за счет ADT.

А теперь попробуй использовать match для return и продолжения вычислений

try!

Кроме игр ничего не интересует?

Лично меня? Тип того, по крайней мере в рамках программирования)

На окамле, эрланге и жабе не пишут всякие сверхнагруженные сервисы? Я что-то пропустил?

А при чем тут это?

Ну вот ты проверил - все ок, а результат null.

Я всё-таки попробую обьяснить. Смотри - вот так нельзя:

let a: Result<i32, String> = Ok(10); // тип для наглядности
if let Err(err) = a {
    println!("Error = {}", err);
}
    
println!("{}", a); // ошибка компиляции

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

Надеюсь, что тебе станет стыдно когда поймёшь, что был не прав.

В rust нет нулевого указателя. Вы совершенно не понимаете того, о чем спорите.

В rust нет нулевого указателя. Вы совершенно не понимаете того, о чем спорите.

Заползи под коврик:

https://doc.rust-lang.org/std/ptr/fn.null.html

Заодно посмотри сколько в том же servo или стандартной библиотеке unsafe кода. Не говоря уже про обертки над сишными либами.

проброс ошибок в случае Rust удобнее за счет ADT.
try!

Ну если рассматривать исключительно проброс ошибок, то Go тут сливает Rust. Впрочем последний тут уже сливает, например, Java.

continue

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

for _ in 0 .. 10 {
    let client = match listener.accept() {
        Ok(c) => c,
        Err(e) => {
            println!("Couldn't accept: {}", e);
            continue;
        }
    };
    println!("Connection: {}!", client);
}

Хотя если судить на «месиво» (с) из unwrap() в типичном коде на rust, то там просто предпочитают забивать на обработку ошибок.

Ты точно много читал «типичного кода» на ржавчине? ))

В статьях unwrap() используют для краткости.

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

Жуть-то какая, хосподя.

Впрочем последний тут уже сливает, например, Java.

Так ведь в джаве исключения. В плане «проброса» они ничем не лучше паники из Go и раста. Разве нет?

Вот с обработкой лучше дела обстоят.

серво, сам раст, карго

Весьма слабовато, но пока есть еще шанс не стать новым Lisp.

Я всё-таки попробую обьяснить. Смотри - вот так нельзя:

Б%дь, ну нельзя же быть таким тугим.

https://play.rust-lang.org/?code=fn main() {%0A%20%20%20%20let%20a%3A%20Result%3Ci32%2C%20String%3E%20%3D%20Ok%2810%29%3B%0A%20%20%20%20if%20let%20Err%28err%29%20%3D%20a%20{%0A%20%20%20%20%20%20%20%20println!%28%22Error%20%3D%20{}%22%2C%20err%29%3B%0A%20%20%20%20}%0A%20%20%20%20%0A%20%20%20%20println!%28%22{}%22%2C%20a%29%3B%0A}%0A&version=stable

application terminated with error code 101

WTF спросишь ты, а я скажу - нужно проверять результат. Дошло?

Вместо битой ссылки:

fn main() {
    let a: Result<i32, String> = Ok(0);
    
    match a {
        Ok(v) => {
            println!("{}", 1/v);
        }
        Err(e) => {
            println!("error parsing header: {:?}", e);
        }
    }
}

Мде. Оказывается, целую страницу речь шла о такой банальщине.

Заявления про то, что модули и карго не нужны из той же оперы.

А вот у вас, похоже, как раз культ карго =) Вас спрашивают «зачем», а вы не можете привести примеров. И объяснить не можете.

// другой анонимус

https://doc.rust-lang.org/std/ptr/fn.null.html

Заодно посмотри сколько в том же servo или стандартной библиотеке unsafe кода. Не говоря уже про обертки над сишными либами.

Т.е. по твоему типичный код на ржавчине - это ffi и низкоуровневые оптимизации? :)

Где ты работаешь с сырыми указателями - не помешает их проверить. И где деление на ноль может быть - тоже. С этим никто не спорит.

Тебе явно надо учиться выражать свои мысли.

Только разница в том, что проброс ошибок в случае Rust удобнее за счет ADT.

Так в чем удобство, если if + return нагляднее вашей лапши на Rust? Зачем усложнять?

Так в чем удобство, если if + return нагляднее вашей лапши на Rust?

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

А при чем тут это?

При том, что в окамле, эрланге и жабе есть сборщик мусора(а именно о нем был разговор)