fn main() {
    let a = (1i32..10).sum();
    let b = a.pow(2);
}

fn sum<S>(self) -> S
    where S: Sum<Self::Item>

impl Sum<i8> for i8
impl<'a> Sum<&'a i8> for i8

#[derive(Debug, Copy, Clone)]
struct Points(i32);

impl std::iter::Sum<u8> for Points {
    fn sum<I>(iter: I) -> Points
        where I: Iterator<Item = u8>
    {
        let mut pts = Points(0);
        for v in iter {
            pts.0 += v as i32;
        }
        pts
    }
}

fn main() {
    let total: Points = (0u8..42u8).sum();
    println!("{:?}", total);
}

#[derive(Clone,Copy)]
struct Summer {
    s: isize,
}

impl Summer {
    fn pow(&self, p: isize) {
        println!("pow({})", p);
    }
}

impl std::iter::Sum<i32> for Summer {
    fn sum<I>(iter: I) -> Self
        where I: Iterator<Item=i32>
    {
        let mut result = 0isize;
        for v in iter {
            result += v as isize;
        }
        Summer{ s: result  }
    }
}

fn main() {
    let a1:i32 = (1i32..10).sum();
    let a2:Summer = (1i32..10).sum();
    let b1 = a1.pow(2);
    let b2 = a2.pow(2);
}