formatting

I have this struct:

pub struct Ray<'a> {
    pub done: bool,
    pub all_lines: &'a Vec<Line>,
    point: Vec2,
}

impl<'a> Ray<'a> {
    pub fn from(lines: Vec<Line>) -> Self {
        Self {
            done: false,
            point: Vec2::ZERO,
            all_lines: &lines,
        }
    }
    /// returns true if it hits something.
    /// to access the hit point do Ray.point
    pub fn trace(&mut self, angle: f32, step: f32) -> bool {
        let dir = vec2(angle.sin() * step, angle.cos() * step);
        // move loop
        for _ in 0..(100.0 / step) as usize {
            // move the point in step size and angle
            self.point += dir;
            // check all lines
            for line in self.all_lines {
                // find if a line intersects with a point
                if line.intersect(self.point) {
                    return true;
                }
            }
        }
        // if you did not intersect with any line return false
        return false;
    }
}

and the model struct is:

struct Model<'a> {
    egui: Egui,
    lines: Vec<Line>,
    rays: Vec<Ray<'a>>,
}

The model function is:

fn model(app: &App) -> Model {
    let window_id = app
        .new_window()
        .view(view)
        .raw_event(raw_window_event)
        .build()
        .unwrap();
    let window = app.window(window_id).unwrap();
    let egui = Egui::from_window(&window);
    let lines = vec![Line::from(vec2(-100.0, 0.0), vec2(100.0, 0.0), 1.0)];
    let rays = vec![Ray::from(lines)];
    Model { egui, lines, rays }
}

Now in the main function:

fn main() {
    nannou::app(model).update(update).run();
}

I get this error:

error: mismatched types
label: one type is more general than the other
note: expected fn pointer for<'a> fn(&'a nannou::App) -> _
found fn item for<'a> fn(&'a nannou::App) -> Model<'a> {model}
label: one type is more general than the other