commit 3e45b61a9920466a8ea06b8ad9350d56ade435bc · pyrox.dev/nixpkgs

+5 -2

lib/lists.nix

···

       509
       509
        
              => 3

     

       510
       510
        
         */

     

       511
       511
        
         last = list:

     

       512
       512
       -
           assert list != []; elemAt list (length list - 1);

     

       512
       512
       +
           assert assertMsg (list != []) "lists.last: list must not be empty!";

     

       513
       513
       +
           elemAt list (length list - 1);

     

       513
       514
        
       

     

       514
       515
        
         /* Return all elements but the last

     

       515
       516
        
       

     
···

       517
       518
        
              init [ 1 2 3 ]

     

       518
       519
        
              => [ 1 2 ]

     

       519
       520
        
         */

     

       520
       520
       -
         init = list: assert list != []; take (length list - 1) list;

     

       521
       521
       +
         init = list:

     

       522
       522
       +
           assert assertMsg (list != []) "lists.init: list must not be empty!";

     

       523
       523
       +
           take (length list - 1) list;

     

       521
       524
        
       

     

       522
       525
        
       

     

       523
       526
        
         /* return the image of the cross product of some lists by a function

+5 -2

lib/strings.nix

···

       410
       410
        
             components = splitString "/" url;

     

       411
       411
        
             filename = lib.last components;

     

       412
       412
        
             name = builtins.head (splitString sep filename);

     

       413
       413
       -
           in assert name !=  filename; name;

     

       413
       413
       +
           in assert name != filename; name;

     

       414
       414
        
       

     

       415
       415
        
         /* Create an --{enable,disable}-<feat> string that can be passed to

     

       416
       416
        
            standard GNU Autoconf scripts.

     
···

       468
       468
        
             strw = lib.stringLength str;

     

       469
       469
        
             reqWidth = width - (lib.stringLength filler);

     

       470
       470
        
           in

     

       471
       471
       -
             assert strw <= width;

     

       471
       471
       +
             assert lib.assertMsg (strw <= width)

     

       472
       472
       +
               "fixedWidthString: requested string length (${

     

       473
       473
       +
                 toString width}) must not be shorter than actual length (${

     

       474
       474
       +
                   toString strw})";

     

       472
       475
        
             if strw == width then str else filler + fixedWidthString reqWidth filler str;

     

       473
       476
        
       

     

       474
       477
        
         /* Format a number adding leading zeroes up to fixed width.

+6 -2

lib/types.nix

···

       119
       119
        
             let

     

       120
       120
        
               betweenDesc = lowest: highest:

     

       121
       121
        
                 "${toString lowest} and ${toString highest} (both inclusive)";

     

       122
       122
       -
               between = lowest: highest: assert lowest <= highest;

     

       122
       122
       +
               between = lowest: highest:

     

       123
       123
       +
                 assert lib.assertMsg (lowest <= highest)

     

       124
       124
       +
                   "ints.between: lowest must be smaller than highest";

     

       123
       125
        
                 addCheck int (x: x >= lowest && x <= highest) // {

     

       124
       126
        
                   name = "intBetween";

     

       125
       127
        
                   description = "integer between ${betweenDesc lowest highest}";

     
···

       439
       441
        
           # Either value of type `finalType` or `coercedType`, the latter is

     

       440
       442
        
           # converted to `finalType` using `coerceFunc`.

     

       441
       443
        
           coercedTo = coercedType: coerceFunc: finalType:

     

       442
       442
       -
             assert coercedType.getSubModules == null;

     

       444
       444
       +
             assert assertMsg (coercedType.getSubModules == null)

     

       445
       445
       +
               "coercedTo: coercedType must not have submodules (it’s a ${

     

       446
       446
       +
                 coercedType.description})";

     

       443
       447
        
             mkOptionType rec {

     

       444
       448
        
               name = "coercedTo";

     

       445
       449
        
               description = "${finalType.description} or ${coercedType.description} convertible to it";

+2 -3

pkgs/applications/misc/lilyterm/default.nix

···

       1
       1
       -
       { stdenv, fetchurl, fetchFromGitHub

     

       1
       1
       +
       { stdenv, lib, fetchurl, fetchFromGitHub

     

       2
       2
        
       , pkgconfig

     

       3
       3
        
       , autoconf, automake, intltool, gettext

     

       4
       4
        
       , gtk, vte

     

       5
       5
        
       

     

       6
       6
       -
       # "stable" or "git"

     

       7
       6
        
       , flavour ? "stable"

     

       8
       7
        
       }:

     

       9
       8
        
       

     

       10
       10
       -
       assert flavour == "stable" || flavour == "git";

     

       9
       9
       +
       assert lib.assertOneOf "flavour" flavour [ "stable"  "git" ];

     

       11
       10
        
       

     

       12
       11
        
       let

     

       13
       12
        
         stuff =

+2 -1

pkgs/applications/science/math/ripser/default.nix

···

       8
       8
        
       

     

       9
       9
        
       with stdenv.lib;

     

       10
       10
        
       

     

       11
       11
       -
       assert elem fileFormat ["lowerTriangularCsv" "upperTriangularCsv" "dipha"];

     

       11
       11
       +
       assert assertOneOf "fileFormat" fileFormat

     

       12
       12
       +
         ["lowerTriangularCsv" "upperTriangularCsv" "dipha"];

     

       12
       13
        
       assert useGoogleHashmap -> sparsehash != null;

     

       13
       14
        
       

     

       14
       15
        
       let