mercy 1.1.1

//! [`Act`] and friends.

use core::{
    error::Error as StdError,
    fmt, hash,
    marker::PhantomData,
    mem::discriminant,
    ops::{Deref, DerefMut},
};

use constr::Constr;

use crate::{
    spair::Spair,
    traits::{Stringable, Stringy},
};

/// State of actor.
#[derive(Copy, Clone)]
struct State(usize);
impl State {
    /// Bitshift for preset states.
    const SHIFT: u32 = usize::BITS - 2;

    /// State when only first string is built.
    const FIRST: State = State(0b01 << State::SHIFT);

    /// State when only second string is built.
    const SECOND: State = State(0b10 << State::SHIFT);

    /// State when neither string is built.
    const NEITHER: State = State(0b11 << State::SHIFT);

    /// Finished state.
    ///
    /// Note: will fail if split is more than `FIRST`, but this would probably be an allocation
    /// failure, so, we just don't worry about it.
    fn new(split: usize) -> State {
        State(split)
    }

    /// If the builder has the first string.
    fn has_first(&self) -> bool {
        self.0 & State::FIRST.0 != State::FIRST.0
    }

    /// If the builder has the second string.
    fn has_second(&self) -> bool {
        self.0 & State::SECOND.0 != State::SECOND.0
    }

    /// The split index, if the builder has both strings.
    fn as_split(&self) -> Option<usize> {
        (self.0 & State::NEITHER.0 == 0).then_some(self.0)
    }
}

/// Wrapper for [`IncompleteError`] and [`DuplicateError`] that allows naming the two strings.
pub struct Custom<E, K1: Constr, K2: Constr> {
    /// Inner error.
    err: E,

    /// Phantom data marker.
    marker: PhantomData<(K1, K2)>,
}
impl<E, K1: Constr, K2: Constr> Custom<E, K1, K2> {
    /// Get inner error.
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    pub fn into_inner(self) -> E {
        self.err
    }
}
impl<E, K1: Constr, K2: Constr> Deref for Custom<E, K1, K2> {
    type Target = E;
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn deref(&self) -> &E {
        &self.err
    }
}
impl<E, K1: Constr, K2: Constr> DerefMut for Custom<E, K1, K2> {
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn deref_mut(&mut self) -> &mut E {
        &mut self.err
    }
}
impl<E: Copy, K1: Constr, K2: Constr> Copy for Custom<E, K1, K2> {}
impl<E: Clone, K1: Constr, K2: Constr> Clone for Custom<E, K1, K2> {
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn clone(&self) -> Self {
        Custom {
            err: self.err.clone(),
            marker: PhantomData,
        }
    }
}
impl<L: PartialEq<R>, R, K1: Constr, K2: Constr> PartialEq<Custom<R, K1, K2>>
    for Custom<L, K1, K2>
{
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn eq(&self, other: &Custom<R, K1, K2>) -> bool {
        self.err == other.err
    }
}
impl<E: Eq, K1: Constr, K2: Constr> Eq for Custom<E, K1, K2> {}
impl<E: hash::Hash, K1: Constr, K2: Constr> hash::Hash for Custom<E, K1, K2> {
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn hash<H: hash::Hasher>(&self, state: &mut H) {
        self.err.hash(state);
    }
}
impl<S: AsRef<str>, K1: Constr, K2: Constr> StdError for CustomIncompleteError<S, K1, K2> {}
impl<S: AsRef<str>, K1: Constr, K2: Constr> fmt::Debug for CustomIncompleteError<S, K1, K2> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let (first, second) = self.pair();
        let mut err = f.debug_struct("IncompleteError");
        match first {
            Some(first) => {
                err.field(K1::STR, &first);
            }
            None => {
                err.field(K1::STR, &format_args!("_"));
            }
        }
        match second {
            Some(second) => {
                err.field(K2::STR, &second);
            }
            None => {
                err.field(K2::STR, &format_args!("_"));
            }
        }
        err.finish()
    }
}
impl<S: AsRef<str>, K1: Constr, K2: Constr> StdError for CustomDuplicateError<S, K1, K2> {}
impl<S: AsRef<str>, K1: Constr, K2: Constr> fmt::Debug for CustomDuplicateError<S, K1, K2> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("DuplicateError")
            .field("pair", &self.pair())
            .field(
                "which",
                &format_args!(
                    "{}",
                    match self.which() {
                        Duplicated::First => K1::STR,
                        Duplicated::Second => K2::STR,
                    }
                ),
            )
            .finish()
    }
}
impl<S: AsRef<str>, K1: Constr, K2: Constr> fmt::Display for CustomIncompleteError<S, K1, K2> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let k1 = K1::STR;
        let k2 = K2::STR;
        match &self.err {
            IncompleteError::Empty => {
                write!(f, "missing {k1} and {k2}")
            }
            IncompleteError::First(first) => {
                let first = first.as_ref();
                write!(f, "got {k1} {first:?}, but missing {k2}")
            }
            IncompleteError::Second(second) => {
                let second = second.as_ref();
                write!(f, "got {k2} {second:?}, but missing {k1}")
            }
        }
    }
}
impl<S: AsRef<str>, K1: Constr, K2: Constr> fmt::Display for CustomDuplicateError<S, K1, K2> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let (first, second) = self.pair();
        let which = match self.which {
            Duplicated::First => K1::STR,
            Duplicated::Second => K2::STR,
        };
        write!(f, "got duplicate {which}: {first:?} and {second:?}")
    }
}

/// Alias for <code>[Custom]&lt;[DuplicateError]&lt;S&gt;, K1, K2&gt;</code>.
pub type CustomDuplicateError<S, K1, K2> = Custom<DuplicateError<S>, K1, K2>;

/// Alias for <code>[Custom]&lt;[IncompleteError]&lt;S&gt;, K1, K2&gt;</code>.
pub type CustomIncompleteError<S, K1, K2> = Custom<IncompleteError<S>, K1, K2>;

/// Error when building an incomplete [`Spair`] via [`Act::finish`].
#[derive(Copy, Clone)]
pub enum IncompleteError<S: AsRef<str>> {
    /// Empty pair.
    Empty,

    /// Only first item in pair.
    First(S),

    /// Only second item in pair.
    Second(S),
}
impl<S: AsRef<str>> IncompleteError<S> {
    /// The partially-formed pair as a pair of options.
    ///
    /// Note that exhaustive matching should be done on the type itself, since the
    /// `(Some(_), Some(_))` variant will never be possible here.
    ///
    /// # Examples
    ///
    /// ```
    /// let err = mercy::act::<String, constr::Empty, false>()
    ///     .first("hello")
    ///     .unwrap()
    ///     .finish()
    ///     .unwrap_err();
    ///
    /// assert_eq!(err.pair(), (Some("hello"), None));
    /// ```
    pub fn pair(&self) -> (Option<&str>, Option<&str>) {
        match self {
            IncompleteError::Empty => (None, None),
            IncompleteError::First(buf) => (Some(buf.as_ref()), None),
            IncompleteError::Second(buf) => (None, Some(buf.as_ref())),
        }
    }

    /// Customize the name of the two keys in the error message.
    ///
    /// To avoid taking up extra space, the keys are provided using [`constr`]s.
    ///
    /// # Examples
    ///
    /// ```
    /// let err = mercy::act::<String, constr::Empty, false>()
    ///     .finish()
    ///     .unwrap_err();
    /// println!("{err}"); // unfinished pair: (_, _)
    ///
    /// constr::constr! {
    ///     type K1 = "greeting";
    ///     type K2 = "entity";
    /// }
    ///
    /// let err: mercy::CustomIncompleteError<String, K1, K2> = err.custom();
    /// println!("{err}"); // missing greeting and entity
    /// ```
    pub fn custom<K1: Constr, K2: Constr>(self) -> CustomIncompleteError<S, K1, K2> {
        Custom {
            err: self,
            marker: PhantomData,
        }
    }
}
impl<S1: AsRef<str>, S2: AsRef<str>> PartialEq<IncompleteError<S2>> for IncompleteError<S1> {
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn eq(&self, other: &IncompleteError<S2>) -> bool {
        match (self, other) {
            (IncompleteError::Empty, IncompleteError::Empty) => true,
            (IncompleteError::First(lhs), IncompleteError::First(rhs))
            | (IncompleteError::Second(lhs), IncompleteError::Second(rhs)) => {
                lhs.as_ref() == rhs.as_ref()
            }
            _ => false,
        }
    }
}
impl<S: AsRef<str>> Eq for IncompleteError<S> {}
impl<S: AsRef<str>> hash::Hash for IncompleteError<S> {
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn hash<H: hash::Hasher>(&self, state: &mut H) {
        let (first, second) = self.pair();
        first.as_ref().hash(state);
        second.as_ref().hash(state);
    }
}
impl<S: AsRef<str>> fmt::Debug for IncompleteError<S> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let (first, second) = self.pair();
        let mut tuple = f.debug_tuple("IncompleteError");
        match first {
            Some(first) => {
                tuple.field(&first);
            }
            None => {
                tuple.field(&format_args!("_"));
            }
        }
        match second {
            Some(second) => {
                tuple.field(&second);
            }
            None => {
                tuple.field(&format_args!("_"));
            }
        }
        tuple.finish()
    }
}
impl<S: AsRef<str>> StdError for IncompleteError<S> {}
impl<S: AsRef<str>> fmt::Display for IncompleteError<S> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let (first, second) = self.pair();
        write!(f, "unfinished pair: (")?;
        match first {
            Some(first) => {
                write!(f, "{first:?}")?;
            }
            None => {
                write!(f, "_")?;
            }
        }
        write!(f, ", ")?;
        match second {
            Some(second) => {
                write!(f, "{second:?}")?;
            }
            None => {
                write!(f, "_")?;
            }
        }
        write!(f, ")")
    }
}

/// Duplicated key returned by [`DuplicateError::which`].
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum Duplicated {
    /// First key duplicated.
    First,

    /// Second key duplicated.
    Second,
}

/// Error when there were duplicate keys provided to a [`Spair`].
///
/// Returned by both [`Act::first`] and [`Act::second`].
pub struct DuplicateError<S: AsRef<str>> {
    /// Pair of duplicates.
    pub(crate) pair: Spair<S>,

    /// Which key was duplicated
    pub(crate) which: Duplicated,
}
impl<S: AsRef<str>> DuplicateError<S> {
    /// The pair of duplicate keys as a [`Spair`].
    ///
    /// # Examples
    ///
    /// ```
    /// let mercy::BuildError::Duplicate(err) = mercy::act::<String, constr::Empty, false>()
    ///     .first("hello")
    ///     .unwrap()
    ///     .first("oops!")
    ///     .unwrap_err();
    ///
    /// assert_eq!(err.spair().pair(), ("hello", "oops!"));
    /// ```
    pub fn spair(&self) -> &Spair<S> {
        &self.pair
    }

    /// The pair of duplicate keys as a pair of strings.
    ///
    /// # Examples
    ///
    /// ```
    /// let mercy::BuildError::Duplicate(err) = mercy::act::<String, constr::Empty, false>()
    ///     .first("hello")
    ///     .unwrap()
    ///     .first("oops!")
    ///     .unwrap_err();
    ///
    /// assert_eq!(err.pair(), ("hello", "oops!"));
    /// ```
    pub fn pair(&self) -> (&str, &str) {
        self.pair.pair()
    }

    /// Which key was duplicated.
    ///
    /// Indicates whether the error was returned by [`Act::first`] or [`Act::second`].
    ///
    /// # Examples
    ///
    /// ```
    /// let mercy::BuildError::Duplicate(err) = mercy::act::<String, constr::Empty, false>()
    ///     .first("hello")
    ///     .unwrap()
    ///     .first("oops!")
    ///     .unwrap_err();
    ///
    /// assert_eq!(err.which(), mercy::Duplicated::First);
    /// ```
    pub fn which(&self) -> Duplicated {
        self.which
    }

    /// Customize the name of the two keys in the error message.
    ///
    /// To avoid taking up extra space, the keys are provided using [`constr`]s.
    ///
    /// # Examples
    ///
    /// ```
    /// let mercy::BuildError::Duplicate(err) = mercy::act::<String, constr::Empty, false>()
    ///     .first("hello")
    ///     .unwrap()
    ///     .first("oops!")
    ///     .unwrap_err();
    /// println!("{err}"); // got duplicate first key: "hello" and "oops!"
    ///
    /// constr::constr! {
    ///     type K1 = "greeting";
    ///     type K2 = "entity";
    /// }
    ///
    /// let err: mercy::CustomDuplicateError<String, K1, K2> = err.custom();
    /// println!("{err}"); // got duplicate greeting: "hello" and "oops!"
    /// ```
    pub fn custom<K1: Constr, K2: Constr>(self) -> CustomDuplicateError<S, K1, K2> {
        Custom {
            err: self,
            marker: PhantomData,
        }
    }
}
impl<S: AsRef<str> + Clone> Clone for DuplicateError<S> {
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn clone(&self) -> Self {
        DuplicateError {
            pair: self.pair.clone(),
            which: self.which,
        }
    }
}
impl<S1: AsRef<str>, S2: AsRef<str>> PartialEq<DuplicateError<S2>> for DuplicateError<S1> {
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn eq(&self, other: &DuplicateError<S2>) -> bool {
        self.which() == other.which() && self.spair() == other.spair()
    }
}
impl<S: AsRef<str>> Eq for DuplicateError<S> {}
impl<S: AsRef<str>> hash::Hash for DuplicateError<S> {
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn hash<H: hash::Hasher>(&self, state: &mut H) {
        self.spair().hash(state);
        self.which().hash(state);
    }
}
impl<S: AsRef<str> + Copy> Copy for DuplicateError<S> {}
impl<S: AsRef<str>> fmt::Debug for DuplicateError<S> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("DuplicateError")
            .field("pair", &self.pair())
            .field("which", &self.which)
            .finish()
    }
}
impl<S: AsRef<str>> StdError for DuplicateError<S> {}
impl<S: AsRef<str>> fmt::Display for DuplicateError<S> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let (first, second) = self.pair();
        let which = match self.which {
            Duplicated::First => "first",
            Duplicated::Second => "second",
        };
        write!(f, "got duplicate {which} key: {first:?} and {second:?}")
    }
}

/// Error when building a [`Spair`] with [`Act::finish`].
pub enum BuildError<S: Stringable> {
    /// Wrote two strings to the same slot.
    Duplicate(DuplicateError<S>),

    /// Insufficient capacity when building pair.
    Capacity(<S::Builder as Stringy>::Error),
}
impl<S: Stringable + Clone> Clone for BuildError<S>
where
    <S::Builder as Stringy>::Error: Clone,
{
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn clone(&self) -> Self {
        match self {
            BuildError::Duplicate(err) => BuildError::Duplicate(err.clone()),
            BuildError::Capacity(err) => BuildError::Capacity(err.clone()),
        }
    }
}
impl<S: Stringable + Copy> Copy for BuildError<S> where <S::Builder as Stringy>::Error: Copy {}
impl<S1: Stringable, S2: Stringable> PartialEq<BuildError<S2>> for BuildError<S1>
where
    <S1::Builder as Stringy>::Error: PartialEq<<S2::Builder as Stringy>::Error>,
{
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn eq(&self, other: &BuildError<S2>) -> bool {
        match (self, other) {
            (BuildError::Duplicate(lhs), BuildError::Duplicate(rhs)) => lhs == rhs,
            (BuildError::Capacity(lhs), BuildError::Capacity(rhs)) => lhs == rhs,
            _ => false,
        }
    }
}
impl<S: Stringable> hash::Hash for BuildError<S>
where
    <S::Builder as Stringy>::Error: hash::Hash,
{
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn hash<H: hash::Hasher>(&self, state: &mut H) {
        discriminant(self).hash(state);
        match self {
            BuildError::Duplicate(err) => err.hash(state),
            BuildError::Capacity(err) => err.hash(state),
        }
    }
}
impl<S: Stringable> Eq for BuildError<S> where <S::Builder as Stringy>::Error: Eq {}
impl<S: Stringable> fmt::Debug for BuildError<S>
where
    <S::Builder as Stringy>::Error: fmt::Debug,
{
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            BuildError::Duplicate(err) => fmt::Debug::fmt(err, f),
            BuildError::Capacity(err) => fmt::Debug::fmt(err, f),
        }
    }
}
impl<S: 'static + Stringable> StdError for BuildError<S>
where
    <S::Builder as Stringy>::Error: 'static + StdError,
{
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        match self {
            BuildError::Duplicate(err) => Some(err),
            BuildError::Capacity(err) => Some(err),
        }
    }
}
impl<S: Stringable> fmt::Display for BuildError<S>
where
    <S::Builder as Stringy>::Error: fmt::Display,
{
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            BuildError::Duplicate(err) => fmt::Display::fmt(err, f),
            BuildError::Capacity(err) => fmt::Display::fmt(err, f),
        }
    }
}

/// Lets you build a [`Spair`].
///
/// See [`Act`] for more information on usage.
///
/// # Examples
///
/// ```
/// constr::constr! { type Sep = "-"; }
///
/// let mut builder = mercy::act::<String, Sep, false>();
///
/// println!("{:?}", builder); // Act(_, _)
/// ```
pub fn act<S: Stringable, Sep: Constr, const SPLIT_SEP: bool>() -> Act<S, Sep, SPLIT_SEP> {
    Act {
        buf: S::Builder::new(),
        state: State::NEITHER,
        phantom: PhantomData,
    }
}

/// Builder made with [`act`].
///
/// [`Act`]ing lets you set individual sides of the pair using a builder. If you don't care about
/// the order of the strings in the pair, you should probably just use [`Spair::new`].
pub struct Act<S: Stringable, Sep: Constr = constr::Empty, const SPLIT_SEP: bool = false> {
    /// Buffer containing string-in-progress.
    buf: S::Builder,

    /// State of builder.
    state: State,

    /// Phantom marker for separator.
    phantom: PhantomData<Sep>,
}
impl<S: Stringable, Sep: Constr, const SPLIT_SEP: bool> Act<S, Sep, SPLIT_SEP> {
    /// Add the first string to the pair.
    ///
    /// # Examples
    ///
    /// ```
    /// constr::constr! { type Sep = "-"; }
    ///
    /// let builder = mercy::act::<String, Sep, false>()
    ///     .first("hello")
    ///     .unwrap();
    ///
    /// println!("{builder:?}"); // Act("hello", _)
    /// ```
    pub fn first<F: AsRef<str>>(mut self, s: F) -> Result<Act<S, Sep, SPLIT_SEP>, BuildError<S>> {
        let s = s.as_ref();
        if self.state.has_first() {
            if let Some(mut split) = self.state.as_split() {
                if SPLIT_SEP {
                    split -= Sep::STR.len();
                }
                self.buf.truncate_back(split);
            }
            let split = self.buf.len();
            self.buf.push_back(s).map_err(BuildError::Capacity)?;

            Err(BuildError::Duplicate(DuplicateError {
                // SAFETY: We formed the pair correctly.
                pair: unsafe { Spair::split_unchecked(self.buf.into(), split) },
                which: Duplicated::First,
            }))
        } else if self.state.has_second() {
            let mut split = self.buf.len();
            if SPLIT_SEP {
                split += Sep::STR.len();
            }
            self.buf
                .push_front_many(&[s, Sep::STR])
                .map_err(BuildError::Capacity)?;
            self.state = State::new(split);
            Ok(self)
        } else {
            self.buf.push_back(s).map_err(BuildError::Capacity)?;
            self.state = State::SECOND;
            Ok(self)
        }
    }

    /// Add the second string to the pair.
    ///
    /// # Examples
    ///
    /// ```
    /// constr::constr! { type Sep = "-"; }
    ///
    /// let builder = mercy::act::<String, Sep, false>()
    ///     .second("world")
    ///     .unwrap();
    ///
    /// println!("{builder:?}"); // Act(_, "world")
    /// ```
    pub fn second<F: AsRef<str>>(mut self, s: F) -> Result<Act<S, Sep, SPLIT_SEP>, BuildError<S>> {
        let s = s.as_ref();
        if self.state.has_second() {
            if let Some(mut split) = self.state.as_split() {
                if !SPLIT_SEP {
                    split += Sep::STR.len();
                }
                self.buf.remove_front(split);
            }
            let split = self.buf.len();
            self.buf.push_back(s).map_err(BuildError::Capacity)?;

            Err(BuildError::Duplicate(DuplicateError {
                // SAFETY: We formed the pair correctly.
                pair: unsafe { Spair::split_unchecked(self.buf.into(), split) },
                which: Duplicated::Second,
            }))
        } else if self.state.has_first() {
            let mut split = self.buf.len();
            if SPLIT_SEP {
                split += Sep::STR.len();
            }
            self.buf
                .push_back_many(&[Sep::STR, s])
                .map_err(BuildError::Capacity)?;
            self.state = State::new(split);
            Ok(self)
        } else {
            self.buf.push_back(s).map_err(BuildError::Capacity)?;
            self.state = State::FIRST;
            Ok(self)
        }
    }

    /// Finish building the pair if complete.
    ///
    /// # Examples
    ///
    /// ```
    /// constr::constr! { type Sep = "-"; }
    ///
    /// let builder = mercy::act::<String, Sep, false>()
    ///     .first("hello")
    ///     .unwrap()
    ///     .second("world")
    ///     .unwrap();
    ///
    /// println!("{builder:?}"); // Act("hello", "world")
    ///
    /// assert_eq!(builder.finish().unwrap().full(), "hello-world");
    /// ```
    pub fn finish(self) -> Result<Spair<S, Sep, SPLIT_SEP>, IncompleteError<S>> {
        if let Some(split) = self.state.as_split() {
            // SAFETY: We formed the pair correctly.
            Ok(unsafe { Spair::split_unchecked(self.buf.into(), split) })
        } else if self.state.has_first() {
            Err(IncompleteError::First(self.buf.into()))
        } else if self.state.has_second() {
            Err(IncompleteError::Second(self.buf.into()))
        } else {
            Err(IncompleteError::Empty)
        }
    }
}
impl<S: Stringable<Builder: Copy>, Sep: Constr, const SPLIT_SEP: bool> Copy
    for Act<S, Sep, SPLIT_SEP>
{
}
impl<S: Stringable<Builder: Clone>, Sep: Constr, const SPLIT_SEP: bool> Clone
    for Act<S, Sep, SPLIT_SEP>
{
    #[cfg_attr(any(coverage_nightly, feature = "nightly"), coverage(off))]
    fn clone(&self) -> Self {
        Act {
            buf: self.buf.clone(),
            state: self.state,
            phantom: PhantomData,
        }
    }
}
impl<S: Stringable, Sep: Constr, const SPLIT_SEP: bool> fmt::Debug for Act<S, Sep, SPLIT_SEP> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(split) = self.state.as_split() {
            // SAFETY: We formed the pair correctly.
            let pair =
                unsafe { <Spair<&str, Sep, SPLIT_SEP>>::split_unchecked(self.buf.as_ref(), split) };
            let (first, second) = pair.pair();
            f.debug_tuple("Act").field(&first).field(&second).finish()
        } else if self.state.has_first() {
            f.debug_tuple("Act")
                .field(&self.buf.as_ref())
                .field(&format_args!("_"))
                .finish()
        } else if self.state.has_second() {
            f.debug_tuple("Act")
                .field(&format_args!("_"))
                .field(&self.buf.as_ref())
                .finish()
        } else {
            f.debug_tuple("Act")
                .field(&format_args!("_"))
                .field(&format_args!("_"))
                .finish()
        }
    }
}