anyerr 0.1.1

Dynamic error library with rich error wrapping and context support
Documentation 
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

use std::fmt::{Display, Formatter, Result as FmtResult};
use std::marker::PhantomData;

use crate::context::{AbstractContext, Entry, Iter, NoContext};

/// The context that stores nothing.
///
/// [`UnitContext`] is a ZST, thus integrating your error type with it leads to
/// zero memory overhead.
#[derive(Debug)]
pub struct UnitContext;

impl Default for UnitContext {
    fn default() -> Self {
        Self
    }
}

impl AbstractContext for UnitContext {
    type Key = Dummy;

    type Value = Dummy;

    type Entry = DummyEntry;

    type Iter<'a> = UnitIter<'a>;

    fn iter(&self) -> Self::Iter<'_> {
        Self::Iter::default()
    }
}

impl NoContext for UnitContext {}

/// An uninhabit type, used as dummy keys or values.
#[derive(Debug, PartialEq, Eq, Hash)]
pub enum Dummy {}

impl Display for Dummy {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        write!(f, "{self:?}")
    }
}

/// An uninhabit type, used as entries.
#[derive(Debug)]
pub enum DummyEntry {}

impl Entry for DummyEntry {
    type Key = Dummy;

    type KeyBorrowed = Dummy;

    type Value = Dummy;

    type ValueBorrowed = Dummy;

    fn new<Q, V>(_key: Q, _value: V) -> Self
    where
        Q: Into<Self::Key>,
        V: Into<Self::Value>,
    {
        unreachable!("`_key` and `_value` are instances of the `Dummy` type, which is uninhabited")
    }

    fn key(&self) -> &Self::KeyBorrowed {
        unreachable!("`_key` and `_value` are instances of the `Dummy` type, which is uninhabited")
    }

    fn value(&self) -> &Self::ValueBorrowed {
        unreachable!("`_key` and `_value` are instances of the `Dummy` type, which is uninhabited")
    }
}

/// The iterator of [`UnitContext`], producing nothing.
#[derive(Debug, Default)]
pub struct UnitIter<'a> {
    _phantom: PhantomData<&'a ()>,
}

impl<'a> Iterator for UnitIter<'a> {
    type Item = &'a DummyEntry;

    fn next(&mut self) -> Option<Self::Item> {
        None
    }
}

impl<'a> Iter<'a> for UnitIter<'a> {
    type Entry = DummyEntry;

    fn compose(self, _other: Self) -> Self {
        self
    }
}