captures

[ArtemGr]

Here's an interesting improvement, IMHO:

pub struct ReIdx(regex::Regex, usize);
impl ReIdx {
  #[unstable]
  pub fn from_regex(re: regex::Regex) -> ReIdx {
    ReIdx(re, 0)
  }
  pub fn from_regex_group(re: regex::Regex, group: usize) -> ReIdx {
    ReIdx(re, group)
  }
}
#[stable(since="0.1.0")]
impl Index<ReIdx> for str {
  type Output = str;
  fn index<'a>(&'a self, index: &ReIdx) -> &'a str {
    match index.0.captures(self) {
      Some(captures) => match captures.pos (index.1) {
        Some ((start, end)) => &self[start .. end],
        None => &self[..0]
      },
      None => &self[..0]
    }
  }
}
impl Index<Result<ReIdx, regex::Error>> for str {
  type Output = str;
  fn index<'a>(&'a self, index: &Result<ReIdx, regex::Error>) -> &'a str {
    match *index {
      Ok(ref ri) => &self.index(ri),
      Err(_) => &self[..0]
    }
  }
}
#[macro_export]
macro_rules! ri {
  ($re:expr) => (ReIdx::from_regex($re));
  ($re:expr, $group:expr) => (ReIdx::from_regex_group($re,$group))
}

With it one can quickly switch from the whole match to a subgroup:

let foo = &uri[ri! (regex! (r"^/path/(\w+)/$"))];
let bar = &uri[ri! (regex! (r"^/path/(\w+)/$"), 1)];

[kstep]

How about indexing by tuple?

let too = &uri[(ri![r"..."], 1)];

[kstep]

I'm afraid to go too far in this experiment, as it will be very difficult to stop at some point.