feat(trait): Allow naming Predicate expressions

This can be important for
- Clarifying the intent of a predicate, especially when looking at test
  results
- Shortening `Predicate::display`s that are too big

This is another step towards #7.

Author: epage

src/lib.rs

@@ -110,6 +110,7 @@ pub mod constant;
 pub mod function;
 pub mod ord;
 pub mod iter;
+pub mod name;
 
 // combinators
 pub mod boolean;

src/name.rs

@@ -0,0 +1,82 @@
+// Copyright (c) 2018 The predicates-rs Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Name predicate expressions.
+
+use std::fmt;
+use std::marker::PhantomData;
+
+use Predicate;
+
+/// Augment an existing predicate with a name.
+///
+/// This is created by the `PredicateNameExt::name` function.
+#[derive(Debug)]
+pub struct NamePredicate<M, Item>
+where
+    M: Predicate<Item>,
+    Item: ?Sized,
+{
+    inner: M,
+    name: &'static str,
+    _phantom: PhantomData<Item>,
+}
+
+impl<M, Item> Predicate<Item> for NamePredicate<M, Item>
+where
+    M: Predicate<Item>,
+    Item: ?Sized,
+{
+    fn eval(&self, item: &Item) -> bool {
+        self.inner.eval(item)
+    }
+}
+
+impl<M, Item> fmt::Display for NamePredicate<M, Item>
+where
+    M: Predicate<Item>,
+    Item: ?Sized,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.name)
+    }
+}
+
+/// `Predicate` extension that adds naming predicate expressions.
+pub trait PredicateNameExt<Item: ?Sized>
+where
+    Self: Predicate<Item>,
+{
+    /// Name a predicate expression.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use predicates::prelude::*;
+    ///
+    /// let predicate_fn = predicate::str::is_empty().not().name("non-empty");
+    /// println!("{}", predicate_fn);
+    /// ```
+    fn name(self, name: &'static str) -> NamePredicate<Self, Item>
+    where
+        Self: Sized,
+    {
+        NamePredicate {
+            inner: self,
+            name,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<P, Item> PredicateNameExt<Item> for P
+where
+    P: Predicate<Item>,
+    Item: ?Sized,
+{
+}

src/prelude.rs

@@ -12,6 +12,7 @@ pub use core::Predicate;
 pub use boolean::PredicateBooleanExt;
 pub use boxed::PredicateBoxExt;
 pub use str::PredicateStrExt;
+pub use name::PredicateNameExt;
 
 /// Predicate factories
 pub mod predicate {