Enum ModulePhaseKind 

pub enum ModulePhaseKind {
    CollectModules,
    PartitionOptionsAndConfig,
    BuildOptionTree,
    GroupDefinitions,
    ResolveConditionals,
    ResolvePriorities,
    MergePerOption,
    TypeCheck,
    EvaluateRecursive,
    EmitConfig,
}

The closed set of operations any module-eval algorithm composes. Adding a new variant IS adding a new primitive to the spec language.

Variants

CollectModules

Resolve imports transitively, deduplicating by content hash. Each module is just an attrset / function; the fixpoint walks until no new imports appear.

PartitionOptionsAndConfig

Distinguish options from config in every module. Some modules are pure-config; others declare options.

BuildOptionTree

Walk option declarations, build a typed option tree. The tree is path-indexed (services.foo.enable).

GroupDefinitions

Walk config definitions, attach each to its option path. Wrappers (mkDefault, mkForce, mkIf cond, mkMerge) are unwrapped into typed PriorityRank + value pairs.

ResolveConditionals

Filter out definitions whose mkIf predicate is false.

ResolvePriorities

Sort definitions per option by priority (lowest level wins).

MergePerOption

For each option, run the type’s MergeStrategy over the surviving definitions. Submodule strategies recurse into this same algorithm.

TypeCheck

Validate every merged value against its option’s TypeCheckKind. Failure produces a typed error.

EvaluateRecursive

Walk recursive references between options (cppnix’s config.foo = config.bar) until fixpoint.

EmitConfig

Produce the final config attrset.

Trait Implementations

impl Clone for ModulePhaseKind

fn clone(&self) -> ModulePhaseKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ModulePhaseKind

impl Debug for ModulePhaseKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ModulePhaseKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ModulePhaseKind

impl PartialEq for ModulePhaseKind

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ModulePhaseKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ModulePhaseKind