commit 24af4c04ee11c685f4cb14d76dea6d02b3488981 · pyrox.dev/nixpkgs

+1 -1

lib/default.nix

···

       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

     

       92
       92
       +
             ifilter0 concatMap flatten remove findSingle findFirst any all count

     

       93
       93
        
             optional optionals toList range replicate partition zipListsWith zipLists

     

       94
       94
        
             reverseList listDfs toposort sort sortOn naturalSort compareLists take

     

       95
       95
        
             drop sublist last init crossLists unique allUnique intersectLists

+49 -1

lib/lists.nix

···

       4
       4
        
       { lib }:

     

       5
       5
        
       let

     

       6
       6
        
         inherit (lib.strings) toInt;

     

       7
       7
       -
         inherit (lib.trivial) compare min id warn;

     

       7
       7
       +
         inherit (lib.trivial) compare min id warn pipe;

     

       8
       8
        
         inherit (lib.attrsets) mapAttrs;

     

       9
       9
        
       in

     

       10
       10
        
       rec {

     
···

       332
       332
        
           :::

     

       333
       333
        
         */

     

       334
       334
        
         imap1 = f: list: genList (n: f (n + 1) (elemAt list n)) (length list);

     

       335
       335
       +
       

     

       336
       336
       +
         /**

     

       337
       337
       +
           Filter a list for elements that satisfy a predicate function.

     

       338
       338
       +
           The predicate function is called with both the index and value for each element.

     

       339
       339
       +
           It must return `true`/`false` to include/exclude a given element in the result.

     

       340
       340
       +
           This function is strict in the result of the predicate function for each element.

     

       341
       341
       +
           This function has O(n) complexity.

     

       342
       342
       +
       

     

       343
       343
       +
           Also see [`builtins.filter`](https://nixos.org/manual/nix/stable/language/builtins.html#builtins-filter) (available as `lib.lists.filter`),

     

       344
       344
       +
           which can be used instead when the index isn't needed.

     

       345
       345
       +
       

     

       346
       346
       +
           # Inputs

     

       347
       347
       +
       

     

       348
       348
       +
           `ipred`

     

       349
       349
       +
       

     

       350
       350
       +
           : The predicate function, it takes two arguments:

     

       351
       351
       +
             - 1. (int): the index of the element.

     

       352
       352
       +
             - 2. (a): the value of the element.

     

       353
       353
       +
       

     

       354
       354
       +
             It must return `true`/`false` to include/exclude a given element from the result.

     

       355
       355
       +
       

     

       356
       356
       +
           `list`

     

       357
       357
       +
       

     

       358
       358
       +
           : The list to filter using the predicate.

     

       359
       359
       +
       

     

       360
       360
       +
           # Type

     

       361
       361
       +
           ```

     

       362
       362
       +
           ifilter0 :: (int -> a -> bool) -> [a] -> [a]

     

       363
       363
       +
           ```

     

       364
       364
       +
       

     

       365
       365
       +
           # Examples

     

       366
       366
       +
           :::{.example}

     

       367
       367
       +
           ## `lib.lists.ifilter0` usage example

     

       368
       368
       +
       

     

       369
       369
       +
           ```nix

     

       370
       370
       +
           ifilter0 (i: v: i == 0 || v > 2) [ 1 2 3 ]

     

       371
       371
       +
           => [ 1 3 ]

     

       372
       372
       +
           ```

     

       373
       373
       +
           :::

     

       374
       374
       +
         */

     

       375
       375
       +
         ifilter0 =

     

       376
       376
       +
           ipred:

     

       377
       377
       +
           input:

     

       378
       378
       +
           map (idx: elemAt input idx) (

     

       379
       379
       +
             filter (idx: ipred idx (elemAt input idx)) (

     

       380
       380
       +
               genList (x: x) (length input)

     

       381
       381
       +
             )

     

       382
       382
       +
           );

     

       335
       383
        
       

     

       336
       384
        
         /**

     

       337
       385
        
           Map and concatenate the result.

+27

lib/tests/misc.nix

···

       63
       63
        
           hasAttrByPath

     

       64
       64
        
           hasInfix

     

       65
       65
        
           id

     

       66
       66
       +
           ifilter0

     

       66
       67
        
           isStorePath

     

       67
       68
        
           lazyDerivation

     

       69
       69
       +
           length

     

       68
       70
        
           lists

     

       69
       71
        
           listToAttrs

     

       70
       72
        
           makeExtensible

     
···

       649
       651
        
         testFilter = {

     

       650
       652
        
           expr = filter (x: x != "a") ["a" "b" "c" "a"];

     

       651
       653
        
           expected = ["b" "c"];

     

       654
       654
       +
         };

     

       655
       655
       +
       

     

       656
       656
       +
         testIfilter0Example = {

     

       657
       657
       +
           expr = ifilter0 (i: v: i == 0 || v > 2) [ 1 2 3 ];

     

       658
       658
       +
           expected = [ 1 3 ];

     

       659
       659
       +
         };

     

       660
       660
       +
         testIfilter0Empty = {

     

       661
       661
       +
           expr = ifilter0 (i: v: abort "shouldn't be evaluated!") [ ];

     

       662
       662
       +
           expected = [ ];

     

       663
       663
       +
         };

     

       664
       664
       +
         testIfilter0IndexOnly = {

     

       665
       665
       +
           expr = length (ifilter0 (i: v: mod i 2 == 0) [ (throw "0") (throw "1") (throw "2") (throw "3")]);

     

       666
       666
       +
           expected = 2;

     

       667
       667
       +
         };

     

       668
       668
       +
         testIfilter0All = {

     

       669
       669
       +
           expr = ifilter0 (i: v: true) [ 10 11 12 13 14 15 ];

     

       670
       670
       +
           expected = [ 10 11 12 13 14 15 ];

     

       671
       671
       +
         };

     

       672
       672
       +
         testIfilter0First = {

     

       673
       673
       +
           expr = ifilter0 (i: v: i == 0) [ 10 11 12 13 14 15 ];

     

       674
       674
       +
           expected = [ 10 ];

     

       675
       675
       +
         };

     

       676
       676
       +
         testIfilter0Last = {

     

       677
       677
       +
           expr = ifilter0 (i: v: i == 5) [ 10 11 12 13 14 15 ];

     

       678
       678
       +
           expected = [ 15 ];

     

       652
       679
        
         };

     

       653
       680
        
       

     

       654
       681
        
         testFold =