···

       
5
       
 
       


     

       
6
       
 
       
let

     

       
7
       
 
       
  inherit (builtins) head length;

     

       
8
       
-
       
  inherit (lib.trivial) mergeAttrs warn;

     

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

     

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

     

       
11
       
 
       
in

     
···

       
885
       
 
       
    # Type

     

       
886
       
 
       


     

       
887
       
 
       
    ```

     

       
888
       
-
       
    cartesianProductOfSets :: AttrSet -> [AttrSet]

     

       
889
       
 
       
    ```

     

       
890
       
 
       


     

       
891
       
 
       
    # Examples

     

       
892
       
 
       
    :::{.example}

     

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

     

       
894
       
 
       


     

       
895
       
 
       
    ```nix

     

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

     

       
897
       
 
       
    => [

     

       
898
       
 
       
         { a = 1; b = 10; }

     

       
899
       
 
       
         { a = 1; b = 20; }

     
···

       
904
       
 
       


     

       
905
       
 
       
    :::

     

       
906
       
 
       
  */

     

       
907
       
-
       
  cartesianProductOfSets =

     

       
908
       
 
       
    attrsOfLists:

     

       
909
       
 
       
    foldl' (listOfAttrs: attrName:

     

       
910
       
 
       
      concatMap (attrs:

     
···

       
912
       
 
       
      ) listOfAttrs

     

       
913
       
 
       
    ) [{}] (attrNames attrsOfLists);

     

       
914
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
915
       
 
       


     

       
916
       
 
       
  /**

     

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

     
···

       
1999
       
 
       
  # DEPRECATED

     

       
2000
       
 
       
  zip = warn

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2002
       
 
       
}

     

···

       
5
       
 
       


     

       
6
       
 
       
let

     

       
7
       
 
       
  inherit (builtins) head length;

     

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

     

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

     

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

     

       
11
       
 
       
in

     
···

       
885
       
 
       
    # Type

     

       
886
       
 
       


     

       
887
       
 
       
    ```

     

       
888
       
+
       
    cartesianProduct :: AttrSet -> [AttrSet]

     

       
889
       
 
       
    ```

     

       
890
       
 
       


     

       
891
       
 
       
    # Examples

     

       
892
       
 
       
    :::{.example}

     

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

     

       
894
       
 
       


     

       
895
       
 
       
    ```nix

     

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

     

       
897
       
 
       
    => [

     

       
898
       
 
       
         { a = 1; b = 10; }

     

       
899
       
 
       
         { a = 1; b = 20; }

     
···

       
904
       
 
       


     

       
905
       
 
       
    :::

     

       
906
       
 
       
  */

     

       
907
       
+
       
  cartesianProduct =

     

       
908
       
 
       
    attrsOfLists:

     

       
909
       
 
       
    foldl' (listOfAttrs: attrName:

     

       
910
       
 
       
      concatMap (attrs:

     
···

       
912
       
 
       
      ) listOfAttrs

     

       
913
       
 
       
    ) [{}] (attrNames attrsOfLists);

     

       
914
       
 
       


     

       
915
       
+
       


     

       
916
       
+
       
  /**

     

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

     

       
918
       
+
       
    Equivalent to using cartesianProduct followed by map.

     

       
919
       
+
       


     

       
920
       
+
       
    # Inputs

     

       
921
       
+
       


     

       
922
       
+
       
    `f`

     

       
923
       
+
       


     

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

     

       
925
       
+
       


     

       
926
       
+
       
    `attrsOfLists`

     

       
927
       
+
       


     

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

     

       
929
       
+
       


     

       
930
       
+
       
    # Type

     

       
931
       
+
       


     

       
932
       
+
       
    ```

     

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

     

       
934
       
+
       
    ```

     

       
935
       
+
       


     

       
936
       
+
       
    # Examples

     

       
937
       
+
       
    :::{.example}

     

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

     

       
939
       
+
       


     

       
940
       
+
       
    ```nix

     

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

     

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

     

       
943
       
+
       
    ```

     

       
944
       
+
       


     

       
945
       
+
       
    :::

     

       
946
       
+
       


     

       
947
       
+
       
  */

     

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

     

       
949
       
 
       


     

       
950
       
 
       
  /**

     

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

     
···

       
2033
       
 
       
  # DEPRECATED

     

       
2034
       
 
       
  zip = warn

     

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

     

       
2036
       
+
       


     

       
2037
       
+
       
  # DEPRECATED

     

       
2038
       
+
       
  cartesianProductOfSets = warnIf (isInOldestRelease 2405)

     

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

     

       
2040
       
 
       
}

     

···

       
86
       
 
       
      zipAttrsWithNames zipAttrsWith zipAttrs recursiveUpdateUntil

     

       
87
       
 
       
      recursiveUpdate matchAttrs mergeAttrsList overrideExisting showAttrPath getOutput

     

       
88
       
 
       
      getBin getLib getDev getMan chooseDevOutputs zipWithNames zip

     

       
89
       
-
       
      recurseIntoAttrs dontRecurseIntoAttrs cartesianProductOfSets

     

       
90
       
-
       
      updateManyAttrsByPath;

     

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

     

       
92
       
 
       
      concatMap flatten remove findSingle findFirst any all count

     

       
93
       
 
       
      optional optionals toList range replicate partition zipListsWith zipLists

     

···

       
86
       
 
       
      zipAttrsWithNames zipAttrsWith zipAttrs recursiveUpdateUntil

     

       
87
       
 
       
      recursiveUpdate matchAttrs mergeAttrsList overrideExisting showAttrPath getOutput

     

       
88
       
 
       
      getBin getLib getDev getMan chooseDevOutputs zipWithNames zip

     

       
89
       
+
       
      recurseIntoAttrs dontRecurseIntoAttrs cartesianProduct cartesianProductOfSets

     

       
90
       
+
       
      mapCartesianProduct updateManyAttrsByPath;

     

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

     

       
92
       
 
       
      concatMap flatten remove findSingle findFirst any all count

     

       
93
       
 
       
      optional optionals toList range replicate partition zipListsWith zipLists

     

···

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

     

       
1689
       
 
       


     

       
1690
       
 
       
    ```nix

     

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

     

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

     

       
1693
       
 
       
    ```

     

       
1694
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1695
       
 
       
    :::

     

       
1696
       
 
       
  */

     

       
1697
       
 
       
  crossLists = warn

     

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

     

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

     

       
1700
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1701
       
 
       


     

       
1702
       
 
       
  /**

     

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

     

···

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

     

       
1689
       
 
       


     

       
1690
       
 
       
    ```nix

     

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

     

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

     

       
1693
       
 
       
    ```

     

       
1694
       
 
       


     

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

     

       
1696
       
+
       


     

       
1697
       
+
       
    ```nix

     

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

     

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

     

       
1700
       
+
       
    ```

     

       
1701
       
 
       
    :::

     

       
1702
       
 
       
  */

     

       
1703
       
 
       
  crossLists = warn

     

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

     

       
0
       
 
       

     

       
1705
       
 
       


     

       
1706
       
+
       
    For example, the following function call:

     

       
1707
       
+
       


     

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

     

       
1709
       
+
       
    [ 4 5 5 6 ]

     

       
1710
       
+
       


     

       
1711
       
+
       
    Can now be replaced by the following one:

     

       
1712
       
+
       


     

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

     

       
1714
       
+
       
    [ 4 5 5 6 ]

     

       
1715
       
+
       
    ''

     

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

     

       
1717
       
 
       


     

       
1718
       
 
       
  /**

     

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

     

···

       
33
       
 
       
    boolToString

     

       
34
       
 
       
    callPackagesWith

     

       
35
       
 
       
    callPackageWith

     

       
36
       
-
       
    cartesianProductOfSets

     

       
37
       
 
       
    cli

     

       
38
       
 
       
    composeExtensions

     

       
39
       
 
       
    composeManyExtensions

     
···

       
71
       
 
       
    makeIncludePath

     

       
72
       
 
       
    makeOverridable

     

       
73
       
 
       
    mapAttrs

     

       
0
       
 
       

     

       
74
       
 
       
    matchAttrs

     

       
75
       
 
       
    mergeAttrs

     

       
76
       
 
       
    meta

     

       
77
       
-
       
    mkOption

     

       
78
       
 
       
    mod

     

       
79
       
 
       
    nameValuePair

     

       
80
       
 
       
    optionalDrvAttr

     
···

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

     

       
118
       
 
       
    expected = true;

     

       
119
       
 
       
  };

     

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

     

       
121
       
 
       


     

       
122
       
 
       
  testSanitizeDerivationName = { name, expected }:

     

       
123
       
 
       
  let

     
···

       
1415
       
 
       
    };

     

       
1416
       
 
       


     

       
1417
       
 
       
  testToPrettyMultiline = {

     

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

     

       
1419
       
 
       
      list = [ 3 4 [ false ] ];

     

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

     

       
1421
       
 
       
      newlinestring = "\n";

     
···

       
1429
       
 
       
        there

     

       
1430
       
 
       
        test'';

     

       
1431
       
 
       
    };

     

       
1432
       
-
       
    expected = rec {

     

       
1433
       
 
       
      list = ''

     

       
1434
       
 
       
        [

     

       
1435
       
 
       
          3

     
···

       
1467
       
 
       
    expected  = "«foo»";

     

       
1468
       
 
       
  };

     

       
1469
       
 
       


     

       
1470
       
-
       
  testToPlist =

     

       
1471
       
-
       
    let

     

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

     

       
1473
       
-
       
    in {

     

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

     

       
1475
       
 
       
      value = {

     

       
1476
       
-
       
        nested.values = rec {

     

       
1477
       
 
       
          int = 42;

     

       
1478
       
 
       
          float = 0.1337;

     

       
1479
       
 
       
          bool = true;

     
···

       
1686
       
 
       
  };

     

       
1687
       
 
       


     

       
1688
       
 
       
  testCartesianProductOfEmptySet = {

     

       
1689
       
-
       
    expr = cartesianProductOfSets {};

     

       
1690
       
 
       
    expected = [ {} ];

     

       
1691
       
 
       
  };

     

       
1692
       
 
       


     

       
1693
       
 
       
  testCartesianProductOfOneSet = {

     

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

     

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

     

       
1696
       
 
       
  };

     

       
1697
       
 
       


     

       
1698
       
 
       
  testCartesianProductOfTwoSets = {

     

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

     

       
1700
       
 
       
    expected = [

     

       
1701
       
 
       
      { a = 1; b = 10; }

     

       
1702
       
 
       
      { a = 1; b = 20; }

     
···

       
1704
       
 
       
  };

     

       
1705
       
 
       


     

       
1706
       
 
       
  testCartesianProductOfTwoSetsWithOneEmpty = {

     

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

     

       
1708
       
 
       
    expected = [ ];

     

       
1709
       
 
       
  };

     

       
1710
       
 
       


     

       
1711
       
 
       
  testCartesianProductOfThreeSets = {

     

       
1712
       
-
       
    expr = cartesianProductOfSets {

     

       
1713
       
 
       
      a = [   1   2   3 ];

     

       
1714
       
 
       
      b = [  10  20  30 ];

     

       
1715
       
 
       
      c = [ 100 200 300 ];

     
···

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

     

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

     

       
1753
       
 
       
    ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1754
       
 
       
  };

     

       
1755
       
 
       


     

       
1756
       
 
       
  # The example from the showAttrPath documentation

     

···

       
33
       
 
       
    boolToString

     

       
34
       
 
       
    callPackagesWith

     

       
35
       
 
       
    callPackageWith

     

       
36
       
+
       
    cartesianProduct

     

       
37
       
 
       
    cli

     

       
38
       
 
       
    composeExtensions

     

       
39
       
 
       
    composeManyExtensions

     
···

       
71
       
 
       
    makeIncludePath

     

       
72
       
 
       
    makeOverridable

     

       
73
       
 
       
    mapAttrs

     

       
74
       
+
       
    mapCartesianProduct

     

       
75
       
 
       
    matchAttrs

     

       
76
       
 
       
    mergeAttrs

     

       
77
       
 
       
    meta

     

       
0
       
 
       

     

       
78
       
 
       
    mod

     

       
79
       
 
       
    nameValuePair

     

       
80
       
 
       
    optionalDrvAttr

     
···

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

     

       
118
       
 
       
    expected = true;

     

       
119
       
 
       
  };

     

       
0
       
 
       

     

       
120
       
 
       


     

       
121
       
 
       
  testSanitizeDerivationName = { name, expected }:

     

       
122
       
 
       
  let

     
···

       
1414
       
 
       
    };

     

       
1415
       
 
       


     

       
1416
       
 
       
  testToPrettyMultiline = {

     

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

     

       
1418
       
 
       
      list = [ 3 4 [ false ] ];

     

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

     

       
1420
       
 
       
      newlinestring = "\n";

     
···

       
1428
       
 
       
        there

     

       
1429
       
 
       
        test'';

     

       
1430
       
 
       
    };

     

       
1431
       
+
       
    expected = {

     

       
1432
       
 
       
      list = ''

     

       
1433
       
 
       
        [

     

       
1434
       
 
       
          3

     
···

       
1466
       
 
       
    expected  = "«foo»";

     

       
1467
       
 
       
  };

     

       
1468
       
 
       


     

       
1469
       
+
       
  testToPlist = {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
1471
       
 
       
      value = {

     

       
1472
       
+
       
        nested.values = {

     

       
1473
       
 
       
          int = 42;

     

       
1474
       
 
       
          float = 0.1337;

     

       
1475
       
 
       
          bool = true;

     
···

       
1682
       
 
       
  };

     

       
1683
       
 
       


     

       
1684
       
 
       
  testCartesianProductOfEmptySet = {

     

       
1685
       
+
       
    expr = cartesianProduct {};

     

       
1686
       
 
       
    expected = [ {} ];

     

       
1687
       
 
       
  };

     

       
1688
       
 
       


     

       
1689
       
 
       
  testCartesianProductOfOneSet = {

     

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

     

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

     

       
1692
       
 
       
  };

     

       
1693
       
 
       


     

       
1694
       
 
       
  testCartesianProductOfTwoSets = {

     

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

     

       
1696
       
 
       
    expected = [

     

       
1697
       
 
       
      { a = 1; b = 10; }

     

       
1698
       
 
       
      { a = 1; b = 20; }

     
···

       
1700
       
 
       
  };

     

       
1701
       
 
       


     

       
1702
       
 
       
  testCartesianProductOfTwoSetsWithOneEmpty = {

     

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

     

       
1704
       
 
       
    expected = [ ];

     

       
1705
       
 
       
  };

     

       
1706
       
 
       


     

       
1707
       
 
       
  testCartesianProductOfThreeSets = {

     

       
1708
       
+
       
    expr = cartesianProduct {

     

       
1709
       
 
       
      a = [   1   2   3 ];

     

       
1710
       
 
       
      b = [  10  20  30 ];

     

       
1711
       
 
       
      c = [ 100 200 300 ];

     
···

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

     

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

     

       
1749
       
 
       
    ];

     

       
1750
       
+
       
  };

     

       
1751
       
+
       


     

       
1752
       
+
       
  testMapCartesianProductOfOneSet = {

     

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

     

       
1754
       
+
       
    expected = [ 2 4 6 ];

     

       
1755
       
+
       
  };

     

       
1756
       
+
       


     

       
1757
       
+
       
  testMapCartesianProductOfTwoSets = {

     

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

     

       
1759
       
+
       
    expected = [ 11 21 ];

     

       
1760
       
+
       
  };

     

       
1761
       
+
       


     

       
1762
       
+
       
  testMapCartesianProcutOfTwoSetsWithOneEmpty = {

     

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

     

       
1764
       
+
       
    expected = [ ];

     

       
1765
       
+
       
  };

     

       
1766
       
+
       


     

       
1767
       
+
       
  testMapCartesianProductOfThreeSets = {

     

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

     

       
1769
       
+
       
      a = [ 1 2 3 ];

     

       
1770
       
+
       
      b = [ 10 20 30 ];

     

       
1771
       
+
       
      c = [ 100 200 300 ];

     

       
1772
       
+
       
    };

     

       
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 ];

     

       
1774
       
 
       
  };

     

       
1775
       
 
       


     

       
1776
       
 
       
  # The example from the showAttrPath documentation

     

···

       
284
       
 
       
      in

     

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

     

       
286
       
 
       
        concatLists (

     

       
287
       
-
       
            builtins.map

     

       
288
       
 
       
            ({dm, wm}: let

     

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

     

       
290
       
 
       
              script = xsession dm wm;

     
···

       
312
       
 
       
                  providedSessions = [ sessionName ];

     

       
313
       
 
       
                })

     

       
314
       
 
       
            )

     

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

     

       
316
       
 
       
          );

     

       
317
       
 
       
  };

     

       
318
       
 
       


     

···

       
284
       
 
       
      in

     

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

     

       
286
       
 
       
        concatLists (

     

       
287
       
+
       
            lib.mapCartesianProduct

     

       
288
       
 
       
            ({dm, wm}: let

     

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

     

       
290
       
 
       
              script = xsession dm wm;

     
···

       
312
       
 
       
                  providedSessions = [ sessionName ];

     

       
313
       
 
       
                })

     

       
314
       
 
       
            )

     

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

     

       
316
       
 
       
          );

     

       
317
       
 
       
  };

     

       
318
       
 
       


     

···

       
5
       
 
       


     

       
6
       
 
       
let

     

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

     

       
8
       
-
       
  testCombinations = pkgs.lib.cartesianProductOfSets {

     

       
9
       
 
       
    predictable = [true false];

     

       
10
       
 
       
    withNetworkd = [true false];

     

       
11
       
 
       
    systemdStage1 = [true false];

     

···

       
5
       
 
       


     

       
6
       
 
       
let

     

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

     

       
8
       
+
       
  testCombinations = pkgs.lib.cartesianProduct {

     

       
9
       
 
       
    predictable = [true false];

     

       
10
       
 
       
    withNetworkd = [true false];

     

       
11
       
 
       
    systemdStage1 = [true false];

     

···

       
63
       
 
       
    runHook postCheck

     

       
64
       
 
       
  '';

     

       
65
       
 
       


     

       
66
       
-
       
  meta = {

     

       
67
       
 
       
    description = "Sandboxed execution environment";

     

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

     

       
69
       
-
       
    license = lib.licenses.isc;

     

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

     

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

     

       
72
       
-
       
      (lib.cartesianProductOfSets {

     

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

     

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

     

       
75
       
-
       
      });

     

       
76
       
 
       
  };

     

       
77
       
 
       


     

       
78
       
 
       
}

     

···

       
63
       
 
       
    runHook postCheck

     

       
64
       
 
       
  '';

     

       
65
       
 
       


     

       
66
       
+
       
  meta = with lib; {

     

       
67
       
 
       
    description = "Sandboxed execution environment";

     

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

     

       
69
       
+
       
    license = licenses.isc;

     

       
70
       
+
       
    maintainers = [ maintainers.ehmry ];

     

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

     

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

     

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

     

       
74
       
+
       
    };

     

       
0
       
 
       

     

       
75
       
 
       
  };

     

       
76
       
 
       


     

       
77
       
 
       
}

     

···

       
15
       
 
       
      '');

     

       
16
       
 
       
in

     

       
17
       
 
       
builtins.listToAttrs (

     

       
18
       
-
       
  map

     

       
19
       
-
       
    texTest

     

       
20
       
-
       
    (lib.attrsets.cartesianProductOfSets {

     

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

     

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

     

       
23
       
 
       
      package = [ "junicode" ];

     

       
24
       
 
       
      file = [ ./test.tex ];

     

       
25
       
-
       
    })

     

       
26
       
 
       
  ++

     

       
27
       
 
       
  [

     

       
28
       
 
       
    (texTest {

     

···

       
15
       
 
       
      '');

     

       
16
       
 
       
in

     

       
17
       
 
       
builtins.listToAttrs (

     

       
18
       
+
       
  lib.mapCartesianProduct texTest

     

       
19
       
+
       
    {

     

       
0
       
 
       

     

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

     

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

     

       
22
       
 
       
      package = [ "junicode" ];

     

       
23
       
 
       
      file = [ ./test.tex ];

     

       
24
       
+
       
    }

     

       
25
       
 
       
  ++

     

       
26
       
 
       
  [

     

       
27
       
 
       
    (texTest {

     

···

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

     

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

     

       
11
       
 
       
  };

     

       
12
       
-
       
  product = lib.attrsets.cartesianProductOfSets dimensions;

     

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

     

       
14
       
-
       
  variants = map variantName product;

     

       
15
       
 
       
in

     

       
16
       
 
       
stdenvNoCC.mkDerivation rec {

     

       
17
       
 
       
  pname = "catppuccin-cursors";

     

···

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

     

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

     

       
11
       
 
       
  };

     

       
0
       
 
       

     

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

     

       
13
       
+
       
  variants = lib.mapCartesianProduct variantName dimensions;

     

       
14
       
 
       
in

     

       
15
       
 
       
stdenvNoCC.mkDerivation rec {

     

       
16
       
 
       
  pname = "catppuccin-cursors";

     

···

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

     

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

     

       
9
       
 
       
  };

     

       
10
       
-
       
  product = lib.cartesianProductOfSets dimensions;

     

       
11
       
 
       
  variantName =

     

       
12
       
 
       
    { color, opacity, thickness, handedness }:

     

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

     

       
14
       
 
       
  variants =

     

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

     

       
16
       
 
       
    # meta.longDescription.)

     

       
17
       
-
       
    map variantName product;

     

       
18
       
 
       
in

     

       
19
       
 
       
stdenvNoCC.mkDerivation rec {

     

       
20
       
 
       
  pname = "comixcursors";

     

···

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

     

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

     

       
9
       
 
       
  };

     

       
0
       
 
       

     

       
10
       
 
       
  variantName =

     

       
11
       
 
       
    { color, opacity, thickness, handedness }:

     

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

     

       
13
       
 
       
  variants =

     

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

     

       
15
       
 
       
    # meta.longDescription.)

     

       
16
       
+
       
    lib.mapCartesianProduct variantName dimensions;

     

       
17
       
 
       
in

     

       
18
       
 
       
stdenvNoCC.mkDerivation rec {

     

       
19
       
 
       
  pname = "comixcursors";

     

···

       
70
       
 
       
    maintainers = [ maintainers.sternenseemann ];

     

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

     

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

     

       
73
       
-
       
      (cartesianProductOfSets {

     

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

     

       
75
       
 
       
          os = [ "linux" ];

     

       
76
       
 
       
      } ++ [

     

···

       
70
       
 
       
    maintainers = [ maintainers.sternenseemann ];

     

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

     

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

     

       
73
       
+
       
      (cartesianProduct {

     

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

     

       
75
       
 
       
          os = [ "linux" ];

     

       
76
       
 
       
      } ++ [