# Higher Order Functions

Rust provides Higher Order Functions (HOF). These are functions that take one or more functions and/or produce a more useful function. HOFs and lazy iterators give Rust its functional flavor.

    fn is_odd(n: u32) -> bool {
        n % 2 == 1
    }

    fn main() {
        println!("Find the sum of all the squared odd numbers under 1000");
        let upper = 1000;

        // Imperative approach
        // Declare accumulator variable
        let mut acc = 0;
        // Iterate: 0, 1, 2, ... to infinity
        for n in 0.. {
            // Square the number
            let n_squared = n * n;

            if n_squared >= upper {
                // Break loop if exceeded the upper limit
                break;
            } else if is_odd(n_squared) {
                // Accumulate value, if it's odd
                acc += n_squared;
            }
        }
        println!("imperative style: {}", acc);

        // Functional approach
        let sum_of_squared_odd_numbers: u32 =
            (0..).map(|n| n * n)                             // All natural numbers squared
                 .take_while(|&n_squared| n_squared < upper) // Below upper limit
                 .filter(|&n_squared| is_odd(n_squared))     // That are odd
                 .fold(0, |acc, n_squared| acc + n_squared); // Sum them
        println!("functional style: {}", sum_of_squared_odd_numbers);
    }

Option and Iterator implement their fair share of HOFs.