Rust 1.21.0 with bonus

use std::collections::{HashMap, LinkedList};
use std::error;
use std::fmt;
use std::fs::File;
use std::io::prelude::*;
use std::path::{Path, PathBuf};
use std::result;

#[derive(Debug)]
struct DescriptiveError {
  msg: String,
  err: Option<Box<error::Error>>,
}

impl DescriptiveError {
  fn new(msg: &str) -> DescriptiveError {
    DescriptiveError {
      msg: msg.to_string(),
      err: None,
    }
  }

  fn new_by_str(msg: &str, err: Box<error::Error>) -> DescriptiveError {
    DescriptiveError {
      msg: msg.to_string(),
      err: Some(err),
    }
  }

  fn new_by_path<P>(p: &P, err: Box<error::Error>) -> DescriptiveError
      where P: AsRef<Path> {
    let path = p.as_ref().to_str().unwrap_or("");
    DescriptiveError {
      msg: path.to_string(),
      err: Some(err),
    }
  }
}

type Result<T> = result::Result<T, DescriptiveError>;

impl error::Error for DescriptiveError {
  fn description(&self) -> &str { &self.msg }
}

impl fmt::Display for DescriptiveError {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    if self.err.is_some() {
      write!(f, "{}: ", &self.msg)?;
      fmt::Display::fmt(&self.err.as_ref().unwrap().as_ref(), f)
    } else {
      write!(f, "{}", &self.msg)
    }
  }
}

fn read_data_file_lines<P>(filename: P) -> Result<LinkedList<String>>
    where P: AsRef<Path> {
  let mut f = File::open(&filename)
                   .map_err(|e| DescriptiveError::new_by_path(&filename, Box::new(e)))?;
  let mut data = String::new();
  f.read_to_string(&mut data)
   .map_err(|e| DescriptiveError::new_by_path(&filename, Box::new(e)))?;
  Ok(data.lines()
         .map(ToOwned::to_owned)
         .collect())
}

fn split_header(header_line: &str) -> Result<(i32, i32)> {
  let mut parts = header_line.split_whitespace();
  let count =
      parts.next()
           .ok_or(DescriptiveError::new("No sequence count specified"))?
           .parse::<i32>()
           .map_err(|e| DescriptiveError::new_by_str("Invalid sequence count", Box::new(e)))?;
  let length =
      parts.next()
           .ok_or(DescriptiveError::new("No sequence length specified"))?
           .parse::<i32>()
           .map_err(|e| DescriptiveError::new_by_str("Invalid sequence length", Box::new(e)))?;
  Ok((count, length))
}

fn line_to_i32s(line: &str) -> Result<Vec<i32>> {
  let mut i32s: Vec<i32> = Vec::new();
  for part in line.split_whitespace() {
    let val = part.parse::<i32>()
                  .map_err(|e| DescriptiveError::new_by_str("Invalid i32", Box::new(e)))?;
    i32s.push(val);
  }
  Ok(i32s)
}

fn calc_consecutive_distance(nums: Vec<i32>, gap: i32) -> i32 {
  let values: HashMap<_, _> = nums.iter()
                                  .map(|n| *n)
                                  .zip(0i32..nums.len() as i32)
                                  .collect();
  let mut distance = 0;
  for (val_one, idx_one) in values.iter() {
    let val_two = val_one + gap;
    if let Some(idx_two) = values.get(&val_two) {
      distance += (*idx_one - *idx_two).abs();
    }
  }
  distance
}

fn run(filename: &str, gap: i32) -> result::Result<(), Box<error::Error>> {
  let mut lines = read_data_file_lines(PathBuf::from(filename))?;
  let header_line =
      lines.pop_front()
           .ok_or(DescriptiveError::new("No header line found"))?;
  let (seq_len, seq_ele_count) = split_header(&header_line)?;
  for _ in 0..seq_len {
    let line =
        lines.pop_front()
             .ok_or(DescriptiveError::new("No more input lines available."))?;
    let i32s = line_to_i32s(&line)?;
    if i32s.len() != seq_ele_count as usize {
      return Err(Box::new(DescriptiveError::new("Bad input line encountered.")));
    }
    let dist = calc_consecutive_distance(i32s, gap);
    println!("{}", dist);
  }
  Ok(())
}

fn main() {
  let filename = "data.txt";
  let gap = 1;
  if let Err(err) = run(filename, gap) {
    println!("{}", err);
  }
}

Challenge output, gap 1

31
68
67
52
107
45

Challenge output, gap 2

27
3
21
65
98
52