commit 65d749c80b8d868a2c1e6aad7e431917a80fe99a · pyrox.dev/nixpkgs

+7 -7

nixos/doc/manual/configuration/modularity.section.md

···

       67
       67
        
       defined in other modules. This is what the `config` function argument is

     

       68
       68
        
       for: it contains the complete, merged system configuration. That is,

     

       69
       69
        
       `config` is the result of combining the configurations returned by every

     

       70
       70
       -
       module [^1] . For example, here is a module that adds some packages to

     

       70
       70
       +
       module. (If you're wondering how it's possible that the (indirect) *result*

     

       71
       71
       +
       of a function is passed as an *input* to that same function: that's

     

       72
       72
       +
       because Nix is a "lazy" language --- it only computes values when

     

       73
       73
       +
       they are needed. This works as long as no individual configuration

     

       74
       74
       +
       value depends on itself.)

     

       75
       75
       +
       

     

       76
       76
       +
       For example, here is a module that adds some packages to

     

       71
       77
        
       [](#opt-environment.systemPackages) only if

     

       72
       78
        
       [](#opt-services.xserver.enable) is set to `true` somewhere else:

     

       73
       79
        
       

     
···

       125
       131
        
       

     

       126
       132
        
       { imports = [ (netConfig "nixos.localdomain") ]; }

     

       127
       133
        
       ```

     

       128
       128
       -
       

     

       129
       129
       -
       [^1]: If you're wondering how it's possible that the (indirect) *result*

     

       130
       130
       -
           of a function is passed as an *input* to that same function: that's

     

       131
       131
       -
           because Nix is a "lazy" language --- it only computes values when

     

       132
       132
       -
           they are needed. This works as long as no individual configuration

     

       133
       133
       -
           value depends on itself.

+10 -11

nixos/doc/manual/from_md/configuration/modularity.section.xml

···

       79
       79
        
           <literal>config</literal> function argument is for: it contains the

     

       80
       80
        
           complete, merged system configuration. That is,

     

       81
       81
        
           <literal>config</literal> is the result of combining the

     

       82
       82
       -
           configurations returned by every module <footnote>

     

       83
       83
       -
             <para>

     

       84
       84
       -
               If you’re wondering how it’s possible that the (indirect)

     

       85
       85
       -
               <emphasis>result</emphasis> of a function is passed as an

     

       86
       86
       -
               <emphasis>input</emphasis> to that same function: that’s because

     

       87
       87
       -
               Nix is a <quote>lazy</quote> language — it only computes values

     

       88
       88
       -
               when they are needed. This works as long as no individual

     

       89
       89
       -
               configuration value depends on itself.

     

       90
       90
       -
             </para>

     

       91
       91
       -
           </footnote> . For example, here is a module that adds some packages

     

       92
       92
       -
           to <xref linkend="opt-environment.systemPackages" /> only if

     

       82
       82
       +
           configurations returned by every module. (If you’re wondering how

     

       83
       83
       +
           it’s possible that the (indirect) <emphasis>result</emphasis> of a

     

       84
       84
       +
           function is passed as an <emphasis>input</emphasis> to that same

     

       85
       85
       +
           function: that’s because Nix is a <quote>lazy</quote> language — it

     

       86
       86
       +
           only computes values when they are needed. This works as long as no

     

       87
       87
       +
           individual configuration value depends on itself.)

     

       88
       88
       +
         </para>

     

       89
       89
       +
         <para>

     

       90
       90
       +
           For example, here is a module that adds some packages to

     

       91
       91
       +
           <xref linkend="opt-environment.systemPackages" /> only if

     

       93
       92
        
           <xref linkend="opt-services.xserver.enable" /> is set to

     

       94
       93
        
           <literal>true</literal> somewhere else:

     

       95
       94
        
         </para>