commit 8c0416ef364f5d5dea9d5694aadc0014bb95c1ca · pyrox.dev/nixpkgs

+26
lib/systems/inspect.nix
···

       100
       100
        
           ];

     

       101
       101
        
         };

     

       102
       102
        
       

     

       103
       103
       +
         # given two patterns, return a pattern which is their logical AND.

     

       104
       104
       +
         # Since a pattern is a list-of-disjuncts, this needs to

     

       105
       105
       +
         patternLogicalAnd = pat1_: pat2_:

     

       106
       106
       +
           let

     

       107
       107
       +
             # patterns can be either a list or a (bare) singleton; turn

     

       108
       108
       +
             # them into singletons for uniform handling

     

       109
       109
       +
             pat1 = lib.toList pat1_;

     

       110
       110
       +
             pat2 = lib.toList pat2_;

     

       111
       111
       +
           in

     

       112
       112
       +
             lib.concatMap (attr1:

     

       113
       113
       +
               map (attr2:

     

       114
       114
       +
                 lib.recursiveUpdateUntil

     

       115
       115
       +
                   (path: subattr1: subattr2:

     

       116
       116
       +
                     if (builtins.intersectAttrs subattr1 subattr2) == {} || subattr1 == subattr2

     

       117
       117
       +
                     then true

     

       118
       118
       +
                     else throw ''

     

       119
       119
       +
                       pattern conflict at path ${toString path}:

     

       120
       120
       +
                         ${builtins.toJSON subattr1}

     

       121
       121
       +
                         ${builtins.toJSON subattr2}

     

       122
       122
       +
                       '')

     

       123
       123
       +
                   attr1

     

       124
       124
       +
                   attr2

     

       125
       125
       +
                   )

     

       126
       126
       +
                 pat2)

     

       127
       127
       +
               pat1;

     

       128
       128
       +
       

     

       103
       129
        
         matchAnyAttrs = patterns:

     

       104
       130
        
           if builtins.isList patterns then attrs: any (pattern: matchAttrs pattern attrs) patterns

     

       105
       131
        
           else matchAttrs patterns;