···

       
19
       
19
       
 
       
  traceXMLVal = x: trace (builtins.toXML x) x;

     

       
20
       
20
       
 
       
  traceXMLValMarked = str: x: trace (str + builtins.toXML x) x;

     

       
21
       
21
       
 
       


     

       
22
       
22
       
+
       
  # strict trace functions (traced structure is fully evaluated and printed)

     

       
23
       
23
       
+
       
  traceSeq = x: y: trace (builtins.deepSeq x x) y;

     

       
24
       
24
       
+
       
  traceValSeq = v: traceVal (builtins.deepSeq v v);

     

       
25
       
25
       
+
       


     

       
22
       
26
       
 
       
  # this can help debug your code as well - designed to not produce thousands of lines

     

       
23
       
27
       
 
       
  traceShowVal = x : trace (showVal x) x;

     

       
24
       
28
       
 
       
  traceShowValMarked = str: x: trace (str + showVal x) x;

     
···

       
69
       
73
       
 
       
  # usage: { testX = allTrue [ true ]; }

     

       
70
       
74
       
 
       
  testAllTrue = expr : { inherit expr; expected = map (x: true) expr; };

     

       
71
       
75
       
 
       


     

       
72
       
72
       
-
       
  # evaluate everything once so that errors will occur earlier

     

       
73
       
73
       
-
       
  # hacky: traverse attrs by adding a dummy

     

       
74
       
74
       
-
       
  # ignores functions (should this behavior change?) See strictf

     

       
75
       
75
       
-
       
  #

     

       
76
       
76
       
-
       
  # Note: This should be a primop! Something like seq of haskell would be nice to

     

       
77
       
77
       
-
       
  # have as well. It's used fore debugging only anyway

     

       
78
       
78
       
-
       
  strict = x :

     

       
79
       
79
       
-
       
    let

     

       
80
       
80
       
-
       
        traverse = x :

     

       
81
       
81
       
-
       
          if isString x then true

     

       
82
       
82
       
-
       
          else if isAttrs x then

     

       
83
       
83
       
-
       
            if x ? outPath then true

     

       
84
       
84
       
-
       
            else all id (mapAttrsFlatten (n: traverse) x)

     

       
85
       
85
       
-
       
          else if isList x then

     

       
86
       
86
       
-
       
            all id (map traverse x)

     

       
87
       
87
       
-
       
          else if isBool x then true

     

       
88
       
88
       
-
       
          else if isFunction x then true

     

       
89
       
89
       
-
       
          else if isInt x then true

     

       
90
       
90
       
-
       
          else if x == null then true

     

       
91
       
91
       
-
       
          else true; # a (store) path?

     

       
92
       
92
       
-
       
    in if traverse x then x else throw "else never reached";

     

       
76
       
76
       
+
       
  strict = v:

     

       
77
       
77
       
+
       
    trace "Warning: strict is deprecated and will be removed in the next release"

     

       
78
       
78
       
+
       
      (builtins.seq v v);

     

       
93
       
79
       
 
       


     

       
94
       
80
       
 
       
  # example: (traceCallXml "myfun" id 3) will output something like

     

       
95
       
81
       
 
       
  # calling myfun arg 1: 3 result: 3