[Rust] std::iter::{Iterator, IntoIter}

https://ideone.com/30uZwT

---

use std::fmt;
use std::iter;
 
 
struct LinearFunctionIterator {
    fun: LinearFunction,
    x: i32,
    end: i32,
}
 
impl LinearFunctionIterator {
    fn new(fun: LinearFunction, begin: i32, end: i32) -> LinearFunctionIterator {
        LinearFunctionIterator {
            fun: fun,
            x: begin,
            end: end,
        }
    }
}
 
impl iter::Iterator for LinearFunctionIterator {
    type Item = f64;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.x == self.end {
            return None
        }
        
        let result = self.fun.feed(self.x as f64);
        
        if self.x < self.end {
            self.x += 1;
        }
        else {
            self.x -= 1;
        }
        
        return Some(result);
    }
}
 
 
struct LinearFunction {
    a: f64,
    b: f64,
}
 
impl LinearFunction {
    fn new(a: f64, b: f64) -> LinearFunction {
        LinearFunction {
            a: a,
            b: b,
        }
    }
 
    fn feed(&self, x: f64) -> f64 {
        self.a * x + self.b
    }
}
 
impl fmt::Display for LinearFunction {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "f(x) = {} * x + {}", self.a, self.b)
    }
}
 
impl iter::IntoIterator for LinearFunction {
    type Item = f64;
    type IntoIter = LinearFunctionIterator;
    
    fn into_iter(self) -> Self::IntoIter {
        LinearFunctionIterator::new(self, 0, 10)
    }
}
 
 
fn main() {
    let fun = LinearFunction::new(2.0, 1.0);
    println!("{}", fun);
    
    for y in fun.into_iter() {
        println!("{}", y.round());
    }
}

---

std::fmt::Display는 덤

IntoIter의 단점이라면 into_iter가 self를 받기 때문에 소유권이 넘어가서 한번 호출하면 다시 쓰기 귀찮다는거?