JSONL em Rust: serde_json, BufReader e Abstrações de Custo Zero

use rayon::prelude::*;
use serde::{Deserialize, Serialize};
use std::fs::File;
use std::io::{BufRead, BufReader, BufWriter, Write};

#[derive(Debug, Deserialize, Serialize)]
struct Record {
    id: u64,
    text: String,
    #[serde(default)]
    word_count: Option<usize>,
}

fn parallel_process_jsonl(
    input_path: &str,
    output_path: &str,
) -> anyhow::Result<usize> {
    // Passo 1: Lê todas as linhas na memória
    let file = File::open(input_path)?;
    let reader = BufReader::new(file);
    let lines: Vec<String> = reader.lines().collect::<Result<_, _>>()?;

    // Passo 2: Parseia e transforma em paralelo
    let processed: Vec<Record> = lines
        .par_iter()
        .filter(|line| !line.trim().is_empty())
        .filter_map(|line| {
            serde_json::from_str::<Record>(line.trim()).ok()
        })
        .map(|mut record| {
            record.word_count = Some(record.text.split_whitespace().count());
            record
        })
        .collect();

    // Passo 3: Escreve os resultados
    let file = File::create(output_path)?;
    let mut writer = BufWriter::new(file);
    let count = processed.len();

    for record in &processed {
        serde_json::to_writer(&mut writer, record)?;
        writer.write_all(b"\n")?;
    }
    writer.flush()?;

    Ok(count)
}

fn main() -> anyhow::Result<()> {
    let count = parallel_process_jsonl("input.jsonl", "output.jsonl")?;
    println!("Processados {} registros em paralelo", count);
    Ok(())
}

use serde::Deserialize;
use std::fs::File;
use std::io::{BufRead, BufReader};
use thiserror::Error;

#[derive(Error, Debug)]
enum JsonlError {
    #[error("Erro de I/O: {0}")]
    Io(#[from] std::io::Error),
    #[error("Erro de parse JSON na linha {line}: {source}")]
    Parse {
        line: usize,
        source: serde_json::Error,
    },
    #[error("Erro de validação na linha {line}: {message}")]
    Validation {
        line: usize,
        message: String,
    },
}

#[derive(Debug, Deserialize)]
struct Record {
    id: u64,
    name: String,
    value: f64,
}

fn validate_record(record: &Record, line: usize) -> Result<(), JsonlError> {
    if record.name.is_empty() {
        return Err(JsonlError::Validation {
            line,
            message: "nome não pode estar vazio".into(),
        });
    }
    if record.value < 0.0 {
        return Err(JsonlError::Validation {
            line,
            message: format!("valor deve ser não-negativo, recebeu {}", record.value),
        });
    }
    Ok(())
}

fn process_jsonl_with_errors(
    path: &str,
) -> Result<Vec<Record>, JsonlError> {
    let file = File::open(path)?; // Erro de Io convertido automaticamente via #[from]
    let reader = BufReader::new(file);
    let mut records = Vec::new();

    for (idx, line) in reader.lines().enumerate() {
        let line_num = idx + 1;
        let line = line?; // Propaga erros de I/O
        let trimmed = line.trim();
        if trimmed.is_empty() {
            continue;
        }

        let record: Record = serde_json::from_str(trimmed)
            .map_err(|e| JsonlError::Parse { line: line_num, source: e })?;

        validate_record(&record, line_num)?;
        records.push(record);
    }

    Ok(records)
}

fn main() {
    match process_jsonl_with_errors("data.jsonl") {
        Ok(records) => println!("Processados {} registros com sucesso", records.len()),
        Err(JsonlError::Io(e)) => eprintln!("Erro de arquivo: {}", e),
        Err(JsonlError::Parse { line, source }) => {
            eprintln!("Erro JSON na linha {}: {}", line, source);
        }
        Err(JsonlError::Validation { line, message }) => {
            eprintln!("Erro de validação na linha {}: {}", line, message);
        }
    }
}