Struct Config 

pub struct Config<T: 'static> { /* private fields */ }

A lazy, composable configuration descriptor (Effect.ts Config<T>).

Create with type-specific constructors (Config::string, Config::integer, …), compose with combinators (Config::with_default, Config::map, Config::nested, …), and evaluate with Config::run (service-injected) or Config::load (direct provider).

Implementations

impl<T: Send + Sync + 'static> Config<T>

pub fn load(&self, provider: &dyn ConfigProvider) -> Result<T, ConfigError>

Evaluate against provider directly (synchronous; useful for tests).

pub fn run<A, E, R>(&self) -> Effect<A, E, R>

where A: From<T> + 'static, E: From<ConfigError> + 'static, R: NeedsConfigProvider + 'static,

Evaluate this descriptor as an Effect, pulling the provider from the environment.

R only needs to satisfy NeedsConfigProvider; callers compose whatever layer stack they like. See config_env for building a minimal context.

pub fn load_current(&self) -> Result<T, ConfigError>

Like load, using the innermost ambient provider from with_config_provider.

Runs eagerly when called (reads the thread-local immediately).

pub fn map<U: Send + Sync + 'static>( self, f: impl Fn(T) -> U + Send + Sync + 'static, ) -> Config<U>

Transform the loaded value (Effect Config.map).

use effect_config::{Config, MapConfigProvider};

let p = MapConfigProvider::from_pairs([("PORT", "8080")]);
let port_u16: u16 = Config::integer("PORT").map(|n| n as u16).load(&p).unwrap();
assert_eq!(port_u16, 8080u16);

pub fn map_attempt<U: Send + Sync + 'static>( self, f: impl Fn(T) -> Result<U, ConfigError> + Send + Sync + 'static, ) -> Config<U>

Transform the loaded value, allowing failure (Effect Config.mapAttempt).

pub fn secret(self) -> Config<Secret<T>>

Wrap the loaded value in Secret so it is never printed (Effect Config.secret).

use effect_config::{Config, MapConfigProvider};

let p = MapConfigProvider::from_pairs([("API_KEY", "s3cr3t")]);
let key = Config::string("API_KEY").secret().load(&p).unwrap();
assert_eq!(format!("{key:?}"), "<redacted>");
assert_eq!(key.expose(), "s3cr3t");

pub fn nested(self, prefix: impl Into<String>) -> Self

Scope all path lookups under prefix segments (Effect Config.nested).

Config::string("PORT").nested("SERVER") looks up ["SERVER", "PORT"].

use effect_config::{Config, MapConfigProvider};

let p = MapConfigProvider::from_pairs([("SERVER_HOST", "127.0.0.1")]);
let host = Config::string("HOST").nested("SERVER").load(&p).unwrap();
assert_eq!(host, "127.0.0.1");

impl<T: Clone + Send + Sync + 'static> Config<T>

pub fn with_default(self, default: T) -> Self

Fall back to default when the key is missing (Effect Config.withDefault).

Only ConfigError::Missing triggers the fallback; parse errors still propagate.

use effect_config::{Config, MapConfigProvider};

let p = MapConfigProvider::from_pairs::<[(&str, &str); 0], _, _>([]);
let port = Config::integer("PORT").with_default(3000).load(&p).unwrap();
assert_eq!(port, 3000);

pub fn validate( self, reason: &'static str, predicate: impl Fn(&T) -> bool + Send + Sync + 'static, ) -> Self

Validate the loaded value; produces ConfigError::Invalid when predicate is false.

use effect_config::{Config, MapConfigProvider};

let p = MapConfigProvider::from_pairs([("PORT", "99999")]);
let err = Config::integer("PORT")
  .validate("port must be 1–65535", |n| (1..=65535).contains(n))
  .load(&p)
  .unwrap_err();
assert!(err.to_string().contains("port must be 1–65535"));

impl Config<String>

pub fn string(path: impl Into<String>) -> Self

Load a required string (Effect Config.string).

path may be dotted to express nesting: "server.host" → ["server", "host"].

impl Config<Option<String>>

pub fn optional_string(path: impl Into<String>) -> Self

Load an optional string; a missing key yields None (Effect Config.option).

impl Config<f64>

pub fn number(path: impl Into<String>) -> Self

Load a floating-point number (Effect Config.number).

impl Config<i64>

pub fn integer(path: impl Into<String>) -> Self

Load a signed integer (Effect Config.integer).

impl Config<bool>

pub fn boolean(path: impl Into<String>) -> Self

Load a boolean (Effect Config.boolean).

impl Config<Vec<String>>

pub fn string_list(path: impl Into<String>) -> Self

Load a delimiter-separated string list (Effect Config.array(Config.string(…))).

pub fn repeat(path: impl Into<String>) -> Self

CSV list (comma-separated, trimmed); ignores ConfigProvider::seq_delim (Effect Config.repeat).

impl Config<Duration>

pub fn duration(path: impl Into<String>) -> Self

Load a Duration using id_effect::duration::duration::decode (Effect.ts Duration decode).

use std::time::Duration;
use effect_config::{Config, MapConfigProvider};

let p = MapConfigProvider::from_pairs([("TIMEOUT", "5s")]);
let t = Config::duration("TIMEOUT").load(&p).unwrap();
assert_eq!(t, Duration::from_secs(5));

impl Config<LogLevel>

pub fn log_level(path: impl Into<String>) -> Self

Load a LogLevel (case-insensitive; see LogLevel).

impl Config<Url>

pub fn url(path: impl Into<String>) -> Self

Load a Url string.

Trait Implementations

impl<T: 'static> Clone for Config<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: 'static> Debug for Config<T>

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

Formats the value using the given formatter.