WEP: Lenient String Parsing (LenientFromStr)

Context

Human-supplied strings become typed values throughout a program: CLI arguments (core:cli::args()), environment variables, config entries, query strings, compile-time parameters (Compile-Time Parameters, v2). Being human-typed, they carry surface variation a strict parser rejects — casing, alternate spellings (1 / 0 for a boolean), radix prefixes, digit separators.

core:prelude already has FromStr, but it is strict by design: it backs hot, machine-facing paths (router path segments, the JSON deserializer) where "TRUE" or "0x2A" must be rejected. Loosening it would break those.

So a parallel, forgiving conversion is missing. core:cli::args() returns a raw List<String>; every caller parses by hand.

Decision

Add LenientFromStr to core:prelude (auto-imported), the forgiving sibling of FromStr.

pub trait LenientFromStr {
    type Err: Error;
    fn from_str_lenient<S: AsStrSlice>(s: S) -> Result<Self, Self::Err>;
}

• Returns Result: leniency widens the accepted spellings, it does not salvage invalid input. An undenotable string still yields Err.
• Err: Error, as FromStr bounds its own: a caller reaching the failure through the bound can report the reason rather than only the expected type.
• One method, as FromStr::from_str is: AsStrSlice already admits an owned String, a reference to one, and a view.
• from_str_lenient sits beside from_str in method completion.

A Separate Trait, Not FromStr or TryFrom<&String>

Strictness and leniency are independent capabilities — a wire-format type wants only strict FromStr, a "human duration" only lenient parsing — so they are separate traits. Against the general TryFrom<&String> (Conversion Traits), LenientFromStr is the named contract: the name promises forgiving, human-friendly spellings.

Leniency Contract

An impl accepts the common human-equivalent spellings for its type (see built-ins) and never panics — an undenotable value is Err. Leniency forgives spelling, not meaning: "0x2A" → 42, "forty-two" → Err.

It does not touch whitespace. from_str_lenient does not trim, so surrounding whitespace yields Err; trimming is the caller's concern (s.trim(), or a consumer-level policy — e.g. compile-time params trims each override before converting). Keeping the conversion faithful avoids silently discarding input and resolves whitespace-significant types (char, String) uniformly.

Built-In Implementations

• Integers and floats ignore _ anywhere in the digit body (1_000, 0xFF_FF). , is not a separator — it collides with the locale decimal comma and with future list/tuple delimiters; _ matches Wado's own numeric literals.
• A leading zero is not octal: 010 is 10, only 0o12 is octal.
• Numeric impls preprocess (strip _, split off sign / radix prefix) then delegate to from_str_radix / from_str (the float FromStr already accepts nan / inf / infinity). char delegates to its FromStr unchanged — one Unicode scalar has one spelling, so there is nothing for leniency to add. Only bool parses directly, for the spellings FromStr refuses. No impl alters whitespace.

Future WEPs may extend the set (e.g. core:temporal multi-format dates).

No Blanket Impl (Yet)

A blanket impl<T: FromStr> LenientFromStr for T would drop the per-type boilerplate but overlaps the bool impl. Wado grants concrete-over-general priority only for variadic impls (Variadic Type Parameters); general specialization is unadopted (soundness unsettled — research-from-into-framework.md). So built-in impls stay explicit; revisit if specialization lands.

User Types

A user type implements LenientFromStr directly, independently of FromStr (either, both, or neither). Newtypes inherit it from their base type — type Port = u16 parses like u16 with no extra impl.

Consumers

• Runtime CLI arguments / environment variables: core:cli gains a typed parse path, e.g. i32::from_str_lenient(&args[1].trim()). The ergonomic surface (a helper that trims and parses) is a core:cli follow-up.
• Compile-time parameters v2: v1 converts built-in types natively with accepted forms matching these impls, so v2 — evaluating LenientFromStr for arbitrary types via wasm-CTFE — preserves built-in behavior.

Implementation Strategy

• Define the trait in core:prelude (lib/core/prelude/traits.wado), auto-imported.
• Add the built-in impls and a single shared Err type, LenientParseError (a short reason string). One unified error keeps the associated-type story simple and gives the infallible String impl a never-returned Err; numeric impls map ParseIntError / ParseFloatError into it.
• Document in docs/stdlib-core-prelude.md and the cheatsheet.

Consequences

• One discoverable contract for forgiving external input, shared by CLI args, env, config, and params.
• FromStr stays strict; hot paths untouched.
• The conversion is faithful: it never trims or otherwise discards input, so whitespace-significant values (char, a space; String, leading indent) survive. Callers trim when they want to.
• Built-in impls mostly wrap FromStr, so little parsing logic is duplicated.
• A type wanting both parses implements two traits — acceptable, since the contracts differ.

Future Extensions

• Blanket impl<T: FromStr> LenientFromStr for T, once specialization is settled.
• A derive for enums (case-insensitive discriminant names).
• Lenient date/time parsing in core:temporal.
• A core:cli typed-argument API on the trait.