mirror of
https://github.com/ilyakooo0/nixpkgs.git
synced 2024-12-26 21:33:03 +03:00
4d545297d8
* lib: introduce imap0, imap1
For historical reasons, imap starts counting at 1 and it's not
consistent with the rest of the lib.
So for now we split imap into imap0 that starts counting at zero and
imap1 that starts counting at 1. And imap is marked as deprecated.
See c71e2d4235 (commitcomment-21873221)
* replace uses of lib.imap
* lib: move imap to deprecated.nix
435 lines
17 KiB
Nix
435 lines
17 KiB
Nix
let lib = import ./default.nix;
|
|
inherit (builtins) isFunction head tail isList isAttrs isInt attrNames;
|
|
|
|
in
|
|
|
|
with import ./lists.nix;
|
|
with import ./attrsets.nix;
|
|
with import ./strings.nix;
|
|
|
|
rec {
|
|
|
|
# returns default if env var is not set
|
|
maybeEnv = name: default:
|
|
let value = builtins.getEnv name; in
|
|
if value == "" then default else value;
|
|
|
|
defaultMergeArg = x : y: if builtins.isAttrs y then
|
|
y
|
|
else
|
|
(y x);
|
|
defaultMerge = x: y: x // (defaultMergeArg x y);
|
|
foldArgs = merger: f: init: x:
|
|
let arg = (merger init (defaultMergeArg init x));
|
|
# now add the function with composed args already applied to the final attrs
|
|
base = (setAttrMerge "passthru" {} (f arg)
|
|
( z: z // rec {
|
|
function = foldArgs merger f arg;
|
|
args = (lib.attrByPath ["passthru" "args"] {} z) // x;
|
|
} ));
|
|
withStdOverrides = base // {
|
|
override = base.passthru.function;
|
|
};
|
|
in
|
|
withStdOverrides;
|
|
|
|
|
|
# predecessors: proposed replacement for applyAndFun (which has a bug cause it merges twice)
|
|
# the naming "overridableDelayableArgs" tries to express that you can
|
|
# - override attr values which have been supplied earlier
|
|
# - use attr values before they have been supplied by accessing the fix point
|
|
# name "fixed"
|
|
# f: the (delayed overridden) arguments are applied to this
|
|
#
|
|
# initial: initial attrs arguments and settings. see defaultOverridableDelayableArgs
|
|
#
|
|
# returns: f applied to the arguments // special attributes attrs
|
|
# a) merge: merge applied args with new args. Wether an argument is overridden depends on the merge settings
|
|
# b) replace: this let's you replace and remove names no matter which merge function has been set
|
|
#
|
|
# examples: see test cases "res" below;
|
|
overridableDelayableArgs =
|
|
f: # the function applied to the arguments
|
|
initial: # you pass attrs, the functions below are passing a function taking the fix argument
|
|
let
|
|
takeFixed = if isFunction initial then initial else (fixed : initial); # transform initial to an expression always taking the fixed argument
|
|
tidy = args:
|
|
let # apply all functions given in "applyPreTidy" in sequence
|
|
applyPreTidyFun = fold ( n: a: x: n ( a x ) ) lib.id (maybeAttr "applyPreTidy" [] args);
|
|
in removeAttrs (applyPreTidyFun args) ( ["applyPreTidy"] ++ (maybeAttr "removeAttrs" [] args) ); # tidy up args before applying them
|
|
fun = n: x:
|
|
let newArgs = fixed:
|
|
let args = takeFixed fixed;
|
|
mergeFun = args.${n};
|
|
in if isAttrs x then (mergeFun args x)
|
|
else assert isFunction x;
|
|
mergeFun args (x ( args // { inherit fixed; }));
|
|
in overridableDelayableArgs f newArgs;
|
|
in
|
|
(f (tidy (lib.fix takeFixed))) // {
|
|
merge = fun "mergeFun";
|
|
replace = fun "keepFun";
|
|
};
|
|
defaultOverridableDelayableArgs = f:
|
|
let defaults = {
|
|
mergeFun = mergeAttrByFunc; # default merge function. merge strategie (concatenate lists, strings) is given by mergeAttrBy
|
|
keepFun = a: b: { inherit (a) removeAttrs mergeFun keepFun mergeAttrBy; } // b; # even when using replace preserve these values
|
|
applyPreTidy = []; # list of functions applied to args before args are tidied up (usage case : prepareDerivationArgs)
|
|
mergeAttrBy = mergeAttrBy // {
|
|
applyPreTidy = a: b: a ++ b;
|
|
removeAttrs = a: b: a ++ b;
|
|
};
|
|
removeAttrs = ["mergeFun" "keepFun" "mergeAttrBy" "removeAttrs" "fixed" ]; # before applying the arguments to the function make sure these names are gone
|
|
};
|
|
in (overridableDelayableArgs f defaults).merge;
|
|
|
|
|
|
|
|
# rec { # an example of how composedArgsAndFun can be used
|
|
# a = composedArgsAndFun (x: x) { a = ["2"]; meta = { d = "bar";}; };
|
|
# # meta.d will be lost ! It's your task to preserve it (eg using a merge function)
|
|
# b = a.passthru.function { a = [ "3" ]; meta = { d2 = "bar2";}; };
|
|
# # instead of passing/ overriding values you can use a merge function:
|
|
# c = b.passthru.function ( x: { a = x.a ++ ["4"]; }); # consider using (maybeAttr "a" [] x)
|
|
# }
|
|
# result:
|
|
# {
|
|
# a = { a = ["2"]; meta = { d = "bar"; }; passthru = { function = .. }; };
|
|
# b = { a = ["3"]; meta = { d2 = "bar2"; }; passthru = { function = .. }; };
|
|
# c = { a = ["3" "4"]; meta = { d2 = "bar2"; }; passthru = { function = .. }; };
|
|
# # c2 is equal to c
|
|
# }
|
|
composedArgsAndFun = f: foldArgs defaultMerge f {};
|
|
|
|
|
|
# shortcut for attrByPath ["name"] default attrs
|
|
maybeAttrNullable = maybeAttr;
|
|
|
|
# shortcut for attrByPath ["name"] default attrs
|
|
maybeAttr = name: default: attrs: attrs.${name} or default;
|
|
|
|
|
|
# Return the second argument if the first one is true or the empty version
|
|
# of the second argument.
|
|
ifEnable = cond: val:
|
|
if cond then val
|
|
else if builtins.isList val then []
|
|
else if builtins.isAttrs val then {}
|
|
# else if builtins.isString val then ""
|
|
else if val == true || val == false then false
|
|
else null;
|
|
|
|
|
|
# Return true only if there is an attribute and it is true.
|
|
checkFlag = attrSet: name:
|
|
if name == "true" then true else
|
|
if name == "false" then false else
|
|
if (elem name (attrByPath ["flags"] [] attrSet)) then true else
|
|
attrByPath [name] false attrSet ;
|
|
|
|
|
|
# Input : attrSet, [ [name default] ... ], name
|
|
# Output : its value or default.
|
|
getValue = attrSet: argList: name:
|
|
( attrByPath [name] (if checkFlag attrSet name then true else
|
|
if argList == [] then null else
|
|
let x = builtins.head argList; in
|
|
if (head x) == name then
|
|
(head (tail x))
|
|
else (getValue attrSet
|
|
(tail argList) name)) attrSet );
|
|
|
|
|
|
# Input : attrSet, [[name default] ...], [ [flagname reqs..] ... ]
|
|
# Output : are reqs satisfied? It's asserted.
|
|
checkReqs = attrSet: argList: condList:
|
|
(
|
|
fold lib.and true
|
|
(map (x: let name = (head x); in
|
|
|
|
((checkFlag attrSet name) ->
|
|
(fold lib.and true
|
|
(map (y: let val=(getValue attrSet argList y); in
|
|
(val!=null) && (val!=false))
|
|
(tail x))))) condList));
|
|
|
|
|
|
# This function has O(n^2) performance.
|
|
uniqList = { inputList, acc ? [] }:
|
|
let go = xs: acc:
|
|
if xs == []
|
|
then []
|
|
else let x = head xs;
|
|
y = if elem x acc then [] else [x];
|
|
in y ++ go (tail xs) (y ++ acc);
|
|
in go inputList acc;
|
|
|
|
uniqListExt = { inputList,
|
|
outputList ? [],
|
|
getter ? (x: x),
|
|
compare ? (x: y: x==y) }:
|
|
if inputList == [] then outputList else
|
|
let x = head inputList;
|
|
isX = y: (compare (getter y) (getter x));
|
|
newOutputList = outputList ++
|
|
(if any isX outputList then [] else [x]);
|
|
in uniqListExt { outputList = newOutputList;
|
|
inputList = (tail inputList);
|
|
inherit getter compare;
|
|
};
|
|
|
|
condConcat = name: list: checker:
|
|
if list == [] then name else
|
|
if checker (head list) then
|
|
condConcat
|
|
(name + (head (tail list)))
|
|
(tail (tail list))
|
|
checker
|
|
else condConcat
|
|
name (tail (tail list)) checker;
|
|
|
|
lazyGenericClosure = {startSet, operator}:
|
|
let
|
|
work = list: doneKeys: result:
|
|
if list == [] then
|
|
result
|
|
else
|
|
let x = head list; key = x.key; in
|
|
if elem key doneKeys then
|
|
work (tail list) doneKeys result
|
|
else
|
|
work (tail list ++ operator x) ([key] ++ doneKeys) ([x] ++ result);
|
|
in
|
|
work startSet [] [];
|
|
|
|
innerModifySumArgs = f: x: a: b: if b == null then (f a b) // x else
|
|
innerModifySumArgs f x (a // b);
|
|
modifySumArgs = f: x: innerModifySumArgs f x {};
|
|
|
|
|
|
innerClosePropagation = acc: xs:
|
|
if xs == []
|
|
then acc
|
|
else let y = head xs;
|
|
ys = tail xs;
|
|
in if ! isAttrs y
|
|
then innerClosePropagation acc ys
|
|
else let acc' = [y] ++ acc;
|
|
in innerClosePropagation
|
|
acc'
|
|
(uniqList { inputList = (maybeAttrNullable "propagatedBuildInputs" [] y)
|
|
++ (maybeAttrNullable "propagatedNativeBuildInputs" [] y)
|
|
++ ys;
|
|
acc = acc';
|
|
}
|
|
);
|
|
|
|
closePropagation = list: (uniqList {inputList = (innerClosePropagation [] list);});
|
|
|
|
# calls a function (f attr value ) for each record item. returns a list
|
|
mapAttrsFlatten = f: r: map (attr: f attr r.${attr}) (attrNames r);
|
|
|
|
# attribute set containing one attribute
|
|
nvs = name: value: listToAttrs [ (nameValuePair name value) ];
|
|
# adds / replaces an attribute of an attribute set
|
|
setAttr = set: name: v: set // (nvs name v);
|
|
|
|
# setAttrMerge (similar to mergeAttrsWithFunc but only merges the values of a particular name)
|
|
# setAttrMerge "a" [] { a = [2];} (x: x ++ [3]) -> { a = [2 3]; }
|
|
# setAttrMerge "a" [] { } (x: x ++ [3]) -> { a = [ 3]; }
|
|
setAttrMerge = name: default: attrs: f:
|
|
setAttr attrs name (f (maybeAttr name default attrs));
|
|
|
|
# Using f = a: b = b the result is similar to //
|
|
# merge attributes with custom function handling the case that the attribute
|
|
# exists in both sets
|
|
mergeAttrsWithFunc = f: set1: set2:
|
|
fold (n: set: if set ? ${n}
|
|
then setAttr set n (f set.${n} set2.${n})
|
|
else set )
|
|
(set2 // set1) (attrNames set2);
|
|
|
|
# merging two attribute set concatenating the values of same attribute names
|
|
# eg { a = 7; } { a = [ 2 3 ]; } becomes { a = [ 7 2 3 ]; }
|
|
mergeAttrsConcatenateValues = mergeAttrsWithFunc ( a: b: (toList a) ++ (toList b) );
|
|
|
|
# merges attributes using //, if a name exists in both attributes
|
|
# an error will be triggered unless its listed in mergeLists
|
|
# so you can mergeAttrsNoOverride { buildInputs = [a]; } { buildInputs = [a]; } {} to get
|
|
# { buildInputs = [a b]; }
|
|
# merging buildPhase doesn't really make sense. The cases will be rare where appending /prefixing will fit your needs?
|
|
# in these cases the first buildPhase will override the second one
|
|
# ! deprecated, use mergeAttrByFunc instead
|
|
mergeAttrsNoOverride = { mergeLists ? ["buildInputs" "propagatedBuildInputs"],
|
|
overrideSnd ? [ "buildPhase" ]
|
|
}: attrs1: attrs2:
|
|
fold (n: set:
|
|
setAttr set n ( if set ? ${n}
|
|
then # merge
|
|
if elem n mergeLists # attribute contains list, merge them by concatenating
|
|
then attrs2.${n} ++ attrs1.${n}
|
|
else if elem n overrideSnd
|
|
then attrs1.${n}
|
|
else throw "error mergeAttrsNoOverride, attribute ${n} given in both attributes - no merge func defined"
|
|
else attrs2.${n} # add attribute not existing in attr1
|
|
)) attrs1 (attrNames attrs2);
|
|
|
|
|
|
# example usage:
|
|
# mergeAttrByFunc {
|
|
# inherit mergeAttrBy; # defined below
|
|
# buildInputs = [ a b ];
|
|
# } {
|
|
# buildInputs = [ c d ];
|
|
# };
|
|
# will result in
|
|
# { mergeAttrsBy = [...]; buildInputs = [ a b c d ]; }
|
|
# is used by prepareDerivationArgs, defaultOverridableDelayableArgs and can be used when composing using
|
|
# foldArgs, composedArgsAndFun or applyAndFun. Example: composableDerivation in all-packages.nix
|
|
mergeAttrByFunc = x: y:
|
|
let
|
|
mergeAttrBy2 = { mergeAttrBy = lib.mergeAttrs; }
|
|
// (maybeAttr "mergeAttrBy" {} x)
|
|
// (maybeAttr "mergeAttrBy" {} y); in
|
|
fold lib.mergeAttrs {} [
|
|
x y
|
|
(mapAttrs ( a: v: # merge special names using given functions
|
|
if x ? ${a}
|
|
then if y ? ${a}
|
|
then v x.${a} y.${a} # both have attr, use merge func
|
|
else x.${a} # only x has attr
|
|
else y.${a} # only y has attr)
|
|
) (removeAttrs mergeAttrBy2
|
|
# don't merge attrs which are neither in x nor y
|
|
(filter (a: ! x ? ${a} && ! y ? ${a})
|
|
(attrNames mergeAttrBy2))
|
|
)
|
|
)
|
|
];
|
|
mergeAttrsByFuncDefaults = foldl mergeAttrByFunc { inherit mergeAttrBy; };
|
|
mergeAttrsByFuncDefaultsClean = list: removeAttrs (mergeAttrsByFuncDefaults list) ["mergeAttrBy"];
|
|
|
|
# merge attrs based on version key into mkDerivation args, see mergeAttrBy to learn about smart merge defaults
|
|
#
|
|
# This function is best explained by an example:
|
|
#
|
|
# {version ? "2.x"}:
|
|
#
|
|
# mkDerivation (mergeAttrsByVersion "package-name" version
|
|
# { # version specific settings
|
|
# "git" = { src = ..; preConfigre = "autogen.sh"; buildInputs = [automake autoconf libtool]; };
|
|
# "2.x" = { src = ..; };
|
|
# }
|
|
# { // shared settings
|
|
# buildInputs = [ common build inputs ];
|
|
# meta = { .. }
|
|
# }
|
|
# )
|
|
#
|
|
# Please note that e.g. Eelco Dolstra usually prefers having one file for
|
|
# each version. On the other hand there are valuable additional design goals
|
|
# - readability
|
|
# - do it once only
|
|
# - try to avoid duplication
|
|
#
|
|
# Marc Weber and Michael Raskin sometimes prefer keeping older
|
|
# versions around for testing and regression tests - as long as its cheap to
|
|
# do so.
|
|
#
|
|
# Very often it just happens that the "shared" code is the bigger part.
|
|
# Then using this function might be appropriate.
|
|
#
|
|
# Be aware that its easy to cause recompilations in all versions when using
|
|
# this function - also if derivations get too complex splitting into multiple
|
|
# files is the way to go.
|
|
#
|
|
# See misc.nix -> versionedDerivation
|
|
# discussion: nixpkgs: pull/310
|
|
mergeAttrsByVersion = name: version: attrsByVersion: base:
|
|
mergeAttrsByFuncDefaultsClean [ { name = "${name}-${version}"; }
|
|
base
|
|
(maybeAttr version (throw "bad version ${version} for ${name}") attrsByVersion)
|
|
];
|
|
|
|
# sane defaults (same name as attr name so that inherit can be used)
|
|
mergeAttrBy = # { buildInputs = concatList; [...]; passthru = mergeAttr; [..]; }
|
|
listToAttrs (map (n: nameValuePair n lib.concat)
|
|
[ "nativeBuildInputs" "buildInputs" "propagatedBuildInputs" "configureFlags" "prePhases" "postAll" "patches" ])
|
|
// listToAttrs (map (n: nameValuePair n lib.mergeAttrs) [ "passthru" "meta" "cfg" "flags" ])
|
|
// listToAttrs (map (n: nameValuePair n (a: b: "${a}\n${b}") ) [ "preConfigure" "postInstall" ])
|
|
;
|
|
|
|
# prepareDerivationArgs tries to make writing configurable derivations easier
|
|
# example:
|
|
# prepareDerivationArgs {
|
|
# mergeAttrBy = {
|
|
# myScript = x: y: x ++ "\n" ++ y;
|
|
# };
|
|
# cfg = {
|
|
# readlineSupport = true;
|
|
# };
|
|
# flags = {
|
|
# readline = {
|
|
# set = {
|
|
# configureFlags = [ "--with-compiler=${compiler}" ];
|
|
# buildInputs = [ compiler ];
|
|
# pass = { inherit compiler; READLINE=1; };
|
|
# assertion = compiler.dllSupport;
|
|
# myScript = "foo";
|
|
# };
|
|
# unset = { configureFlags = ["--without-compiler"]; };
|
|
# };
|
|
# };
|
|
# src = ...
|
|
# buildPhase = '' ... '';
|
|
# name = ...
|
|
# myScript = "bar";
|
|
# };
|
|
# if you don't have need for unset you can omit the surrounding set = { .. } attr
|
|
# all attrs except flags cfg and mergeAttrBy will be merged with the
|
|
# additional data from flags depending on config settings
|
|
# It's used in composableDerivation in all-packages.nix. It's also used
|
|
# heavily in the new python and libs implementation
|
|
#
|
|
# should we check for misspelled cfg options?
|
|
# TODO use args.mergeFun here as well?
|
|
prepareDerivationArgs = args:
|
|
let args2 = { cfg = {}; flags = {}; } // args;
|
|
flagName = name: "${name}Support";
|
|
cfgWithDefaults = (listToAttrs (map (n: nameValuePair (flagName n) false) (attrNames args2.flags)))
|
|
// args2.cfg;
|
|
opts = attrValues (mapAttrs (a: v:
|
|
let v2 = if v ? set || v ? unset then v else { set = v; };
|
|
n = if cfgWithDefaults.${flagName a} then "set" else "unset";
|
|
attr = maybeAttr n {} v2; in
|
|
if (maybeAttr "assertion" true attr)
|
|
then attr
|
|
else throw "assertion of flag ${a} of derivation ${args.name} failed"
|
|
) args2.flags );
|
|
in removeAttrs
|
|
(mergeAttrsByFuncDefaults ([args] ++ opts ++ [{ passthru = cfgWithDefaults; }]))
|
|
["flags" "cfg" "mergeAttrBy" ];
|
|
|
|
|
|
nixType = x:
|
|
if isAttrs x then
|
|
if x ? outPath then "derivation"
|
|
else "attrs"
|
|
else if isFunction x then "function"
|
|
else if isList x then "list"
|
|
else if x == true then "bool"
|
|
else if x == false then "bool"
|
|
else if x == null then "null"
|
|
else if isInt x then "int"
|
|
else "string";
|
|
|
|
/* deprecated:
|
|
|
|
For historical reasons, imap has an index starting at 1.
|
|
|
|
But for consistency with the rest of the library we want an index
|
|
starting at zero.
|
|
*/
|
|
imap = imap1;
|
|
}
|