Fix clippy warnings

src/coord.rs

 
         TileCoord {
             zoom: self.zoom,
-            x: x,
-            y: y,
+            x,
+            y,
         }
     }
 

src/main.rs

                             input_state.mouse_position.x * input_state.dpi_factor,
                             input_state.mouse_position.y * input_state.dpi_factor,
                         ),
-                        f64::from(delta.y) * (1.0 / 320.0),
+                        delta.y * (1.0 / 320.0),
                     );
                 }
                 Action::Redraw

src/ortho_tile_layer.rs

     fn new(view_center: LatLonRad, viewport_size: (u32, u32), sphere_radius: f64, lat: f64) -> Self {
         LatScreenEllipse {
             center: ScreenCoord {
-                x: viewport_size.0 as f64 * 0.5,
-                y: viewport_size.1 as f64 * 0.5 * (lat - view_center.lat).sin() * sphere_radius,
+                x: f64::from(viewport_size.0) * 0.5,
+                y: f64::from(viewport_size.1) * 0.5 * (lat - view_center.lat).sin() * sphere_radius,
             },
             radius_x: lat.cos() * sphere_radius,
             radius_y: lat.cos() * -view_center.lat.sin() * sphere_radius,

src/orthografic_view.rs

         //TODO Add a little safety margin since the rendered globe is not a perfect sphere and its
         // screen area is underestimated by the tesselation.
         let sphere_diameter = 2.0f64.powf(map_view.zoom) *
-            (f64::consts::FRAC_1_PI * map_view.tile_size as f64);
+            (f64::consts::FRAC_1_PI * f64::from(map_view.tile_size));
 
-        return map_view.width.hypot(map_view.height) < sphere_diameter;
+        map_view.width.hypot(map_view.height) < sphere_diameter
     }
 
     /// Returns the tile zoom value that is used for rendering with the current zoom.
 
             if vertices.iter().all(|v| v.z > 0.0) {
                 // Tile is on the backside of the sphere
-                return false;
+                false
             } else {
-                return vertices.iter().any(&point_on_screen);
+                vertices.iter().any(&point_on_screen)
             }
         };
 
 
         let mut neighbors = Vec::with_capacity(4);
 
-        loop {
-            if let Some(tn) = stack.pop() {
-                match tn {
-                    TileNeighbor::Coord(tc) => {
-                        if tile_is_visible(tc) {
-                            tiles.push(tc.into());
-                            tile_neighbors(tc, &mut neighbors);
-                            for tn in &neighbors {
-                                if !visited.contains(tn) {
-                                    visited.insert(*tn);
-                                    stack.push(*tn);
-                                }
-                            }
+        while let Some(tn) = stack.pop() {
+            if let TileNeighbor::Coord(tc) = tn {
+                if tile_is_visible(tc) {
+                    tiles.push(tc.into());
+                    tile_neighbors(tc, &mut neighbors);
+                    for tn in &neighbors {
+                        if !visited.contains(tn) {
+                            visited.insert(*tn);
+                            stack.push(*tn);
                         }
-                    },
-                    _ => {},
+                    }
                 }
-            } else {
-                break;
             }
         }
 
     }
 
     pub fn radius_physical_pixels(map_view: &MapView) -> f64 {
-        2.0f64.powf(map_view.zoom) * (FRAC_1_PI * map_view.tile_size as f64)
+        2.0f64.powf(map_view.zoom) * (FRAC_1_PI * f64::from(map_view.tile_size))
     }
 
     pub fn transformation_matrix(map_view: &MapView) -> Matrix3<f64> {
             )
         };
 
-        let transform = Transform::<Point3<f64>>::concat(&rot_mat_y, &rot_mat_x);
-        let transform = Transform::<Point3<f64>>::concat(&scale_mat, &transform);
-        transform
+        Transform::<Point3<f64>>::concat(
+            &scale_mat,
+            &Transform::<Point3<f64>>::concat(&rot_mat_y, &rot_mat_x)
+        )
     }
 }
 

src/projection.rs

+use std::str::FromStr;
+
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum Projection {
     Orthografic,
 }
 
-
 impl Projection {
     pub fn to_str(&self) -> &str {
         match *self {
             Projection::Orthografic => "orthografic",
         }
     }
+}
+
+impl FromStr for Projection {
+    type Err = ();
 
-    pub fn from_str(s: &str) -> Option<Projection> {
+    fn from_str(s: &str) -> Result<Self, ()> {
         match s {
-            "mercator" => Some(Projection::Mercator),
-            "orthografic" => Some(Projection::Orthografic),
-            _ => None,
+            "mercator" => Ok(Projection::Mercator),
+            "orthografic" => Ok(Projection::Orthografic),
+            _ => Err(()),
         }
     }
 }

src/session.rs

 use std::fs::File;
 use std::io::Read;
 use std::path::Path;
+use std::str::FromStr;
 use toml::Value;
 use toml::value::Table;
 use toml;
 
                 let projection = match view.get("projection") {
                     Some(&Value::String(ref s)) => {
-                        Projection::from_str(s).unwrap_or_else(|| Projection::Mercator)
+                        Projection::from_str(s).unwrap_or_else(|_| Projection::Mercator)
                     },
                     Some(_) => return Err("projection has to be a string.".to_string()),
                     None => Projection::Mercator,