RUST: Using traits to implement generic Point<T> and Line<T> with a len() function that computes as f64.

main.rs

#![allow(dead_code)]
#![allow(unused_imports)]
use std::mem;
use std::ops;
use std::convert;

struct Point<T> {
    x: T,
    y: T
}

impl<T> Point<T> {
    fn new(x: T, y: T) -> Point<T> { Point { x: x, y: y } }
}

struct Line<T> {
    start: Point<T>,
    end: Point<T>
}

impl<T> Line<T> {
    fn new(x1: T, x2: T, y1: T, y2: T) -> Line<T> { Line { start: Point::new(x1, y1), end: Point::new(x2, y2) } }
}

impl<T:ops::Sub+convert::Into<f64>> Line<T> where f64: std::convert::From<<T as std::ops::Sub>::Output> {
    fn len(self) -> f64 {
        let dx:f64 = (self.start.x - self.end.x).into();
        let dy:f64 = (self.start.y - self.end.y).into();
        (dx * dx + dy * dy).sqrt()
    }
}

fn methods() {
    let ln = Line::new(1, 2, 5, 2);
    println!("{}", ln.len());
}

fn main() {
    methods();
}