anchor.diff:      in trace (generators.toPretty { allowPrettyValues = true; }
                  (modify depth snip x)) y;
   
  -  /* A combination of `traceVal` and `traceSeq` */
  -  traceValSeqFn = f: v: traceValFn f (builtins.deepSeq v v);
  +  /* A combination of `traceVal` and `traceSeq` that applies a
  +     provided function to the value to be traced after `deepSeq`ing
  +     it.
  +  */
  +  traceValSeqFn =
  +    # Function to apply
  +    f:
  +    # Value to trace
  +    v: traceValFn f (builtins.deepSeq v v);
  +
  +  /* A combination of `traceVal` and `traceSeq`. */
     traceValSeq = traceValSeqFn id;
   
  +  /* A combination of `traceVal` and `traceSeqN` that applies a
  +  provided function to the value to be traced. */
  +  traceValSeqNFn =
  +    # Function to apply
  +    f:
  +    depth:
  +    # Value to trace
  +    v: traceSeqN depth (f v) v;
  +
     /* A combination of `traceVal` and `traceSeqN`. */
  -  traceValSeqNFn = f: depth: v: traceSeqN depth (f v) v;
     traceValSeqN = traceValSeqNFn id;
   
   
     # -- TESTING --
   
  -  /* Evaluate a set of tests.  A test is an attribute set {expr,
  -     expected}, denoting an expression and its expected result.  The
  -     result is a list of failed tests, each represented as {name,
  -     expected, actual}, denoting the attribute name of the failing
  -     test and its expected and actual results.  Used for regression
  -     testing of the functions in lib; see tests.nix for an example.
  -     Only tests having names starting with "test" are run.
  -     Add attr { tests = ["testName"]; } to run these test only
  -  */
  -  runTests = tests: lib.concatLists (lib.attrValues (lib.mapAttrs (name: test:
  +  /* Evaluate a set of tests.  A test is an attribute set `{expr,
  +     expected}`, denoting an expression and its expected result.  The
  +     result is a list of failed tests, each represented as `{name,
  +     expected, actual}`, denoting the attribute name of the failing
  +     test and its expected and actual results.
  +
  +     Used for regression testing of the functions in lib; see
  +     tests.nix for an example. Only tests having names starting with
  +     "test" are run.
  +
  +     Add attr { tests = ["testName"]; } to run these tests only.
  +  */
  +  runTests =
  +    # Tests to run
  +    tests: lib.concatLists (lib.attrValues (lib.mapAttrs (name: test:
       let testsToRun = if tests ? tests then tests.tests else [];
       in if (substring 0 4 name == "test" ||  elem name testsToRun)
          && ((testsToRun == []) || elem name tests.tests)
  
positive.code:       then [ { inherit name; expected = test.expected; result = test.expr; } ]
        else [] ) tests));
  
    # create a test assuming that list elements are true
    # usage: { testX = allTrue [ true ]; }
    testAllTrue = expr: { inherit expr; expected = map (x: true) expr; };
  
  
  
negative.code:        trace: { a = { b = { c = 3; }; }; }
         => null
    */
    traceSeq =
      # The value to trace
      x:
      # The value to return
      y: trace (builtins.deepSeq x x) y;
  
    /* Like `traceSeq`, but only evaluate down to depth n.
       This is very useful because lots of `traceSeq` usages
  