// iterators4.rs
// Execute `rustlings hint iterators4` or use the `hint` watch subcommand for a hint.

pub fn factorial(num: u64) -> u64 {
    // Complete this function to return the factorial of num
    // Do not use:
    // - return
    // Try not to use:
    // - imperative style loops (for, while)
    // - additional variables
    // For an extra challenge, don't use:
    // - recursion
    // Execute `rustlings hint iterators4` for hints.
    (1..num + 1).fold(1, |a, b| a * b)
    // Explicación con ejemplo factorial(4):
    // (1..num + 1) es la iteración (1, 2, 3, 4) porque:
    // * La iteración tiene un límite de elementos igual a num + 1, en este caso 5:
    // * (0, 1, 2, 3, 4) => 5 elementos
    // * Sin embargo, solo toma a partir del elemento 1:
    // * (1, 2, 3, 4)
    // * Una manera más elegante es:
    //   (1..=num), demostración:
    //   assert_eq!((1..num + 1), (1..=num));
    // De ahí el fold realiza la siguiente multiplicación:
    // ((((1 * 1) * 2) * 3) * 4)
    // * El primer argumento de fold es 1 y este corresponde al primer 1 en (1 * 1)
    // * La variable 'a' es el resultado acumulativo de a * b
    // * La variable 'b' es cada uno de los elementos del iterador (1, 2, 3, 4)
    // Una opción más sintética hubiera sido:
    // (1..=num).product()
    // Sin embargo, el hint pidió revisar los métodos 'fold' y 'rfold'…
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn factorial_of_0() {
        assert_eq!(1, factorial(0));
    }

    #[test]
    fn factorial_of_1() {
        assert_eq!(1, factorial(1));
    }
    #[test]
    fn factorial_of_2() {
        assert_eq!(2, factorial(2));
    }

    #[test]
    fn factorial_of_4() {
        assert_eq!(24, factorial(4));
    }
}