···

       
168
       
168
       
 
       
       ] { a.b.c = 0; }

     

       
169
       
169
       
 
       
       => { a = { b = { d = 1; }; }; x = { y = "xy"; }; }

     

       
170
       
170
       
 
       


     

       
171
       
171
       
-
       
    Type: updateManyAttrsByPath :: [{ path :: [String], update :: (Any -> Any) }] -> AttrSet -> AttrSet

     

       
171
       
171
       
+
       
    Type: updateManyAttrsByPath :: [{ path :: [String]; update :: (Any -> Any); }] -> AttrSet -> AttrSet

     

       
172
       
172
       
 
       
  */

     

       
173
       
173
       
 
       
  updateManyAttrsByPath = let

     

       
174
       
174
       
 
       
    # When recursing into attributes, instead of updating the `path` of each

     
···

       
414
       
414
       
 
       
       => { name = "some"; value = 6; }

     

       
415
       
415
       
 
       


     

       
416
       
416
       
 
       
     Type:

     

       
417
       
417
       
-
       
       nameValuePair :: String -> Any -> { name :: String, value :: Any }

     

       
417
       
417
       
+
       
       nameValuePair :: String -> Any -> { name :: String; value :: Any; }

     

       
418
       
418
       
 
       
  */

     

       
419
       
419
       
 
       
  nameValuePair =

     

       
420
       
420
       
 
       
    # Attribute name

     
···

       
449
       
449
       
 
       
       => { foo_x = "bar-a"; foo_y = "bar-b"; }

     

       
450
       
450
       
 
       


     

       
451
       
451
       
 
       
     Type:

     

       
452
       
452
       
-
       
       mapAttrs' :: (String -> Any -> { name = String; value = Any }) -> AttrSet -> AttrSet

     

       
452
       
452
       
+
       
       mapAttrs' :: (String -> Any -> { name :: String; value :: Any; }) -> AttrSet -> AttrSet

     

       
453
       
453
       
 
       
  */

     

       
454
       
454
       
 
       
  mapAttrs' =

     

       
455
       
455
       
 
       
    # A function, given an attribute's name and value, returns a new `nameValuePair`.

     
···

       
649
       
649
       
 
       


     

       
650
       
650
       
 
       
     Example:

     

       
651
       
651
       
 
       
       zipAttrsWith (name: values: values) [{a = "x";} {a = "y"; b = "z";}]

     

       
652
       
652
       
-
       
       => { a = ["x" "y"]; b = ["z"] }

     

       
652
       
652
       
+
       
       => { a = ["x" "y"]; b = ["z"]; }

     

       
653
       
653
       
 
       


     

       
654
       
654
       
 
       
     Type:

     

       
655
       
655
       
 
       
       zipAttrsWith :: (String -> [ Any ] -> Any) -> [ AttrSet ] -> AttrSet

     
···

       
664
       
664
       
 
       


     

       
665
       
665
       
 
       
     Example:

     

       
666
       
666
       
 
       
       zipAttrs [{a = "x";} {a = "y"; b = "z";}]

     

       
667
       
667
       
-
       
       => { a = ["x" "y"]; b = ["z"] }

     

       
667
       
667
       
+
       
       => { a = ["x" "y"]; b = ["z"]; }

     

       
668
       
668
       
 
       


     

       
669
       
669
       
 
       
     Type:

     

       
670
       
670
       
 
       
       zipAttrs :: [ AttrSet ] -> AttrSet

     

···

       
306
       
306
       
 
       
  /* Splits the elements of a list in two lists, `right` and

     

       
307
       
307
       
 
       
     `wrong`, depending on the evaluation of a predicate.

     

       
308
       
308
       
 
       


     

       
309
       
309
       
-
       
     Type: (a -> bool) -> [a] -> { right :: [a], wrong :: [a] }

     

       
309
       
309
       
+
       
     Type: (a -> bool) -> [a] -> { right :: [a]; wrong :: [a]; }

     

       
310
       
310
       
 
       


     

       
311
       
311
       
 
       
     Example:

     

       
312
       
312
       
 
       
       partition (x: x > 2) [ 5 1 2 3 4 ]

     
···

       
374
       
374
       
 
       
  /* Merges two lists of the same size together. If the sizes aren't the same

     

       
375
       
375
       
 
       
     the merging stops at the shortest.

     

       
376
       
376
       
 
       


     

       
377
       
377
       
-
       
     Type: zipLists :: [a] -> [b] -> [{ fst :: a, snd :: b}]

     

       
377
       
377
       
+
       
     Type: zipLists :: [a] -> [b] -> [{ fst :: a; snd :: b; }]

     

       
378
       
378
       
 
       


     

       
379
       
379
       
 
       
     Example:

     

       
380
       
380
       
 
       
       zipLists [ 1 2 ] [ "a" "b" ]

     

···

       
114
       
114
       
 
       


     

       
115
       
115
       
 
       
     You can omit the default path if the name of the option is also attribute path in nixpkgs.

     

       
116
       
116
       
 
       


     

       
117
       
117
       
-
       
     Type: mkPackageOption :: pkgs -> string -> { default :: [string], example :: null | string | [string] } -> option

     

       
117
       
117
       
+
       
     Type: mkPackageOption :: pkgs -> string -> { default :: [string]; example :: null | string | [string]; } -> option

     

       
118
       
118
       
 
       


     

       
119
       
119
       
 
       
     Example:

     

       
120
       
120
       
 
       
       mkPackageOption pkgs "hello" { }

     
···

       
201
       
201
       
 
       


     

       
202
       
202
       
 
       
  /* Extracts values of all "value" keys of the given list.

     

       
203
       
203
       
 
       


     

       
204
       
204
       
-
       
     Type: getValues :: [ { value :: a } ] -> [a]

     

       
204
       
204
       
+
       
     Type: getValues :: [ { value :: a; } ] -> [a]

     

       
205
       
205
       
 
       


     

       
206
       
206
       
 
       
     Example:

     

       
207
       
207
       
 
       
       getValues [ { value = 1; } { value = 2; } ] // => [ 1 2 ]

     
···

       
211
       
211
       
 
       


     

       
212
       
212
       
 
       
  /* Extracts values of all "file" keys of the given list

     

       
213
       
213
       
 
       


     

       
214
       
214
       
-
       
     Type: getFiles :: [ { file :: a } ] -> [a]

     

       
214
       
214
       
+
       
     Type: getFiles :: [ { file :: a; } ] -> [a]

     

       
215
       
215
       
 
       


     

       
216
       
216
       
 
       
     Example:

     

       
217
       
217
       
 
       
       getFiles [ { file = "file1"; } { file = "file2"; } ] // => [ "file1" "file2" ]