fused_error 0.1.2

A simple library for working with composable errors.
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
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
129
130
131
132
133
134
135
136
137
138

use crate::{Accumulator, FusedError};

use std::{
    fmt::{self, Debug},
    mem::ManuallyDrop,
};

#[must_use]
pub(crate) struct FusedResult<T, E> {
    pub ok: ManuallyDrop<T>,
    pub errors: Accumulator<E>,
}

impl<T, E> FusedResult<T, E> {
    #[inline]
    pub fn new(value: T, acc: Accumulator<E>) -> Self {
        FusedResult {
            ok: ManuallyDrop::new(value),
            errors: acc,
        }
    }

    #[inline]
    pub unsafe fn split(&mut self) -> (T, Accumulator<E>) {
        let value = ManuallyDrop::take(&mut self.ok);
        let acc = Accumulator::from_vec(self.errors.inner.take());
        (value, acc)
    }

    #[must_use]
    #[inline]
    pub unsafe fn take_value(&mut self) -> T {
        self.errors.inner.ignore();
        ManuallyDrop::take(&mut self.ok)
    }

    #[must_use]
    #[inline]
    pub unsafe fn take_errors(&mut self) -> Vec<E> {
        ManuallyDrop::drop(&mut self.ok);
        self.errors.inner.take()
    }

    #[must_use]
    #[inline]
    pub unsafe fn take_err(&mut self) -> Option<E>
    where
        E: FusedError,
    {
        ManuallyDrop::drop(&mut self.ok);
        self.errors.inner.reduce()
    }

    #[inline]
    pub unsafe fn result(&mut self) -> Result<T, E>
    where
        E: FusedError,
    {
        match self.errors.inner.reduce() {
            Some(err) => {
                ManuallyDrop::drop(&mut self.ok);
                Err(err)
            }
            None => {
                let ok = ManuallyDrop::take(&mut self.ok);
                Ok(ok)
            }
        }
    }

    #[inline]
    #[track_caller]
    pub unsafe fn fail_with(&mut self, msg: &str)
    where
        T: Debug,
        E: Debug,
    {
        let msg = format!("{msg}: {self:#?}");
        self.ignore();
        panic!("{msg}");
    }

    #[inline(never)]
    #[cold]
    #[track_caller]
    pub unsafe fn fail(&mut self, method: &'static str)
    where
        T: Debug,
        E: Debug,
    {
        let msg = match self.errors.len() {
            0 => format!("called `FusedResult::{method}` when no errors were present"),
            n => {
                format!(
                    "called `FusedResult::{method}` without handling {n} error{}",
                    if n == 1 { "" } else { "s" },
                )
            }
        };

        self.fail_with(&msg);
    }

    #[inline]
    pub unsafe fn ignore(&mut self) {
        ManuallyDrop::drop(&mut self.ok);
        self.errors.inner.ignore();
    }
}

// We manually implement `Debug` to omit the `ManuallyDrop` indirection.
impl<T: Debug, E: Debug> Debug for FusedResult<T, E> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("FusedResult")
            .field("ok", &*self.ok)
            .field("errors", &self.errors)
            .finish()
    }
}

impl<T, E> Drop for FusedResult<T, E> {
    fn drop(&mut self) {
        if cfg!(debug_assertions) && !self.errors.is_handled() {
            // SAFETY: If the accumulator didn't get handled correctly, it's
            // safe to assume the `ManuallyDrop` hasn't been handled either.
            unsafe { ManuallyDrop::drop(&mut self.ok) };

            let len = self.errors.len();
            match len {
                0 => panic!("`fused_error::FusedResult` dropped without getting handled"),
                n => panic!(
                    "`fused_error::FusedResult` dropped without handling {n} error{}",
                    if n == 1 { "" } else { "s" },
                ),
            }
        }
    }
}