main.rs

// Random code from https://docs.microsoft.com/en-ca/learn/paths/rust-first-steps/

use std::fmt;

trait Distance<T> {
    fn distance(&self) -> T;
}

#[derive(Debug, PartialEq)]
struct Point<T> {
    x: T,
    y: T
}

impl fmt::Display for Point<i32> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

impl fmt::Display for Point<f32> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

impl Distance<i32> for Point<i32> {
    fn distance(&self) -> i32 {
        return self.x * self.y
    }
}

impl Distance<f32> for Point<f32> {
    fn distance(&self) -> f32 {
        return self.x * self.y
    }
}

// fn foo<T>(v: T) -> T {
//     return v
// }

struct Numbers {
    current: i32,
    end: i32
}

impl Numbers {
    fn new(start: i32, end: i32) -> Numbers {
        Numbers {
            current: start,
            end: end
        }
    }
}

impl Iterator for Numbers {
    type Item = i32;

    fn next(&mut self) -> Option<i32> {
        if self.current == self.end {
            return None
        }

        let v = self.current;
        self.current += 1;
        Some(v)
    }
}

//

struct Container<T> {
    value: T,
}

impl<T> Container<T> {
    pub fn new(value: T) -> Self {
        Container { value }
    }
}

//

struct Groups<T> {
    inner: Vec<T>,
}

impl<T> Groups<T> {
    fn new(inner: Vec<T>) -> Self {
	    Groups { inner }
    }
}

impl<T: PartialEq> Iterator for Groups<T> {
    type Item = Vec<T>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.inner.is_empty() {
            return None
        }

        let mut out: Vec<T> = Vec::new();
        while !self.inner.is_empty() && (out.is_empty() || self.inner[0] == out[0]) {
            out.push(self.inner.remove(0))
        }
        Some(out)
    }
}

// fn next(&mut self) -> Option<Self::Item> {
//     if self.inner.is_empty() {
//         return None
//     }

//     let mut out: Vec<T> = Vec::new();
//     out.push(self.inner.remove(0));

//     while !self.inner.is_empty() && self.inner[0] == out[0] {
//         out.push(self.inner.remove(0))
//     }
    
//     Some(out)
// }


//

fn main() {
    let p1 = Point { x: 1, y: 2 };
    println!("{}", p1.distance());
 
    let p2 = Point { x: 1.0, y: 2.0 };
    println!("{}", p2.distance());

    let p3 = Point { x: 11.0, y: 22.0 };
    println!("{}", p3.distance());

    if p2 != p3 {
        println!("p2 {} != p3 {}", p2, p3);
    }

    let mut n = Numbers::new(100, 200);
    println!("{}", n.next().unwrap());
    println!("{}", n.next().unwrap());
    println!("{}", n.next().unwrap());

    for n in Numbers::new(7, 13) {
        println!("{}", n);
    }

    //

    assert_eq!(Container::new(42).value, 42);
    assert_eq!(Container::new(3.14).value, 3.14);
    assert_eq!(Container::new("Foo").value, "Foo");
    assert_eq!(Container::new(String::from("Bar")).value, String::from("Bar"));
    assert_eq!(Container::new(true).value, true);
    assert_eq!(Container::new(-12).value, -12);
    assert_eq!(Container::new(Some("text")).value, Some("text"));

    //

    let data = vec![4, 1, 1, 2, 1, 3, 3, -2, -2, -2, 5, 5];
    // groups:     |->|---->|->|->|--->|----------->|--->|
    assert_eq!(
	    Groups::new(data).into_iter().collect::<Vec<Vec<_>>>(),
	    vec![
	        vec![4],
    	    vec![1, 1],
	        vec![2],
    	    vec![1],
	        vec![3, 3],
	        vec![-2, -2, -2],
    	    vec![5, 5],
	    ]
    );

    let data2 = vec![1, 2, 2, 1, 1, 2, 2, 3, 4, 4, 3];
    // groups:      |->|---->|---->|----|->|----->|->|
    assert_eq!(
	    Groups::new(data2).into_iter().collect::<Vec<Vec<_>>>(),
	    vec![
	        vec![1],
    	    vec![2, 2],
	        vec![1, 1],
	        vec![2, 2],
    	    vec![3],
	        vec![4, 4],
	        vec![3],
	    ]
    )
}