Enum DepList 

pub enum DepList {
    Prod,
    Dev,
}

Closed-set typed enum for the two dep-list author-surface axes every top-level crate::Caixa carries — the runtime-closure :deps slot (Prod) and the dev-only-closure :deps-dev slot (Dev). Every substrate consumer that dispatches on “which of the two dep-lists” (the feira add mutation head, the future per-cluster dev-closure- audit overlay the M4 CR materializer resolves per-CR, the future caixa app graph per-list dep summary, every future Caixa::push_dep / Caixa::deps_by_list typed-method dispatch a caller reaches for) reads through this enum rather than through a bare &'static str — the closed-set is expressed at the type layer, so a future third dep-list axis (a :deps-build build-only closure once the substrate grows cross-artifact heterogeneous dep-graphs, per CAIXA-SDLC §I) is one variant plus one arm per method and the compiler enforces exhaustiveness on every consumer’s match arms.

The wire byte-string Self::as_str returns is the same author- surface tag the sibling crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV constants carry — the DepError::DuplicateNome / DepError::DepIsSelf list: &'static str payload family the substrate already emits routes through the same source of truth (an author reading a DepError::DuplicateNome refusal can grep their caixa.lisp for the offending :deps / :deps-dev block in one edit whether the diagnostic came from a Caixa::validate_deps walk or a Caixa::push_dep mutation).

Same “closed-set typed-enum discriminator with canonical projections per axis” discipline the sibling closed-set typed enums on the caixa typed surface carry (crate::aplicacao::PlacementStrategy cc8f749, crate::aplicacao::RateLimitUnit 6bce03d, crate::supervisor::RestartStrategy, crate::supervisor::RestartPolicy, crate::upgrade::UpgradeInstruction, crate::CaixaKind) — extended onto the outer-Caixa two-list dep-graph axis, the substrate’s last unlifted closed-set-shaped &'static str-carrying axis on the top-level manifest surface.

Variants

Prod

Runtime-closure :deps axis — the load-bearing dep-list the lacre closure resolves at every build. Wire-format crate::render::DEP_AUTHOR_KEY_DEPS.

Dev

Dev-only-closure :deps-dev axis — Cargo’s [dev-dependencies] table’s dev-time-only visibility contract per CAIXA-SDLC §I. Wire-format crate::render::DEP_AUTHOR_KEY_DEPS_DEV.

Implementations

impl DepList

pub const fn is_prod(&self) -> bool

pub const fn is_dev(&self) -> bool

impl DepList

pub const ALL: &'static [Self]

Exhaustive iteration surface for every consumer that reads the full closed-set (the future M4 admission webhook’s per-list summary rejection body, any future round-trip pin harness). A future variant addition extends this slice as a single edit and every consumer picks up the new entry by construction — the compiler-checked exhaustiveness on the sibling method match arms is the build-time guarantee that no arm forgets to grow.

pub const fn as_str(self) -> &'static str

Canonical author-surface tag every substrate consumer that names the offending dep-list in a diagnostic reaches for — crate::render::DEP_AUTHOR_KEY_DEPS for Self::Prod and crate::render::DEP_AUTHOR_KEY_DEPS_DEV for Self::Dev, the same &'static str payload the sibling DepError::DuplicateNome and DepError::DepIsSelf variants already carry. Routing every dep-list diagnostic through the closed-set enum’s as_str closes the last &'static str-shape literal-carry axis on the two-list dep-graph surface — a future kebab-case rebrand (":deps" → ":packages") or a wire-format promotion (a distinct diagnostic form for the Dev arm) reaches every consumer through one edit on the canonical constant, not a coordinated rewrite across the substrate’s dep-graph consumers.

pub fn from_wire(s: &str) -> Option<Self>

Substrate-canonical reverse projection on the two-list dep-graph axis — parses the author-surface wire tag back to the typed variant, or None when s is outside the closed-set arm-string set Self::as_str emits. Dispatches on the same lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV constants the Self::as_str emitter walks, so the parse and emit halves of the round-trip migrate through one caixa-core edit on any future list-axis addition.

Prior to this lift the substrate carried only the forward Self → &str projection on the two-list dep-graph axis (the Self::as_str emitter, the std::fmt::Display impl routed through it, the two DepError::DuplicateNome / DepError::DepIsSelf variants that carry the wire tag verbatim as a &'static str list: field). Every future consumer that wanted to promote the wire tag back to the typed enum (a future feira dep --list <deps|deps-dev> CLI arg-parse that binds the wire form into the typed enum before dispatching to crate::Caixa::deps_of / crate::Caixa::push_dep, the M4 mesh.pleme.io/v1alpha1/Caixa CR materializer’s admission-time wire re-parse of the per-list diagnostic body, a future DepError widening that promotes the two list: &'static str fields to a typed list: DepList carry so downstream consumers dispatch on the enum rather than string-comparing the wire scalar) would have had to re-inline a two-arm match s { ":deps" => …, ":deps-dev" => …, _ => … } cascade that expressed no compile-time link back to the typed DepList enum. A future variant addition (a :build-dep or :test-dep third list once the substrate grows Cargo-style split-graphs, a :tool-dep for build-time-only tooling per the peer Cargo [build-dependencies] / [target.<cfg>.dev-dependencies] future admission surface) would silently split the wire byte-string the emitter walks from the parser’s arm-set — the round-trip would carry the new list through the forward projection but land on the fallback silently at every non-updated reverse parser, far from the arm-addition commit that caused the drift. Lifting the resolver to a typed method on the substrate primitive closes the drift footgun by construction: the parser’s accept-set is the same set the Self::as_str emitter walks (routed through the same lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV consts), so both halves of the round-trip migrate through one caixa-core edit on any future list-axis addition.

Same closed-set-reverse-projection discipline the sibling crate::CaixaKind::from_wire (2aa6d23) / crate::supervisor::RestartStrategy::from_wire (4eec29c) / crate::supervisor::RestartPolicy::from_wire (dd32ccf) / crate::aplicacao::PlacementStrategy::from_wire (18c7342) / crate::aplicacao::RateLimitUnit::from_suffix typed enums carry on the peer wire-side str → Self axes — extended onto the two-list dep-graph closed-set axis, the sixth substrate-side closed-set typed enum on the caixa surface to converge on the two-way str ↔ Self round-trip. Method-named from_wire (not from_str) to match the peer shapes verbatim and side-step the derived std::str::FromStr impls the sibling gen_platform::FromStrKind-carrying axes install on their kebab-case dispatcher-catalog identity. Returns Option<Self> (rather than Result<Self, _>) to match the peer shapes: the caller picks the diagnostic form appropriate for its use site — a future feira dep --list … arg-parse that surfaces unknown list: <arg> at the CLI builds one on top by iterating Self::ALL, while the future M4 admission-webhook’s rejection path folds None onto its per-CR structured refusal body.

Trait Implementations

impl AsRef<str> for DepList

Substrate-canonical AsRef<str> projection on the two-list dep-graph closed-set typed enum — routes through the same DepList::as_str pub const fn scalar accessor the paired std::fmt::Display impl already delegates through, so any future consumer that binds a DepList through the standard-library impl AsRef<str> bound (a std::process::Command::arg shell-out that composes the canonical author-surface tag into a feira dep --list <deps|deps-dev> diagnostic overlay, a tracing::field::Value::Str-arm structured-log recorder on the DepError::DuplicateNome / DepError::DepIsSelf refusal paths, a std::collections::HashMap lookup keyed on the canonical tag through map.get::<str>(list.as_ref()) on a future M4 admission- webhook’s per-list rejection-body composition table) reaches the paired crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV byte-string through one substrate-primitive dispatch rather than an open-coded .as_str() re-inlining at every wire-up.

Same “route the trait impl through the substrate-primitive accessor” discipline the sibling crate::CaixaDialeto AsRef<str> impl (1723611), the crate::aplicacao::RateLimitUnit AsRef<str> impl (d8136db), the crate::CaixaKind AsRef<str> impl (cd2091f), the M3 crate::aplicacao::PlacementStrategy AsRef<str> impl (d86edd2), the M2 crate::supervisor::RestartPolicy AsRef<str> impl (419ea81), the M2 crate::supervisor::RestartStrategy AsRef<str> impl (63eb1a4), and the crate::CaixaVersion AsRef<str> impl (16d5c7e) carry — closes the substrate primitive’s AsRef<str> projection axis on the seventh (and last unlifted) closed-set typed enum on the caixa surface: the two-list dep-graph axis previously carried [fmt::Display]-through-as_str but not yet the paired AsRef<str> impl, so a downstream consumer that bound the enum through the standard-library AsRef<str> trait had to reach the canonical byte-string through an open-coded .as_str() call rather than the trait-idiomatic .as_ref() the peer closed-set typed enums already admit.

Pinned load-bearing by [tests::dep_list_as_ref_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm closed set) and [tests::dep_list_as_ref_str_routes_through_display_via_shared_accessor] (three-path convergence: AsRef<str> + Display + as_str all resolve to the same byte-string per arm) — any future silent detour that routes the impl through a divergent projection (a per-arm inline match self { DepList::Prod => ":deps", … } re-inlining that opens a compile-time link to the un-lifted arm-literal, a swap onto a second projection axis) trips at caixa-core test time under assert_eq! rather than at a downstream impl AsRef<str>-bound consumer’s silent split.

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for DepList

fn clone(&self) -> DepList

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DepList

impl Debug for DepList

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

Formats the value using the given formatter.

impl Display for DepList

Route std::fmt::Display through DepList::as_str, so every consumer that formats the axis as user-facing text (a future feira app graph per-list summary, a future M4 admission-webhook rejection body naming the offending list, this crate’s own DepError #[error(...)] templates when they widen to carry a typed DepList) lands on the same author-surface tag the crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV constants carry. Same as-str-through-Display convergence discipline the sibling crate::aplicacao::PlacementStrategy, crate::aplicacao::RateLimitUnit, crate::supervisor::RestartStrategy, crate::supervisor::RestartPolicy, and crate::CaixaKind closed-set typed enums carry.

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

Formats the value using the given formatter.

impl Eq for DepList

impl From<&DepList> for &'static str

Trait-idiomatic forward projection on the two-list dep-graph DepList closed-set typed enum from a borrowed input onto the &'static str axis — the borrowed-input companion to the paired owned-input [From<DepList> for &'static str] impl immediately above. Routes byte-for-byte through the same substrate-primitive DepList::as_str pub const fn accessor so every consumer that binds a &DepList through the standard-library .into() / [From<&Self> for &'static str] axis (a DepList::ALL.iter().map(<&'static str>::from).collect::<Vec<_>>() per-arm accept-set materializer that iterates the substrate- canonical DepList::ALL slice — whose iterator yields &DepList, not DepList, so the owned-input From<DepList> axis alone forces every call site through an explicit .copied() / dereference / Copy-bound restatement rather than the direct trait-idiomatic projection; a future generic <T: Copy + for<'a> Into<&'static str>>-bound diagnostic column that walks the iter().map(Into::into) shape verbatim; the future M4 admission-webhook rejection body that composes the accepted-set enumeration from an iterated DepList::ALL.iter().map(|l| l.into()) pipe rather than a per-arm match l { … } cascade) reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV const the paired owned-input [From<DepList> for &'static str], the sibling std::fmt::Display, AsRef<str>, and DepList::as_str surfaces already return.

Opens the substrate-wide trait-idiomatic borrowed-input forward-projection family on the last-touched closed-set fieldless typed enum — first-mover on the borrowed-input axis, mirroring the role crate::supervisor::RestartStrategy played on the owned- input axis (523157d). Rust’s From trait does not auto-derive the From<&Self> sibling from a From<Self> impl (the blanket impl<T, U> From<&T> for U where T: Copy, U: From<T> does not exist in core), so every closed-set typed enum that carries the owned-input axis but not the borrowed-input axis forces every borrowed-input call site through a .copied() / <&'static str>::from(*list) / list.as_str() detour whose type bounds have no compile-time link to the substrate primitive. The remaining fourteen substrate-wide closed-set fieldless typed enum peers (CaixaKind, CaixaDialeto, RestartStrategy, RestartPolicy, WitShape, RateLimitUnit, PlacementStrategy, PathShapeViolation, InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) are the future targets of this campaign.

Pinned load-bearing by [tests::dep_list_from_borrowed_into_static_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm emit-set via a borrowed input, plus a const-context materialization witness) and [tests::dep_list_from_owned_and_borrowed_into_static_str_agree_on_every_arm] (cross-axis partition pin against the paired owned-input [From<DepList> for &'static str] impl).

fn from(list: &DepList) -> &'static str

Converts to this type from the input type.

impl From<&DepList> for String

Trait-idiomatic borrowed-input, owned-String output forward projection on the two-list dep-graph DepList closed-set typed enum — the fourth (and closing) corner of the {Self, &Self} × {&'static str, String} 2×2 trait-idiomatic projection family on this enum, mirror of the peer M2 OTP-shape [From<&RestartStrategy> for String] (579385f) and [From<&RestartPolicy> for String] (8465740) that opened and closed the corner on the sibling supervisor-level restart-strategy and per-child restart-decision enums. Routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor (via str::to_owned) so every consumer that holds a borrowed [&DepList] and needs an owned String — a future serde_json::Value::String(String::from(&list)) structured-payload composer over a borrowed field, a future Iterator::map over &[DepList] that projects to owned keys through .iter().map(String::from) (whose iterator yields &DepList, not DepList, so the owned-input [From<DepList> for String] axis alone forces every call site through an explicit .copied() / spurious Copy deref restatement rather than the direct trait- idiomatic projection), a future HashMap::<String, DepList>::from_iter that keys off a borrowed-iteration axis where dereferencing the list would force an unnecessary Copy at every step, the future wasm-operator’s per-manifest list_axes.iter().map(String::from).collect() per-list author-surface-tag diagnostic emit whose iteration axis is borrowed by construction — reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV const the paired std::fmt::Display, AsRef<str>, DepList::as_str, and the three other trait-idiomatic forward-projection impls ([From<DepList> for &'static str], [From<&DepList> for &'static str], [From<DepList> for String]) already return.

Third peer on the substrate-wide trait-idiomatic borrowed-input, owned-String output forward-projection family opened on crate::supervisor::RestartStrategy (579385f) and closed on crate::supervisor::RestartPolicy (8465740) — extends the {Self, &Self} × {&'static str, String} 2×2 projection corner off the M2 OTP-shape axis pair onto the first non-M2 closed-set fieldless typed enum peer (the two-list dep-graph axis). Rust’s standard library does not carry a blanket impl<T: AsRef<str>> From<&T> for String (nor an impl<T: fmt::Display> From<&T> for String), so every closed-set typed enum that carries the paired AsRef<str> / Display / From<Self> for &'static str / From<&Self> for &'static str / From<Self> for String quintuple but not the borrowed-input owned- String axis forces every borrowed-input owned-string call site through a list.as_str().to_owned() / String::from(*list) (with a spurious Copy) / list.to_string() (through Display) detour whose type bounds have no compile-time link to the substrate primitive.

Same as the peer crate::supervisor::RestartStrategy / crate::supervisor::RestartPolicy borrowed-input owned-String axis pairs (whose forward emit and reverse parse share one vocabulary by construction — PascalCase on the M2 OTP-shape peers), DepList’s DepList::as_str emit and DepList::from_wire parse resolve through the same lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV consts by construction (the ":deps" / ":deps-dev" leading-colon lispy author-surface tags — there is no wire/diagnostic axis split on this enum), so the borrowed-input owned-String projection this impl exposes composes directly with the paired trait-idiomatic reverse TryFrom<&str> axis on the owned-String’s String::as_str borrow — no intermediate wire-vocab hop like the peer crate::CaixaKind axis pair requires.

The remaining ten closed-set typed enums on the caixa substrate surface (CaixaKind, CaixaDialeto, PlacementStrategy, WitShape, RateLimitUnit, PathShapeViolation, InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) are the future targets of this 2×2-completion campaign — each carries the same paired quintuple that this borrowed-input owned- String axis extends onto.

Pinned load-bearing by [tests::dep_list_from_into_borrowed_owned_string_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm emit-set through the borrowed-input surface) and [tests::dep_list_from_into_borrowed_owned_string_agrees_with_paired_axes_on_every_arm] (cross-axis partition pin against the paired owned-input owned- String [From<DepList> for String] impl, the paired borrowed- input owned-[&'static str] [From<&DepList> for &'static str] impl, and the sibling ToString::to_string surface routed through std::fmt::Display, plus a direct round-trip witness through TryFrom<&str> on the owned-String’s String::as_str borrow that closes the two-way &Self → String → Self round-trip on the trait-idiomatic borrowed-input owned-String forward + reverse axis pair).

fn from(list: &DepList) -> String

Converts to this type from the input type.

impl From<&DepList> for Cow<'static, str>

Trait-idiomatic borrowed-input, std::borrow::Cow<'static, str> output forward projection on the two-list dep-graph DepList closed-set typed enum — the borrowed-input companion to the paired owned-input [From<DepList> for std::borrow::Cow<'static, str>] impl immediately above (6858bac). Routes byte-for-byte through the same substrate-primitive DepList::as_str pub const fn accessor (via std::borrow::Cow::Borrowed) so every consumer that holds a &DepList and needs a std::borrow::Cow<'static, str> — a DepList::ALL.iter().map(std::borrow::Cow::from).collect::<Vec<_>>() per-arm accept-set materializer whose iterator over &'static [DepList] yields &DepList (not DepList, so the paired owned-input [From<DepList> for std::borrow::Cow<'static, str>] axis alone forces every call site through an explicit .copied() / dereference / Copy-bound restatement rather than the direct trait-idiomatic projection), a future generic <T: for<'a> Into<std::borrow::Cow<'static, str>>>-bound emitter on a per-:deps / :deps-dev diagnostic column that walks the iter().map(Into::into) shape verbatim, the future M4 caixa.pleme.io/v1alpha1/Caixa CR admission-webhook rejection body that composes the accepted-:deps / :deps-dev list-key enumeration from an iterated DepList::ALL.iter().map(|l| l.into()) pipe rather than a per-arm match l { … } cascade — reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV byte-string the paired std::fmt::Display, AsRef<str>, DepList::as_str, the four {Self, &Self} × {&'static str, String} 2×2 trait-idiomatic forward-projection corners, and the paired owned-input [From<DepList> for std::borrow::Cow<'static, str>] impl already return.

Deliberately returns std::borrow::Cow::Borrowed rather than std::borrow::Cow::Owned — the substrate-primitive DepList::as_str accessor’s return carries the &'static str lifetime by construction (each match arm resolves to one of the two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings with static lifetime), so the zero-alloc borrowed arm is the type-correct projection with no runtime allocation on the borrowed-input surface just as on the paired owned-input surface.

Closes the {Self, &Self} input-shape corner on the outside-M3 caixa-core two-list dep-graph std::borrow::Cow<'static, str> axis opened one commit prior (6858bac) on the paired owned-input [From<DepList> for std::borrow::Cow<'static, str>] impl — first outside-M3 caixa-core peer on the axis, one commit after the paired M3-mesh-shape crate::aplicacao::RateLimitUnit :politicas :rate-limit canonical-suffix (1d59925), the paired M3-mesh-shape crate::aplicacao::PlacementStrategy :placement :estrategia distribution-strategy (eee504d + afdf0f4), the paired M3-mesh-shape crate::aplicacao::WitShape :contratos :wit census-label (8634dec + 25690ef), the paired M2 OTP-shape crate::supervisor::RestartStrategy (7dd28b3 + 9b3e4b3) and crate::supervisor::RestartPolicy (0612398 + ee577fd), and the paired top-level crate::CaixaKind (99c1735 + d45c409) peers closed the M3-mesh-shape, M2-OTP-shape, and top-level tiers. Rust’s standard library does not carry a blanket impl<T: AsRef<str>> From<&T> for Cow<'static, str> (nor an impl<T: fmt::Display> From<&T> for Cow<'static, str>), so every closed-set fieldless typed enum peer on the substrate that carries the paired owned-input [Cow<'static, str>] axis but not the borrowed-input axis forces every borrowed-input [Cow<'static, str>]-parameterized call site through a spurious Copy deref (std::borrow::Cow::from(*list)) or a std::borrow::Cow::Borrowed(list.as_str()) open-code whose type bounds have no compile-time link to the substrate primitive.

The remaining outside-M3 caixa-core peers (crate::CaixaDialeto, crate::render::PathShapeViolation) and the outside-caixa-core peers (InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) are the remaining future targets of the campaign; closing this borrowed-input corner on DepList leaves crate::CaixaDialeto as the next outside-M3 caixa-core closed-set fieldless typed enum peer target on the std::borrow::Cow<'static, str> axis.

Same three-path convergence discipline as the paired sibling [From<&DepList> for &'static str], [From<&DepList> for String], std::fmt::Display, and AsRef<str> surfaces (this borrowed- input std::borrow::Cow<'static, str> axis, the paired owned- input [From<DepList> for std::borrow::Cow<'static, str>] axis, the paired sibling {Self, &Self} × {&'static str, String} 2×2 corners, and DepList::as_str all route through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str values by construction), so a future variant addition, rename, or per-arm wire-tag drift reaches every forward-projection path through exactly one caixa-core edit at the DepList::as_str match head.

Pinned load-bearing by [tests::dep_list_from_borrowed_into_static_cow_str_routes_through_as_str_accessor] (byte-parity + zero-alloc std::borrow::Cow::Borrowed-arm pin against DepList::as_str across the two-arm DepList::ALL through the borrowed-input surface) and [tests::dep_list_from_borrowed_into_static_cow_str_agrees_with_paired_axes_on_every_arm] (cross-axis partition pin against the paired owned-input [From<DepList> for std::borrow::Cow<'static, str>], the paired borrowed-input owned-&'static str [From<&DepList> for &'static str], and the paired borrowed-input owned-String [From<&DepList> for String] impls, plus a .iter().map(std::borrow::Cow::from) pipe witness over DepList::ALL — whose iterator yields &DepList by construction, so the borrowed-input std::borrow::Cow<'static, str> axis is what routes the pipe through the substrate-primitive DepList::as_str accessor with the zero-alloc std::borrow::Cow::Borrowed arm by construction and without a spurious Copy deref).

fn from(list: &DepList) -> Cow<'static, str>

Converts to this type from the input type.

impl From<&DepList> for Box<str>

Trait-idiomatic borrowed-input, Box<str> output forward projection on the outside-M3 caixa-core two-list dep-graph DepList closed-set fieldless typed enum. Routes byte-for-byte through the substrate- primitive DepList::as_str pub const fn accessor via Box::<str>::from on the returned &'static str, so every consumer that binds a let key: Box<str> = (&list).into();-shaped call site or a DepList::ALL.iter().map(Box::<str>::from)-shaped pipe (whose iterator over &'static [DepList] yields &DepList by construction) — a per-:deps / :deps-dev census-key materializer that stashes the dep-list discriminator in a Box<str>-typed heap-owned scalar for cheap clone off a borrowed handle, a future M4 admission-webhook rejection body whose per-arm Box<str> field composes from a borrowed DepList handle off a &DepList borrow, a future feira lint --explain-dep-list per-axis listing that iterates DepList::ALL into per-arm owned Box<str> labels — reaches the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings the sibling {Self, &Self} × {&'static str, String, Cow<'static, str>} forward-projection corner and the paired owned-input [From<DepList> for Box<str>] already return.

Rust’s standard library carries impl From<&str> for Box<str> and impl From<String> for Box<str> but no blanket impl<T: AsRef<str>> From<&T> for Box<str> (nor a Copy-based impl<T: Copy, U: From<T>> From<&T> for U), so this borrowed-input axis is a distinct trait-idiomatic surface that the pipe shape DepList::ALL.iter().map(Box::<str>::from) reaches through this impl and no other — without it, the same pipe would force an explicit .copied() restatement (.iter().copied().map(Box::<str>::from)) whose type bounds have no compile-time link back to the substrate primitive, and a let key: Box<str> = (&list).into();-shaped call site would force an explicit Copy deref (Box::<str>::from(*list)) or a Box::<str>::from(list.as_str()) open-code with the same defect.

Closes the {Self, &Self} input-shape corner on the second caixa- core-internal closed-set fieldless typed enum peer of the substrate- wide trait-idiomatic Box<str> forward-projection campaign — one commit after the paired render-side path-shape-diagnostic crate::render::PathShapeViolation pair (0d87a72) opened the caixa- core-internal tier — matching the trajectory the paired caixa-theme [caixa_theme::style::Semantic] pair (0cd7dc3, both corners in one axis), the caixa-provedor [caixa_provedor::FerriteRuntime] pair (14886a8, both corners in one axis), and the render-side crate::render::PathShapeViolation pair (0d87a72, both corners in one axis) walked before it.

Same discipline as the paired outside-caixa-core, crate::supervisor, crate::aplicacao, and crate::render Box<str> {Self, &Self}-closers: forward emit (this impl, the paired owned-input [From<DepList> for Box<str>] impl, the sibling {&'static str, String, Cow<'static, str>} forward-projection corner, std::fmt::Display, AsRef<str>, DepList::as_str) and reverse parse (DepList::from_wire, TryFrom<&str>) route through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings by construction, so the round-trip composes directly without the wire-vocab intermediate hop the peer crate::CaixaKind axis pair requires.

Pinned load-bearing by [tests::dep_list_from_borrowed_into_box_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set on the borrowed-input surface, plus a blanket-derived Into shape witness, plus a .iter().map(Box::<str>::from) pipe witness over DepList::ALL — whose iterator yields &DepList by construction, so the borrowed- input Box<str> axis is what routes the pipe through the substrate- primitive DepList::as_str accessor without a spurious Copy deref).

fn from(list: &DepList) -> Box<str>

Converts to this type from the input type.

impl From<&DepList> for Arc<str>

Trait-idiomatic borrowed-input, std::sync::Arc<str> output forward projection on the outside-M3 caixa-core two-list dep-graph DepList closed-set fieldless typed enum — the borrowed-input companion to the paired owned-input [From<DepList> for std::sync::Arc<str>] impl immediately above. Routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor via std::sync::Arc::<str>::from on the returned &'static str, so every consumer that binds a let key: std::sync::Arc<str> = (&list).into();-shaped call site or a DepList::ALL.iter().map(std::sync::Arc::<str>::from)-shaped pipe (whose iterator over &'static [DepList] yields &DepList by construction) reaches the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte- strings the paired owned-input [From<DepList> for std::sync::Arc<str>] and the sibling {Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>} forward-projection corner already return.

Rust’s standard library carries impl From<&str> for std::sync::Arc<str> and impl From<String> for std::sync::Arc<str> but no blanket impl<T: AsRef<str>> From<&T> for std::sync::Arc<str> (nor a Copy- based impl<T: Copy, U: From<T>> From<&T> for U), so this borrowed- input axis is a distinct trait-idiomatic surface that the pipe shape DepList::ALL.iter().map(std::sync::Arc::<str>::from) reaches through this impl and no other — without it, the same pipe would force a spurious Copy deref (std::sync::Arc::<str>::from((*list).as_str())) or a .copied() restatement whose type bounds have no compile-time link back to the substrate primitive.

Closes the {Self, &Self} input-shape corner on the second caixa- core-internal closed-set fieldless typed enum peer of the substrate- wide trait-idiomatic std::sync::Arc<str> forward-projection campaign — one commit after the paired top-level crate::CaixaKind pair (c17be64) opened the caixa-core-internal Arc tier — matching the trajectory the paired top-level crate::CaixaKind pair (c17be64, both corners in one axis) walked before it. Leaves the remaining caixa-core-internal closed-set fieldless typed enum peers (crate::dialeto::CaixaDialeto, crate::render::PathShapeViolation) as the campaign’s next multi- peer targets on the caixa-core-internal tier of the Arc axis.

Pinned load-bearing by [tests::dep_list_from_borrowed_into_arc_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set on the borrowed-input surface, plus a blanket-derived Into shape witness, a cross-axis partition pin against the paired owned-input [From<DepList> for std::sync::Arc<str>] and the sibling borrowed- input {&'static str, String, Cow<'static, str>, Box<str>} return- shape axes, and a .iter().map(std::sync::Arc::<str>::from) pipe witness over DepList::ALL that resolves through the borrowed- input axis without a spurious Copy deref).

fn from(list: &DepList) -> Arc<str>

Converts to this type from the input type.

impl From<DepList> for &'static str

Trait-idiomatic forward projection on the two-list dep-graph DepList closed-set typed enum onto the &'static str axis — routes byte-for-byte through the paired substrate-primitive DepList::as_str pub const fn accessor so <&'static str>::from(list) / list.into::<&'static str>() reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV const the sibling std::fmt::Display, AsRef<str>, and DepList::as_str surfaces already return.

Closes the substrate-wide trait-idiomatic forward-projection campaign for real — the campaign opened on crate::supervisor::RestartStrategy via 523157d and traced through the 13 sibling closed-set typed enums (9fb37d0, edb827b, c189a6f, afa3562, 56998ec, 7fdfbf4, 070a6de, f2ca7bc, d4559cb, 5cc3b8b, 2a56127, 07f36bb, 85d0443) silently omitted DepList on both trait-idiomatic axes despite every peer’s docstring naming it as a sibling. Paired with the [TryFrom<&str> for DepList] impl immediately above, this closes the two-way DepList ↔ &'static str round-trip on the trait- idiomatic axis pair, mirroring the pre-existing method-named DepList::as_str + DepList::from_wire pair on the substrate-primitive axis pair.

The paired DepList::as_str returns &'static str by construction — each arm resolves to a crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str with static lifetime — so the trait’s return-type promise is upheld structurally.

Pinned load-bearing by [tests::dep_list_from_into_static_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm emit-set, plus a const-context materialization witness for the &'static str lifetime promise) and [tests::dep_list_from_into_static_str_and_as_str_partition_the_emit_set] (partition pin + two-way round-trip through the paired TryFrom<&str> axis).

fn from(list: DepList) -> &'static str

Converts to this type from the input type.

impl From<DepList> for String

Trait-idiomatic forward projection on the two-list dep-graph DepList closed-set typed enum from an owned input onto the owned-String axis — routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor so every consumer that binds a DepList through the standard-library .into() / [From<Self> for String] (equivalently Into<String>) axis reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV byte-string the paired owned-input [From<DepList> for &'static str], the borrowed-input [From<&DepList> for &'static str], the sibling std::fmt::Display, AsRef<str>, and DepList::as_str surfaces already return.

Extends the trait-idiomatic owned-String forward-projection family (opened on crate::supervisor::RestartStrategy — 7baa18a — the first-mover on the M2 OTP-shape sibling-restart-strategy axis, extended onto crate::supervisor::RestartPolicy — 7851725 — the second-of-two-in-M2 per-child restart-decision axis, then onto crate::CaixaKind — 231a18c — the structurally most fundamental closed-set fieldless typed enum on the caixa surface, then onto crate::CaixaDialeto — 88942cd — the dialect-classification axis) onto the fifth peer: the two-list dep-graph axis DepList carries. Rust’s standard library does not carry a blanket impl<T: AsRef<str>> From<T> for String (nor an impl<T: fmt::Display> From<T> for String), so every closed-set typed enum that carries the paired AsRef<str> / std::fmt::Display / [From<Self> for &'static str] / [From<&Self> for &'static str] quadruple but not the owned-String axis forces every owned-string call site through a .to_string() / .as_str().to_owned() / String::from(list.as_str()) detour whose type bounds have no compile-time link to the substrate primitive.

Same as the peer crate::supervisor::RestartStrategy / crate::supervisor::RestartPolicy / crate::CaixaDialeto owned-String axis pairs (whose forward emit and reverse parse share one vocabulary by construction — PascalCase on the three prior peers, the ":deps" / ":deps-dev" leading-colon lispy author-surface tags on this one), DepList’s DepList::as_str emit and DepList::from_wire parse resolve through the same lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV consts by construction (there is no wire/diagnostic axis split on this enum — both halves of the round-trip route through the same two pub const &str values), so the owned-String forward projection this impl exposes composes directly with the paired trait-idiomatic reverse TryFrom<&str> axis on the owned-String’s String::as_str borrow — no intermediate wire-vocab hop like the peer crate::CaixaKind axis pair requires.

The remaining ten closed-set typed enums on the caixa substrate surface (PlacementStrategy, WitShape, RateLimitUnit, PathShapeViolation, InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) are the future targets of this campaign — each carries the same paired AsRef<str> / std::fmt::Display / [From<Self> for &'static str] / [From<&Self> for &'static str] quadruple that this owned-String axis extends onto.

Pinned load-bearing by [tests::dep_list_from_into_owned_string_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set plus a blanket .into::<String>() shape witness) and [tests::dep_list_from_into_owned_string_and_static_str_agree_on_every_arm] (cross-axis partition against the sibling owned-&'static str axis and the ToString::to_string surface, a .iter().copied().map(String::from) pipe witness over DepList::ALL, plus a direct Self → String → Self round-trip via TryFrom<&str> on the owned-String’s String::as_str borrow — composes directly without the wire-vocab intermediate hop the peer crate::CaixaKind axis pair requires).

fn from(list: DepList) -> String

Converts to this type from the input type.

impl From<DepList> for Cow<'static, str>

Trait-idiomatic forward projection on the two-list dep-graph DepList closed-set typed enum from an owned input onto the borrowed-heap-string std::borrow::Cow<'static, str> axis — routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor (via std::borrow::Cow::Borrowed) so every consumer that binds a DepList through the standard-library .into() / [From<Self> for std::borrow::Cow<'static, str>] (equivalently Into<std::borrow::Cow<'static, str>>) axis reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV canonical pub const &str values the paired [From<DepList> for &'static str], [From<&DepList> for &'static str], [From<DepList> for String], and [From<&DepList> for String] 2×2 trait-idiomatic forward- projection corners, the sibling std::fmt::Display, AsRef<str>, and DepList::as_str surfaces already return, rather than an open-coded per-call-site std::borrow::Cow::Borrowed(list.as_str()) / std::borrow::Cow::Owned(list.to_string()) composition whose type bounds have no compile-time link back to the substrate primitive.

Deliberately returns std::borrow::Cow::Borrowed rather than std::borrow::Cow::Owned — the substrate-primitive DepList::as_str accessor’s return carries the &'static str lifetime by construction (each match arm resolves to one of the two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str values with static lifetime), so the zero-alloc borrowed arm is the type-correct projection with no runtime allocation. The paired std::borrow::Cow::Owned arm stays reachable at the call site through the existing [From<DepList> for String] axis composed with std::borrow::Cow::from on the resulting owned String — a caller who chose to mutate the projection lands on the owned arm by their own composition, not by the substrate- primitive projection silently allocating on their behalf.

Rust’s standard library carries no blanket impl<T: AsRef<str>> From<T> for Cow<'static, str> (nor an impl<T: fmt::Display> From<T> for Cow<'static, str>), so the paired sibling [From<DepList> for &'static str], [From<DepList> for String], AsRef<str>, and std::fmt::Display surfaces do not implicitly extend to a std::borrow::Cow<'static, str>-bound call site — every such site is forced through a Cow::Borrowed(list.as_str()) / Cow::Owned(list.to_string()) open-code whose type bounds have no compile-time link back to the substrate primitive until this lift.

First-mover on the outside-M3 substrate-wide tier of the substrate-wide trait-idiomatic std::borrow::Cow<'static, str> forward-projection campaign, opening the tier on the first caixa-core-internal closed-set fieldless typed enum peer outside the M2 OTP-shape and M3 mesh-shape tiers. The crate::CaixaKind top-level first-mover (99c1735 owned-input, d45c409 borrowed-input) opened the axis on the structurally most fundamental closed-set fieldless typed enum; the paired M2 OTP-shape crate::supervisor::RestartStrategy (7dd28b3, 9b3e4b3) and crate::supervisor::RestartPolicy (0612398, ee577fd) closed the M2 OTP-shape tier; the paired M3-mesh-shape crate::aplicacao::WitShape :contratos :wit census-label (8634dec, 25690ef), crate::aplicacao::PlacementStrategy :placement :estrategia distribution-strategy (eee504d, afdf0f4), and crate::aplicacao::RateLimitUnit :politicas :rate-limit canonical-suffix (1d59925, From<&RateLimitUnit> Cow closer) closed the M3-mesh-shape tier. The remaining outside-M3 caixa-core peers (crate::CaixaDialeto, crate::render::PathShapeViolation) and the outside- caixa-core peers (InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) are the remaining future targets of this campaign; the paired borrowed-input [From<&DepList> for std::borrow::Cow<'static, str>] {Self, &Self}-closer on this outside-M3-tier-opening peer is the next commit’s target.

Same three-path convergence discipline as the paired sibling [From<DepList> for &'static str] / [From<DepList> for String] / std::fmt::Display / AsRef<str> surfaces (this std::borrow::Cow<'static, str> axis, the paired sibling surfaces, and DepList::as_str all route through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str values by construction), so a future variant addition, rename, or per-arm wire-tag drift reaches every forward-projection path through exactly one caixa-core edit at the DepList::as_str match head.

Pinned load-bearing by [tests::dep_list_from_into_static_cow_str_routes_through_as_str_accessor] (byte-parity + zero-alloc std::borrow::Cow::Borrowed-arm pin against DepList::as_str across the two-arm DepList::ALL) and [tests::dep_list_from_into_static_cow_str_agrees_with_paired_axes_on_every_arm] (cross-axis partition pin against the paired [From<DepList> for &'static str], [From<DepList> for String], and ToString-through-std::fmt::Display axes, plus a .iter().copied().map(Cow::from) pipe witness over DepList::ALL that materializes the two-arm accept-set through the std::borrow::Cow<'static, str> axis alone and pins the zero-alloc discipline on every element).

fn from(list: DepList) -> Cow<'static, str>

Converts to this type from the input type.

impl From<DepList> for Box<str>

Trait-idiomatic owned-input, Box<str> output forward projection on the outside-M3 caixa-core two-list dep-graph DepList closed-set fieldless typed enum. Routes byte-for-byte through the substrate- primitive DepList::as_str pub const fn accessor via Box::<str>::from on the returned &'static str, so every consumer that binds a let key: Box<str> = list.into();-shaped call site — a per-:deps / :deps-dev census-key materializer that stashes the dep-list discriminator in a Box<str>-typed heap-owned scalar for cheap clone off an owned handle, a future M4 [caixa.pleme.io/v1alpha1/Caixa] CR materializer’s per-list admission- webhook rejection body whose per-arm Box<str> field composes from an owned DepList handle naming the accepted-list-tag list, a future feira lint --explain-dep-list=<axis> per-arm listing that stashes each arm as an owned Box<str> label — reaches the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings the sibling {Self, &Self} × {&'static str, String, Cow<'static, str>} forward-projection corner already returns.

Rust’s standard library carries impl From<&str> for Box<str> and impl From<String> for Box<str> but no blanket impl<T: AsRef<str>> From<T> for Box<str>, so this axis is a distinct trait-idiomatic surface that a downstream DepList → Box<str> .into() reaches through this impl and no other — without a Box::from(list.as_str()) open-code whose type bounds have no compile-time link back to the substrate primitive.

Extends the caixa-core-internal tier of the substrate-wide trait- idiomatic Box<str> forward-projection campaign onto the second caixa-core-internal peer, after the render-side path-shape-diagnostic crate::render::PathShapeViolation pair (0d87a72, both corners in one axis) opened the tier. Follows the M2 OTP-shape crate::supervisor::RestartStrategy / crate::supervisor::RestartPolicy pair (59ae5dc + cb1d068), the M3 mesh-shape crate::aplicacao::PlacementStrategy / crate::aplicacao::WitShape / crate::aplicacao::RateLimitUnit triple (6d73e84 → df7040c) that closed the M3 mesh-shape tier, and the outside-caixa-core tier (InvariantKind 10613a7 + 5901887, ArchVerdict 3e08f5a + c4319a8, Severity 5116c95, FixSafety cf0174b, Semantic 0cd7dc3, FerriteRuntime 14886a8) that closed one tier prior. Same discipline as those peers: forward emit (this impl, the sibling {&'static str, String, Cow<'static, str>} forward-projection corner, std::fmt::Display, AsRef<str>, DepList::as_str) and reverse parse (DepList::from_wire, TryFrom<&str>) route through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings by construction, so the round-trip composes directly without the wire-vocab intermediate hop the peer crate::CaixaKind axis pair requires.

A future variant addition (a Build build-time-only dep-list axis the CAIXA-SDLC hints name as a trajectory item once the Cargo [build-dependencies] table gains substrate visibility) reaches the paired Box<str> output axis through one match-arm edit on the DepList::as_str pub const fn accessor, not a coordinated rewrite of every downstream Box::from(list.as_str()) open-code.

Pinned load-bearing by [tests::dep_list_from_into_box_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set on the owned-input surface, plus a blanket- derived Into shape witness).

fn from(list: DepList) -> Box<str>

Converts to this type from the input type.

impl From<DepList> for Arc<str>

Trait-idiomatic owned-input, std::sync::Arc<str> output forward projection on the outside-M3 caixa-core two-list dep-graph DepList closed-set fieldless typed enum. Routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor via std::sync::Arc::<str>::from on the returned &'static str, so every consumer that binds a let key: std::sync::Arc<str> = list.into();-shaped call site reaches the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings the sibling {Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>} forward-projection corner already returns.

Rust’s standard library carries impl From<&str> for std::sync::Arc<str> and impl From<String> for std::sync::Arc<str> but no blanket impl<T: AsRef<str>> From<T> for std::sync::Arc<str> (nor an impl<T: fmt::Display> From<T> for std::sync::Arc<str>), so this axis is a distinct trait-idiomatic surface that a let key: std::sync::Arc<str> = list.into();-shaped call site reaches through this impl and no other — a paired std::sync::Arc::<str>::from(list.as_str()) open-code has no compile- time link back to the substrate primitive, and a two-step std::sync::Arc::<str>::from(String::from(list)) composition through the owned-String axis allocates twice (once into the intermediate String, once into the std::sync::Arc<str> on the From<String> conversion) where the single-step trait impl allocates once. The shared-ownership + Sync + Send contract std::sync::Arc<str> provides is the distinct value the sibling Box<str> axis’s owned- move return-shape cannot provide — a per-:deps / :deps-dev census key reachable from multiple concurrent per-Caixa reconcile / per-lint tasks through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV byte-strings, without a .clone()-per-task materialization the owned-move Box<str> axis would force.

Extends the caixa-core-internal tier of the substrate-wide trait- idiomatic std::sync::Arc<str> forward-projection campaign onto the second caixa-core-internal peer, after the top-level crate::CaixaKind pair (c17be64, both corners in one axis) opened the tier. Follows the M2 OTP-shape crate::supervisor::RestartStrategy / crate::supervisor::RestartPolicy pair (bca2ec8 + b3e72d7 / b05724e + ea91551), the M3 mesh-shape crate::aplicacao::PlacementStrategy / crate::aplicacao::WitShape / crate::aplicacao::RateLimitUnit triple (977d577 → dae722f), and the outside-caixa-core tier (InvariantKind 4e923c1 + 03c043f, ArchVerdict 1682f8b + 92ddfb2, Severity a7a9a6d + 4f041e1, FixSafety fb73edb + 822138e, Semantic 65dbcff + f3a55c7, FerriteRuntime 938d915 + 0afef4b) that closed prior tiers on this same Arc axis. Same discipline as those peers: forward emit (this impl, the sibling {Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>} forward-projection corner, std::fmt::Display, AsRef<str>, DepList::as_str) and reverse parse (DepList::from_wire, TryFrom<&str>) route through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte- strings by construction, so the round-trip composes directly without the wire-vocab intermediate hop the peer crate::CaixaKind axis pair requires.

A future variant addition (a Build build-time-only dep-list axis the CAIXA-SDLC hints name as a trajectory item once the Cargo [build-dependencies] table gains substrate visibility) reaches the paired std::sync::Arc<str> output axis through one match-arm edit on the DepList::as_str pub const fn accessor, not a coordinated rewrite of every downstream std::sync::Arc::<str>::from(list.as_str()) open-code.

Pinned load-bearing by [tests::dep_list_from_into_arc_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set on the owned-input surface, plus a blanket- derived Into shape witness and cross-axis byte-parity pins against the sibling owned-input {&'static str, String, Cow<'static, str>, Box<str>} return-shape axes).

fn from(list: DepList) -> Arc<str>

Converts to this type from the input type.

impl Hash for DepList

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DepList

fn eq(&self, other: &DepList) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for DepList

impl TryFrom<&str> for DepList

Trait-idiomatic reverse projection on the two-list dep-graph DepList closed-set typed enum — routes through the paired substrate-primitive DepList::from_wire Option<Self> accessor so <DepList>::try_from(":deps") reaches the same two-arm accept-set the sibling DepList::from_wire resolver dispatches through, rather than an open-coded per-arm match s { ":deps" => Ok(Self::Prod), … } cascade whose arm-set has no compile-time link back to the substrate primitive.

Corrects a completeness gap in the substrate-wide trait-idiomatic reverse-projection campaign (opened by crate::CaixaKind via 3c83606, closed onto 14 sibling closed-set fieldless typed enums across the caixa surface — 5b828ed, 6fdd0d9, 5472902, bf78400, e67e48a, e21a857, 0a4cc45, a7bf74c, df86c94, bd7da69, 42ab951 — which silently omitted DepList despite this enum being listed as a sibling closed-set fieldless typed enum in every peer’s docstring). Every sibling closed-set fieldless typed enum on the caixa surface now carries both trait-idiomatic axes (TryFrom<&str> for Self + From<Self> for &'static str) paired against the substrate-primitive canonical projection accessors (as_str/variant_slug + from_wire) — the two-list dep-graph closed-set is the fifteenth and true-final peer.

type Error = () matches the sibling DepList::from_wire’s Option<Self> return-shape’s deliberate deferral of error typing: the caller picks the diagnostic form appropriate for its use site (a future feira dep --list <deps|deps-dev> arg-parse composes unknown list: <arg> — accepted: {…} enumerating DepList::ALL; the M4 admission-webhook rejection body wraps Err(()) with the accepted-set enumeration).

Pinned load-bearing by [tests::dep_list_try_from_str_routes_through_from_wire_accessor] (byte-parity pin against DepList::from_wire across the two-arm accept-set) and [tests::dep_list_try_from_str_rejects_unknown_byte_strings] (rejection witness against silent accept-set widening).

type Error = ()

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.