core/nodes/1_lib/default.nix

let
    # no "external"dependencies
in
  let # internal dependencies
    foundation  = import ./source/detangled/1_foundation.nix;
    static      = import ./source/detangled/2_static.nix;
    fixedPoints = import ./source/detangled/3_fixed-points.nix;
  in
    let
      untangledBase = {
        # constants
        sourceTypes  = static.setup.sourceTypes;
        licenses     = static.setup.licenses;
        maintainers  = static.setup.maintainers;
        teams        = static.setup.teams;
        
        # just to be overridable
        builtins = builtins;
        
        # top level helpers
        loadStatic = foundation.loadStatic;
        foldr      = foundation.foldr;
        
        # namespaces
        fixedPoints = fixedPoints;
      };
      
      #   
      # legacy lib
      #   
      lib = fixedPoints.makeExtensible (
        self:
          untangledBase // {
            trivial         = import ./source/trivial.nix           { lib = self; };
            attrsets        = import ./source/attrsets.nix          { lib = self; };
            lists           = import ./source/lists.nix             { lib = self; };
            strings         = import ./source/strings.nix           { lib = self; };
            stringsWithDeps = import ./source/strings-with-deps.nix { lib = self; };
            customisation   = import ./source/customisation.nix     { lib = self; };
            derivations     = import ./source/derivations.nix       { lib = self; };
            meta            = import ./source/meta.nix              { lib = self; };
            versions        = import ./source/versions.nix          { lib = self; };
            modules         = import ./source/modules.nix           { lib = self; };
            options         = import ./source/options.nix           { lib = self; };
            types           = import ./source/types.nix             { lib = self; };
            systems         = import ./source/systems               { lib = self; };
            cli             = import ./source/cli.nix               { lib = self; };
            gvariant        = import ./source/gvariant.nix          { lib = self; };
            generators      = import ./source/generators.nix        { lib = self; };
            asserts         = import ./source/asserts.nix           { lib = self; };
            debug           = import ./source/debug.nix             { lib = self; };
            fetchers        = import ./source/fetchers.nix          { lib = self; };
            path            = import ./source/path                  { lib = self; };
            filesystem      = import ./source/filesystem.nix        { lib = self; };
            fileset         = import ./source/fileset               { lib = self; };
            sources         = import ./source/sources.nix           { lib = self; };
            kernel          = import ./source/kernel.nix            { lib = self; };
        
            platforms = self.systems.doubles; # back-compat aliases # TODO: these are not the same as system.platform, we should probably try and unify them
        
            # builtin aliases
            add              = builtins.add;
            addErrorContext  = builtins.addErrorContext;
            attrNames        = builtins.attrNames;
            concatLists      = builtins.concatLists;
            deepSeq          = builtins.deepSeq;
            elem             = builtins.elem;
            elemAt           = builtins.elemAt;
            filter           = builtins.filter;
            genericClosure   = builtins.genericClosure;
            genList          = builtins.genList;
            getAttr          = builtins.getAttr;
            hasAttr          = builtins.hasAttr;
            head             = builtins.head;
            isAttrs          = builtins.isAttrs;
            isBool           = builtins.isBool;
            isInt            = builtins.isInt;
            isList           = builtins.isList;
            isPath           = builtins.isPath;
            isString         = builtins.isString;
            length           = builtins.length;
            lessThan         = builtins.lessThan;
            listToAttrs      = builtins.listToAttrs;
            pathExists       = builtins.pathExists;
            readFile         = builtins.readFile;
            replaceStrings   = builtins.replaceStrings;
            seq              = builtins.seq;
            stringLength     = builtins.stringLength;
            sub              = builtins.sub;
            substring        = builtins.substring;
            tail             = builtins.tail;
            trace            = builtins.trace;
            
            # trivial to top level
            id                  = self.trivial.id;
            const               = self.trivial.const;
            pipe                = self.trivial.pipe;
            concat              = self.trivial.concat;
            or                  = self.trivial.or;
            and                 = self.trivial.and;
            xor                 = self.trivial.xor;
            bitAnd              = self.trivial.bitAnd;
            bitOr               = self.trivial.bitOr;
            bitXor              = self.trivial.bitXor;
            bitNot              = self.trivial.bitNot;
            boolToString        = self.trivial.boolToString;
            mergeAttrs          = self.trivial.mergeAttrs;
            flip                = self.trivial.flip;
            mapNullable         = self.trivial.mapNullable;
            inNixShell          = self.trivial.inNixShell;
            isFloat             = self.trivial.isFloat;
            min                 = self.trivial.min;
            max                 = self.trivial.max;
            importJSON          = self.trivial.importJSON;
            importTOML          = self.trivial.importTOML;
            warn                = self.trivial.warn;
            warnIf              = self.trivial.warnIf;
            warnIfNot           = self.trivial.warnIfNot;
            throwIf             = self.trivial.throwIf;
            throwIfNot          = self.trivial.throwIfNot;
            checkListOfEnum     = self.trivial.checkListOfEnum;
            info                = self.trivial.info;
            showWarnings        = self.trivial.showWarnings;
            nixpkgsVersion      = self.trivial.nixpkgsVersion;
            version             = self.trivial.version;
            isInOldestRelease   = self.trivial.isInOldestRelease;
            mod                 = self.trivial.mod;
            compare             = self.trivial.compare;
            splitByAndCompare   = self.trivial.splitByAndCompare;
            functionArgs        = self.trivial.functionArgs;
            setFunctionArgs     = self.trivial.setFunctionArgs;
            isFunction          = self.trivial.isFunction;
            toFunction          = self.trivial.toFunction;
            mirrorFunctionArgs  = self.trivial.mirrorFunctionArgs;
            toHexString         = self.trivial.toHexString;
            toBaseDigits        = self.trivial.toBaseDigits;
            inPureEvalMode      = self.trivial.inPureEvalMode;
            
            # fixed points to top level
            fix                           = self.fixedPoints.fix;
            fix'                          = self.fixedPoints.fix';
            converge                      = self.fixedPoints.converge;
            extends                       = self.fixedPoints.extends;
            composeExtensions             = self.fixedPoints.composeExtensions;
            composeManyExtensions         = self.fixedPoints.composeManyExtensions;
            makeExtensible                = self.fixedPoints.makeExtensible;
            makeExtensibleWithCustomName  = self.fixedPoints.makeExtensibleWithCustomName;
            
            # attrsets to top level
            attrByPath              = self.attrsets.attrByPath;
            hasAttrByPath           = self.attrsets.hasAttrByPath;
            setAttrByPath           = self.attrsets.setAttrByPath;
            getAttrFromPath         = self.attrsets.getAttrFromPath;
            attrVals                = self.attrsets.attrVals;
            attrValues              = self.attrsets.attrValues;
            getAttrs                = self.attrsets.getAttrs;
            catAttrs                = self.attrsets.catAttrs;
            filterAttrs             = self.attrsets.filterAttrs;
            filterAttrsRecursive    = self.attrsets.filterAttrsRecursive;
            foldlAttrs              = self.attrsets.foldlAttrs;
            foldAttrs               = self.attrsets.foldAttrs;
            collect                 = self.attrsets.collect;
            nameValuePair           = self.attrsets.nameValuePair;
            mapAttrs                = self.attrsets.mapAttrs;
            mapAttrs'               = self.attrsets.mapAttrs';
            mapAttrsToList          = self.attrsets.mapAttrsToList;
            attrsToList             = self.attrsets.attrsToList;
            concatMapAttrs          = self.attrsets.concatMapAttrs;
            mapAttrsRecursive       = self.attrsets.mapAttrsRecursive;
            mapAttrsRecursiveCond   = self.attrsets.mapAttrsRecursiveCond;
            genAttrs                = self.attrsets.genAttrs;
            isDerivation            = self.attrsets.isDerivation;
            toDerivation            = self.attrsets.toDerivation;
            optionalAttrs           = self.attrsets.optionalAttrs;
            zipAttrsWithNames       = self.attrsets.zipAttrsWithNames;
            zipAttrsWith            = self.attrsets.zipAttrsWith;
            zipAttrs                = self.attrsets.zipAttrs;
            recursiveUpdateUntil    = self.attrsets.recursiveUpdateUntil;
            recursiveUpdate         = self.attrsets.recursiveUpdate;
            matchAttrs              = self.attrsets.matchAttrs;
            mergeAttrsList          = self.attrsets.mergeAttrsList;
            overrideExisting        = self.attrsets.overrideExisting;
            showAttrPath            = self.attrsets.showAttrPath;
            getOutput               = self.attrsets.getOutput;
            getBin                  = self.attrsets.getBin;
            getLib                  = self.attrsets.getLib;
            getDev                  = self.attrsets.getDev;
            getMan                  = self.attrsets.getMan;
            chooseDevOutputs        = self.attrsets.chooseDevOutputs;
            zipWithNames            = self.attrsets.zipWithNames;
            zip                     = self.attrsets.zip;
            recurseIntoAttrs        = self.attrsets.recurseIntoAttrs;
            dontRecurseIntoAttrs    = self.attrsets.dontRecurseIntoAttrs;
            cartesianProduct        = self.attrsets.cartesianProduct;
            cartesianProductOfSets  = self.attrsets.cartesianProductOfSets;
            mapCartesianProduct     = self.attrsets.mapCartesianProduct;
            updateManyAttrsByPath   = self.attrsets.updateManyAttrsByPath;
            
            # lists to top level
            singleton          = self.lists.singleton;
            forEach            = self.lists.forEach;
            foldr              = self.lists.foldr;
            fold               = self.lists.fold;
            foldl              = self.lists.foldl;
            foldl'             = self.lists.foldl';
            imap0              = self.lists.imap0;
            imap1              = self.lists.imap1;
            ifilter0           = self.lists.ifilter0;
            concatMap          = self.lists.concatMap;
            flatten            = self.lists.flatten;
            remove             = self.lists.remove;
            findSingle         = self.lists.findSingle;
            findFirst          = self.lists.findFirst;
            any                = self.lists.any;
            all                = self.lists.all;
            count              = self.lists.count;
            optional           = self.lists.optional;
            optionals          = self.lists.optionals;
            toList             = self.lists.toList;
            range              = self.lists.range;
            replicate          = self.lists.replicate;
            partition          = self.lists.partition;
            zipListsWith       = self.lists.zipListsWith;
            zipLists           = self.lists.zipLists;
            reverseList        = self.lists.reverseList;
            listDfs            = self.lists.listDfs;
            toposort           = self.lists.toposort;
            sort               = self.lists.sort;
            sortOn             = self.lists.sortOn;
            naturalSort        = self.lists.naturalSort;
            compareLists       = self.lists.compareLists;
            take               = self.lists.take;
            drop               = self.lists.drop;
            sublist            = self.lists.sublist;
            last               = self.lists.last;
            init               = self.lists.init;
            crossLists         = self.lists.crossLists;
            unique             = self.lists.unique;
            allUnique          = self.lists.allUnique;
            intersectLists     = self.lists.intersectLists;
            subtractLists      = self.lists.subtractLists;
            mutuallyExclusive  = self.lists.mutuallyExclusive;
            groupBy            = self.lists.groupBy;
            groupBy'           = self.lists.groupBy';
            
            # strings to top level
            concatStrings         = self.strings.concatStrings;
            concatMapStrings      = self.strings.concatMapStrings;
            concatImapStrings     = self.strings.concatImapStrings;
            intersperse           = self.strings.intersperse;
            concatStringsSep      = self.strings.concatStringsSep;
            concatMapStringsSep   = self.strings.concatMapStringsSep;
            concatImapStringsSep  = self.strings.concatImapStringsSep;
            concatLines           = self.strings.concatLines;
            makeSearchPath        = self.strings.makeSearchPath;
            makeSearchPathOutput  = self.strings.makeSearchPathOutput;
            makeLibraryPath       = self.strings.makeLibraryPath;
            makeIncludePath       = self.strings.makeIncludePath;
            makeBinPath           = self.strings.makeBinPath;
            optionalString        = self.strings.optionalString;
            hasInfix              = self.strings.hasInfix;
            hasPrefix             = self.strings.hasPrefix;
            hasSuffix             = self.strings.hasSuffix;
            stringToCharacters    = self.strings.stringToCharacters;
            stringAsChars         = self.strings.stringAsChars;
            escape                = self.strings.escape;
            escapeShellArg        = self.strings.escapeShellArg;
            escapeShellArgs       = self.strings.escapeShellArgs;
            isStorePath           = self.strings.isStorePath;
            isStringLike          = self.strings.isStringLike;
            isValidPosixName      = self.strings.isValidPosixName;
            toShellVar            = self.strings.toShellVar;
            toShellVars           = self.strings.toShellVars;
            escapeRegex           = self.strings.escapeRegex;
            escapeURL             = self.strings.escapeURL;
            escapeXML             = self.strings.escapeXML;
            replaceChars          = self.strings.replaceChars;
            lowerChars            = self.strings.lowerChars;
            upperChars            = self.strings.upperChars;
            toLower               = self.strings.toLower;
            toUpper               = self.strings.toUpper;
            addContextFrom        = self.strings.addContextFrom;
            splitString           = self.strings.splitString;
            removePrefix          = self.strings.removePrefix;
            removeSuffix          = self.strings.removeSuffix;
            versionOlder          = self.strings.versionOlder;
            versionAtLeast        = self.strings.versionAtLeast;
            getName               = self.strings.getName;
            getVersion            = self.strings.getVersion;
            cmakeOptionType       = self.strings.cmakeOptionType;
            cmakeBool             = self.strings.cmakeBool;
            cmakeFeature          = self.strings.cmakeFeature;
            mesonOption           = self.strings.mesonOption;
            mesonBool             = self.strings.mesonBool;
            mesonEnable           = self.strings.mesonEnable;
            nameFromURL           = self.strings.nameFromURL;
            enableFeature         = self.strings.enableFeature;
            enableFeatureAs       = self.strings.enableFeatureAs;
            withFeature           = self.strings.withFeature;
            withFeatureAs         = self.strings.withFeatureAs;
            fixedWidthString      = self.strings.fixedWidthString;
            fixedWidthNumber      = self.strings.fixedWidthNumber;
            toInt                 = self.strings.toInt;
            toIntBase10           = self.strings.toIntBase10;
            readPathsFromFile     = self.strings.readPathsFromFile;
            fileContents          = self.strings.fileContents;
            
            # stringsWithDeps to top level
            textClosureList  = self.stringsWithDeps.textClosureList;
            textClosureMap   = self.stringsWithDeps.textClosureMap;
            noDepEntry       = self.stringsWithDeps.noDepEntry;
            fullDepEntry     = self.stringsWithDeps.fullDepEntry;
            packEntry        = self.stringsWithDeps.packEntry;
            stringAfter      = self.stringsWithDeps.stringAfter;
            
            # customisation to top level
            overrideDerivation      = self.customisation.overrideDerivation;
            makeOverridable         = self.customisation.makeOverridable;
            callPackageWith         = self.customisation.callPackageWith;
            callPackagesWith        = self.customisation.callPackagesWith;
            extendDerivation        = self.customisation.extendDerivation;
            hydraJob                = self.customisation.hydraJob;
            makeScope               = self.customisation.makeScope;
            makeScopeWithSplicing   = self.customisation.makeScopeWithSplicing;
            makeScopeWithSplicing'  = self.customisation.makeScopeWithSplicing';
            
            # derivations to top level
            lazyDerivation   = self.derivations.lazyDerivation;
            optionalDrvAttr  = self.derivations.optionalDrvAttr;
            
            # meta to top level
            addMetaAttrs          = self.meta.addMetaAttrs;
            dontDistribute        = self.meta.dontDistribute;
            setName               = self.meta.setName;
            updateName            = self.meta.updateName;
            appendToName          = self.meta.appendToName;
            mapDerivationAttrset  = self.meta.mapDerivationAttrset;
            setPrio               = self.meta.setPrio;
            lowPrio               = self.meta.lowPrio;
            lowPrioSet            = self.meta.lowPrioSet;
            hiPrio                = self.meta.hiPrio;
            hiPrioSet             = self.meta.hiPrioSet;
            getLicenseFromSpdxId  = self.meta.getLicenseFromSpdxId;
            getExe                = self.meta.getExe;
            getExe'               = self.meta.getExe';
            
            # filesystem to top level
            pathType                        = self.filesystem.pathType;
            pathIsDirectory                 = self.filesystem.pathIsDirectory;
            pathIsRegularFile               = self.filesystem.pathIsRegularFile;
            packagesFromDirectoryRecursive  = self.filesystem.packagesFromDirectoryRecursive;
            
            # sources to top level
            cleanSourceFilter      = self.sources.cleanSourceFilter;
            cleanSource            = self.sources.cleanSource;
            sourceByRegex          = self.sources.sourceByRegex;
            sourceFilesBySuffices  = self.sources.sourceFilesBySuffices;
            commitIdFromGitRepo    = self.sources.commitIdFromGitRepo;
            cleanSourceWith        = self.sources.cleanSourceWith;
            pathHasContext         = self.sources.pathHasContext;
            canCleanSource         = self.sources.canCleanSource;
            pathIsGitRepo          = self.sources.pathIsGitRepo;
            
            # modules to top level
            evalModules                = self.modules.evalModules;
            setDefaultModuleLocation   = self.modules.setDefaultModuleLocation;
            unifyModuleSyntax          = self.modules.unifyModuleSyntax;
            applyModuleArgsIfFunction  = self.modules.applyModuleArgsIfFunction;
            mergeModules               = self.modules.mergeModules;
            mergeModules'              = self.modules.mergeModules';
            mergeOptionDecls           = self.modules.mergeOptionDecls;
            mergeDefinitions           = self.modules.mergeDefinitions;
            pushDownProperties         = self.modules.pushDownProperties;
            dischargeProperties        = self.modules.dischargeProperties;
            filterOverrides            = self.modules.filterOverrides;
            sortProperties             = self.modules.sortProperties;
            fixupOptionType            = self.modules.fixupOptionType;
            mkIf                       = self.modules.mkIf;
            mkAssert                   = self.modules.mkAssert;
            mkMerge                    = self.modules.mkMerge;
            mkOverride                 = self.modules.mkOverride;
            mkOptionDefault            = self.modules.mkOptionDefault;
            mkDefault                  = self.modules.mkDefault;
            mkImageMediaOverride       = self.modules.mkImageMediaOverride;
            mkForce                    = self.modules.mkForce;
            mkVMOverride               = self.modules.mkVMOverride;
            mkFixStrictness            = self.modules.mkFixStrictness;
            mkOrder                    = self.modules.mkOrder;
            mkBefore                   = self.modules.mkBefore;
            mkAfter                    = self.modules.mkAfter;
            mkAliasDefinitions         = self.modules.mkAliasDefinitions;
            mkAliasAndWrapDefinitions  = self.modules.mkAliasAndWrapDefinitions;
            fixMergeModules            = self.modules.fixMergeModules;
            mkRemovedOptionModule      = self.modules.mkRemovedOptionModule;
            mkRenamedOptionModule      = self.modules.mkRenamedOptionModule;
            mkRenamedOptionModuleWith  = self.modules.mkRenamedOptionModuleWith;
            mkMergedOptionModule       = self.modules.mkMergedOptionModule;
            mkChangedOptionModule      = self.modules.mkChangedOptionModule;
            mkAliasOptionModule        = self.modules.mkAliasOptionModule;
            mkDerivedConfig            = self.modules.mkDerivedConfig;
            doRename                   = self.modules.doRename;
            mkAliasOptionModuleMD      = self.modules.mkAliasOptionModuleMD;
            
            # options to top level
            isOption                 = self.options.isOption;
            mkEnableOption           = self.options.mkEnableOption;
            mkSinkUndeclaredOptions  = self.options.mkSinkUndeclaredOptions;
            mergeDefaultOption       = self.options.mergeDefaultOption;
            mergeOneOption           = self.options.mergeOneOption;
            mergeEqualOption         = self.options.mergeEqualOption;
            mergeUniqueOption        = self.options.mergeUniqueOption;
            getValues                = self.options.getValues;
            getFiles                 = self.options.getFiles;
            optionAttrSetToDocList   = self.options.optionAttrSetToDocList;
            optionAttrSetToDocList'  = self.options.optionAttrSetToDocList';
            scrubOptionValue         = self.options.scrubOptionValue;
            literalExpression        = self.options.literalExpression;
            literalExample           = self.options.literalExample;
            showOption               = self.options.showOption;
            showOptionWithDefLocs    = self.options.showOptionWithDefLocs;
            showFiles                = self.options.showFiles;
            unknownModule            = self.options.unknownModule;
            mkOption                 = self.options.mkOption;
            mkPackageOption          = self.options.mkPackageOption;
            mkPackageOptionMD        = self.options.mkPackageOptionMD;
            mdDoc                    = self.options.mdDoc;
            literalMD                = self.options.literalMD;
            
            # types to top level
            isType            = self.types.isType;
            setType           = self.types.setType;
            defaultTypeMerge  = self.types.defaultTypeMerge;
            defaultFunctor    = self.types.defaultFunctor;
            isOptionType      = self.types.isOptionType;
            mkOptionType      = self.types.mkOptionType;
            
            # asserts to top level
            assertMsg    = self.asserts.assertMsg;
            assertOneOf  = self.asserts.assertOneOf;
            
            # debug to top level
            traceIf         = self.debug.traceIf;
            traceVal        = self.debug.traceVal;
            traceValFn      = self.debug.traceValFn;
            traceSeq        = self.debug.traceSeq;
            traceSeqN       = self.debug.traceSeqN;
            traceValSeq     = self.debug.traceValSeq;
            traceValSeqFn   = self.debug.traceValSeqFn;
            traceValSeqN    = self.debug.traceValSeqN;
            traceValSeqNFn  = self.debug.traceValSeqNFn;
            traceFnSeqN     = self.debug.traceFnSeqN;
            runTests        = self.debug.runTests;
            testAllTrue     = self.debug.testAllTrue;
            
            # versions to top level
            splitVersion  = self.versions.splitVersion;
          }
      );
    in lib