When the Glider Never Stops Whispering Pressure

Imagine you’re strapped to a foam wing, and the BMP280 sensor is whispering pressure readings at 25 Hz. It will never stop. Not when you thermal. Not when you land. It produces an infinite sequence, and your job is to turn each sample into a pitch without drowning in memory.

This is the promise of lazy evaluation: describe the transformation, and the runtime computes only what you ask for. Haskell made this the default in 1990, but the idea traces back to Peter Henderson’s streams in 1980 and earlier work on demand-driven computation. The sensor doesn’t care about your memory budget — lazy streams do.

pressures :: [Double]
pressures = [1013.25, 1012.8, 1011.9, 1010.5, 1009.2, 1008.1]

toPitch :: Double -> Double
toPitch p = let alt = 44330 * (1 - (p / 1013.25) ** 0.1903)
            in 200 + (alt / 3000) * 600

main :: IO ()
main = print $ map toPitch pressures

The Haskell version is almost declarative: here’s a list, here’s a function, apply it. Nothing happens until print forces evaluation. The list could be infinite — map wouldn’t care.

Rust takes a different path: iterators are lazy by construction, but you must opt into each transformation explicitly.

fn main() {
    let pressures = [1013.25, 1012.8, 1011.9, 1010.5, 1009.2, 1008.1];
    let pitches: Vec<f64> = pressures.iter()
        .map(|&p| 44330.0 * (1.0 - (p / 1013.25_f64).powf(0.1903)))
        .map(|alt| 200.0 + (alt / 3000.0) * 600.0)
        .collect();
    println!("{:?}", pitches);
}

The .collect() is the forcing function here — without it, the chain remains a blueprint. Both versions output the same rising pitches as pressure drops: roughly [200, 201, 202, 205, 207, 209] Hz. The glider climbs; the tone rises.

The trade-off? Haskell’s laziness can hide space leaks if you’re not careful — thunks pile up like uncommitted flight logs. Rust makes you name your intentions, which is verbose but predictable. For a sensor stream running on an ESP32, Rust’s zero-cost iterators win. For rapid prototyping at the desk, Haskell’s brevity is hard to beat.

Either way, the lesson is the same: don’t materialise what you don’t need. The sky sends infinite data. Process it one thermal at a time.