···

       
509
       
 
       
       => 3

     

       
510
       
 
       
  */

     

       
511
       
 
       
  last = list:

     

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

     

       
0
       
 
       

     

       
513
       
 
       


     

       
514
       
 
       
  /* Return all elements but the last

     

       
515
       
 
       


     
···

       
517
       
 
       
       init [ 1 2 3 ]

     

       
518
       
 
       
       => [ 1 2 ]

     

       
519
       
 
       
  */

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
521
       
 
       


     

       
522
       
 
       


     

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

     

···

       
509
       
 
       
       => 3

     

       
510
       
 
       
  */

     

       
511
       
 
       
  last = list:

     

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

     

       
513
       
+
       
    elemAt list (length list - 1);

     

       
514
       
 
       


     

       
515
       
 
       
  /* Return all elements but the last

     

       
516
       
 
       


     
···

       
518
       
 
       
       init [ 1 2 3 ]

     

       
519
       
 
       
       => [ 1 2 ]

     

       
520
       
 
       
  */

     

       
521
       
+
       
  init = list:

     

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

     

       
523
       
+
       
    take (length list - 1) list;

     

       
524
       
 
       


     

       
525
       
 
       


     

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

     

···

       
410
       
 
       
      components = splitString "/" url;

     

       
411
       
 
       
      filename = lib.last components;

     

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

     

       
413
       
-
       
    in assert name !=  filename; name;

     

       
414
       
 
       


     

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

     

       
416
       
 
       
     standard GNU Autoconf scripts.

     
···

       
468
       
 
       
      strw = lib.stringLength str;

     

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

     

       
470
       
 
       
    in

     

       
471
       
-
       
      assert strw <= width;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
473
       
 
       


     

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

     

···

       
410
       
 
       
      components = splitString "/" url;

     

       
411
       
 
       
      filename = lib.last components;

     

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

     

       
413
       
+
       
    in assert name != filename; name;

     

       
414
       
 
       


     

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

     

       
416
       
 
       
     standard GNU Autoconf scripts.

     
···

       
468
       
 
       
      strw = lib.stringLength str;

     

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

     

       
470
       
 
       
    in

     

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

     

       
472
       
+
       
        "fixedWidthString: requested string length (${

     

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

     

       
474
       
+
       
            toString strw})";

     

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

     

       
476
       
 
       


     

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

     

···

       
119
       
 
       
      let

     

       
120
       
 
       
        betweenDesc = lowest: highest:

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
124
       
 
       
            name = "intBetween";

     

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

     
···

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

     

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

     

       
441
       
 
       
    coercedTo = coercedType: coerceFunc: finalType:

     

       
442
       
-
       
      assert coercedType.getSubModules == null;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
443
       
 
       
      mkOptionType rec {

     

       
444
       
 
       
        name = "coercedTo";

     

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

     

···

       
119
       
 
       
      let

     

       
120
       
 
       
        betweenDesc = lowest: highest:

     

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

     

       
122
       
+
       
        between = lowest: highest:

     

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

     

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

     

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

     

       
126
       
 
       
            name = "intBetween";

     

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

     
···

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

     

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

     

       
443
       
 
       
    coercedTo = coercedType: coerceFunc: finalType:

     

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

     

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

     

       
446
       
+
       
          coercedType.description})";

     

       
447
       
 
       
      mkOptionType rec {

     

       
448
       
 
       
        name = "coercedTo";

     

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

     

···

       
1
       
-
       
{ stdenv, fetchurl, fetchFromGitHub

     

       
2
       
 
       
, pkgconfig

     

       
3
       
 
       
, autoconf, automake, intltool, gettext

     

       
4
       
 
       
, gtk, vte

     

       
5
       
 
       


     

       
6
       
-
       
# "stable" or "git"

     

       
7
       
 
       
, flavour ? "stable"

     

       
8
       
 
       
}:

     

       
9
       
 
       


     

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

     

       
11
       
 
       


     

       
12
       
 
       
let

     

       
13
       
 
       
  stuff =

     

···

       
1
       
+
       
{ stdenv, lib, fetchurl, fetchFromGitHub

     

       
2
       
 
       
, pkgconfig

     

       
3
       
 
       
, autoconf, automake, intltool, gettext

     

       
4
       
 
       
, gtk, vte

     

       
5
       
 
       


     

       
0
       
 
       

     

       
6
       
 
       
, flavour ? "stable"

     

       
7
       
 
       
}:

     

       
8
       
 
       


     

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

     

       
10
       
 
       


     

       
11
       
 
       
let

     

       
12
       
 
       
  stuff =

     

···

       
8
       
 
       


     

       
9
       
 
       
with stdenv.lib;

     

       
10
       
 
       


     

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

     

       
0
       
 
       

     

       
12
       
 
       
assert useGoogleHashmap -> sparsehash != null;

     

       
13
       
 
       


     

       
14
       
 
       
let

     

···

       
8
       
 
       


     

       
9
       
 
       
with stdenv.lib;

     

       
10
       
 
       


     

       
11
       
+
       
assert assertOneOf "fileFormat" fileFormat

     

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

     

       
13
       
 
       
assert useGoogleHashmap -> sparsehash != null;

     

       
14
       
 
       


     

       
15
       
 
       
let