commit e00a40a257e9d960a94020989e00b7d7c1238294 · pyrox.dev/nixpkgs

+43 -5

lib/attrsets.nix

···

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
        
         inherit (builtins) head length;

     

       8
       8
       -
         inherit (lib.trivial) mergeAttrs warn;

     

       8
       8
       +
         inherit (lib.trivial) isInOldestRelease mergeAttrs warn warnIf;

     

       9
       9
        
         inherit (lib.strings) concatStringsSep concatMapStringsSep escapeNixIdentifier sanitizeDerivationName;

     

       10
       10
        
         inherit (lib.lists) foldr foldl' concatMap elemAt all partition groupBy take foldl;

     

       11
       11
        
       in

     
···

       885
       885
        
           # Type

     

       886
       886
        
       

     

       887
       887
        
           ```

     

       888
       888
       -
           cartesianProductOfSets :: AttrSet -> [AttrSet]

     

       888
       888
       +
           cartesianProduct :: AttrSet -> [AttrSet]

     

       889
       889
        
           ```

     

       890
       890
        
       

     

       891
       891
        
           # Examples

     

       892
       892
        
           :::{.example}

     

       893
       893
       -
           ## `lib.attrsets.cartesianProductOfSets` usage example

     

       893
       893
       +
           ## `lib.attrsets.cartesianProduct` usage example

     

       894
       894
        
       

     

       895
       895
        
           ```nix

     

       896
       896
       -
           cartesianProductOfSets { a = [ 1 2 ]; b = [ 10 20 ]; }

     

       896
       896
       +
           cartesianProduct { a = [ 1 2 ]; b = [ 10 20 ]; }

     

       897
       897
        
           => [

     

       898
       898
        
                { a = 1; b = 10; }

     

       899
       899
        
                { a = 1; b = 20; }

     
···

       904
       904
        
       

     

       905
       905
        
           :::

     

       906
       906
        
         */

     

       907
       907
       -
         cartesianProductOfSets =

     

       907
       907
       +
         cartesianProduct =

     

       908
       908
        
           attrsOfLists:

     

       909
       909
        
           foldl' (listOfAttrs: attrName:

     

       910
       910
        
             concatMap (attrs:

     
···

       912
       912
        
             ) listOfAttrs

     

       913
       913
        
           ) [{}] (attrNames attrsOfLists);

     

       914
       914
        
       

     

       915
       915
       +
       

     

       916
       916
       +
         /**

     

       917
       917
       +
           Return the result of function f applied to the cartesian product of attribute set value combinations.

     

       918
       918
       +
           Equivalent to using cartesianProduct followed by map.

     

       919
       919
       +
       

     

       920
       920
       +
           # Inputs

     

       921
       921
       +
       

     

       922
       922
       +
           `f`

     

       923
       923
       +
       

     

       924
       924
       +
           : A function, given an attribute set, it returns a new value.

     

       925
       925
       +
       

     

       926
       926
       +
           `attrsOfLists`

     

       927
       927
       +
       

     

       928
       928
       +
           : Attribute set with attributes that are lists of values

     

       929
       929
       +
       

     

       930
       930
       +
           # Type

     

       931
       931
       +
       

     

       932
       932
       +
           ```

     

       933
       933
       +
           mapCartesianProduct :: (AttrSet -> a) -> AttrSet -> [a]

     

       934
       934
       +
           ```

     

       935
       935
       +
       

     

       936
       936
       +
           # Examples

     

       937
       937
       +
           :::{.example}

     

       938
       938
       +
           ## `lib.attrsets.mapCartesianProduct` usage example

     

       939
       939
       +
       

     

       940
       940
       +
           ```nix

     

       941
       941
       +
           mapCartesianProduct ({a, b}: "${a}-${b}") { a = [ "1" "2" ]; b = [ "3" "4" ]; }

     

       942
       942
       +
           => [ "1-3" "1-4" "2-3" "2-4" ]

     

       943
       943
       +
           ```

     

       944
       944
       +
       

     

       945
       945
       +
           :::

     

       946
       946
       +
       

     

       947
       947
       +
         */

     

       948
       948
       +
         mapCartesianProduct = f: attrsOfLists: map f (cartesianProduct attrsOfLists);

     

       915
       949
        
       

     

       916
       950
        
         /**

     

       917
       951
        
           Utility function that creates a `{name, value}` pair as expected by `builtins.listToAttrs`.

     
···

       1999
       2033
        
         # DEPRECATED

     

       2000
       2034
        
         zip = warn

     

       2001
       2035
        
           "lib.zip is a deprecated alias of lib.zipAttrsWith." zipAttrsWith;

     

       2036
       2036
       +
       

     

       2037
       2037
       +
         # DEPRECATED

     

       2038
       2038
       +
         cartesianProductOfSets = warnIf (isInOldestRelease 2405)

     

       2039
       2039
       +
           "lib.cartesianProductOfSets is a deprecated alias of lib.cartesianProduct." cartesianProduct;

     

       2002
       2040
        
       }

+2 -2

lib/default.nix

···

       86
       86
        
             zipAttrsWithNames zipAttrsWith zipAttrs recursiveUpdateUntil

     

       87
       87
        
             recursiveUpdate matchAttrs mergeAttrsList overrideExisting showAttrPath getOutput

     

       88
       88
        
             getBin getLib getDev getMan chooseDevOutputs zipWithNames zip

     

       89
       89
       -
             recurseIntoAttrs dontRecurseIntoAttrs cartesianProductOfSets

     

       90
       90
       -
             updateManyAttrsByPath;

     

       89
       89
       +
             recurseIntoAttrs dontRecurseIntoAttrs cartesianProduct cartesianProductOfSets

     

       90
       90
       +
             mapCartesianProduct updateManyAttrsByPath;

     

       91
       91
        
           inherit (self.lists) singleton forEach foldr fold foldl foldl' imap0 imap1

     

       92
       92
        
             concatMap flatten remove findSingle findFirst any all count

     

       93
       93
        
             optional optionals toList range replicate partition zipListsWith zipLists

+19 -3

lib/lists.nix

···

       1688
       1688
        
           ## `lib.lists.crossLists` usage example

     

       1689
       1689
        
       

     

       1690
       1690
        
           ```nix

     

       1691
       1691
       -
           crossLists (x:y: "${toString x}${toString y}") [[1 2] [3 4]]

     

       1691
       1691
       +
           crossLists (x: y: "${toString x}${toString y}") [[1 2] [3 4]]

     

       1692
       1692
        
           => [ "13" "14" "23" "24" ]

     

       1693
       1693
        
           ```

     

       1694
       1694
        
       

     

       1695
       1695
       +
           The following function call is equivalent to the one deprecated above:

     

       1696
       1696
       +
       

     

       1697
       1697
       +
           ```nix

     

       1698
       1698
       +
           mapCartesianProduct (x: "${toString x.a}${toString x.b}") { a = [1 2]; b = [3 4]; }

     

       1699
       1699
       +
           => [ "13" "14" "23" "24" ]

     

       1700
       1700
       +
           ```

     

       1695
       1701
        
           :::

     

       1696
       1702
        
         */

     

       1697
       1703
        
         crossLists = warn

     

       1698
       1698
       -
           "lib.crossLists is deprecated, use lib.cartesianProductOfSets instead."

     

       1699
       1699
       -
           (f: foldl (fs: args: concatMap (f: map f args) fs) [f]);

     

       1704
       1704
       +
           ''lib.crossLists is deprecated, use lib.mapCartesianProduct instead.

     

       1700
       1705
        
       

     

       1706
       1706
       +
           For example, the following function call:

     

       1707
       1707
       +
       

     

       1708
       1708
       +
           nix-repl> lib.crossLists (x: y: x+y) [[1 2] [3 4]]

     

       1709
       1709
       +
           [ 4 5 5 6 ]

     

       1710
       1710
       +
       

     

       1711
       1711
       +
           Can now be replaced by the following one:

     

       1712
       1712
       +
       

     

       1713
       1713
       +
           nix-repl> lib.mapCartesianProduct ({x,y}: x+y) { x = [1 2]; y = [3 4]; }

     

       1714
       1714
       +
           [ 4 5 5 6 ]

     

       1715
       1715
       +
           ''

     

       1716
       1716
       +
           (f: foldl (fs: args: concatMap (f: map f args) fs) [f]);

     

       1701
       1717
        
       

     

       1702
       1718
        
         /**

     

       1703
       1719
        
           Remove duplicate elements from the `list`. O(n^2) complexity.

+35 -15

lib/tests/misc.nix

···

       33
       33
        
           boolToString

     

       34
       34
        
           callPackagesWith

     

       35
       35
        
           callPackageWith

     

       36
       36
       -
           cartesianProductOfSets

     

       36
       36
       +
           cartesianProduct

     

       37
       37
        
           cli

     

       38
       38
        
           composeExtensions

     

       39
       39
        
           composeManyExtensions

     
···

       71
       71
        
           makeIncludePath

     

       72
       72
        
           makeOverridable

     

       73
       73
        
           mapAttrs

     

       74
       74
       +
           mapCartesianProduct

     

       74
       75
        
           matchAttrs

     

       75
       76
        
           mergeAttrs

     

       76
       77
        
           meta

     

       77
       77
       -
           mkOption

     

       78
       78
        
           mod

     

       79
       79
        
           nameValuePair

     

       80
       80
        
           optionalDrvAttr

     
···

       117
       117
        
           expr = (builtins.tryEval expr).success;

     

       118
       118
        
           expected = true;

     

       119
       119
        
         };

     

       120
       120
       -
         testingDeepThrow = expr: testingThrow (builtins.deepSeq expr expr);

     

       121
       120
        
       

     

       122
       121
        
         testSanitizeDerivationName = { name, expected }:

     

       123
       122
        
         let

     
···

       1415
       1414
        
           };

     

       1416
       1415
        
       

     

       1417
       1416
        
         testToPrettyMultiline = {

     

       1418
       1418
       -
           expr = mapAttrs (const (generators.toPretty { })) rec {

     

       1417
       1417
       +
           expr = mapAttrs (const (generators.toPretty { })) {

     

       1419
       1418
        
             list = [ 3 4 [ false ] ];

     

       1420
       1419
        
             attrs = { foo = null; bar.foo = "baz"; };

     

       1421
       1420
        
             newlinestring = "\n";

     
···

       1429
       1428
        
               there

     

       1430
       1429
        
               test'';

     

       1431
       1430
        
           };

     

       1432
       1432
       -
           expected = rec {

     

       1431
       1431
       +
           expected = {

     

       1433
       1432
        
             list = ''

     

       1434
       1433
        
               [

     

       1435
       1434
        
                 3

     
···

       1467
       1466
        
           expected  = "«foo»";

     

       1468
       1467
        
         };

     

       1469
       1468
        
       

     

       1470
       1470
       -
         testToPlist =

     

       1471
       1471
       -
           let

     

       1472
       1472
       -
             deriv = derivation { name = "test"; builder = "/bin/sh"; system = "aarch64-linux"; };

     

       1473
       1473
       -
           in {

     

       1469
       1469
       +
         testToPlist = {

     

       1474
       1470
        
           expr = mapAttrs (const (generators.toPlist { })) {

     

       1475
       1471
        
             value = {

     

       1476
       1476
       -
               nested.values = rec {

     

       1472
       1472
       +
               nested.values = {

     

       1477
       1473
        
                 int = 42;

     

       1478
       1474
        
                 float = 0.1337;

     

       1479
       1475
        
                 bool = true;

     
···

       1686
       1682
        
         };

     

       1687
       1683
        
       

     

       1688
       1684
        
         testCartesianProductOfEmptySet = {

     

       1689
       1689
       -
           expr = cartesianProductOfSets {};

     

       1685
       1685
       +
           expr = cartesianProduct {};

     

       1690
       1686
        
           expected = [ {} ];

     

       1691
       1687
        
         };

     

       1692
       1688
        
       

     

       1693
       1689
        
         testCartesianProductOfOneSet = {

     

       1694
       1694
       -
           expr = cartesianProductOfSets { a = [ 1 2 3 ]; };

     

       1690
       1690
       +
           expr = cartesianProduct { a = [ 1 2 3 ]; };

     

       1695
       1691
        
           expected = [ { a = 1; } { a = 2; } { a = 3; } ];

     

       1696
       1692
        
         };

     

       1697
       1693
        
       

     

       1698
       1694
        
         testCartesianProductOfTwoSets = {

     

       1699
       1699
       -
           expr = cartesianProductOfSets { a = [ 1 ]; b = [ 10 20 ]; };

     

       1695
       1695
       +
           expr = cartesianProduct { a = [ 1 ]; b = [ 10 20 ]; };

     

       1700
       1696
        
           expected = [

     

       1701
       1697
        
             { a = 1; b = 10; }

     

       1702
       1698
        
             { a = 1; b = 20; }

     
···

       1704
       1700
        
         };

     

       1705
       1701
        
       

     

       1706
       1702
        
         testCartesianProductOfTwoSetsWithOneEmpty = {

     

       1707
       1707
       -
           expr = cartesianProductOfSets { a = [ ]; b = [ 10 20 ]; };

     

       1703
       1703
       +
           expr = cartesianProduct { a = [ ]; b = [ 10 20 ]; };

     

       1708
       1704
        
           expected = [ ];

     

       1709
       1705
        
         };

     

       1710
       1706
        
       

     

       1711
       1707
        
         testCartesianProductOfThreeSets = {

     

       1712
       1712
       -
           expr = cartesianProductOfSets {

     

       1708
       1708
       +
           expr = cartesianProduct {

     

       1713
       1709
        
             a = [   1   2   3 ];

     

       1714
       1710
        
             b = [  10  20  30 ];

     

       1715
       1711
        
             c = [ 100 200 300 ];

     
···

       1751
       1747
        
             { a = 3; b = 30; c = 200; }

     

       1752
       1748
        
             { a = 3; b = 30; c = 300; }

     

       1753
       1749
        
           ];

     

       1750
       1750
       +
         };

     

       1751
       1751
       +
       

     

       1752
       1752
       +
         testMapCartesianProductOfOneSet = {

     

       1753
       1753
       +
           expr = mapCartesianProduct ({a}: a * 2) { a = [ 1 2 3 ]; };

     

       1754
       1754
       +
           expected = [ 2 4 6 ];

     

       1755
       1755
       +
         };

     

       1756
       1756
       +
       

     

       1757
       1757
       +
         testMapCartesianProductOfTwoSets = {

     

       1758
       1758
       +
           expr = mapCartesianProduct ({a,b}: a + b) { a = [ 1 ]; b = [ 10 20 ]; };

     

       1759
       1759
       +
           expected = [ 11 21 ];

     

       1760
       1760
       +
         };

     

       1761
       1761
       +
       

     

       1762
       1762
       +
         testMapCartesianProcutOfTwoSetsWithOneEmpty = {

     

       1763
       1763
       +
           expr = mapCartesianProduct (x: x.a + x.b) { a = [ ]; b = [ 10 20 ]; };

     

       1764
       1764
       +
           expected = [ ];

     

       1765
       1765
       +
         };

     

       1766
       1766
       +
       

     

       1767
       1767
       +
         testMapCartesianProductOfThreeSets = {

     

       1768
       1768
       +
           expr = mapCartesianProduct ({a,b,c}: a + b + c) {

     

       1769
       1769
       +
             a = [ 1 2 3 ];

     

       1770
       1770
       +
             b = [ 10 20 30 ];

     

       1771
       1771
       +
             c = [ 100 200 300 ];

     

       1772
       1772
       +
           };

     

       1773
       1773
       +
           expected = [ 111 211 311 121 221 321 131 231 331 112 212 312 122 222 322 132 232 332 113 213 313 123 223 323 133 233 333 ];

     

       1754
       1774
        
         };

     

       1755
       1775
        
       

     

       1756
       1776
        
         # The example from the showAttrPath documentation

+2 -2

nixos/modules/services/x11/display-managers/default.nix

···

       284
       284
        
             in

     

       285
       285
        
               # We will generate every possible pair of WM and DM.

     

       286
       286
        
               concatLists (

     

       287
       287
       -
                   builtins.map

     

       287
       287
       +
                   lib.mapCartesianProduct

     

       288
       288
        
                   ({dm, wm}: let

     

       289
       289
        
                     sessionName = "${dm.name}${optionalString (wm.name != "none") ("+" + wm.name)}";

     

       290
       290
        
                     script = xsession dm wm;

     
···

       312
       312
        
                         providedSessions = [ sessionName ];

     

       313
       313
        
                       })

     

       314
       314
        
                   )

     

       315
       315
       -
                   (cartesianProductOfSets { dm = dms; wm = wms; })

     

       315
       315
       +
                   { dm = dms; wm = wms; }

     

       316
       316
        
                 );

     

       317
       317
        
         };

     

       318
       318

+1 -1

nixos/tests/predictable-interface-names.nix

···

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
        
         inherit (import ../lib/testing-python.nix { inherit system pkgs; }) makeTest;

     

       8
       8
       -
         testCombinations = pkgs.lib.cartesianProductOfSets {

     

       8
       8
       +
         testCombinations = pkgs.lib.cartesianProduct {

     

       9
       9
        
           predictable = [true false];

     

       10
       10
        
           withNetworkd = [true false];

     

       11
       11
        
           systemdStage1 = [true false];

+7 -8

pkgs/by-name/so/solo5/package.nix

···

       63
       63
        
           runHook postCheck

     

       64
       64
        
         '';

     

       65
       65
        
       

     

       66
       66
       -
         meta = {

     

       66
       66
       +
         meta = with lib; {

     

       67
       67
        
           description = "Sandboxed execution environment";

     

       68
       68
        
           homepage = "https://github.com/solo5/solo5";

     

       69
       69
       -
           license = lib.licenses.isc;

     

       70
       70
       -
           maintainers = with lib.maintainers; [ ehmry ];

     

       71
       71
       -
           platforms = builtins.map ({arch, os}: "${arch}-${os}")

     

       72
       72
       -
             (lib.cartesianProductOfSets {

     

       73
       73
       -
               arch = [ "aarch64" "x86_64" ];

     

       74
       74
       -
               os = [ "freebsd" "genode" "linux" "openbsd" ];

     

       75
       75
       -
             });

     

       69
       69
       +
           license = licenses.isc;

     

       70
       70
       +
           maintainers = [ maintainers.ehmry ];

     

       71
       71
       +
           platforms = mapCartesianProduct ({ arch, os }: "${arch}-${os}") {

     

       72
       72
       +
             arch = [ "aarch64" "x86_64" ];

     

       73
       73
       +
             os = [ "freebsd" "genode" "linux" "openbsd" ];

     

       74
       74
       +
           };

     

       76
       75
        
         };

     

       77
       76
        
       

     

       78
       77
        
       }

+3 -4

pkgs/data/fonts/junicode/tests.nix

···

       15
       15
        
             '');

     

       16
       16
        
       in

     

       17
       17
        
       builtins.listToAttrs (

     

       18
       18
       -
         map

     

       19
       19
       -
           texTest

     

       20
       20
       -
           (lib.attrsets.cartesianProductOfSets {

     

       18
       18
       +
         lib.mapCartesianProduct texTest

     

       19
       19
       +
           {

     

       21
       20
        
             tex = [ "xelatex" "lualatex" ];

     

       22
       21
        
             fonttype = [ "ttf" "otf" ];

     

       23
       22
        
             package = [ "junicode" ];

     

       24
       23
        
             file = [ ./test.tex ];

     

       25
       25
       -
           })

     

       24
       24
       +
           }

     

       26
       25
        
         ++

     

       27
       26
        
         [

     

       28
       27
        
           (texTest {

+1 -2

pkgs/data/icons/catppuccin-cursors/default.nix

···

       9
       9
        
           palette = [ "Frappe" "Latte" "Macchiato" "Mocha" ];

     

       10
       10
        
           color = [ "Blue" "Dark" "Flamingo" "Green" "Lavender" "Light" "Maroon" "Mauve" "Peach" "Pink" "Red" "Rosewater" "Sapphire" "Sky" "Teal" "Yellow" ];

     

       11
       11
        
         };

     

       12
       12
       -
         product = lib.attrsets.cartesianProductOfSets dimensions;

     

       13
       12
        
         variantName = { palette, color }: (lib.strings.toLower palette) + color;

     

       14
       14
       -
         variants = map variantName product;

     

       13
       13
       +
         variants = lib.mapCartesianProduct variantName dimensions;

     

       15
       14
        
       in

     

       16
       15
        
       stdenvNoCC.mkDerivation rec {

     

       17
       16
        
         pname = "catppuccin-cursors";

+1 -2

pkgs/data/icons/comixcursors/default.nix

···

       7
       7
        
           thickness = [ "" "Slim_" ];  # Thick or slim edges.

     

       8
       8
        
           handedness = [ "" "LH_" ];   # Right- or left-handed.

     

       9
       9
        
         };

     

       10
       10
       -
         product = lib.cartesianProductOfSets dimensions;

     

       11
       10
        
         variantName =

     

       12
       11
        
           { color, opacity, thickness, handedness }:

     

       13
       12
        
           "${handedness}${opacity}${thickness}${color}";

     

       14
       13
        
         variants =

     

       15
       14
        
           # (The order of this list is already good looking enough to show in the

     

       16
       15
        
           # meta.longDescription.)

     

       17
       17
       -
           map variantName product;

     

       16
       16
       +
           lib.mapCartesianProduct variantName dimensions;

     

       18
       17
        
       in

     

       19
       18
        
       stdenvNoCC.mkDerivation rec {

     

       20
       19
        
         pname = "comixcursors";

+1 -1

pkgs/development/ocaml-modules/ocaml-freestanding/default.nix

···

       70
       70
        
           maintainers = [ maintainers.sternenseemann ];

     

       71
       71
        
           homepage = "https://github.com/mirage/ocaml-freestanding";

     

       72
       72
        
           platforms = builtins.map ({ arch, os }: "${arch}-${os}")

     

       73
       73
       -
             (cartesianProductOfSets {

     

       73
       73
       +
             (cartesianProduct {

     

       74
       74
        
                 arch = [ "aarch64" "x86_64" ];

     

       75
       75
        
                 os = [ "linux" ];

     

       76
       76
        
             } ++ [