···

       
5
       
5
       
 
       
  inherit (builtins) head tail length;

     

       
6
       
6
       
 
       
  inherit (lib.trivial) and;

     

       
7
       
7
       
 
       
  inherit (lib.strings) concatStringsSep sanitizeDerivationName;

     

       
8
       
8
       
-
       
  inherit (lib.lists) fold concatMap concatLists;

     

       
8
       
8
       
+
       
  inherit (lib.lists) fold foldr concatMap concatLists;

     

       
9
       
9
       
 
       
in

     

       
10
       
10
       
 
       


     

       
11
       
11
       
 
       
rec {

     
···

       
152
       
152
       
 
       
       => { a = [ 2 3 ]; }

     

       
153
       
153
       
 
       
  */

     

       
154
       
154
       
 
       
  foldAttrs = op: nul: list_of_attrs:

     

       
155
       
155
       
-
       
    fold (n: a:

     

       
156
       
156
       
-
       
        fold (name: o:

     

       
155
       
155
       
+
       
    foldr (n: a:

     

       
156
       
156
       
+
       
        foldr (name: o:

     

       
157
       
157
       
 
       
          o // { ${name} = op n.${name} (a.${name} or nul); }

     

       
158
       
158
       
 
       
        ) a (attrNames n)

     

       
159
       
159
       
 
       
    ) {} list_of_attrs;

     
···

       
433
       
433
       
 
       
       => true

     

       
434
       
434
       
 
       
   */

     

       
435
       
435
       
 
       
  matchAttrs = pattern: attrs: assert isAttrs pattern;

     

       
436
       
436
       
-
       
    fold and true (attrValues (zipAttrsWithNames (attrNames pattern) (n: values:

     

       
436
       
436
       
+
       
    foldr and true (attrValues (zipAttrsWithNames (attrNames pattern) (n: values:

     

       
437
       
437
       
 
       
      let pat = head values; val = head (tail values); in

     

       
438
       
438
       
 
       
      if length values == 1 then false

     

       
439
       
439
       
 
       
      else if isAttrs pat then isAttrs val && matchAttrs pat val

     

···

       
77
       
77
       
 
       
  # Output : are reqs satisfied? It's asserted.

     

       
78
       
78
       
 
       
  checkReqs = attrSet: argList: condList:

     

       
79
       
79
       
 
       
  (

     

       
80
       
80
       
-
       
    fold lib.and true

     

       
80
       
80
       
+
       
    foldr lib.and true

     

       
81
       
81
       
 
       
      (map (x: let name = (head x); in

     

       
82
       
82
       
 
       


     

       
83
       
83
       
 
       
        ((checkFlag attrSet name) ->

     

       
84
       
84
       
-
       
        (fold lib.and true

     

       
84
       
84
       
+
       
        (foldr lib.and true

     

       
85
       
85
       
 
       
        (map (y: let val=(getValue attrSet argList y); in

     

       
86
       
86
       
 
       
                (val!=null) && (val!=false))

     

       
87
       
87
       
 
       
        (tail x))))) condList));

     
···

       
177
       
177
       
 
       
  # merge attributes with custom function handling the case that the attribute

     

       
178
       
178
       
 
       
  # exists in both sets

     

       
179
       
179
       
 
       
  mergeAttrsWithFunc = f: set1: set2:

     

       
180
       
180
       
-
       
    fold (n: set: if set ? ${n}

     

       
180
       
180
       
+
       
    foldr (n: set: if set ? ${n}

     

       
181
       
181
       
 
       
                        then setAttr set n (f set.${n} set2.${n})

     

       
182
       
182
       
 
       
                        else set )

     

       
183
       
183
       
 
       
           (set2 // set1) (attrNames set2);

     
···

       
196
       
196
       
 
       
  mergeAttrsNoOverride = { mergeLists ? ["buildInputs" "propagatedBuildInputs"],

     

       
197
       
197
       
 
       
                           overrideSnd ? [ "buildPhase" ]

     

       
198
       
198
       
 
       
                         }: attrs1: attrs2:

     

       
199
       
199
       
-
       
    fold (n: set:

     

       
199
       
199
       
+
       
    foldr (n: set:

     

       
200
       
200
       
 
       
        setAttr set n ( if set ? ${n}

     

       
201
       
201
       
 
       
            then # merge

     

       
202
       
202
       
 
       
              if elem n mergeLists # attribute contains list, merge them by concatenating

     
···

       
224
       
224
       
 
       
          mergeAttrBy2 = { mergeAttrBy = lib.mergeAttrs; }

     

       
225
       
225
       
 
       
                      // (maybeAttr "mergeAttrBy" {} x)

     

       
226
       
226
       
 
       
                      // (maybeAttr "mergeAttrBy" {} y); in

     

       
227
       
227
       
-
       
    fold lib.mergeAttrs {} [

     

       
227
       
227
       
+
       
    foldr lib.mergeAttrs {} [

     

       
228
       
228
       
 
       
      x y

     

       
229
       
229
       
 
       
      (mapAttrs ( a: v: # merge special names using given functions

     

       
230
       
230
       
 
       
          if x ? ${a}

     

···

       
305
       
305
       
 
       
  warn = msg: builtins.trace "warning: ${msg}";

     

       
306
       
306
       
 
       
  info = msg: builtins.trace "INFO: ${msg}";

     

       
307
       
307
       
 
       


     

       
308
       
308
       
-
       
  showWarnings = warnings: res: lib.fold (w: x: warn w x) res warnings;

     

       
308
       
308
       
+
       
  showWarnings = warnings: res: lib.foldr (w: x: warn w x) res warnings;

     

       
309
       
309
       
 
       


     

       
310
       
310
       
 
       
  ## Function annotations

     

       
311
       
311
       
 
       


     

···

       
12
       
12
       
 
       
  # E.g. if some `options` came from modules in ${pkgs.customModules}/nix,

     

       
13
       
13
       
 
       
  # you'd need to include `extraSources = [ pkgs.customModules ]`

     

       
14
       
14
       
 
       
  prefixesToStrip = map (p: "${toString p}/") ([ ../../.. ] ++ extraSources);

     

       
15
       
15
       
-
       
  stripAnyPrefixes = lib.flip (lib.fold lib.removePrefix) prefixesToStrip;

     

       
15
       
15
       
+
       
  stripAnyPrefixes = lib.flip (lib.foldr lib.removePrefix) prefixesToStrip;

     

       
16
       
16
       
 
       


     

       
17
       
17
       
 
       
  optionsDoc = buildPackages.nixosOptionsDoc {

     

       
18
       
18
       
 
       
    inherit options revision;

     

···

       
386
       
386
       
 
       
    };

     

       
387
       
387
       
 
       
  };

     

       
388
       
388
       
 
       


     

       
389
       
389
       
-
       
  idsAreUnique = set: idAttr: !(fold (name: args@{ dup, acc }:

     

       
389
       
389
       
+
       
  idsAreUnique = set: idAttr: !(foldr (name: args@{ dup, acc }:

     

       
390
       
390
       
 
       
    let

     

       
391
       
391
       
 
       
      id = builtins.toString (builtins.getAttr idAttr (builtins.getAttr name set));

     

       
392
       
392
       
 
       
      exists = builtins.hasAttr id acc;

     

···

       
39
       
39
       
 
       
            if c x then true

     

       
40
       
40
       
 
       
            else lib.traceSeqN 1 x false;

     

       
41
       
41
       
 
       
      in traceXIfNot isConfig;

     

       
42
       
42
       
-
       
    merge = args: fold (def: mergeConfig def.value) {};

     

       
42
       
42
       
+
       
    merge = args: foldr (def: mergeConfig def.value) {};

     

       
43
       
43
       
 
       
  };

     

       
44
       
44
       
 
       


     

       
45
       
45
       
 
       
  overlayType = mkOptionType {

     

···

       
279
       
279
       
 
       
    src_plan = plan;

     

       
280
       
280
       
 
       
    tsformat = timestampFormat;

     

       
281
       
281
       
 
       
    zend_delay = toString sendDelay;

     

       
282
       
282
       
-
       
  } // fold (a: b: a // b) {} (

     

       
282
       
282
       
+
       
  } // foldr (a: b: a // b) {} (

     

       
283
       
283
       
 
       
    map mkDestAttrs (builtins.attrValues destinations)

     

       
284
       
284
       
 
       
  );

     

       
285
       
285
       
 
       


     

···

       
193
       
193
       
 
       
      # We need to handle the last column specially here, because it's

     

       
194
       
194
       
 
       
      # open-ended (command + args).

     

       
195
       
195
       
 
       
      lines = [ labels labelDefaults ] ++ (map (l: init l ++ [""]) masterCf);

     

       
196
       
196
       
-
       
    in fold foldLine (genList (const 0) (length labels)) lines;

     

       
196
       
196
       
+
       
    in foldr foldLine (genList (const 0) (length labels)) lines;

     

       
197
       
197
       
 
       


     

       
198
       
198
       
 
       
    # Pad a string with spaces from the right (opposite of fixedWidthString).

     

       
199
       
199
       
 
       
    pad = width: str: let

     
···

       
202
       
202
       
 
       
    in str + optionalString (padWidth > 0) padding;

     

       
203
       
203
       
 
       


     

       
204
       
204
       
 
       
    # It's + 2 here, because that's the amount of spacing between columns.

     

       
205
       
205
       
-
       
    fullWidth = fold (width: acc: acc + width + 2) 0 maxWidths;

     

       
205
       
205
       
+
       
    fullWidth = foldr (width: acc: acc + width + 2) 0 maxWidths;

     

       
206
       
206
       
 
       


     

       
207
       
207
       
 
       
    formatLine = line: concatStringsSep "  " (zipListsWith pad maxWidths line);

     

       
208
       
208
       
 
       


     

···

       
79
       
79
       
 
       


     

       
80
       
80
       
 
       
    systemd.services =

     

       
81
       
81
       
 
       


     

       
82
       
82
       
-
       
      lib.fold ( s : acc : acc //

     

       
82
       
82
       
+
       
      lib.foldr ( s : acc : acc //

     

       
83
       
83
       
 
       
        {

     

       
84
       
84
       
 
       
          "autossh-${s.name}" =

     

       
85
       
85
       
 
       
            let

     

···

       
160
       
160
       
 
       


     

       
161
       
161
       
 
       
    users.groups.nylon.gid = config.ids.gids.nylon;

     

       
162
       
162
       
 
       


     

       
163
       
163
       
-
       
    systemd.services = fold (a: b: a // b) {} nylonUnits;

     

       
163
       
163
       
+
       
    systemd.services = foldr (a: b: a // b) {} nylonUnits;

     

       
164
       
164
       
 
       


     

       
165
       
165
       
 
       
  };

     

       
166
       
166
       
 
       
}

     

···

       
87
       
87
       
 
       
  };

     

       
88
       
88
       
 
       


     

       
89
       
89
       
 
       
  config = mkIf (cfg != []) {

     

       
90
       
90
       
-
       
    systemd.services = fold (a: b: a // b) {} (

     

       
90
       
90
       
+
       
    systemd.services = foldr (a: b: a // b) {} (

     

       
91
       
91
       
 
       
      mapAttrsToList (name: qtcfg: {

     

       
92
       
92
       
 
       
        "quicktun-${name}" = {

     

       
93
       
93
       
 
       
          wantedBy = [ "multi-user.target" ];

     

···

       
351
       
351
       
 
       


     

       
352
       
352
       
 
       
  config = mkIf (cfg.networks != { }) {

     

       
353
       
353
       
 
       


     

       
354
       
354
       
-
       
    environment.etc = fold (a: b: a // b) { }

     

       
354
       
354
       
+
       
    environment.etc = foldr (a: b: a // b) { }

     

       
355
       
355
       
 
       
      (flip mapAttrsToList cfg.networks (network: data:

     

       
356
       
356
       
 
       
        flip mapAttrs' data.hosts (host: text: nameValuePair

     

       
357
       
357
       
 
       
          ("tinc/${network}/hosts/${host}")

     

···

       
19
       
19
       
 
       
    ${ethtool} -s ${interface} ${methodParameter {inherit method password;}}

     

       
20
       
20
       
 
       
  '';

     

       
21
       
21
       
 
       


     

       
22
       
22
       
-
       
  concatStrings = fold (x: y: x + y) "";

     

       
22
       
22
       
+
       
  concatStrings = foldr (x: y: x + y) "";

     

       
23
       
23
       
 
       
  lines = concatStrings (map (l: line l) interfaces);

     

       
24
       
24
       
 
       


     

       
25
       
25
       
 
       
in

     

···

       
126
       
126
       
 
       
    else showWarnings config.warnings baseSystem;

     

       
127
       
127
       
 
       


     

       
128
       
128
       
 
       
  # Replace runtime dependencies

     

       
129
       
129
       
-
       
  system = fold ({ oldDependency, newDependency }: drv:

     

       
129
       
129
       
+
       
  system = foldr ({ oldDependency, newDependency }: drv:

     

       
130
       
130
       
 
       
      pkgs.replaceDependency { inherit oldDependency newDependency drv; }

     

       
131
       
131
       
 
       
    ) baseSystemAssertWarn config.system.replaceRuntimeDependencies;

     

       
132
       
132
       
 
       


     

···

       
75
       
75
       
 
       
             else "${convertedFont}");

     

       
76
       
76
       
 
       
    });

     

       
77
       
77
       
 
       


     

       
78
       
78
       
-
       
  bootDeviceCounters = fold (device: attr: attr // { ${device} = (attr.${device} or 0) + 1; }) {}

     

       
78
       
78
       
+
       
  bootDeviceCounters = foldr (device: attr: attr // { ${device} = (attr.${device} or 0) + 1; }) {}

     

       
79
       
79
       
 
       
    (concatMap (args: args.devices) cfg.mirroredBoots);

     

       
80
       
80
       
 
       


     

       
81
       
81
       
 
       
  convertedFont = (pkgs.runCommand "grub-font-converted.pf2" {}

     

···

       
8
       
8
       
 
       
  keyedEncDevs = filter (dev: dev.encrypted.keyFile != null) encDevs;

     

       
9
       
9
       
 
       
  keylessEncDevs = filter (dev: dev.encrypted.keyFile == null) encDevs;

     

       
10
       
10
       
 
       
  anyEncrypted =

     

       
11
       
11
       
-
       
    fold (j: v: v || j.encrypted.enable) false encDevs;

     

       
11
       
11
       
+
       
    foldr (j: v: v || j.encrypted.enable) false encDevs;

     

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       
  encryptedFSOptions = {

     

       
14
       
14
       
 
       


     

···

       
68
       
68
       
 
       


     

       
69
       
69
       
 
       
let

     

       
70
       
70
       
 
       
  # Combine the `features' attribute sets of all the kernel patches.

     

       
71
       
71
       
-
       
  kernelFeatures = lib.fold (x: y: (x.features or {}) // y) ({

     

       
71
       
71
       
+
       
  kernelFeatures = lib.foldr (x: y: (x.features or {}) // y) ({

     

       
72
       
72
       
 
       
    iwlwifi = true;

     

       
73
       
73
       
 
       
    efiBootStub = true;

     

       
74
       
74
       
 
       
    needsCifsUtils = true;

     

···

       
77
       
77
       
 
       
            in if fn != null then [{key = fn;}] ++ xs

     

       
78
       
78
       
 
       
               else xs;

     

       
79
       
79
       
 
       


     

       
80
       
80
       
-
       
        in pkgs.lib.fold foundDeps [] deps;

     

       
80
       
80
       
+
       
        in pkgs.lib.foldr foundDeps [] deps;

     

       
81
       
81
       
 
       
    };

     

       
82
       
82
       
 
       


     

       
83
       
83