Time-series data structures in Rust require careful consideration of performance, memory usage, and data organization. I’ll share practical techniques for building robust time-series systems using Rust’s powerful features.

Ring buffers serve as efficient containers for recent time-series data. These circular structures maintain a fixed-size window of the most recent values while automatically discarding older entries. Here’s an implementation that handles both data and timestamps:

pub struct TimeSeriesBuffer<T> {
    data: Vec<T>,
    timestamps: Vec<u64>,
    head: usize,
    capacity: usize,
}

impl<T: Clone + Default> TimeSeriesBuffer<T> {
    pub fn new(capacity: usize) -> Self {
        Self {
            data: vec![T::default(); capacity],
            timestamps: vec![0; capacity],
            head: 0,
            capacity,
        }
    }

    pub fn push(&mut self, timestamp: u64, value: T) {
        self.data[self.head] = value;
        self.timestamps[self.head] = timestamp;
        self.head = (self.head + 1) % self.capacity;
    }
}

Compression becomes essential when dealing with large datasets. Delta encoding proves particularly effective for time-series data by storing differences between consecutive values rather than absolute values:

pub struct TimeSeriesCompressor {
    previous_value: i64,
    previous_timestamp: u64,
}

impl TimeSeriesCompressor {
    pub fn compress(&mut self, timestamp: u64, value: i64) -> CompressedPoint {
        let delta_time = timestamp - self.previous_timestamp;
        let delta_value = value - self.previous_value;
        
        self.previous_timestamp = timestamp;
        self.previous_value = value;
        
        CompressedPoint {
            delta_time,
            delta_value,
        }
    }
}

Memory-mapped files offer excellent performance for large-scale time-series storage. This approach allows direct file access without loading entire datasets into memory:

use memmap2::MmapMut;
use std::collections::BTreeMap;

pub struct TimeSeriesStorage {
    mmap: MmapMut,
    index: BTreeMap<u64, usize>,
}

impl TimeSeriesStorage {
    pub fn write(&mut self, timestamp: u64, data: &[u8]) -> std::io::Result<()> {
        let offset = self.mmap.len();
        self.mmap.extend_from_slice(data)?;
        self.index.insert(timestamp, offset);
        Ok(())
    }
}

Time-based bucketing helps organize data efficiently. This technique groups data points into time intervals, improving query performance and storage efficiency:

pub struct TimeBucket {
    start_time: u64,
    duration: u64,
    data: Vec<TimePoint>,
}

impl TimeBucket {
    pub fn add_point(&mut self, timestamp: u64, value: f64) -> bool {
        if self.contains(timestamp) {
            self.data.push(TimePoint { timestamp, value });
            true
        } else {
            false
        }
    }
    
    fn contains(&self, timestamp: u64) -> bool {
        timestamp >= self.start_time && timestamp < self.start_time + self.duration
    }
}

Statistical aggregations form a crucial part of time-series analysis. This implementation provides efficient computation of common metrics:

pub struct TimeSeriesAggregator {
    count: u32,
    sum: f64,
    min: f64,
    max: f64,
    sum_squares: f64,
}

impl TimeSeriesAggregator {
    pub fn update(&mut self, value: f64) {
        self.count += 1;
        self.sum += value;
        self.min = self.min.min(value);
        self.max = self.max.max(value);
        self.sum_squares += value * value;
    }
    
    pub fn mean(&self) -> f64 {
        self.sum / self.count as f64
    }
    
    pub fn variance(&self) -> f64 {
        (self.sum_squares / self.count as f64) - self.mean().powi(2)
    }
}

Downsampling reduces data resolution while preserving important characteristics. This implementation supports various reduction methods:

pub enum DownsampleMethod {
    Mean,
    Max,
    Min,
    First,
    Last,
}

pub struct TimeSeriesDownsampler {
    method: DownsampleMethod,
    window_size: usize,
}

impl TimeSeriesDownsampler {
    pub fn process(&self, values: &[f64]) -> Vec<f64> {
        values.chunks(self.window_size)
            .map(|chunk| match self.method {
                DownsampleMethod::Mean => chunk.iter().sum::<f64>() / chunk.len() as f64,
                DownsampleMethod::Max => chunk.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(b)),
                DownsampleMethod::Min => chunk.iter().fold(f64::INFINITY, |a, &b| a.min(b)),
                DownsampleMethod::First => chunk[0],
                DownsampleMethod::Last => chunk[chunk.len() - 1],
            })
            .collect()
    }
}

These techniques combine to create a robust foundation for time-series applications. The implementations prioritize performance while maintaining clean, idiomatic Rust code. They can be customized and extended based on specific requirements.

Consider thread safety, error handling, and proper resource management when implementing these patterns in production systems. Regular benchmarking and profiling help identify bottlenecks and optimization opportunities.

Remember to implement proper testing strategies for each component. Property-based testing proves particularly valuable for time-series implementations, ensuring correctness across various data patterns and edge cases.

The provided implementations serve as building blocks. Combine them thoughtfully based on your specific use case, data volumes, and performance requirements. Monitor memory usage and adjust buffer sizes and compression ratios accordingly.