Rust на примерах — страница 51 из 65

collect()

Result реализует FromIter так что вектор из результатов (Vec>) может быть преобразован в результат с вектором (Result, E>). Если будет найдена хотя бы одна Result::Err, итерирование завершится.

fn main() {
let strings = vec!["tofu", "93", "18"];
let numbers: Result, _> = strings
.into_iter()
.map(|s| s.parse::())
.collect();
println!("Результаты: {:?}", numbers);
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Та же самая техника может использоваться с Option.

Сбор всех корректных значений и ошибок с помощьюpartition()

fn main() {
let strings = vec!["tofu", "93", "18"];
let (numbers, errors): (Vec<_>, Vec<_>) = strings
.into_iter()
.map(|s| s.parse::())
.partition(Result::is_ok);
println!("Числа: {:?}", numbers);
println!("Ошибки: {:?}", errors);
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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

fn main() {
let strings = vec!["tofu", "93", "18"];
let (numbers, errors): (Vec<_>, Vec<_>) = strings
.into_iter()
.map(|s| s.parse::())
.partition(Result::is_ok);
let numbers: Vec<_> = numbers.into_iter().map(Result::unwrap).collect();
let errors: Vec<_> = errors.into_iter().map(Result::unwrap_err).collect();
println!("Числа: {:?}", numbers);
println!("Ошибки: {:?}", errors);
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Типы стандартной библиотеки

Стандартная библиотека (std) предоставляет множество пользовательских типов, которые значительно расширяют примитивы. Некоторые из них:

   • расширяемую строку Strings: "hello world"

   • динамический массив: [1, 2, 3]

   • опциональные типы: Option

   • типы для обработки ошибок: Result

   • указатели на объекты в куче: Box

Смотрите также:

Примитивы и std

Box, стек и куча

Все значения в Rust по умолчанию располагаются на стеке. Значения могут быть упакованы (созданы в куче) при помощи Box. Box - это умный указатель на расположенное в куче значение типа T. Когда Box покидает область видимости, вызывается его деструктор, который уничтожает внутренний объект, и занятая им память в куче освобождается.

Упакованные значения могут быть разыменованы с помощью операции *. Эта операция убирает один уровень косвенности.

use std::mem;
#[allow(dead_code)]
#[derive(Debug, Clone, Copy)]
struct Point {
x: f64,
y: f64,
}
// `Rectangle` может быть определён по расположению в пространстве
// его верхнего левого и нижнего правого углов
#[allow(dead_code)]
struct Rectangle {
top_left: Point,
bottom_right: Point,
}
fn origin() -> Point {
Point { x: 0.0, y: 0.0 }
}
fn boxed_origin() -> Box {
// Аллоцируем точку в куче и вернём указатель на неё
Box::new(Point { x: 0.0, y: 0.0 })
}
fn main() {
// (все аннотации типов избыточны)
// Переменные, аллоцированные на стеке
let point: Point = origin();
let rectangle: Rectangle = Rectangle {
top_left: origin(),
bottom_right: Point { x: 3.0, y: -4.0 }
};
// Прямоугольник, аллоцированный в куче
let boxed_rectangle: Box = Box::new(Rectangle {
top_left: origin(),
bottom_right: Point { x: 3.0, y: -4.0 },
});
// Результат функции может быть упакован
let boxed_point: Box = Box::new(origin());
// Двойная косвенность
let box_in_a_box: Box> = Box::new(boxed_origin());
println!("Точка занимает {} байт на стеке",
mem::size_of_val(&point));
println!("Прямоугольник занимает {} байт на стеке",
mem::size_of_val(&rectangle));
// box size == pointer size
println!("Упакованная точка занимает {} байт на стеке",
mem::size_of_val(&boxed_point));
println!("Упакованный прямоугольник занимает {} байт на стеке",
mem::size_of_val(&boxed_rectangle));
println!("Упакованная 'упаковка' занимает {} байт на стеке",
mem::size_of_val(&box_in_a_box));
// Копируем данные из `boxed_point` в `unboxed_point`
let unboxed_point: Point = *boxed_point;
println!("Распакованная точка занимает {} байт на стеке",
mem::size_of_val(&unboxed_point));
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה