Crate has_some 

A very simple trait that relieves some tiresome things about using is_empty in iterator filters and other “not is_empty” contexts.

Three annoyances are covered:

• Having to always code !T.is_empty() when it’s clearer to have T.has_some();
• Having to code a closure in Iterator::filter for the above semantics, rather than just passing a function
• Having to code a closure in Iterator::filter even for T.is_empty when the Item of the iterator is a reference (or a double reference!).

I fully admit that the implementation is banal - but it works!

Examples

When you want to know if a collection has some elements

Before:

let empty_string = "";
let not_empty_string = "this is not empty";
assert!(empty_string.is_empty());
assert!(!not_empty_string.is_empty());

Now:

use has_some::HasSome;
let empty_string = "";
let not_empty_string = "this is not empty";
assert!(empty_string.is_empty());
assert!(not_empty_string.has_some());

When you have an iterator that emits owned types as items

Before:

let vector = vec!["some_data".to_owned(), "".to_owned(), "more data".to_owned()];
let vector2 = vector.clone();

let empties: Vec<String> = vector.into_iter().filter(String::is_empty).collect();
let not_empties: Vec<String> = vector2.into_iter().filter(|s|!s.is_empty()).collect();

assert_eq!([""], empties.as_slice());
assert_eq!(["some_data", "more data"], not_empties.as_slice());

Now:

use has_some::HasSome;
let vector = vec!["some_data".to_owned(), "".to_owned(), "more data".to_owned()];
let vector2 = vector.clone();

let empties: Vec<String> = vector.into_iter().filter(String::is_empty).collect();
let not_empties: Vec<String> = vector2.into_iter().filter(String::has_some).collect();

assert_eq!([""], empties.as_slice());
assert_eq!(["some_data", "more data"], not_empties.as_slice());

When you have an iterator that emits reference types as items

Before:

let vector = vec!["some_data".to_owned(), "".to_owned(), "more data".to_owned()];

let empties: Vec<&String> = vector.iter().filter(|s|s.is_empty()).collect();
let not_empties: Vec<&String> = vector.iter().filter(|s|!s.is_empty()).collect();

assert_eq!([""], empties.as_slice());
assert_eq!(["some_data", "more data"], not_empties.as_slice());

Now:

use has_some::HasSome;
let vector = vec!["some_data".to_owned(), "".to_owned(), "more data".to_owned()];

let empties: Vec<&String> = vector.iter().filter(String::is_empty2).collect();
let not_empties: Vec<&String> = vector.iter().filter(String::has_some2).collect();

assert_eq!([""], empties.as_slice());
assert_eq!(["some_data", "more data"], not_empties.as_slice());

Or even those pesky double references:

use has_some::HasSome;
let vector = vec!["some_data", "", "more data"];

let empties: Vec<&&str> = vector.iter().filter(str::is_empty3).collect();
let not_empties: Vec<&&str> = vector.iter().filter(str::has_some3).collect();

assert_eq!([&""], empties.as_slice());
assert_eq!([&"some_data", &"more data"], not_empties.as_slice());

Traits

HasSome

HasSomeConsume

The rare case where is_empty consumes self.