···

       
38
       
38
       
 
       
    in foldl' (length list - 1);

     

       
39
       
39
       
 
       


     

       
40
       
40
       
 
       


     

       
41
       
41
       
+
       
  # Strict version of foldl.

     

       
42
       
42
       
+
       
  foldl' = builtins.foldl' or foldl;

     

       
43
       
43
       
+
       


     

       
44
       
44
       
+
       


     

       
41
       
45
       
 
       
  # map with index: `imap (i: v: "${v}-${toString i}") ["a" "b"] ==

     

       
42
       
46
       
 
       
  # ["a-1" "b-2"]'

     

       
43
       
47
       
 
       
  imap = f: list:

     
···

       
59
       
63
       
 
       
  # == [1 2 3 4 5]' and `flatten 1 == [1]'.

     

       
60
       
64
       
 
       
  flatten = x:

     

       
61
       
65
       
 
       
    if isList x

     

       
62
       
62
       
-
       
    then fold (x: y: (flatten x) ++ y) [] x

     

       
66
       
66
       
+
       
    then foldl' (x: y: x ++ (flatten y)) [] x

     

       
63
       
67
       
 
       
    else [x];

     

       
64
       
68
       
 
       


     

       
65
       
69
       
 
       


     
···

       
96
       
100
       
 
       


     

       
97
       
101
       
 
       
  # Count how many times function `pred' returns true for the elements

     

       
98
       
102
       
 
       
  # of `list'.

     

       
99
       
99
       
-
       
  count = pred: fold (x: c: if pred x then c + 1 else c) 0;

     

       
103
       
103
       
+
       
  count = pred: foldl' (c: x: if pred x then c + 1 else c) 0;

     

       
100
       
104
       
 
       


     

       
101
       
105
       
 
       


     

       
102
       
106
       
 
       
  # Return a singleton list or an empty list, depending on a boolean

     

···

       
76
       
76
       
 
       
          else yieldConfig (prefix ++ [n]) v) set) ["_definedNames"];

     

       
77
       
77
       
 
       
        in

     

       
78
       
78
       
 
       
        if options._module.check.value && set ? _definedNames then

     

       
79
       
79
       
-
       
          fold (m: res:

     

       
80
       
80
       
-
       
            fold (name: res:

     

       
79
       
79
       
+
       
          foldl' (res: m:

     

       
80
       
80
       
+
       
            foldl' (res: name:

     

       
81
       
81
       
 
       
              if set ? ${name} then res else throw "The option `${showOption (prefix ++ [name])}' defined in `${m.file}' does not exist.")

     

       
82
       
82
       
 
       
              res m.names)

     

       
83
       
83
       
 
       
            res set._definedNames

     
···

       
225
       
225
       
 
       
     'opts' is a list of modules.  Each module has an options attribute which

     

       
226
       
226
       
 
       
     correspond to the definition of 'loc' in 'opt.file'. */

     

       
227
       
227
       
 
       
  mergeOptionDecls = loc: opts:

     

       
228
       
228
       
-
       
    fold (opt: res:

     

       
228
       
228
       
+
       
    foldl' (res: opt:

     

       
229
       
229
       
 
       
      if opt.options ? default && res ? default ||

     

       
230
       
230
       
 
       
         opt.options ? example && res ? example ||

     

       
231
       
231
       
 
       
         opt.options ? description && res ? description ||

     
···

       
251
       
251
       
 
       
            else if opt.options ? options then map (coerceOption opt.file) options' ++ res.options

     

       
252
       
252
       
 
       
            else res.options;

     

       
253
       
253
       
 
       
        in opt.options // res //

     

       
254
       
254
       
-
       
          { declarations = [opt.file] ++ res.declarations;

     

       
254
       
254
       
+
       
          { declarations = res.declarations ++ [opt.file];

     

       
255
       
255
       
 
       
            options = submodules;

     

       
256
       
256
       
 
       
          }

     

       
257
       
257
       
 
       
    ) { inherit loc; declarations = []; options = []; } opts;

     
···

       
302
       
302
       
 
       
        in

     

       
303
       
303
       
 
       
          processOrder (processOverride (processIfAndMerge defs));

     

       
304
       
304
       
 
       


     

       
305
       
305
       
-
       
        # Type-check the remaining definitions, and merge them

     

       
306
       
306
       
-
       
        mergedValue = fold (def: res:

     

       
305
       
305
       
+
       
        # Type-check the remaining definitions, and merge them.

     

       
306
       
306
       
+
       
        mergedValue = foldl' (res: def:

     

       
307
       
307
       
 
       
          if type.check def.value then res

     

       
308
       
308
       
 
       
          else throw "The option value `${showOption loc}' in `${def.file}' is not a ${type.name}.")

     

       
309
       
309
       
 
       
          (type.merge loc defsFinal) defsFinal;

     
···

       
384
       
384
       
 
       
      defaultPrio = 100;

     

       
385
       
385
       
 
       
      getPrio = def: if def.value._type or "" == "override" then def.value.priority else defaultPrio;

     

       
386
       
386
       
 
       
      min = x: y: if x < y then x else y;

     

       
387
       
387
       
-
       
      highestPrio = fold (def: prio: min (getPrio def) prio) 9999 defs;

     

       
387
       
387
       
+
       
      highestPrio = foldl' (prio: def: min (getPrio def) prio) 9999 defs;

     

       
388
       
388
       
 
       
      strip = def: if def.value._type or "" == "override" then def // { value = def.value.content; } else def;

     

       
389
       
389
       
 
       
    in concatMap (def: if getPrio def == highestPrio then [(strip def)] else []) defs;

     

       
390
       
390
       
 
       


     

···

       
53
       
53
       
 
       
    if length list == 1 then head list

     

       
54
       
54
       
 
       
    else if all isFunction list then x: mergeDefaultOption loc (map (f: f x) list)

     

       
55
       
55
       
 
       
    else if all isList list then concatLists list

     

       
56
       
56
       
-
       
    else if all isAttrs list then fold lib.mergeAttrs {} list

     

       
57
       
57
       
-
       
    else if all isBool list then fold lib.or false list

     

       
56
       
56
       
+
       
    else if all isAttrs list then foldl' lib.mergeAttrs {} list

     

       
57
       
57
       
+
       
    else if all isBool list then foldl' lib.or false list

     

       
58
       
58
       
 
       
    else if all isString list then lib.concatStrings list

     

       
59
       
59
       
 
       
    else if all isInt list && all (x: x == head list) list then head list

     

       
60
       
60
       
 
       
    else throw "Cannot merge definitions of `${showOption loc}' given in ${showFiles (getFiles defs)}.";

     
···

       
68
       
68
       
 
       
  /* "Merge" option definitions by checking that they all have the same value. */

     

       
69
       
69
       
 
       
  mergeEqualOption = loc: defs:

     

       
70
       
70
       
 
       
    if defs == [] then abort "This case should never happen."

     

       
71
       
71
       
-
       
    else fold (def: val:

     

       
71
       
71
       
+
       
    else foldl' (val: def:

     

       
72
       
72
       
 
       
      if def.value != val then

     

       
73
       
73
       
 
       
        throw "The option `${showOption loc}' has conflicting definitions, in ${showFiles (getFiles defs)}."

     

       
74
       
74
       
 
       
      else

     

···

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
  # Concatenate a list of strings.

     

       
15
       
15
       
-
       
  concatStrings = lib.fold (x: y: x + y) "";

     

       
15
       
15
       
+
       
  concatStrings = lib.foldl' (x: y: x + y) "";

     

       
16
       
16
       
 
       


     

       
17
       
17
       
 
       


     

       
18
       
18
       
 
       
  # Map a function over a list and concatenate the resulting strings.

     

···

       
88
       
88
       
 
       
    attrs = mkOptionType {

     

       
89
       
89
       
 
       
      name = "attribute set";

     

       
90
       
90
       
 
       
      check = isAttrs;

     

       
91
       
91
       
-
       
      merge = loc: fold (def: mergeAttrs def.value) {};

     

       
91
       
91
       
+
       
      merge = loc: foldl' (res: def: mergeAttrs res def.value) {};

     

       
92
       
92
       
 
       
    };

     

       
93
       
93
       
 
       


     

       
94
       
94
       
 
       
    # derivation is a reserved keyword.