Struct ModuleNode 

pub struct ModuleNode {
    pub id: ModuleId,
    pub label: String,
    pub ast_graph_hash: [u8; 32],
    pub option_decls: Vec<OptionDecl>,
    pub setters: Vec<ConfigSetter>,
    pub imports: Vec<ImportEdge>,
    pub body_env_prefix: Vec<EnvPrefixBinding>,
}

One module: the typed projection of one .nix (or future .tlisp) file’s contribution to the system.

Fields

id: ModuleId

label: String

Human-readable label (the file path relative to the flake root, e.g. "profiles/nixos-attic-cache-warmer/default.nix").

ast_graph_hash: [u8; 32]

Hash of the AstGraph this module was lowered from. Two modules with byte-identical AST contribute identically; the compiler can memoize on this.

option_decls: Vec<OptionDecl>

Option declarations this module contributes to the schema.

setters: Vec<ConfigSetter>

Config-setter fragments. One per logical assignment in the module’s body. mkMerge / mkIf are pre-split here.

imports: Vec<ImportEdge>

Import edges: which other modules this one pulls into the system. Resolved at parse time so the runtime view is flat.

body_env_prefix: Vec<EnvPrefixBinding>

Env-prefix bindings captured from the module’s outer wrappers (let-in bindings, with-scope attrsets). Each entry maps an identifier name to the AST node id whose evaluation produces the binding’s value. The evaluator seeds each setter’s evaluation env with these BEFORE adding config — so a setter body that references cfg (bound by an outer let cfg = config.foo;) resolves correctly.

Two entry kinds today:

• Named bindings from outer let ... in BODY clauses.
• Synthetic __with_<n> entries for each outer with X; scope, where X’s evaluation result is unpacked into the env (its attrset attrs become top-level idents). __with_<n> itself is never directly referenced; it’s a placeholder so the evaluator knows to unpack the value.

Trait Implementations

impl Archive for ModuleNode

where ModuleId: Archive, String: Archive, [u8; 32]: Archive, Vec<OptionDecl>: Archive, Vec<ConfigSetter>: Archive, Vec<ImportEdge>: Archive, Vec<EnvPrefixBinding>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedModuleNode

The archived representation of this type.

type Resolver = ModuleNodeResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for ModuleNode

fn clone(&self) -> ModuleNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModuleNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ModuleNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<ModuleNode, __D> for Archived<ModuleNode>

where ModuleId: Archive, <ModuleId as Archive>::Archived: Deserialize<ModuleId, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, [u8; 32]: Archive, <[u8; 32] as Archive>::Archived: Deserialize<[u8; 32], __D>, Vec<OptionDecl>: Archive, <Vec<OptionDecl> as Archive>::Archived: Deserialize<Vec<OptionDecl>, __D>, Vec<ConfigSetter>: Archive, <Vec<ConfigSetter> as Archive>::Archived: Deserialize<Vec<ConfigSetter>, __D>, Vec<ImportEdge>: Archive, <Vec<ImportEdge> as Archive>::Archived: Deserialize<Vec<ImportEdge>, __D>, Vec<EnvPrefixBinding>: Archive, <Vec<EnvPrefixBinding> as Archive>::Archived: Deserialize<Vec<EnvPrefixBinding>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ModuleNode, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl PartialEq for ModuleNode

fn eq(&self, other: &ModuleNode) -> 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 ModuleNode

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for ModuleNode

where ModuleId: Serialize<__S>, String: Serialize<__S>, [u8; 32]: Serialize<__S>, Vec<OptionDecl>: Serialize<__S>, Vec<ConfigSetter>: Serialize<__S>, Vec<ImportEdge>: Serialize<__S>, Vec<EnvPrefixBinding>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for ModuleNode

impl TataraDomain for ModuleNode

const KEYWORD: &'static str = "defmodule-node"

The Lisp keyword (e.g., "defmonitor").

fn compile_from_args(args: &[Sexp]) -> Result<Self>

Parse the argument list (everything after the keyword) into Self.

fn compile_from_sexp(form: &Sexp) -> Result<Self, LispError>

Parse a complete form; validates the head symbol matches KEYWORD.