Use Display trait for printing errors

...instead of using the `description` method.

src/config.rs

-use std::error::Error;
 use std::fs::File;
 use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
     /// not exist.
     fn default_tile_cache_dir() -> Result<PathBuf, String> {
         let xdg_dirs = xdg::BaseDirectories::with_prefix("deltamap")
-            .map_err(|e| e.description().to_string())?;
+            .map_err(|e| format!("{}", e))?;
 
         match xdg_dirs.find_cache_file("tiles") {
             Some(dir) => Ok(dir),
                 )
             },
             Ok(_) => Err("TOML file has invalid structure. Expected a Table as the top-level element.".to_string()),
-            Err(e) => Err(e.description().to_string()),
+            Err(e) => Err(format!("{}", e)),
         }
     }
 
     pub fn from_toml_file<P: AsRef<Path>>(path: P) -> Result<Config, String> {
-        let mut file = File::open(path).map_err(|e| e.description().to_string())?;
+        let mut file = File::open(path).map_err(|e| format!("{}", e))?;
 
         let mut content = String::new();
-        file.read_to_string(&mut content).map_err(|e| e.description().to_string())?;
+        file.read_to_string(&mut content).map_err(|e| format!("{}", e))?;
 
         Config::from_toml_str(&content)
     }

src/main.rs

 use coord::ScreenCoord;
 use glutin::{ControlFlow, ElementState, Event, GlContext, MouseButton, MouseScrollDelta, VirtualKeyCode, WindowEvent};
 use map_view_gl::MapViewGl;
-use std::error::Error;
 use std::time::{Duration, Instant};
 use tile_source::TileSource;
 
             .validator(|s| {
                 s.parse::<f64>()
                     .map(|_| ())
-                    .map_err(|e| e.description().to_string())
+                    .map_err(|e| format!("{}", e))
             })
             .help("Set target frames per second (default is 60). \
                 This should equal the refresh rate of the display.")

src/program.rs

 use ::context;
 use context::Context;
-use std::error::Error;
 use std::ffi::CStr;
 use std::fs::File;
 use std::io::BufReader;
     pub fn from_paths<P: AsRef<Path>>(cx: &'a Context, vert_path: P, frag_path: P) -> Result<Program<'a>, String> {
         let vert_src = {
             let file = File::open(&vert_path)
-                .map_err(|e| e.description().to_string())?;
+                .map_err(|e| format!("{}", e))?;
             let mut reader = BufReader::new(file);
             let mut buf: Vec<u8> = vec![];
             reader.read_to_end(&mut buf)
-                .map_err(|e| e.description().to_string())?;
+                .map_err(|e| format!("{}", e))?;
             buf
         };
 
         let frag_src = {
             let file = File::open(&frag_path)
-                .map_err(|e| e.description().to_string())?;
+                .map_err(|e| format!("{}", e))?;
             let mut reader = BufReader::new(file);
             let mut buf: Vec<u8> = vec![];
             reader.read_to_end(&mut buf)
-                .map_err(|e| e.description().to_string())?;
+                .map_err(|e| format!("{}", e))?;
             buf
         };
 

src/tile_loader.rs

 use std::cmp::Ordering;
 use std::cmp;
 use std::collections::hash_set::HashSet;
-use std::error::Error;
 use std::fs::File;
 use std::io::Write;
 use std::path::{Path, PathBuf};
                                         }
                                         if let Err(e) = remote_request_tx.send(RemoteLoaderMessage::PopQueue) {
                                             //TODO what now? restart worker?
-                                            error!("remote worker terminated, {}", e.description());
+                                            error!("remote worker terminated, {}", e);
                                         }
                                     }
                                 } else if result_tx.send((request.tile, None)).is_err() {
 
                                     if request.write_to_file {
                                         if let Err(e) = Self::write_to_file(&request.path, &buf) {
-                                            warn!("could not write file {}, {}", request.path.display(), e.description());
+                                            warn!("could not write file {}, {}", request.path.display(), e);
                                         }
                                     }
 
                                     if write_to_file {
                                         let path = source.local_tile_path(tile);
                                         if let Err(e) = Self::write_to_file(&path, &buf) {
-                                            warn!("could not write file {}, {}", &path.display(), e.description());
+                                            warn!("could not write file {}, {}", &path.display(), e);
                                         }
                                     }
                                     debug!("sync ok from network {:?}", tile);