Struct Warned 

pub struct Warned<T, W> {
    pub value: T,
    pub warnings: Vec<W>,
}

Represents a value with warnings.

Fields

value: T

warnings: Vec<W>

Implementations

impl<T, W> Warned<T, W>

pub fn new(value: T, warnings: impl IntoIterator<Item = W>) -> Self

use warned::*;
let a = Warned::new(123, vec!["x", "y"]);
assert_eq!(a.value, 123);
assert_eq!(a.warnings, vec!["x", "y"]);

pub fn unwrap<V>(self, warnings: &mut Vec<V>) -> T

where W: Into<V>,

use warned::*;
let mut warnings: Vec<&str> = vec![];
assert_eq!(Warned::new(123, vec!["x", "y"]).unwrap(&mut warnings), 123);
assert_eq!(warnings, vec!["x", "y"]);

pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Warned<U, W>

use warned::*;
let a = Warned::new(123, vec!["x", "y"]);
let b = a.map(|value| 2 * value);
assert_eq!(b.value, 246);
assert_eq!(b.warnings, vec!["x", "y"]);

pub fn map_warnings<V>(self, f: impl Fn(W) -> V) -> Warned<T, V>

use warned::*;
let a = Warned::new(123, vec!["x", "y"]);
let b = a.map_warnings(|s| s.to_uppercase());
assert_eq!(b.value, 123);
assert_eq!(b.warnings, vec!["X", "Y"]);

pub fn and_then<U>(self, f: impl Fn(T) -> Warned<U, W>) -> Warned<U, W>

use warned::*;
let a = Warned::new(123, vec!["x", "y"]);
let b = a.and_then(|value| Warned::new(value as f64 / 2.0, vec!["z"]));
assert_eq!(b.value, 123.0 / 2.0);
assert_eq!(b.warnings, vec!["x", "y", "z"]);

pub fn into_result(self) -> Result<T, Vec<W>>

Returns Ok only if self has no warnings. Otherwise, returns Err.

use warned::*;
assert_eq!(Warned::<_, &str>::new(123, []).into_result(), Ok(123));
assert_eq!(Warned::new(123, ["warning"]).into_result(), Err(vec!["warning"]));

pub fn from_result_or_else(src: Result<T, W>, f: impl FnOnce() -> T) -> Self

Returns a value with no warnings if the src is Ok. Otherwise, returns a value of f() with single warning.

use warned::Warned;

let a = Warned::<_, &str>::from_result_or_else(Ok(1), || 2);
assert_eq!(a.value, 1);
assert!(a.warnings.is_empty());

let b = Warned::<_, &str>::from_result_or_else(Err("oops"), || 2);
assert_eq!(b.value, 2);
assert_eq!(b.warnings, vec!["oops"]);

pub fn from_result_or(src: Result<T, W>, default: T) -> Self

Returns a value with no warnings if the src is Ok. Otherwise, returns a given default value with single warning.

use warned::Warned;

let a = Warned::<_, &str>::from_result_or(Ok(1), 2);
assert_eq!(a.value, 1);
assert!(a.warnings.is_empty());

let b = Warned::<_, &str>::from_result_or(Err("oops"), 2);
assert_eq!(b.value, 2);
assert_eq!(b.warnings, vec!["oops"]);

pub fn from_result_or_default(src: Result<T, W>) -> Self

where T: Default,

Returns a value with no warnings if the src is Ok. Otherwise, returns a T::default() value with single warning.

use warned::Warned;

let a = Warned::<i32, &str>::from_result_or_default(Ok(1));
assert_eq!(a.value, 1);
assert!(a.warnings.is_empty());

let b = Warned::<i32, &str>::from_result_or_default(Err("oops"));
assert_eq!(b.value, 0);
assert_eq!(b.warnings, vec!["oops"]);

impl<T, W> Warned<Option<T>, W>

pub fn from_result(src: Result<T, W>) -> Self

Returns a Some value with no warnings if the src is Ok. Otherwise, returns None with single warning.

use warned::Warned;

let a = Warned::<Option<i32>, &str>::from_result(Ok(111));
assert_eq!(a.value, Some(111));
assert!(a.warnings.is_empty());

let b = Warned::<Option<i32>, &str>::from_result(Err("oops"));
assert!(b.value.is_none());
assert_eq!(b.warnings, vec!["oops"]);

Trait Implementations

impl<T: Clone, W: Clone> Clone for Warned<T, W>

fn clone(&self) -> Warned<T, W>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, W: Debug> Debug for Warned<T, W>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default, W> Default for Warned<T, W>

fn default() -> Self

use warned::*;
let a = Warned::<Vec<i32>, String>::default();
assert!(a.value.is_empty());
assert!(a.warnings.is_empty());

impl<T, W> Deref for Warned<T, W>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T1, T2, W> From<(Warned<T1, W>, Warned<T2, W>)> for Warned<(T1, T2), W>

fn from((a, b): (Warned<T1, W>, Warned<T2, W>)) -> Self

use warned::Warned;
let a = Warned::new(123, vec!["x", "xx"]);
let b = Warned::new(321, vec!["y", "yy"]);
let c: Warned<(_, _), _> = (a, b).into();
assert_eq!(c.value, (123, 321));
assert_eq!(c.warnings, vec!["x", "xx", "y", "yy"]);

impl<T, E> From<Result<T, E>> for Warned<Option<T>, E>

fn from(result: Result<T, E>) -> Self

use warned::Warned;

let a: Warned<Option<i32>, &str> = Ok(111).into();
assert_eq!(a.value, Some(111));
assert!(a.warnings.is_empty());

let b: Warned<Option<i32>, &str> = Err::<i32, _>("oops").into();
assert!(b.value.is_none());
assert_eq!(b.warnings, vec!["oops"]);

impl<T: Default, E> From<Result<T, E>> for Warned<T, E>

fn from(result: Result<T, E>) -> Self

use warned::Warned;

let a: Warned<i32, &str> = Ok(111).into();
assert_eq!(a.value, 111);
assert!(a.warnings.is_empty());

let b: Warned<i32, &str> = Err::<i32, _>("oops").into();
assert_eq!(b.value, 0);
assert_eq!(b.warnings, vec!["oops"]);

impl<T, W> From<T> for Warned<T, W>

fn from(value: T) -> Self

use warned::*;
let a: Warned<i32, String> = (111).into();
assert_eq!(a.value, 111);
assert!(a.warnings.is_empty());

impl<T, W> From<Warned<T, W>> for Result<T, Vec<W>>

fn from(src: Warned<T, W>) -> Self

use warned::*;
assert_eq!(Ok(123), Warned::<_, &str>::new(123, []).into());
assert_eq!(Err(vec!["warning"]), Warned::new(123, ["warning"]).into());

impl<T, Ts: FromIterator<T>, W> FromIterator<Result<T, W>> for Warned<Ts, W>

fn from_iter<I: IntoIterator<Item = Result<T, W>>>(iter: I) -> Self

use warned::Warned;
let src = vec![Ok(111), Err("oops"), Err("oops2"), Ok(222)];
let dst = src.into_iter().collect::<Warned<Vec<_>, _>>();
assert_eq!(dst.value, vec![111, 222]);
assert_eq!(dst.warnings, vec!["oops", "oops2"]);

impl<T, Ts: FromIterator<T>, W> FromIterator<Warned<T, W>> for Warned<Ts, W>

fn from_iter<I: IntoIterator<Item = Warned<T, W>>>(iter: I) -> Self

use warned::Warned;
let src: Vec<Warned<i32, &str>> = vec![
    Warned::new(111, vec![]),
    Warned::new(222, vec!["oops"]),
    Warned::new(333, vec!["foo", "bar"])
];
let dst = src.into_iter().collect::<Warned<Vec<_>, _>>();
assert_eq!(dst.value, vec![111, 222, 333]);
assert_eq!(dst.warnings, vec!["oops", "foo", "bar"]);

impl<T: PartialEq, W: PartialEq> PartialEq for Warned<T, W>

fn eq(&self, other: &Warned<T, W>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq, W: Eq> Eq for Warned<T, W>

impl<T, W> StructuralPartialEq for Warned<T, W>