nixpkgs/lib/lists.nix

# General list operations.

with import ./trivial.nix;

rec {

  inherit (builtins) head tail length isList elemAt concatLists filter elem genList;

  /*  Create a list consisting of a single element.  `singleton x' is
      sometimes more convenient with respect to indentation than `[x]'
      when x spans multiple lines.

      Example:
        singleton "foo"
        => [ "foo" ]
  */
  singleton = x: [x];

  /* "Fold" a binary function `op' between successive elements of
     `list' with `nul' as the starting value, i.e., `fold op nul [x_1
     x_2 ... x_n] == op x_1 (op x_2 ... (op x_n nul))'.  (This is
     Haskell's foldr).

     Example:
       concat = fold (a: b: a + b) "z"
       concat [ "a" "b" "c" ]
       => "abcz"
  */
  fold = op: nul: list:
    let
      len = length list;
      fold' = n:
        if n == len
        then nul
        else op (elemAt list n) (fold' (n + 1));
    in fold' 0;

  /* Left fold: `fold op nul [x_1 x_2 ... x_n] == op (... (op (op nul
     x_1) x_2) ... x_n)'.

     Example:
       lconcat = foldl (a: b: a + b) "z"
       lconcat [ "a" "b" "c" ]
       => "zabc"
  */
  foldl = op: nul: list:
    let
      len = length list;
      foldl' = n:
        if n == -1
        then nul
        else op (foldl' (n - 1)) (elemAt list n);
    in foldl' (length list - 1);

  /* Strict version of foldl.

     The difference is that evaluation is forced upon access. Usually used
     with small whole results (in contract with lazily-generated list or large
     lists where only a part is consumed.)
  */
  foldl' = builtins.foldl' or foldl;

  /* Map with index

     FIXME(zimbatm): why does this start to count at 1?

     Example:
       imap (i: v: "${v}-${toString i}") ["a" "b"]
       => [ "a-1" "b-2" ]
  */
  imap = f: list: genList (n: f (n + 1) (elemAt list n)) (length list);

  /* Map and concatenate the result.

     Example:
       concatMap (x: [x] ++ ["z"]) ["a" "b"]
       => [ "a" "z" "b" "z" ]
  */
  concatMap = f: list: concatLists (map f list);

  /* Flatten the argument into a single list; that is, nested lists are
     spliced into the top-level lists.

     Example:
       flatten [1 [2 [3] 4] 5]
       => [1 2 3 4 5]
       flatten 1
       => [1]
  */
  flatten = x:
    if isList x
    then foldl' (x: y: x ++ (flatten y)) [] x
    else [x];

  /* Remove elements equal to 'e' from a list.  Useful for buildInputs.

     Example:
       remove 3 [ 1 3 4 3 ]
       => [ 1 4 ]
  */
  remove = e: filter (x: x != e);

  /* Find the sole element in the list matching the specified
     predicate, returns `default' if no such element exists, or
     `multiple' if there are multiple matching elements.

     Example:
       findSingle (x: x == 3) "none" "multiple" [ 1 3 3 ]
       => "multiple"
       findSingle (x: x == 3) "none" "multiple" [ 1 3 ]
       => 3
       findSingle (x: x == 3) "none" "multiple" [ 1 9 ]
       => "none"
  */
  findSingle = pred: default: multiple: list:
    let found = filter pred list; len = length found;
    in if len == 0 then default
      else if len != 1 then multiple
      else head found;

  /* Find the first element in the list matching the specified
     predicate or returns `default' if no such element exists.

     Example:
       findFirst (x: x > 3) 7 [ 1 6 4 ]
       => 6
       findFirst (x: x > 9) 7 [ 1 6 4 ]
       => 7
  */
  findFirst = pred: default: list:
    let found = filter pred list;
    in if found == [] then default else head found;

  /* Return true iff function `pred' returns true for at least element
     of `list'.

     Example:
       any isString [ 1 "a" { } ]
       => true
       any isString [ 1 { } ]
       => false
  */
  any = builtins.any or (pred: fold (x: y: if pred x then true else y) false);

  /* Return true iff function `pred' returns true for all elements of
     `list'.

     Example:
       all (x: x < 3) [ 1 2 ]
       => true
       all (x: x < 3) [ 1 2 3 ]
       => false
  */
  all = builtins.all or (pred: fold (x: y: if pred x then y else false) true);

  /* Count how many times function `pred' returns true for the elements
     of `list'.

     Example:
       count (x: x == 3) [ 3 2 3 4 6 ]
       => 2
  */
  count = pred: foldl' (c: x: if pred x then c + 1 else c) 0;

  /* Return a singleton list or an empty list, depending on a boolean
     value.  Useful when building lists with optional elements
     (e.g. `++ optional (system == "i686-linux") flashplayer').

     Example:
       optional true "foo"
       => [ "foo" ]
       optional false "foo"
       => [ ]
  */
  optional = cond: elem: if cond then [elem] else [];

  /* Return a list or an empty list, dependening on a boolean value.

     Example:
       optionals true [ 2 3 ]
       => [ 2 3 ]
       optionals false [ 2 3 ]
       => [ ]
  */
  optionals = cond: elems: if cond then elems else [];


  /* If argument is a list, return it; else, wrap it in a singleton
     list.  If you're using this, you should almost certainly
     reconsider if there isn't a more "well-typed" approach.

     Example:
       toList [ 1 2 ]
       => [ 1 2 ]
       toList "hi"
       => [ "hi "]
  */
  toList = x: if isList x then x else [x];

  /* Return a list of integers from `first' up to and including `last'.

     Example:
       range 2 4
       => [ 2 3 4 ]
       range 3 2
       => [ ]
  */
  range = first: last:
    if first > last then
      []
    else
      genList (n: first + n) (last - first + 1);

  /* Splits the elements of a list in two lists, `right' and
     `wrong', depending on the evaluation of a predicate.

     Example:
       partition (x: x > 2) [ 5 1 2 3 4 ]
       => { right = [ 5 3 4 ]; wrong = [ 1 2 ]; }
  */
  partition = pred:
    fold (h: t:
      if pred h
      then { right = [h] ++ t.right; wrong = t.wrong; }
      else { right = t.right; wrong = [h] ++ t.wrong; }
    ) { right = []; wrong = []; };

  /* Merges two lists of the same size together. If the sizes aren't the same
     the merging stops at the shortest. How both lists are merged is defined
     by the first argument.

     Example:
       zipListsWith (a: b: a + b) ["h" "l"] ["e" "o"]
       => ["he" "lo"]
  */
  zipListsWith = f: fst: snd:
    genList
      (n: f (elemAt fst n) (elemAt snd n)) (min (length fst) (length snd));

  /* Merges two lists of the same size together. If the sizes aren't the same
     the merging stops at the shortest.

     Example:
       zipLists [ 1 2 ] [ "a" "b" ]
       => [ { fst = 1; snd = "a"; } { fst = 2; snd = "b"; } ]
  */
  zipLists = zipListsWith (fst: snd: { inherit fst snd; });

  /* Reverse the order of the elements of a list.

     Example:

       reverseList [ "b" "o" "j" ]
       => [ "j" "o" "b" ]
  */
  reverseList = xs:
    let l = length xs; in genList (n: elemAt xs (l - n - 1)) l;

  /* Sort a list based on a comparator function which compares two
     elements and returns true if the first argument is strictly below
     the second argument.  The returned list is sorted in an increasing
     order.  The implementation does a quick-sort.

     Example:
       sort (a: b: a < b) [ 5 3 7 ]
       => [ 3 5 7 ]
  */
  sort = builtins.sort or (
    strictLess: list:
    let
      len = length list;
      first = head list;
      pivot' = n: acc@{ left, right }: let el = elemAt list n; next = pivot' (n + 1); in
        if n == len
          then acc
        else if strictLess first el
          then next { inherit left; right = [ el ] ++ right; }
        else
          next { left = [ el ] ++ left; inherit right; };
      pivot = pivot' 1 { left = []; right = []; };
    in
      if len < 2 then list
      else (sort strictLess pivot.left) ++  [ first ] ++  (sort strictLess pivot.right));

  /* Return the first (at most) N elements of a list.

     Example:
       take 2 [ "a" "b" "c" "d" ]
       => [ "a" "b" ]
       take 2 [ ]
       => [ ]
  */
  take = count: sublist 0 count;

  /* Remove the first (at most) N elements of a list.

     Example:
       drop 2 [ "a" "b" "c" "d" ]
       => [ "c" "d" ]
       drop 2 [ ]
       => [ ]
  */
  drop = count: list: sublist count (length list) list;

  /* Return a list consisting of at most ‘count’ elements of ‘list’,
     starting at index ‘start’.

     Example:
       sublist 1 3 [ "a" "b" "c" "d" "e" ]
       => [ "b" "c" "d" ]
       sublist 1 3 [ ]
       => [ ]
  */
  sublist = start: count: list:
    let len = length list; in
    genList
      (n: elemAt list (n + start))
      (if start >= len then 0
       else if start + count > len then len - start
       else count);

  /* Return the last element of a list.

     Example:
       last [ 1 2 3 ]
       => 3
  */
  last = list:
    assert list != []; elemAt list (length list - 1);

  /* Return all elements but the last

     Example:
       init [ 1 2 3 ]
       => [ 1 2 ]
  */
  init = list: assert list != []; take (length list - 1) list;


  /* FIXME(zimbatm) Not used anywhere
   */
  crossLists = f: foldl (fs: args: concatMap (f: map f args) fs) [f];


  /* Remove duplicate elements from the list. O(n^2) complexity.

     Example:

       unique [ 3 2 3 4 ]
       => [ 3 2 4 ]
   */
  unique = list:
    if list == [] then
      []
    else
      let
        x = head list;
        xs = unique (drop 1 list);
      in [x] ++ remove x xs;

  /* Intersects list 'e' and another list. O(nm) complexity.

     Example:
       intersectLists [ 1 2 3 ] [ 6 3 2 ]
       => [ 3 2 ]
  */
  intersectLists = e: filter (x: elem x e);

  /* Subtracts list 'e' from another list. O(nm) complexity.

     Example:
       subtractLists [ 3 2 ] [ 1 2 3 4 5 3 ]
       => [ 1 4 5 ]
  */
  subtractLists = e: filter (x: !(elem x e));

  /*** deprecated stuff ***/

  deepSeqList = throw "removed 2016-02-29 because unused and broken";

}