···

       
0
       
 
       

     

       
1
       
 
       
# Operations on attribute sets.

     

       
2
       
 
       


     

       
3
       
 
       
let

     

       
4
       
 
       
  inherit (builtins) head tail length;

     

       
5
       
-
       
  inherit (import ./trivial.nix) and or;

     

       
6
       
-
       
  inherit (import ./default.nix) fold;

     

       
7
       
-
       
  inherit (import ./strings.nix) concatStringsSep;

     

       
8
       
-
       
  inherit (import ./lists.nix) concatMap concatLists all deepSeqList;

     

       
9
       
 
       
in

     

       
10
       
 
       


     

       
11
       
 
       
rec {

     

···

       
1
       
+
       
{ lib }:

     

       
2
       
 
       
# Operations on attribute sets.

     

       
3
       
 
       


     

       
4
       
 
       
let

     

       
5
       
 
       
  inherit (builtins) head tail length;

     

       
6
       
+
       
  inherit (lib.trivial) and or;

     

       
7
       
+
       
  inherit (lib.strings) concatStringsSep;

     

       
8
       
+
       
  inherit (lib.lists) fold concatMap concatLists all deepSeqList;

     

       
0
       
 
       

     

       
9
       
 
       
in

     

       
10
       
 
       


     

       
11
       
 
       
rec {

     

···

       
0
       
 
       

     

       
1
       
 
       
let

     

       
2
       
 
       


     

       
3
       
-
       
  lib = import ./default.nix;

     

       
4
       
 
       
  inherit (builtins) attrNames isFunction;

     

       
5
       
 
       


     

       
6
       
 
       
in

     

···

       
1
       
+
       
{ lib }:

     

       
2
       
 
       
let

     

       
3
       
 
       


     

       
0
       
 
       

     

       
4
       
 
       
  inherit (builtins) attrNames isFunction;

     

       
5
       
 
       


     

       
6
       
 
       
in

     

···

       
1
       
-
       
let lib = import ./default.nix;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2
       
 
       


     

       
3
       
 
       
inherit (builtins) trace attrNamesToStr isAttrs isFunction isList isInt

     

       
4
       
 
       
        isString isBool head substring attrNames;

     

···

       
1
       
+
       
{ lib }:

     

       
2
       
+
       


     

       
3
       
+
       
let

     

       
4
       
 
       


     

       
5
       
 
       
inherit (builtins) trace attrNamesToStr isAttrs isFunction isList isInt

     

       
6
       
 
       
        isString isBool head substring attrNames;

     

···

       
5
       
 
       
 */

     

       
6
       
 
       
let

     

       
7
       
 
       


     

       
8
       
-
       
  # often used, or depending on very little

     

       
9
       
-
       
  trivial = import ./trivial.nix;

     

       
10
       
-
       
  fixedPoints = import ./fixed-points.nix;

     

       
11
       
 
       


     

       
12
       
-
       
  # datatypes

     

       
13
       
-
       
  attrsets = import ./attrsets.nix;

     

       
14
       
-
       
  lists = import ./lists.nix;

     

       
15
       
-
       
  strings = import ./strings.nix;

     

       
16
       
-
       
  stringsWithDeps = import ./strings-with-deps.nix;

     

       
17
       
 
       


     

       
18
       
-
       
  # packaging

     

       
19
       
-
       
  customisation = import ./customisation.nix;

     

       
20
       
-
       
  maintainers = import ./maintainers.nix;

     

       
21
       
-
       
  meta = import ./meta.nix;

     

       
22
       
-
       
  sources = import ./sources.nix;

     

       
23
       
 
       


     

       
24
       
-
       
  # module system

     

       
25
       
-
       
  modules = import ./modules.nix;

     

       
26
       
-
       
  options = import ./options.nix;

     

       
27
       
-
       
  types = import ./types.nix;

     

       
0
       
 
       

     

       
28
       
 
       


     

       
29
       
-
       
  # constants

     

       
30
       
-
       
  licenses = import ./licenses.nix;

     

       
31
       
-
       
  systems = import ./systems;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
32
       
 
       


     

       
33
       
-
       
  # misc

     

       
34
       
-
       
  debug = import ./debug.nix;

     

       
35
       
-
       
  generators = import ./generators.nix;

     

       
36
       
-
       
  misc = import ./deprecated.nix;

     

       
37
       
 
       


     

       
38
       
-
       
  # domain-specific

     

       
39
       
-
       
  sandbox = import ./sandbox.nix;

     

       
40
       
-
       
  fetchers = import ./fetchers.nix;

     

       
41
       
 
       


     

       
42
       
-
       
  # Eval-time filesystem handling

     

       
43
       
-
       
  filesystem = import ./filesystem.nix;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
44
       
 
       


     

       
45
       
-
       
in

     

       
46
       
-
       
  { inherit trivial fixedPoints

     

       
47
       
-
       
            attrsets lists strings stringsWithDeps

     

       
48
       
-
       
            customisation maintainers meta sources

     

       
49
       
-
       
            modules options types

     

       
50
       
-
       
            licenses systems

     

       
51
       
-
       
            debug generators misc

     

       
52
       
-
       
            sandbox fetchers filesystem;

     

       
53
       
 
       


     

       
54
       
 
       
    # back-compat aliases

     

       
55
       
 
       
    platforms = systems.doubles;

     

       
56
       
-
       
  }

     

       
57
       
-
       
  # !!! don't include everything at top-level; perhaps only the most

     

       
58
       
-
       
  # commonly used functions.

     

       
59
       
-
       
  // trivial // fixedPoints

     

       
60
       
-
       
  // lists // strings // stringsWithDeps // attrsets // sources

     

       
61
       
-
       
  // options // types // meta // debug // misc // modules

     

       
62
       
-
       
  // customisation

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
5
       
 
       
 */

     

       
6
       
 
       
let

     

       
7
       
 
       


     

       
8
       
+
       
  callLibs = file: import file { inherit lib; };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
9
       
 
       


     

       
10
       
+
       
  lib = rec {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
11
       
 
       


     

       
12
       
+
       
    # often used, or depending on very little

     

       
13
       
+
       
    trivial = callLibs ./trivial.nix;

     

       
14
       
+
       
    fixedPoints = callLibs ./fixed-points.nix;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
15
       
 
       


     

       
16
       
+
       
    # datatypes

     

       
17
       
+
       
    attrsets = callLibs ./attrsets.nix;

     

       
18
       
+
       
    lists = callLibs ./lists.nix;

     

       
19
       
+
       
    strings = callLibs ./strings.nix;

     

       
20
       
+
       
    stringsWithDeps = callLibs ./strings-with-deps.nix;

     

       
21
       
 
       


     

       
22
       
+
       
    # packaging

     

       
23
       
+
       
    customisation = callLibs ./customisation.nix;

     

       
24
       
+
       
    maintainers = callLibs ./maintainers.nix;

     

       
25
       
+
       
    meta = callLibs ./meta.nix;

     

       
26
       
+
       
    sources = callLibs ./sources.nix;

     

       
27
       
+
       


     

       
28
       
+
       


     

       
29
       
+
       
    # module system

     

       
30
       
+
       
    modules = callLibs ./modules.nix;

     

       
31
       
+
       
    options = callLibs ./options.nix;

     

       
32
       
+
       
    types = callLibs ./types.nix;

     

       
33
       
 
       


     

       
34
       
+
       
    # constants

     

       
35
       
+
       
    licenses = callLibs ./licenses.nix;

     

       
36
       
+
       
    systems = callLibs ./systems;

     

       
0
       
 
       

     

       
37
       
 
       


     

       
38
       
+
       
    # misc

     

       
39
       
+
       
    debug = callLibs ./debug.nix;

     

       
0
       
 
       

     

       
40
       
 
       


     

       
41
       
+
       
    generators = callLibs ./generators.nix;

     

       
42
       
+
       
    misc = callLibs ./deprecated.nix;

     

       
43
       
+
       
    # domain-specific

     

       
44
       
+
       
    sandbox = callLibs ./sandbox.nix;

     

       
45
       
+
       
    fetchers = callLibs ./fetchers.nix;

     

       
46
       
 
       


     

       
47
       
+
       
    # Eval-time filesystem handling

     

       
48
       
+
       
    filesystem = callLibs ./filesystem.nix;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
49
       
 
       


     

       
50
       
 
       
    # back-compat aliases

     

       
51
       
 
       
    platforms = systems.doubles;

     

       
52
       
+
       


     

       
53
       
+
       
    inherit (builtins) add addErrorContext attrNames

     

       
54
       
+
       
      concatLists deepSeq elem elemAt filter genericClosure genList

     

       
55
       
+
       
      getAttr hasAttr head isAttrs isBool isFunction isInt isList

     

       
56
       
+
       
      isString length lessThan listToAttrs pathExists readFile

     

       
57
       
+
       
      replaceStrings seq stringLength sub substring tail;

     

       
58
       
+
       
    inherit (trivial) id const concat or and boolToString mergeAttrs

     

       
59
       
+
       
      flip mapNullable inNixShell min max importJSON warn info

     

       
60
       
+
       
      nixpkgsVersion mod;

     

       
61
       
+
       


     

       
62
       
+
       
    inherit (fixedPoints) fix fix' extends composeExtensions

     

       
63
       
+
       
      makeExtensible makeExtensibleWithCustomName;

     

       
64
       
+
       
    inherit (attrsets) attrByPath hasAttrByPath setAttrByPath

     

       
65
       
+
       
      getAttrFromPath attrVals attrValues catAttrs filterAttrs

     

       
66
       
+
       
      filterAttrsRecursive foldAttrs collect nameValuePair mapAttrs

     

       
67
       
+
       
      mapAttrs' mapAttrsToList mapAttrsRecursive mapAttrsRecursiveCond

     

       
68
       
+
       
      genAttrs isDerivation toDerivation optionalAttrs

     

       
69
       
+
       
      zipAttrsWithNames zipAttrsWith zipAttrs recursiveUpdateUntil

     

       
70
       
+
       
      recursiveUpdate matchAttrs overrideExisting getOutput getBin

     

       
71
       
+
       
      getLib getDev chooseDevOutputs zipWithNames zip;

     

       
72
       
+
       
    inherit (lists) singleton foldr fold foldl foldl' imap0 imap1

     

       
73
       
+
       
      concatMap flatten remove findSingle findFirst any all count

     

       
74
       
+
       
      optional optionals toList range partition zipListsWith zipLists

     

       
75
       
+
       
      reverseList listDfs toposort sort take drop sublist last init

     

       
76
       
+
       
      crossLists unique intersectLists subtractLists

     

       
77
       
+
       
      mutuallyExclusive;

     

       
78
       
+
       
    inherit (strings) concatStrings concatMapStrings concatImapStrings

     

       
79
       
+
       
      intersperse concatStringsSep concatMapStringsSep

     

       
80
       
+
       
      concatImapStringsSep makeSearchPath makeSearchPathOutput

     

       
81
       
+
       
      makeLibraryPath makeBinPath makePerlPath optionalString

     

       
82
       
+
       
      hasPrefix hasSuffix stringToCharacters stringAsChars escape

     

       
83
       
+
       
      escapeShellArg escapeShellArgs replaceChars lowerChars upperChars

     

       
84
       
+
       
      toLower toUpper addContextFrom splitString removePrefix

     

       
85
       
+
       
      removeSuffix versionOlder versionAtLeast getVersion nameFromURL

     

       
86
       
+
       
      enableFeature fixedWidthString fixedWidthNumber isStorePath

     

       
87
       
+
       
      toInt readPathsFromFile fileContents;

     

       
88
       
+
       
    inherit (stringsWithDeps) textClosureList textClosureMap

     

       
89
       
+
       
      noDepEntry fullDepEntry packEntry stringAfter;

     

       
90
       
+
       
    inherit (customisation) overrideDerivation makeOverridable

     

       
91
       
+
       
      callPackageWith callPackagesWith addPassthru hydraJob makeScope;

     

       
92
       
+
       
    inherit (meta) addMetaAttrs dontDistribute setName updateName

     

       
93
       
+
       
      appendToName mapDerivationAttrset lowPrio lowPrioSet hiPrio

     

       
94
       
+
       
      hiPrioSet;

     

       
95
       
+
       
    inherit (sources) pathType pathIsDirectory cleanSourceFilter

     

       
96
       
+
       
      cleanSource sourceByRegex sourceFilesBySuffices

     

       
97
       
+
       
      commitIdFromGitRepo;

     

       
98
       
+
       
    inherit (modules) evalModules closeModules unifyModuleSyntax

     

       
99
       
+
       
      applyIfFunction unpackSubmodule packSubmodule mergeModules

     

       
100
       
+
       
      mergeModules' mergeOptionDecls evalOptionValue mergeDefinitions

     

       
101
       
+
       
      pushDownProperties dischargeProperties filterOverrides

     

       
102
       
+
       
      sortProperties fixupOptionType mkIf mkAssert mkMerge mkOverride

     

       
103
       
+
       
      mkOptionDefault mkDefault mkForce mkVMOverride mkStrict

     

       
104
       
+
       
      mkFixStrictness mkOrder mkBefore mkAfter mkAliasDefinitions

     

       
105
       
+
       
      mkAliasAndWrapDefinitions fixMergeModules mkRemovedOptionModule

     

       
106
       
+
       
      mkRenamedOptionModule mkMergedOptionModule mkChangedOptionModule

     

       
107
       
+
       
      mkAliasOptionModule doRename filterModules;

     

       
108
       
+
       
    inherit (options) isOption mkEnableOption mkSinkUndeclaredOptions

     

       
109
       
+
       
      mergeDefaultOption mergeOneOption mergeEqualOption getValues

     

       
110
       
+
       
      getFiles optionAttrSetToDocList optionAttrSetToDocList'

     

       
111
       
+
       
      scrubOptionValue literalExample showOption showFiles

     

       
112
       
+
       
      unknownModule mkOption;

     

       
113
       
+
       
    inherit (types) isType setType defaultTypeMerge defaultFunctor

     

       
114
       
+
       
      isOptionType mkOptionType;

     

       
115
       
+
       
    inherit (debug) addErrorContextToAttrs traceIf traceVal

     

       
116
       
+
       
      traceXMLVal traceXMLValMarked traceSeq traceSeqN traceValSeq

     

       
117
       
+
       
      traceValSeqN traceShowVal traceShowValMarked

     

       
118
       
+
       
      showVal traceCall traceCall2 traceCall3 traceValIfNot runTests

     

       
119
       
+
       
      testAllTrue strict traceCallXml attrNamesToStr;

     

       
120
       
+
       
    inherit (misc) maybeEnv defaultMergeArg defaultMerge foldArgs

     

       
121
       
+
       
      defaultOverridableDelayableArgs composedArgsAndFun

     

       
122
       
+
       
      maybeAttrNullable maybeAttr ifEnable checkFlag getValue

     

       
123
       
+
       
      checkReqs uniqList uniqListExt condConcat lazyGenericClosure

     

       
124
       
+
       
      innerModifySumArgs modifySumArgs innerClosePropagation

     

       
125
       
+
       
      closePropagation mapAttrsFlatten nvs setAttr setAttrMerge

     

       
126
       
+
       
      mergeAttrsWithFunc mergeAttrsConcatenateValues

     

       
127
       
+
       
      mergeAttrsNoOverride mergeAttrByFunc mergeAttrsByFuncDefaults

     

       
128
       
+
       
      mergeAttrsByFuncDefaultsClean mergeAttrBy

     

       
129
       
+
       
      prepareDerivationArgs nixType imap overridableDelayableArgs;

     

       
130
       
+
       
  };

     

       
131
       
+
       
in lib

     

···

       
1
       
-
       
let lib = import ./default.nix;

     

       
0
       
 
       

     

       
2
       
 
       
    inherit (builtins) isFunction head tail isList isAttrs isInt attrNames;

     

       
3
       
 
       


     

       
4
       
 
       
in

     

       
5
       
 
       


     

       
6
       
-
       
with import ./lists.nix;

     

       
7
       
-
       
with import ./attrsets.nix;

     

       
8
       
-
       
with import ./strings.nix;

     

       
9
       
 
       


     

       
10
       
 
       
rec {

     

       
11
       
 
       


     

···

       
1
       
+
       
{ lib }:

     

       
2
       
+
       
let

     

       
3
       
 
       
    inherit (builtins) isFunction head tail isList isAttrs isInt attrNames;

     

       
4
       
 
       


     

       
5
       
 
       
in

     

       
6
       
 
       


     

       
7
       
+
       
with lib.lists;

     

       
8
       
+
       
with lib.attrsets;

     

       
9
       
+
       
with lib.strings;

     

       
10
       
 
       


     

       
11
       
 
       
rec {

     

       
12
       
 
       


     

···

       
1
       
 
       
# snippets that can be shared by multiple fetchers (pkgs/build-support)

     

       
0
       
 
       

     

       
2
       
 
       
{

     

       
3
       
 
       


     

       
4
       
 
       
  proxyImpureEnvVars = [

     

···

       
1
       
 
       
# snippets that can be shared by multiple fetchers (pkgs/build-support)

     

       
2
       
+
       
{ lib }:

     

       
3
       
 
       
{

     

       
4
       
 
       


     

       
5
       
 
       
  proxyImpureEnvVars = [

     

···

       
0
       
 
       

     

       
1
       
 
       
{ # haskellPathsInDir : Path -> Map String Path

     

       
2
       
 
       
  # A map of all haskell packages defined in the given path,

     

       
3
       
 
       
  # identified by having a cabal file with the same name as the

     

···

       
1
       
+
       
{ lib }:

     

       
2
       
 
       
{ # haskellPathsInDir : Path -> Map String Path

     

       
3
       
 
       
  # A map of all haskell packages defined in the given path,

     

       
4
       
 
       
  # identified by having a cabal file with the same name as the

     

···

       
0
       
 
       

     

       
1
       
 
       
rec {

     

       
2
       
 
       
  # Compute the fixed point of the given function `f`, which is usually an

     

       
3
       
 
       
  # attribute set that expects its final, non-recursive representation as an

     

···

       
1
       
+
       
{ ... }:

     

       
2
       
 
       
rec {

     

       
3
       
 
       
  # Compute the fixed point of the given function `f`, which is usually an

     

       
4
       
 
       
  # attribute set that expects its final, non-recursive representation as an

     

···

       
7
       
 
       
 * Tests can be found in ./tests.nix

     

       
8
       
 
       
 * Documentation in the manual, #sec-generators

     

       
9
       
 
       
 */

     

       
10
       
-
       
with import ./trivial.nix;

     

       
0
       
 
       

     

       
11
       
 
       
let

     

       
12
       
-
       
  libStr = import ./strings.nix;

     

       
13
       
-
       
  libAttr = import ./attrsets.nix;

     

       
14
       
 
       


     

       
15
       
 
       
  flipMapAttrs = flip libAttr.mapAttrs;

     

       
16
       
 
       
in

     

···

       
7
       
 
       
 * Tests can be found in ./tests.nix

     

       
8
       
 
       
 * Documentation in the manual, #sec-generators

     

       
9
       
 
       
 */

     

       
10
       
+
       
{ lib }:

     

       
11
       
+
       
with (lib).trivial;

     

       
12
       
 
       
let

     

       
13
       
+
       
  libStr = lib.strings;

     

       
14
       
+
       
  libAttr = lib.attrsets;

     

       
15
       
 
       


     

       
16
       
 
       
  flipMapAttrs = flip libAttr.mapAttrs;

     

       
17
       
 
       
in

     

···

       
0
       
 
       

     

       
1
       
 
       
let

     

       
2
       
-
       


     

       
3
       
-
       
  lib = import ./default.nix;

     

       
4
       
 
       


     

       
5
       
 
       
  spdx = lic: lic // {

     

       
6
       
 
       
    url = "http://spdx.org/licenses/${lic.spdxId}";

     
···

       
408
       
 
       
    url = "https://raw.githubusercontent.com/raboof/notion/master/LICENSE";

     

       
409
       
 
       
    fullName = "Notion modified LGPL";

     

       
410
       
 
       
  };

     

       
411
       
-
       
  

     

       
412
       
 
       
  ofl = spdx {

     

       
413
       
 
       
    spdxId = "OFL-1.1";

     

       
414
       
 
       
    fullName = "SIL Open Font License 1.1";

     

···

       
1
       
+
       
{ lib }:

     

       
2
       
 
       
let

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       


     

       
4
       
 
       
  spdx = lic: lic // {

     

       
5
       
 
       
    url = "http://spdx.org/licenses/${lic.spdxId}";

     
···

       
407
       
 
       
    url = "https://raw.githubusercontent.com/raboof/notion/master/LICENSE";

     

       
408
       
 
       
    fullName = "Notion modified LGPL";

     

       
409
       
 
       
  };

     

       
410
       
+
       


     

       
411
       
 
       
  ofl = spdx {

     

       
412
       
 
       
    spdxId = "OFL-1.1";

     

       
413
       
 
       
    fullName = "SIL Open Font License 1.1";

     

···

       
1
       
 
       
# General list operations.

     

       
2
       
-
       


     

       
3
       
-
       
with import ./trivial.nix;

     

       
4
       
 
       


     

       
5
       
 
       
rec {

     

       
6
       
 
       


     

···

       
1
       
 
       
# General list operations.

     

       
2
       
+
       
{ lib }:

     

       
3
       
+
       
with lib.trivial;

     

       
4
       
 
       


     

       
5
       
 
       
rec {

     

       
6
       
 
       


     

···

       
0
       
 
       

     

       
1
       
 
       
/* List of NixOS maintainers. The format is:

     

       
2
       
 
       


     

       
3
       
 
       
    handle = "Real Name <address@example.org>";

     

···

       
1
       
+
       
{ ...}:

     

       
2
       
 
       
/* List of NixOS maintainers. The format is:

     

       
3
       
 
       


     

       
4
       
 
       
    handle = "Real Name <address@example.org>";

     

···

       
1
       
 
       
/* Some functions for manipulating meta attributes, as well as the

     

       
2
       
 
       
   name attribute. */

     

       
3
       
 
       


     

       
4
       
-
       
let lib = import ./default.nix;

     

       
5
       
-
       
in

     

       
6
       
 
       


     

       
7
       
 
       
rec {

     

       
8
       
 
       


     

···

       
1
       
 
       
/* Some functions for manipulating meta attributes, as well as the

     

       
2
       
 
       
   name attribute. */

     

       
3
       
 
       


     

       
4
       
+
       
{ lib }:

     

       
0
       
 
       

     

       
5
       
 
       


     

       
6
       
 
       
rec {

     

       
7
       
 
       


     

···

       
1
       
-
       
with import ./lists.nix;

     

       
2
       
-
       
with import ./strings.nix;

     

       
3
       
-
       
with import ./trivial.nix;

     

       
4
       
-
       
with import ./attrsets.nix;

     

       
5
       
-
       
with import ./options.nix;

     

       
6
       
-
       
with import ./debug.nix;

     

       
7
       
-
       
with import ./types.nix;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
8
       
 
       


     

       
9
       
 
       
rec {

     

       
10
       
 
       


     

···

       
1
       
+
       
{ lib }:

     

       
2
       
+
       


     

       
3
       
+
       
with lib.lists;

     

       
4
       
+
       
with lib.strings;

     

       
5
       
+
       
with lib.trivial;

     

       
6
       
+
       
with lib.attrsets;

     

       
7
       
+
       
with lib.options;

     

       
8
       
+
       
with lib.debug;

     

       
9
       
+
       
with lib.types;

     

       
10
       
 
       


     

       
11
       
 
       
rec {

     

       
12
       
 
       


     

···

       
1
       
 
       
# Nixpkgs/NixOS option handling.

     

       
0
       
 
       

     

       
2
       
 
       


     

       
3
       
-
       
let lib = import ./default.nix; in

     

       
4
       
-
       


     

       
5
       
-
       
with import ./trivial.nix;

     

       
6
       
-
       
with import ./lists.nix;

     

       
7
       
-
       
with import ./attrsets.nix;

     

       
8
       
-
       
with import ./strings.nix;

     

       
9
       
 
       


     

       
10
       
 
       
rec {

     

       
11
       
 
       


     

···

       
1
       
 
       
# Nixpkgs/NixOS option handling.

     

       
2
       
+
       
{ lib }:

     

       
3
       
 
       


     

       
4
       
+
       
with lib.trivial;

     

       
5
       
+
       
with lib.lists;

     

       
6
       
+
       
with lib.attrsets;

     

       
7
       
+
       
with lib.strings;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
8
       
 
       


     

       
9
       
 
       
rec {

     

       
10
       
 
       


     

···

       
1
       
-
       
with import ./strings.nix;

     

       
0
       
 
       

     

       
2
       
 
       


     

       
3
       
 
       
/* Helpers for creating lisp S-exprs for the Apple sandbox

     

       
4
       
 
       


     

···

       
1
       
+
       
{ lib }:

     

       
2
       
+
       
with lib.strings;

     

       
3
       
 
       


     

       
4
       
 
       
/* Helpers for creating lisp S-exprs for the Apple sandbox

     

       
5
       
 
       


     

···

       
1
       
 
       
# Functions for copying sources to the Nix store.

     

       
2
       
-
       


     

       
3
       
-
       
let lib = import ./default.nix; in

     

       
4
       
 
       


     

       
5
       
 
       
rec {

     

       
6
       
 
       


     

···

       
1
       
 
       
# Functions for copying sources to the Nix store.

     

       
2
       
+
       
{ lib }:

     

       
0
       
 
       

     

       
3
       
 
       


     

       
4
       
 
       
rec {

     

       
5
       
 
       


     

···

       
0
       
 
       

     

       
1
       
 
       
/*

     

       
2
       
 
       
Usage:

     

       
3
       
 
       


     
···

       
40
       
 
       
  [1] maybe this behaviour should be removed to keep things simple (?)

     

       
41
       
 
       
*/

     

       
42
       
 
       


     

       
43
       
-
       
with import ./lists.nix;

     

       
44
       
-
       
with import ./attrsets.nix;

     

       
45
       
-
       
with import ./strings.nix;

     

       
46
       
 
       


     

       
47
       
 
       
rec {

     

       
48
       
 
       


     

···

       
1
       
+
       
{ lib }:

     

       
2
       
 
       
/*

     

       
3
       
 
       
Usage:

     

       
4
       
 
       


     
···

       
41
       
 
       
  [1] maybe this behaviour should be removed to keep things simple (?)

     

       
42
       
 
       
*/

     

       
43
       
 
       


     

       
44
       
+
       
with lib.lists;

     

       
45
       
+
       
with lib.attrsets;

     

       
46
       
+
       
with lib.strings;

     

       
47
       
 
       


     

       
48
       
 
       
rec {

     

       
49
       
 
       


     

···

       
1
       
 
       
/* String manipulation functions. */

     

       
2
       
-
       


     

       
3
       
-
       
let lib = import ./default.nix;

     

       
4
       
 
       


     

       
5
       
 
       
inherit (builtins) length;

     

       
6
       
 
       


     

···

       
1
       
 
       
/* String manipulation functions. */

     

       
2
       
+
       
{ lib }:

     

       
3
       
+
       
let

     

       
4
       
 
       


     

       
5
       
 
       
inherit (builtins) length;

     

       
6
       
 
       


     

···

       
1
       
-
       
let inherit (import ../attrsets.nix) mapAttrs; in

     

       
0
       
 
       

     

       
2
       
 
       


     

       
3
       
 
       
rec {

     

       
4
       
-
       
  doubles = import ./doubles.nix;

     

       
5
       
-
       
  parse = import ./parse.nix;

     

       
6
       
-
       
  inspect = import ./inspect.nix;

     

       
7
       
-
       
  platforms = import ./platforms.nix;

     

       
8
       
-
       
  examples = import ./examples.nix;

     

       
9
       
 
       


     

       
10
       
 
       
  # Elaborate a `localSystem` or `crossSystem` so that it contains everything

     

       
11
       
 
       
  # necessary.

     

···

       
1
       
+
       
{ lib }:

     

       
2
       
+
       
  let inherit (lib.attrsets) mapAttrs; in

     

       
3
       
 
       


     

       
4
       
 
       
rec {

     

       
5
       
+
       
  doubles = import ./doubles.nix { inherit lib; };

     

       
6
       
+
       
  parse = import ./parse.nix { inherit lib; };

     

       
7
       
+
       
  inspect = import ./inspect.nix { inherit lib; };

     

       
8
       
+
       
  platforms = import ./platforms.nix { inherit lib; };

     

       
9
       
+
       
  examples = import ./examples.nix { inherit lib; };

     

       
10
       
 
       


     

       
11
       
 
       
  # Elaborate a `localSystem` or `crossSystem` so that it contains everything

     

       
12
       
 
       
  # necessary.

     

···

       
0
       
 
       

     

       
1
       
 
       
let

     

       
2
       
-
       
  lists = import ../lists.nix;

     

       
3
       
-
       
  parse = import ./parse.nix;

     

       
4
       
-
       
  inherit (import ./inspect.nix) predicates;

     

       
5
       
-
       
  inherit (import ../attrsets.nix) matchAttrs;

     

       
6
       
 
       


     

       
7
       
 
       
  all = [

     

       
8
       
 
       
    "aarch64-linux"

     

···

       
1
       
+
       
{ lib }:

     

       
2
       
 
       
let

     

       
3
       
+
       
  inherit (lib) lists;

     

       
4
       
+
       
  parse = import ./parse.nix { inherit lib; };

     

       
5
       
+
       
  inherit (import ./inspect.nix { inherit lib; }) predicates;

     

       
6
       
+
       
  inherit (lib.attrsets) matchAttrs;

     

       
7
       
 
       


     

       
8
       
 
       
  all = [

     

       
9
       
 
       
    "aarch64-linux"

     

···

       
1
       
 
       
# These can be passed to nixpkgs as either the `localSystem` or

     

       
2
       
 
       
# `crossSystem`. They are put here for user convenience, but also used by cross

     

       
3
       
 
       
# tests and linux cross stdenv building, so handle with care!

     

       
4
       
-
       


     

       
5
       
-
       
let platforms = import ./platforms.nix; in

     

       
6
       
 
       


     

       
7
       
 
       
rec {

     

       
8
       
 
       
  #

     

···

       
1
       
 
       
# These can be passed to nixpkgs as either the `localSystem` or

     

       
2
       
 
       
# `crossSystem`. They are put here for user convenience, but also used by cross

     

       
3
       
 
       
# tests and linux cross stdenv building, so handle with care!

     

       
4
       
+
       
{ lib }:

     

       
5
       
+
       
let platforms = import ./platforms.nix { inherit lib; }; in

     

       
6
       
 
       


     

       
7
       
 
       
rec {

     

       
8
       
 
       
  #

     

···

       
1
       
-
       
with import ./parse.nix;

     

       
2
       
-
       
with import ../attrsets.nix;

     

       
3
       
-
       
with import ../lists.nix;

     

       
0
       
 
       

     

       
4
       
 
       


     

       
5
       
 
       
rec {

     

       
6
       
 
       
  patterns = rec {

     

···

       
1
       
+
       
{ lib }:

     

       
2
       
+
       
with import ./parse.nix { inherit lib; };

     

       
3
       
+
       
with lib.attrsets;

     

       
4
       
+
       
with lib.lists;

     

       
5
       
 
       


     

       
6
       
 
       
rec {

     

       
7
       
 
       
  patterns = rec {

     

···

       
4
       
 
       
# http://llvm.org/docs/doxygen/html/Triple_8cpp_source.html especially

     

       
5
       
 
       
# Triple::normalize. Parsing should essentially act as a more conservative

     

       
6
       
 
       
# version of that last function.

     

       
7
       
-
       


     

       
8
       
-
       
with import ../lists.nix;

     

       
9
       
-
       
with import ../types.nix;

     

       
10
       
-
       
with import ../attrsets.nix;

     

       
11
       
-
       
with (import ./inspect.nix).predicates;

     

       
12
       
 
       


     

       
13
       
 
       
let

     

       
14
       
-
       
  lib = import ../default.nix;

     

       
15
       
 
       
  setTypesAssert = type: pred:

     

       
16
       
 
       
    mapAttrs (name: value:

     

       
17
       
 
       
      assert pred value;

     

···

       
4
       
 
       
# http://llvm.org/docs/doxygen/html/Triple_8cpp_source.html especially

     

       
5
       
 
       
# Triple::normalize. Parsing should essentially act as a more conservative

     

       
6
       
 
       
# version of that last function.

     

       
7
       
+
       
{ lib }:

     

       
8
       
+
       
with lib.lists;

     

       
9
       
+
       
with lib.types;

     

       
10
       
+
       
with lib.attrsets;

     

       
11
       
+
       
with (import ./inspect.nix { inherit lib; }).predicates;

     

       
12
       
 
       


     

       
13
       
 
       
let

     

       
0
       
 
       

     

       
14
       
 
       
  setTypesAssert = type: pred:

     

       
15
       
 
       
    mapAttrs (name: value:

     

       
16
       
 
       
      assert pred value;

     

···

       
0
       
 
       

     

       
1
       
 
       
rec {

     

       
2
       
 
       
  pcBase = {

     

       
3
       
 
       
    name = "pc";

     

···

       
1
       
+
       
{ lib }:

     

       
2
       
 
       
rec {

     

       
3
       
 
       
  pcBase = {

     

       
4
       
 
       
    name = "pc";

     

···

       
0
       
 
       

     

       
1
       
 
       
rec {

     

       
2
       
 
       


     

       
3
       
 
       
  /* The identity function

     
···

       
55
       
 
       
    isInt add sub lessThan

     

       
56
       
 
       
    seq deepSeq genericClosure;

     

       
57
       
 
       


     

       
58
       
-
       
  inherit (import ./strings.nix) fileContents;

     

       
59
       
 
       


     

       
60
       
 
       
  # Return the Nixpkgs version number.

     

       
61
       
 
       
  nixpkgsVersion =

     

···

       
1
       
+
       
{ lib }:

     

       
2
       
 
       
rec {

     

       
3
       
 
       


     

       
4
       
 
       
  /* The identity function

     
···

       
56
       
 
       
    isInt add sub lessThan

     

       
57
       
 
       
    seq deepSeq genericClosure;

     

       
58
       
 
       


     

       
59
       
+
       
  inherit (lib.strings) fileContents;

     

       
60
       
 
       


     

       
61
       
 
       
  # Return the Nixpkgs version number.

     

       
62
       
 
       
  nixpkgsVersion =

     

···

       
1
       
 
       
# Definitions related to run-time type checking.  Used in particular

     

       
2
       
 
       
# to type-check NixOS configurations.

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       


     

       
4
       
-
       
with import ./lists.nix;

     

       
5
       
-
       
with import ./attrsets.nix;

     

       
6
       
-
       
with import ./options.nix;

     

       
7
       
-
       
with import ./trivial.nix;

     

       
8
       
-
       
with import ./strings.nix;

     

       
9
       
-
       
let inherit (import ./modules.nix) mergeDefinitions filterOverrides; in

     

       
10
       
-
       


     

       
11
       
 
       
rec {

     

       
12
       
-
       


     

       
13
       
 
       
  isType = type: x: (x._type or "") == type;

     

       
14
       
 
       


     

       
15
       
 
       
  setType = typeName: value: value // {

     
···

       
95
       
 
       
  # When adding new types don't forget to document them in

     

       
96
       
 
       
  # nixos/doc/manual/development/option-types.xml!

     

       
97
       
 
       
  types = rec {

     

       
98
       
-
       


     

       
99
       
 
       
    unspecified = mkOptionType {

     

       
100
       
 
       
      name = "unspecified";

     

       
101
       
 
       
    };

     
···

       
291
       
 
       
    submodule = opts:

     

       
292
       
 
       
      let

     

       
293
       
 
       
        opts' = toList opts;

     

       
294
       
-
       
        inherit (import ./modules.nix) evalModules;

     

       
295
       
 
       
      in

     

       
296
       
 
       
      mkOptionType rec {

     

       
297
       
 
       
        name = "submodule";

     
···

       
395
       
 
       
    addCheck = elemType: check: elemType // { check = x: elemType.check x && check x; };

     

       
396
       
 
       


     

       
397
       
 
       
  };

     

       
0
       
 
       

     

       
398
       
 
       


     

       
399
       
-
       
}

     

···

       
1
       
 
       
# Definitions related to run-time type checking.  Used in particular

     

       
2
       
 
       
# to type-check NixOS configurations.

     

       
3
       
+
       
{ lib }:

     

       
4
       
+
       
with lib.lists;

     

       
5
       
+
       
with lib.attrsets;

     

       
6
       
+
       
with lib.options;

     

       
7
       
+
       
with lib.trivial;

     

       
8
       
+
       
with lib.strings;

     

       
9
       
+
       
let

     

       
10
       
 
       


     

       
11
       
+
       
  inherit (lib.modules) mergeDefinitions filterOverrides;

     

       
12
       
+
       
  outer_types =

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
13
       
 
       
rec {

     

       
0
       
 
       

     

       
14
       
 
       
  isType = type: x: (x._type or "") == type;

     

       
15
       
 
       


     

       
16
       
 
       
  setType = typeName: value: value // {

     
···

       
96
       
 
       
  # When adding new types don't forget to document them in

     

       
97
       
 
       
  # nixos/doc/manual/development/option-types.xml!

     

       
98
       
 
       
  types = rec {

     

       
0
       
 
       

     

       
99
       
 
       
    unspecified = mkOptionType {

     

       
100
       
 
       
      name = "unspecified";

     

       
101
       
 
       
    };

     
···

       
291
       
 
       
    submodule = opts:

     

       
292
       
 
       
      let

     

       
293
       
 
       
        opts' = toList opts;

     

       
294
       
+
       
        inherit (lib.modules) evalModules;

     

       
295
       
 
       
      in

     

       
296
       
 
       
      mkOptionType rec {

     

       
297
       
 
       
        name = "submodule";

     
···

       
395
       
 
       
    addCheck = elemType: check: elemType // { check = x: elemType.check x && check x; };

     

       
396
       
 
       


     

       
397
       
 
       
  };

     

       
398
       
+
       
};

     

       
399
       
 
       


     

       
400
       
+
       
in outer_types // outer_types.types