7 промтов для Rust: системное программирование, CLI и WebAssembly

Напиши на Rust парсер INI-файла. Требования:
- Используй только std (без внешних крейтов).
- Возвращай Result с кастомной ошибкой для каждого типа сбоя (отсутствие секции, дубликат ключа, неверный формат).
- Пример входных данных: [server] host = 127.0.0.1 port = 8080
- Вывод: HashMap<String, HashMap<String, String>>

use std::collections::HashMap;

#[derive(Debug)]
pub enum IniError {
    MissingSection(String),
    DuplicateKey { section: String, key: String },
    ParseError { line: usize, message: String },
}

pub fn parse_ini(input: &str) -> Result<HashMap<String, HashMap<String, String>>, IniError> {
    let mut result = HashMap::new();
    let mut current_section = String::from("global");
    // ... логика парсинга с возвратом Err при ошибках
    Ok(result)
}

Напиши программу, которая принимает список файлов через аргументы командной строки и выводит количество строк в каждом. Используй std::env::args и BufReader. Если файл не найден — выведи ошибку в stderr и продолжи.

use std::fs::File;
use std::io::{BufRead, BufReader};

fn count_lines(path: &str) -> std::io::Result<usize> {
    let file = File::open(path)?;
    let reader = BufReader::new(file);
    Ok(reader.lines().count())
}

fn main() {
    let args: Vec<String> = std::env::args().collect();
    for arg in &args[1..] {
        match count_lines(arg) {
            Ok(n) => println!("{}: {}", arg, n),
            Err(e) => eprintln!("Ошибка при чтении {}: {}", arg, e),
        }
    }
}

Используя крейты reqwest (версия 0.12) и tokio, создай функцию fetch_with_retry(url: &str, max_retries: u32) -> Result<String>. При ошибках транспорта (не 4xx) делай повтор с экспоненциальной задержкой. Таймаут на запрос — 5 секунд.

use reqwest::Client;
use tokio::time::{sleep, Duration};

pub async fn fetch_with_retry(url: &str, max_retries: u32) -> anyhow::Result<String> {
    let client = Client::builder()
        .timeout(Duration::from_secs(5))
        .build()?;

    for attempt in 0..max_retries {
        let resp = client.get(url).send().await;
        match resp {
            Ok(r) if r.status().is_success() => return Ok(r.text().await?),
            Ok(r) if r.status().is_client_error() => return Err(anyhow::anyhow!("4xx ошибка: {}", r.status())),
            _ => {
                if attempt < max_retries - 1 {
                    sleep(Duration::from_secs(2u64.pow(attempt))).await;
                }
            }
        }
    }
    Err(anyhow::anyhow!("Все попытки исчерпаны"))
}

Используя крейт clap версии 4.5, опиши структуру Args: входной файл (String), выходной формат (enum: PNG, JPEG, WEBP), качество (u8, от 1 до 100, по умолчанию 85). Добавь автоматическую генерацию подсказки --help.

use clap::Parser;

#[derive(Parser, Debug)]
#[command(name = "imgconv")]
pub struct Args {
    #[arg(short, long)]
    input: String,

    #[arg(short, long, default_value = "png")]
    format: ImageFormat,

    #[arg(short, long, default_value_t = 85, value_parser = clap::value_parser!(u8).range(1..=100))]
    quality: u8,
}

#[derive(clap::ValueEnum, Clone, Debug)]
pub enum ImageFormat {
    Png,
    Jpeg,
    Webp,
}

Напиши на Rust функцию, которая принимает через WASM указатель на массив f64 и его длину, вычисляет сумму и среднее, возвращает через структуру. Используй #[no_mangle] и extern "C". Избегай сериализации — работай напрямую с памятью.

#[no_mangle]
pub extern "C" fn process_array(ptr: *const f64, len: usize) -> f64 {
    let slice = unsafe { std::slice::from_raw_parts(ptr, len) };
    let sum: f64 = slice.iter().sum();
    sum / len as f64
}

Создай структуру Cache<K, V>, где K: Hash + Eq + Clone, V: Clone. Используй RwLock<HashMap<K, (V, Instant)>>. Методы: get(key) -> Option<V>, set(key, V, ttl: Duration). При get проверяй TTL и удаляй просроченные записи. Добавь автоматическую очистку раз в 10 минут через фоновый поток.

use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use std::time::{Duration, Instant};

pub struct Cache<K, V> {
    inner: Arc<RwLock<HashMap<K, (V, Instant)>>>,
    cleanup_interval: Duration,
}

impl<K: Hash + Eq + Clone, V: Clone> Cache<K, V> {
    pub fn new(cleanup_interval: Duration) -> Self {
        // ... запуск фонового потока с tokio или std::thread
    }

    pub fn get(&self, key: &K) -> Option<V> {
        let map = self.inner.read().ok()?;
        map.get(key).and_then(|(v, expiry)| {
            if Instant::now() < *expiry { Some(v.clone()) } else { None }
        })
    }
}

Оберни C-функции libpng в безопасный Rust-интерфейс. Используй std::ffi::CStr, std::ptr::NonNull, и drop-флаги для предотвращения утечек. Реализуй структуру PngImage с полями width, height, pixels: Vec<u8>. Обработай ошибки через errno.

use std::ffi::CStr;
use std::ptr::NonNull;

pub struct PngImage {
    width: u32,
    height: u32,
    pixels: Vec<u8>,
    raw: NonNull<libc::c_void>, // указатель на внутренние данные libpng
}

impl Drop for PngImage {
    fn drop(&mut self) {
        unsafe { libpng_sys::png_destroy_read_struct(&mut self.raw.as_ptr(), ...) }
    }
}