Обмен UDP-сообщениями в Rust

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

Создадим сокеты на портах 7001 и 7002, передадим байты с одной стороны и примем их на другой:

use std::net::UdpSocket;

fn main() {
	let side_a = match UdpSocket::bind("127.0.0.1:7001") {
		Ok(s) => s,
		Err(_) => return,
	};
	let side_b = match UdpSocket::bind("127.0.0.1:7002") {
		Ok(s) => s,
		Err(_) => return,
	};
	match side_a.send_to(b"step", "127.0.0.1:7002") {
		Ok(_) => {}
		Err(_) => return,
	}
	let mut buf = [0u8; 16];
	match side_b.recv_from(&mut buf) {
		Ok((n, from)) => {
			println!("b got {} from {}", n, from);
		}
		Err(_) => return,
	}
}

Сторона b видит адрес отправителя и длину полезной нагрузки. Следующий шаг - ответить и прочитать ответ на первой стороне:

use std::net::UdpSocket;

fn main() {
	let side_a = match UdpSocket::bind("127.0.0.1:7001") {
		Ok(s) => s,
		Err(_) => return,
	};
	let side_b = match UdpSocket::bind("127.0.0.1:7002") {
		Ok(s) => s,
		Err(_) => return,
	};
	match side_a.send_to(b"go", "127.0.0.1:7002") {
		Ok(_) => {}
		Err(_) => return,
	}
	let mut buf = [0u8; 16];
	match side_b.recv_from(&mut buf) {
		Ok((_n, peer)) => {
			match side_b.send_to(b"back", peer) {
				Ok(_) => {}
				Err(_) => return,
			}
		}
		Err(_) => return,
	}
	match side_a.recv_from(&mut buf) {
		Ok((n, _)) => println!("a reply {}", n),
		Err(_) => {}
	}
}

Дан адрес:

let addr = "127.0.0.1:7002";

На 127.0.0.1:7001 передайте b"ping" на этот адрес, затем на стороне 7002 примите пакет и выведите длину полезных байт.

Дан адрес:

let addr = "127.0.0.1:7001";

Сделайте обмен: запрос с этого порта, ответ со второго на адрес из приема, затем прием ответа на первом порту. Напечатайте done после успешного чтения ответа.

Скажите, почему при UDP нельзя считать, что каждый отправленный пакет обязательно будет прочитан.