···

       
147
       
147
       
 
       
    , # The deprecation message to display when this type is used by an option

     

       
148
       
148
       
 
       
      # If null, the type isn't deprecated

     

       
149
       
149
       
 
       
      deprecationMessage ? null

     

       
150
       
150
       
+
       
    , # The types that occur in the definition of this type. This is used to

     

       
151
       
151
       
+
       
      # issue deprecation warnings recursively. Can also be used to reuse

     

       
152
       
152
       
+
       
      # nested types

     

       
153
       
153
       
+
       
      nestedTypes ? {}

     

       
150
       
154
       
 
       
    }:

     

       
151
       
155
       
 
       
    { _type = "option-type";

     

       
152
       
152
       
-
       
      inherit name check merge emptyValue getSubOptions getSubModules substSubModules typeMerge functor deprecationMessage;

     

       
156
       
156
       
+
       
      inherit name check merge emptyValue getSubOptions getSubModules substSubModules typeMerge functor deprecationMessage nestedTypes;

     

       
153
       
157
       
 
       
      description = if description == null then name else description;

     

       
154
       
158
       
 
       
    };

     

       
155
       
159
       
 
       


     
···

       
365
       
369
       
 
       
      getSubModules = elemType.getSubModules;

     

       
366
       
370
       
 
       
      substSubModules = m: listOf (elemType.substSubModules m);

     

       
367
       
371
       
 
       
      functor = (defaultFunctor name) // { wrapped = elemType; };

     

       
372
       
372
       
+
       
      nestedTypes.elemType = elemType;

     

       
368
       
373
       
 
       
    };

     

       
369
       
374
       
 
       


     

       
370
       
375
       
 
       
    nonEmptyListOf = elemType:

     
···

       
389
       
394
       
 
       
      getSubModules = elemType.getSubModules;

     

       
390
       
395
       
 
       
      substSubModules = m: attrsOf (elemType.substSubModules m);

     

       
391
       
396
       
 
       
      functor = (defaultFunctor name) // { wrapped = elemType; };

     

       
397
       
397
       
+
       
      nestedTypes.elemType = elemType;

     

       
392
       
398
       
 
       
    };

     

       
393
       
399
       
 
       


     

       
394
       
400
       
 
       
    # A version of attrsOf that's lazy in its values at the expense of

     
···

       
413
       
419
       
 
       
      getSubModules = elemType.getSubModules;

     

       
414
       
420
       
 
       
      substSubModules = m: lazyAttrsOf (elemType.substSubModules m);

     

       
415
       
421
       
 
       
      functor = (defaultFunctor name) // { wrapped = elemType; };

     

       
422
       
422
       
+
       
      nestedTypes.elemType = elemType;

     

       
416
       
423
       
 
       
    };

     

       
417
       
424
       
 
       


     

       
418
       
425
       
 
       
    # TODO: drop this in the future:

     
···

       
421
       
428
       
 
       
      deprecationMessage = "Mixing lists with attribute values is no longer"

     

       
422
       
429
       
 
       
        + " possible; please use `types.attrsOf` instead. See"

     

       
423
       
430
       
 
       
        + " https://github.com/NixOS/nixpkgs/issues/1800 for the motivation.";

     

       
431
       
431
       
+
       
      nestedTypes.elemType = elemType;

     

       
424
       
432
       
 
       
    };

     

       
425
       
433
       
 
       


     

       
426
       
434
       
 
       
    # Value of given type but with no merging (i.e. `uniq list`s are not concatenated).

     
···

       
433
       
441
       
 
       
      getSubModules = elemType.getSubModules;

     

       
434
       
442
       
 
       
      substSubModules = m: uniq (elemType.substSubModules m);

     

       
435
       
443
       
 
       
      functor = (defaultFunctor name) // { wrapped = elemType; };

     

       
444
       
444
       
+
       
      nestedTypes.elemType = elemType;

     

       
436
       
445
       
 
       
    };

     

       
437
       
446
       
 
       


     

       
438
       
447
       
 
       
    # Null or value of ...

     
···

       
451
       
460
       
 
       
      getSubModules = elemType.getSubModules;

     

       
452
       
461
       
 
       
      substSubModules = m: nullOr (elemType.substSubModules m);

     

       
453
       
462
       
 
       
      functor = (defaultFunctor name) // { wrapped = elemType; };

     

       
463
       
463
       
+
       
      nestedTypes.elemType = elemType;

     

       
454
       
464
       
 
       
    };

     

       
455
       
465
       
 
       


     

       
456
       
466
       
 
       
    functionTo = elemType: mkOptionType {

     
···

       
535
       
545
       
 
       
        substSubModules = m: submoduleWith (attrs // {

     

       
536
       
546
       
 
       
          modules = m;

     

       
537
       
547
       
 
       
        });

     

       
548
       
548
       
+
       
        nestedTypes = lib.optionalAttrs (freeformType != null) {

     

       
549
       
549
       
+
       
          freeformType = freeformType;

     

       
550
       
550
       
+
       
        };

     

       
538
       
551
       
 
       
        functor = defaultFunctor name // {

     

       
539
       
552
       
 
       
          type = types.submoduleWith;

     

       
540
       
553
       
 
       
          payload = {

     
···

       
596
       
609
       
 
       
           then functor.type mt1 mt2

     

       
597
       
610
       
 
       
           else null;

     

       
598
       
611
       
 
       
      functor = (defaultFunctor name) // { wrapped = [ t1 t2 ]; };

     

       
612
       
612
       
+
       
      nestedTypes.left = t1;

     

       
613
       
613
       
+
       
      nestedTypes.right = t2;

     

       
599
       
614
       
 
       
    };

     

       
600
       
615
       
 
       


     

       
601
       
616
       
 
       
    # Any of the types in the given list

     
···

       
627
       
642
       
 
       
        substSubModules = m: coercedTo coercedType coerceFunc (finalType.substSubModules m);

     

       
628
       
643
       
 
       
        typeMerge = t1: t2: null;

     

       
629
       
644
       
 
       
        functor = (defaultFunctor name) // { wrapped = finalType; };

     

       
645
       
645
       
+
       
        nestedTypes.coercedType = coercedType;

     

       
646
       
646
       
+
       
        nestedTypes.finalType = finalType;

     

       
630
       
647
       
 
       
      };

     

       
631
       
648
       
 
       


     

       
632
       
649
       
 
       
    # Obsolete alternative to configOf.  It takes its option