New route syntax

README.md

@@ -12,7 +12,7 @@ use matchit::Router;
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut router = Router::new();
     router.insert("/home", "Welcome!")?;
-    router.insert("/users/:id", "A User")?;
+    router.insert("/users/{id}", "A User")?;
 
     let matched = router.at("/users/978")?;
     assert_eq!(matched.params.get("id"), Some("978"));
@@ -28,11 +28,11 @@ Along with static routes, the router also supports dynamic route segments. These
 
 ### Named Parameters
 
-Named parameters like `/:id` match anything until the next `/` or the end of the path:
+Named parameters like `/{id}` match anything until the next `/` or the end of the path:
 
 ```rust,ignore
 let mut m = Router::new();
-m.insert("/users/:id", true)?;
+m.insert("/users/{id}", true)?;
 
 assert_eq!(m.at("/users/1")?.params.get("id"), Some("1"));
 assert_eq!(m.at("/users/23")?.params.get("id"), Some("23"));
@@ -45,7 +45,7 @@ Catch-all parameters start with `*` and match anything until the end of the path
 
 ```rust,ignore
 let mut m = Router::new();
-m.insert("/*p", true)?;
+m.insert("/{*p}", true)?;
 
 assert_eq!(m.at("/foo.js")?.params.get("p"), Some("foo.js"));
 assert_eq!(m.at("/c/bar.css")?.params.get("p"), Some("c/bar.css"));
@@ -62,7 +62,7 @@ Static and dynamic route segments are allowed to overlap. If they do, static seg
 let mut m = Router::new();
 m.insert("/", "Welcome!").unwrap();      // priority: 1
 m.insert("/about", "About Me").unwrap(); // priority: 1
-m.insert("/*filepath", "...").unwrap();  // priority: 2
+m.insert("/{*filepath}", "...").unwrap();  // priority: 2
 ```
 
 ## How does it work?

benches/bench.rs

@@ -13,7 +13,7 @@ fn compare_routers(c: &mut Criterion) {
     let mut group = c.benchmark_group("Compare Routers");
 
     let mut matchit = matchit::Router::new();
-    for route in register!(colon) {
+    for route in register!(brackets) {
         matchit.insert(route, true).unwrap();
     }
     group.bench_function("matchit", |b| {

src/error.rs

@@ -5,16 +5,16 @@
 /// Represents errors that can occur when inserting a new route.
 #[non_exhaustive]
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub enum InsertError {
     /// Attempted to insert a path that conflicts with an existing route.
     Conflict {
         /// The existing route that the insertion is conflicting with.
         with: String,
     },
     /// Only one parameter per route segment is allowed.
-    TooManyParams,
-    /// Parameters must be registered with a name.
-    UnnamedParam,
+    InvalidParam,
+    /// Parameters must be registered with a valid name.
+    InvalidParamName,
     /// Catch-all parameters are only allowed at the end of a path.
     InvalidCatchAll,
 }
@@ -23,14 +23,14 @@
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::Conflict { with } => {
                 write!(
                     f,
                     "insertion failed due to conflict with previously registered route: {}",
                     with
                 )
             }
-            Self::TooManyParams => write!(f, "only one parameter is allowed per path segment"),
-            Self::UnnamedParam => write!(f, "parameters must be registered with a name"),
+            Self::InvalidParam => write!(f, "only one parameter is allowed per path segment"),
+            Self::InvalidParamName => write!(f, "parameters must be registered with a valid name"),
             Self::InvalidCatchAll => write!(
                 f,
                 "catch-all parameters are only allowed at the end of a route"
@@ -47,7 +47,7 @@
         if prefix == current.prefix {
             let mut route = route.to_owned();
             denormalize_params(&mut route, &current.param_remapping);
             return InsertError::Conflict {
                 with: String::from_utf8(route).unwrap(),
             };
         }
@@ -71,7 +71,7 @@
 
         denormalize_params(&mut route, &last.param_remapping);
 
         InsertError::Conflict {
             with: String::from_utf8(route).unwrap(),
         }
     }
@@ -93,7 +93,7 @@
 /// # Ok(())
 /// # }
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum MatchError {
     /// No matching route was found.
     NotFound,
 }

src/lib.rs

@@ -12,7 +12,7 @@
 //! # fn main() -> Result<(), Box<dyn std::error::Error>> {
 //! let mut router = Router::new();
 //! router.insert("/home", "Welcome!")?;
-//! router.insert("/users/:id", "A User")?;
+//! router.insert("/users/{id}", "A User")?;
 //!
 //! let matched = router.at("/users/978")?;
 //! assert_eq!(matched.params.get("id"), Some("978"));
@@ -27,13 +27,13 @@
 //!
 //! ### Named Parameters
 //!
-//! Named parameters like `/:id` match anything until the next `/` or the end of the path:
+//! Named parameters like `/{id}` match anything until the next `/` or the end of the path:
 //!
 //! ```rust
 //! # use matchit::Router;
 //! # fn main() -> Result<(), Box<dyn std::error::Error>> {
 //! let mut m = Router::new();
-//! m.insert("/users/:id", true)?;
+//! m.insert("/users/{id}", true)?;
 //!
 //! assert_eq!(m.at("/users/1")?.params.get("id"), Some("1"));
 //! assert_eq!(m.at("/users/23")?.params.get("id"), Some("23"));
@@ -52,7 +52,7 @@
 //! # use matchit::Router;
 //! # fn main() -> Result<(), Box<dyn std::error::Error>> {
 //! let mut m = Router::new();
-//! m.insert("/*p", true)?;
+//! m.insert("/{*p}", true)?;
 //!
 //! assert_eq!(m.at("/foo.js")?.params.get("p"), Some("foo.js"));
 //! assert_eq!(m.at("/c/bar.css")?.params.get("p"), Some("c/bar.css"));
@@ -74,7 +74,7 @@
 //! let mut m = Router::new();
 //! m.insert("/", "Welcome!").unwrap()    ;  // priority: 1
 //! m.insert("/about", "About Me").unwrap(); // priority: 1
-//! m.insert("/*filepath", "...").unwrap();  // priority: 2
+//! m.insert("/{*filepath}", "...").unwrap();  // priority: 2
 //!
 //! # Ok(())
 //! # }

src/params.rs

@@ -1,9 +1,7 @@
-use std::iter;
-use std::mem;
-use std::slice;
+use std::{fmt, iter, mem, slice};
 
 /// A single URL parameter, consisting of a key and a value.
-#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Default, Copy, Clone)]
+#[derive(PartialEq, Eq, Ord, PartialOrd, Default, Copy, Clone)]
 struct Param<'k, 'v> {
     key: &'k [u8],
     value: &'v [u8],
@@ -25,7 +23,7 @@
 /// ```rust
 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
 /// # let mut router = matchit::Router::new();
-/// # router.insert("/users/:id", true).unwrap();
+/// # router.insert("/users/{id}", true).unwrap();
 /// let matched = router.at("/users/1")?;
 ///
 /// // you can iterate through the keys and values
@@ -39,15 +37,15 @@
 /// # Ok(())
 /// # }
 /// ```
-#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Clone)]
+#[derive(PartialEq, Eq, Ord, PartialOrd, Clone)]
 pub struct Params<'k, 'v> {
     kind: ParamsKind<'k, 'v>,
 }
 
 // most routes have 1-3 dynamic parameters, so we can avoid a heap allocation in common cases.
 const SMALL: usize = 3;
 
-#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Clone)]
+#[derive(PartialEq, Eq, Ord, PartialOrd, Clone)]
 enum ParamsKind<'k, 'v> {
     None,
     Small([Param<'k, 'v>; SMALL], usize),
@@ -55,13 +53,14 @@
 }
 
 impl<'k, 'v> Params<'k, 'v> {
     pub(crate) fn new() -> Self {
-        let kind = ParamsKind::None;
-        Self { kind }
+        Self {
+            kind: ParamsKind::None,
+        }
     }
 
     /// Returns the number of parameters.
     pub fn len(&self) -> usize {
         match &self.kind {
             ParamsKind::None => 0,
             ParamsKind::Small(_, len) => *len,
@@ -100,12 +99,12 @@
     }
 
     /// Returns an iterator over the parameters in the list.
     pub fn iter(&self) -> ParamsIter<'_, 'k, 'v> {
         ParamsIter::new(self)
     }
 
     /// Returns `true` if there are no parameters in the list.
     pub fn is_empty(&self) -> bool {
         match &self.kind {
             ParamsKind::None => true,
             ParamsKind::Small(_, len) => *len == 0,
@@ -159,6 +158,12 @@
     }
 }
 
+impl fmt::Debug for Params<'_, '_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.iter()).finish()
+    }
+}
+
 /// An iterator over the keys and values of a route's [parameters](crate::Params).
 pub struct ParamsIter<'ps, 'k, 'v> {
     kind: ParamsIterKind<'ps, 'k, 'v>,
@@ -201,11 +206,6 @@
 mod tests {
     use super::*;
 
-    #[test]
-    fn no_alloc() {
-        assert_eq!(Params::new().kind, ParamsKind::None);
-    }
-
     #[test]
     fn heap_alloc() {
         let vec = vec![