1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
// Copyright (c) 2018 The predicates-rs Project Developers. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/license/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. //! Definition of `Predicate` for wrapping a `Fn(&T) -> bool` use std::fmt; use std::marker::PhantomData; use reflection; use utils; use Predicate; /// Predicate that wraps a function over a reference that returns a `bool`. /// This type is returned by the `predicate::function` function. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct FnPredicate<F, T> where F: Fn(&T) -> bool, T: ?Sized, { function: F, name: &'static str, _phantom: PhantomData<T>, } impl<F, T> FnPredicate<F, T> where F: Fn(&T) -> bool, T: ?Sized, { /// Provide a descriptive name for this function. /// /// # Examples /// /// ``` /// use predicates::prelude::*; /// /// struct Example { /// string: String, /// number: i32, /// } /// /// let string_check = predicate::function(|x: &Example| x.string == "hello") /// .fn_name("is_hello"); /// println!("predicate: {}", string_check); /// ``` pub fn fn_name(mut self, name: &'static str) -> Self { self.name = name; self } } impl<F, T> Predicate<T> for FnPredicate<F, T> where F: Fn(&T) -> bool, T: ?Sized, { fn eval(&self, variable: &T) -> bool { (self.function)(variable) } fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> { utils::default_find_case(self, expected, variable) } } impl<F, T> reflection::PredicateReflection for FnPredicate<F, T> where F: Fn(&T) -> bool, T: ?Sized, { } impl<F, T> fmt::Display for FnPredicate<F, T> where F: Fn(&T) -> bool, T: ?Sized, { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}(var)", self.name) } } /// Creates a new predicate that wraps over the given function. The returned /// type implements `Predicate` and therefore has all combinators available to /// it. /// /// # Examples /// /// ``` /// use predicates::prelude::*; /// /// struct Example { /// string: String, /// number: i32, /// } /// /// let string_check = predicate::function(|x: &Example| x.string == "hello"); /// let number_check = predicate::function(|x: &Example| x.number == 42); /// let predicate_fn = string_check.and(number_check); /// let good_example = Example { string: "hello".into(), number: 42 }; /// assert_eq!(true, predicate_fn.eval(&good_example)); /// let bad_example = Example { string: "goodbye".into(), number: 0 }; /// assert_eq!(false, predicate_fn.eval(&bad_example)); /// ``` pub fn function<F, T>(function: F) -> FnPredicate<F, T> where F: Fn(&T) -> bool, T: ?Sized, { FnPredicate { function, name: "fn", _phantom: PhantomData, } } #[test] fn str_function() { let f = function(|x: &str| x == "hello"); assert!(f.eval(&"hello")); assert!(!f.eval(&"goodbye")); }