commit feb8cbdc38c6b10b2c66a96151d8d560e960c29f · pyrox.dev/nixpkgs

+24
lib/debug.nix
···

       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
       +
       

     

       24
       24
       +
         /* `builtins.trace`, but the value is `builtins.deepSeq`ed first. */

     

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

     

       26
       26
       +
       

     

       27
       27
       +
         /* Like `traceSeq`, but only down to depth n.

     

       28
       28
       +
          * This is very useful because lots of `traceSeq` usages

     

       29
       29
       +
          * lead to an infinite recursion.

     

       30
       30
       +
          */

     

       31
       31
       +
         traceSeqN = depth: x: y: with lib;

     

       32
       32
       +
           let snip = v: if      isList  v then noQuotes "[…]" v

     

       33
       33
       +
                         else if isAttrs v then noQuotes "{…}" v

     

       34
       34
       +
                         else v;

     

       35
       35
       +
               noQuotes = str: v: { __pretty = const str; val = v; };

     

       36
       36
       +
               modify = n: fn: v: if (n == 0) then fn v

     

       37
       37
       +
                             else if isList  v then map (modify (n - 1) fn) v

     

       38
       38
       +
                             else if isAttrs v then mapAttrs

     

       39
       39
       +
                               (const (modify (n - 1) fn)) v

     

       40
       40
       +
                             else v;

     

       41
       41
       +
           in trace (generators.toPretty { allowPrettyValues = true; }

     

       42
       42
       +
                      (modify depth snip x)) y;

     

       43
       43
       +
       

     

       44
       44
       +
         /* `traceSeq`, but the same value is traced and returned */

     

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

     

       46
       46
       +
         /* `traceValSeq` but with fixed depth */

     

       47
       47
       +
         traceValSeqN = depth: v: traceSeqN depth v v;

     

       48
       48
       +
       

     

       25
       49
        
       

     

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

     

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