2 files changed, 0 insertions, 279 deletions
diff --git a/mingling_picker/src/value/flag.rs b/mingling_picker/src/value/flag.rs
deleted file mode 100644
index ee0d6ee..0000000
--- a/mingling_picker/src/value/flag.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-use std::{
-    fmt::{Debug, Display},
-    ops::{Deref, Not},
-};
-
-/// Parsed result of a boolean-style command-line flag.
-///
-/// `Flag` is a **value type** that can be declared in [`PickerArg`].
-/// When the user passes `--verbose` on the command line, the parsed result is `Flag::Active`;
-/// when the flag is absent, the result is `Flag::Inactive`.
-///
-/// # Why not just `bool`?
-///
-/// Unlike a raw `bool`, `Flag` carries **explicit semantics** about whether
-/// the flag was actually provided by the user (`Active`) or simply omitted
-/// (`Inactive`). This distinction matters when you want to distinguish
-/// "the user intentionally omitted the flag" from "the flag was processed but
-/// resolved to false" — the `Pickable` implementation for `Flag` always
-/// returns `Parsed(Flag::Inactive)` when no matching argument is found,
-/// rather than `NotFound`, making it always succeed with a meaningful default.
-///
-/// # Conversions
-///
-/// `Flag` interoperates seamlessly with `bool`: `Flag::Active` is `true`,
-/// `Flag::Inactive` is `false`. The [`Deref`] impl allows using a `Flag`
-/// directly in boolean contexts:
-///
-/// ```
-/// # use mingling_picker::value::Flag;
-/// let flag = Flag::Active;
-/// if *flag { /* runs */ }
-/// ```
-///
-/// [`PickerArg`]: crate::PickerArg
-#[derive(Default, Clone, Copy, PartialEq, Eq)]
-pub enum Flag {
-    /// The flag was **not** present on the command line.
-    ///
-    /// This is the default state, equivalent to `false`.
-    #[default]
-    Inactive,
-
-    /// The flag **was** present on the command line.
-    ///
-    /// Equivalent to `true`.
-    Active,
-}
-
-impl Debug for Flag {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Inactive => write!(f, "inactive"),
-            Self::Active => write!(f, "active"),
-        }
-    }
-}
-
-impl Display for Flag {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Inactive => write!(f, "inactive"),
-            Self::Active => write!(f, "active"),
-        }
-    }
-}
-
-impl Flag {
-    /// Converts this `Flag` into a `bool`.
-    ///
-    /// Returns `true` if the flag is [`Active`], `false` if [`Inactive`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use mingling_picker::value::Flag;
-    /// assert!(Flag::Active.bool());
-    /// assert!(!Flag::Inactive.bool());
-    /// ```
-    ///
-    /// [`Active`]: Flag::Active
-    /// [`Inactive`]: Flag::Inactive
-    #[must_use]
-    #[inline(always)]
-    pub fn bool(&self) -> bool {
-        *self == Flag::Active
-    }
-}
-
-impl PartialEq<bool> for Flag {
-    fn eq(&self, other: &bool) -> bool {
-        self.bool() == *other
-    }
-}
-
-/// Compares `bool` with `Flag` using `==`.
-impl PartialEq<Flag> for bool {
-    fn eq(&self, other: &Flag) -> bool {
-        *self == other.bool()
-    }
-}
-
-impl From<bool> for Flag {
-    fn from(value: bool) -> Self {
-        if value { Flag::Active } else { Flag::Inactive }
-    }
-}
-
-impl From<Flag> for bool {
-    fn from(val: Flag) -> Self {
-        val == Flag::Active
-    }
-}
-
-/// Allows `Flag` to be used in boolean contexts via `*flag`.
-///
-/// # Examples
-///
-/// ```
-/// # use mingling_picker::value::Flag;
-/// let flag = Flag::Active;
-/// if *flag {
-///     println!("flag is set");
-/// }
-/// ```
-impl Deref for Flag {
-    type Target = bool;
-
-    fn deref(&self) -> &bool {
-        match self {
-            Flag::Active => &true,
-            Flag::Inactive => &false,
-        }
-    }
-}
-
-impl Not for Flag {
-    type Output = Flag;
-
-    fn not(self) -> Flag {
-        match self {
-            Flag::Active => Flag::Inactive,
-            Flag::Inactive => Flag::Active,
-        }
-    }
-}
diff --git a/mingling_picker/src/value/vec_until.rs b/mingling_picker/src/value/vec_until.rs
deleted file mode 100644
index 1b79641..0000000
--- a/mingling_picker/src/value/vec_until.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-use std::marker::PhantomData;
-use std::ops::{Deref, DerefMut};
-
-use crate::{
-    BoundaryCheck, MultiPickableWithBoundary, Pickable, PickerArg, PickerArgAttr, PickerArgResult,
-    SinglePickable, TagPhaseContext,
-    matcher_needed::Matcher,
-    parselib::{MultiArgMatcher, ParserStyle},
-};
-
-/// A `Vec`-like container that stops collecting when [`BoundaryCheck`]
-/// returns `true`.
-///
-/// This type exists to signal "I know what I'm doing with boundaries"
-/// at the type level (as opposed to `Vec<T>` which greedily takes
-/// everything).
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct VecUntil<T> {
-    pub(crate) inner: Vec<T>,
-    _marker: PhantomData<T>,
-}
-
-impl<T> VecUntil<T> {
-    pub fn into_inner(self) -> Vec<T> {
-        self.inner
-    }
-}
-
-impl<T> From<Vec<T>> for VecUntil<T> {
-    fn from(v: Vec<T>) -> Self {
-        VecUntil {
-            inner: v,
-            _marker: PhantomData,
-        }
-    }
-}
-
-impl<T> From<VecUntil<T>> for Vec<T> {
-    fn from(v: VecUntil<T>) -> Self {
-        v.inner
-    }
-}
-
-impl<T> Deref for VecUntil<T> {
-    type Target = Vec<T>;
-    fn deref(&self) -> &Vec<T> {
-        &self.inner
-    }
-}
-
-impl<T> DerefMut for VecUntil<T> {
-    fn deref_mut(&mut self) -> &mut Vec<T> {
-        &mut self.inner
-    }
-}
-
-// MultiPickableWithBoundary impl
-
-impl<T> MultiPickableWithBoundary for VecUntil<T>
-where
-    T: SinglePickable + BoundaryCheck,
-{
-    type Checker = T;
-
-    fn pick_multi(raw: Vec<String>) -> PickerArgResult<Self> {
-        let mut inner = Vec::with_capacity(raw.len());
-        for s in &raw {
-            match T::pick_single(Some(s)) {
-                PickerArgResult::Parsed(v) => inner.push(v),
-                PickerArgResult::NotFound => return PickerArgResult::NotFound,
-                PickerArgResult::Unparsed => {}
-            }
-        }
-        PickerArgResult::Parsed(VecUntil {
-            inner,
-            _marker: PhantomData,
-        })
-    }
-}
-
-// Pickable impl
-
-impl<'a, T> Pickable<'a> for VecUntil<T>
-where
-    T: SinglePickable + BoundaryCheck,
-{
-    fn get_attr(flag: &'a PickerArg<'a, Self>) -> PickerArgAttr {
-        PickerArgAttr::positional_or_multi(flag)
-    }
-
-    fn tag(ctx: TagPhaseContext) -> Vec<usize> {
-        let args = ctx.args;
-        let is_positional = ctx.arg_info.positional;
-        let positions = MultiArgMatcher::match_all(ctx.into());
-        if positions.is_empty() {
-            return positions;
-        }
-
-        let start = if is_positional { 0 } else { 1 };
-        if start >= positions.len() {
-            return positions;
-        }
-
-        let mut cut = start;
-        for &idx in &positions[start..] {
-            if let Some(raw) = args.get(idx)
-                && T::check_boundary(raw)
-            {
-                break;
-            }
-            cut += 1;
-        }
-
-        positions[..cut].to_vec()
-    }
-
-    fn pick(raw_strs: &[&str]) -> PickerArgResult<Self> {
-        let strs = strip_flag(raw_strs);
-        let owned: Vec<String> = strs.iter().map(|&s| s.to_string()).collect();
-        <VecUntil<T> as MultiPickableWithBoundary>::pick_multi(owned)
-    }
-}
-
-/// If the first raw string looks like a named flag (starts with the
-/// style's long or short prefix), strip it — it's the flag, not a value.
-fn strip_flag<'a>(raw_strs: &'a [&'a str]) -> &'a [&'a str] {
-    if let Some(first) = raw_strs.first() {
-        let style = ParserStyle::global_style();
-        if first.starts_with(style.long_prefix) || first.starts_with(style.short_prefix) {
-            return &raw_strs[1..];
-        }
-    }
-    raw_strs
-}