#[derive(Debug)]
struct Data {
    data: Vec<f64>,
    ptr: usize,
}

impl Data {
    fn new(s: &[f64]) -> Data {
        Data {
            data: s.to_vec(),
            ptr: 0,
        }
    }
}

impl Data {
    fn add(&self, arg: f64) -> Data {
        let mut v = self.data.clone();

        for (i, x) in self.data.iter().enumerate() {
            v[i] = x + arg;
        }

        Data {
            data: v,
            ptr: 0,
        }
    }

    fn add_with_empty_vector(&self, arg:f64) -> Data {
        let mut v = vec![];

        for x in &self.data {
            v.push(x.clone() + arg);
        }

        Data {
            data: v,
            ptr: 0,
        }
    }
}

impl Iterator for Data {
    type Item = f64;

    fn next(&mut self) -> Option<Self::Item> {
        let rtn = if self.ptr < self.data.len() {
            Some(self.data[self.ptr])
        } else {
            None
        };

        self.ptr += 1;

        rtn
    }
}

trait Add : std::fmt::Debug {
    fn add(&self) {
        println!("{:?}", self);
    }
}

impl Add for Vec<f64> {
}

impl Add for [f64] {
    fn add(&self) {
        println!("{:?} as a slice", self);
    }
}

fn main() {
    let v = vec![1.0, 2.0, 3.0];

    let data = Data::new(&v);

    println!("{:?}", data.add(2.0));
    println!("{:?}", data.add(2.0).data);

    println!("{:?}", data.add_with_empty_vector(3.0));
    println!("{:?}",
            data.add_with_empty_vector(3.0).data);

    v.add();

    &v[..].add();
}