* Split lib/default.nix into several files, as it had become a big

  mess.  Also cleaned up some functions:

  - foldl appeared broken (it recursively called fold).
  - Renamed logicalAND/logicalOR to and/or.
  - Removed listOfListsToAttrs, eqStrings: obsolete.
  - Removed isInList, which does the same thing as elem.
  - stringToCharacters: don't return a "" at the end of the list.
  - Renamed concatList to concat, as concatList (singular) is a
    misnomer: it takes two lists.  Likewise, renamed mergeAttr to
    mergeAttrs.

  misc.nix still contains a lot of stuff that should be refactored and
  moved to other files.

svn path=/nixpkgs/trunk/; revision=14013

1 files changed, 385 insertions, 0 deletions

diff --git a/pkgs/lib/misc.nix b/pkgs/lib/misc.nix
new file mode 100644
index 00000000000..548b8d22edf
--- /dev/null
+++ b/pkgs/lib/misc.nix
@@ -0,0 +1,385 @@
+let lib = import ./default.nix; in
+
+with import ./lists.nix;
+with import ./attrsets.nix;
+with import ./strings.nix;
+
+rec {
+
+
+  # accumulates / merges all attr sets until null is fed.
+  # example: sumArgs id { a = 'a'; x = 'x'; } { y = 'y'; x = 'X'; } null
+  # result : { a = 'a'; x = 'X'; y = 'Y'; }
+  innerSumArgs = f : x : y : (if y == null then (f x)
+	else (innerSumArgs f (x // y)));
+  sumArgs = f : innerSumArgs f {};
+
+  # Advanced sumArgs version. Hm, twice as slow, I'm afraid.
+  # composedArgs id (x:x//{a="b";}) (x:x//{b=x.a + "c";}) null;
+  # {a="b" ; b="bc";};
+  innerComposedArgs = f : x : y : (if y==null then (f x)
+  	else (if (builtins.isAttrs y) then 
+		(innerComposedArgs f (x//y))
+	else (innerComposedArgs f (y x))));
+  composedArgs = f: innerComposedArgs f {};
+
+  defaultMergeArg = x : y: if builtins.isAttrs y then
+    y
+  else 
+    (y x);
+  defaultMerge = x: y: x // (defaultMergeArg x y);
+  sumTwoArgs = f: x: y: 
+    f (defaultMerge x y);
+  foldArgs = merger: f: init: x: 
+    let arg=(merger init (defaultMergeArg init x)); in  
+      # now add the function with composed args already applied to the final attrs
+    setAttrMerge "passthru" {} (f arg) ( x : x // { function = foldArgs merger f arg; } );
+
+  # returns f x // { passthru.fun = y : f (merge x y); } while preserving other passthru names.
+  # example: let ex = applyAndFun (x : removeAttrs x ["fixed"])  (mergeOrApply mergeAttr) {name = 6;};
+  #              usage1 = ex.passthru.fun { name = 7; };    # result: { name = 7;}
+  #              usage2 = ex.passthru.fun (a: a // {name = __add a.name 1; }); # result: { a = 7; }
+  # fix usage:
+  #              usage3a = ex.passthru.fun (a: a // {name2 = a.fixed.toBePassed; }); # usage3a will fail because toBePassed is not yet given
+  #              usage3b usage3a.passthru.fun { toBePassed = "foo";}; # result { name = 7; name2 = "foo"; toBePassed = "foo"; fixed = <this attrs>; }
+  applyAndFun = f : merge : x : assert (__isAttrs x || __isFunction x);
+    let takeFix = if (__isFunction x) then x else (attr: merge attr x); in
+    setAttrMerge "passthru" {} (lib.fix (fixed : f (takeFix {inherit fixed;})))
+      ( y : y //
+        {
+          fun = z : applyAndFun f merge (fixed: merge (takeFix fixed) z);
+          funMerge = z : applyAndFun f merge (fixed: let e = takeFix fixed; in merge e (merge e z));
+        } );
+  mergeOrApply = merge : x : y : if (__isFunction y) then  y x else merge x y;
+
+  # 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 {};
+
+  # example a = pairMap (x : y : x + y) ["a" "b" "c" "d"];
+  # result: ["ab" "cd"]
+  innerPairMap = acc: f: l: 
+  	if l == [] then acc else
+	innerPairMap (acc ++ [(f (head l)(head (tail l)))])
+		f (tail (tail l));
+  pairMap = innerPairMap [];
+
+  
+  # shortcut for getAttr ["name"] default attrs
+  maybeAttr = name: default: attrs:
+    if (__hasAttr name attrs) then (__getAttr name attrs) else 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 (getAttr ["flags"] [] attrSet)) then true else
+	getAttr [name] false attrSet ;
+
+
+  # Input : attrSet, [ [name default] ... ], name
+  # Output : its value or default.
+  getValue = attrSet: argList: name:
+  ( getAttr [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)) ;
+	
+   
+  uniqList = {inputList, outputList ? []}:
+	if (inputList == []) then outputList else
+	let x=head inputList; 
+	newOutputList = outputList ++
+	 (if elem x outputList then [] else [x]);
+	in uniqList {outputList=newOutputList; 
+		inputList = (tail inputList);};
+
+  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;
+
+  # Merge sets of attributes and use the function f to merge
+  # attributes values.
+  zip = f: sets:
+    builtins.listToAttrs (map (name: {
+      inherit name;
+      value =
+        f name
+          (map (__getAttr name)
+            (filter (__hasAttr name) sets));
+    }) (concatMap builtins.attrNames sets));
+
+  # flatten a list of elements by following the properties of the elements.
+  # next   : return the list of following elements.
+  # seen   : lists of elements already visited.
+  # default: result if 'x' is empty.
+  # x      : list of values that have to be processed.
+  uniqFlatten = next: seen: default: x:
+    if x == []
+    then default
+    else
+      let h = head x; t = tail x; n = next h; in
+      if elem h seen
+      then uniqFlatten next seen default t
+      else uniqFlatten next (seen ++ [h]) (default ++ [h]) (n ++ t)
+    ;
+
+  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 {};
+
+  debugVal = if builtins ? trace then x: (builtins.trace x x) else x: x;
+  debugXMLVal = if builtins ? trace then x: (builtins.trace (builtins.toXML x) x) else x: x;
+
+  # this can help debug your code as well - designed to not produce thousands of lines
+  traceWhatis = x : __trace (whatis x) x;
+  traceMarked = str: x: __trace (str + (whatis x)) x;
+  attrNamesToStr = a : concatStringsSep "; " (map (x : "${x}=") (__attrNames a));
+  whatis = x :
+      if (__isAttrs x) then
+          if (x ? outPath) then "x is a derivation, name ${if x ? name then x.name else "<no name>"}, { ${attrNamesToStr x} }"
+          else "x is attr set { ${attrNamesToStr x} }"
+      else if (__isFunction x) then "x is a function"
+      else if (x == []) then "x is an empty list"
+      else if (__isList x) then "x is a list, first item is : ${whatis (__head x)}"
+      else if (x == true) then "x is boolean true"
+      else if (x == false) then "x is boolean false"
+      else if (x == null) then "x is null"
+      else "x is probably a string starting, starting characters: ${__substring 0 50 x}..";
+  # trace the arguments passed to function and its result 
+  traceCall  = n : f : a : let t = n2 : x : traceMarked "${n} ${n2}:" x; in t "result" (f (t "arg 1" a));
+  traceCall2 = n : f : a : b : let t = n2 : x : traceMarked "${n} ${n2}:" x; in t "result" (f (t "arg 1" a) (t "arg 2" b));
+  traceCall3 = n : f : a : b : c : let t = n2 : x : traceMarked "${n} ${n2}:" x; in t "result" (f (t "arg 1" a) (t "arg 2" b) (t "arg 3" c));
+
+
+
+  innerClosePropagation = ready: list: if list == [] then ready else
+    if (head list) ? propagatedBuildInputs then 
+      innerClosePropagation (ready ++ [(head list)]) 
+        ((head list).propagatedBuildInputs ++ (tail list)) else
+      innerClosePropagation (ready ++ [(head list)]) (tail list);
+
+  closePropagation = list: (uniqList {inputList = (innerClosePropagation [] list);});
+
+  # calls a function (f attr value ) for each record item. returns a list
+  # should be renamed to mapAttrsFlatten
+  mapRecordFlatten = f : r : map (attr: f attr (builtins.getAttr attr r) ) (attrNames r);
+
+  # maps a function on each attr value
+  # f = attr : value : ..
+  mapAttrs = f : r : listToAttrs ( mapRecordFlatten (a : v : nv a ( f a v ) )  r);
+
+  # to be used with listToAttrs (_a_ttribute _v_alue)
+  nv = name : value : { inherit name value; };
+  # attribute set containing one attribute
+  nvs = name : value : listToAttrs [ (nv 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));
+
+  # iterates over a list of attributes collecting the attribute attr if it exists
+  catAttrs = attr : l : fold ( s : l : if (hasAttr attr s) then [(builtins.getAttr attr s)] ++ l else l) [] l;
+
+  attrVals = nameList : attrSet :
+    map (x: builtins.getAttr x attrSet) nameList;
+
+  # 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 (__hasAttr n set) 
+                        then setAttr set n (f (__getAttr n set) (__getAttr n set2))
+                        else set )
+           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 exisits 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 does'nt 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
+  # ! depreceated, use mergeAttrByFunc instead
+  mergeAttrsNoOverride = { mergeLists ? ["buildInputs" "propagatedBuildInputs"],
+                           overrideSnd ? [ "buildPhase" ]
+                         } : attrs1 : attrs2 :
+    fold (n: set : 
+        setAttr set n ( if (__hasAttr n set) 
+            then # merge 
+              if elem n mergeLists # attribute contains list, merge them by concatenating
+                then (__getAttr n attrs2) ++ (__getAttr n attrs1)
+              else if elem n overrideSnd
+                then __getAttr n attrs1
+              else throw "error mergeAttrsNoOverride, attribute ${n} given in both attributes - no merge func defined"
+            else __getAttr n attrs2 # 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 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 (__hasAttr a x)
+             then if (__hasAttr a y)
+               then v (__getAttr a x) (__getAttr a y) # both have attr, use merge func
+               else (__getAttr a x) # only x has attr
+             else (__getAttr a y) # only y has attr)
+          ) (removeAttrs mergeAttrBy2
+                         # don't merge attrs which are neither in x nor y
+                         (filter (a : (! __hasAttr a x) && (! __hasAttr a y) )
+                                 (__attrNames mergeAttrBy2))
+            )
+      )
+    ];
+  mergeAttrsByFuncDefaults = foldl mergeAttrByFunc { inherit mergeAttrBy; };
+  # sane defaults (same name as attr name so that inherit can be used)
+  mergeAttrBy = # { buildInputs = concatList; [...]; passthru = mergeAttr; [..]; }
+    listToAttrs (map (n : nv n lib.concat) [ "buildInputs" "propagatedBuildInputs" "configureFlags" "prePhases" "postAll" ])
+    // listToAttrs (map (n : nv n lib.mergeAttrs) [ "passthru" "meta" "cfg" "flags" ]);
+
+  # returns atribute values as a list 
+  flattenAttrs = set : map ( attr : builtins.getAttr attr set) (attrNames set);
+  mapIf = cond : f :  fold ( x : l : if (cond x) then [(f x)] ++ l else l) [];
+
+  # pick attrs subset_attr_names and apply f 
+  subsetmap = f : attrs : subset_attr_names : 
+    listToAttrs (fold ( attr : r : if __hasAttr attr attrs
+          then r ++ [ (  nv attr ( f (__getAttr attr attrs) ) ) ] else r ) []
+      subset_attr_names );
+
+  # 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?
+  prepareDerivationArgs = args:
+    let args2 = { cfg = {}; flags = {}; } // args;
+        flagName = name : "${name}Support";
+        cfgWithDefaults = (listToAttrs (map (n : nv (flagName n) false) (attrNames args2.flags)))
+                          // args2.cfg;
+        opts = flattenAttrs (mapAttrs (a : v :
+                let v2 = if (v ? set || v ? unset) then v else { set = v; };
+                    n = if (__getAttr (flagName a) cfgWithDefaults) 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" "fixed" ]; # fixed may be passed as fix argument or such
+
+
+}
\ No newline at end of file