commit 6c2bf141cf87d62cc8e79a155b12d3382dd10558 · pyrox.dev/nixpkgs

+20 -28

lib/lists.nix

···

       2
       2
        
       

     

       3
       3
        
       with import ./trivial.nix;

     

       4
       4
        
       

     

       5
       5
       -
       let

     

       6
       6
       -
       

     

       7
       7
       -
         inc = builtins.add 1;

     

       8
       8
       -
       

     

       9
       9
       -
         dec = n: builtins.sub n 1;

     

       10
       10
       -
       

     

       11
       11
       -
       in rec {

     

       5
       5
       +
       rec {

     

       12
       6
        
       

     

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

     

       14
       8
        
       

     
···

       29
       23
        
             fold' = n:

     

       30
       24
        
               if n == len

     

       31
       25
        
               then nul

     

       32
       32
       -
               else op (elemAt list n) (fold' (inc n));

     

       26
       26
       +
               else op (elemAt list n) (fold' (n + 1));

     

       33
       27
        
           in fold' 0;

     

       34
       28
        
       

     

       35
       29
        
         # Left fold: `fold op nul [x_1 x_2 ... x_n] == op (... (op (op nul

     
···

       38
       32
        
           let

     

       39
       33
        
             len = length list;

     

       40
       34
        
             foldl' = n:

     

       41
       41
       -
               if n == minus1

     

       35
       35
       +
               if n == -1

     

       42
       36
        
               then nul

     

       43
       43
       -
               else op (foldl' (dec n)) (elemAt list n);

     

       44
       44
       -
           in foldl' (dec (length list));

     

       45
       45
       -
       

     

       46
       46
       -
         minus1 = dec 0;

     

       37
       37
       +
               else op (foldl' (n - 1)) (elemAt list n);

     

       38
       38
       +
           in foldl' (length list - 1);

     

       47
       39
        
       

     

       48
       40
        
       

     

       49
       41
        
         # map with index: `imap (i: v: "${v}-${toString i}") ["a" "b"] ==

     
···

       54
       46
        
             imap' = n:

     

       55
       47
        
               if n == len

     

       56
       48
        
                 then []

     

       57
       57
       -
                 else [ (f (inc n) (elemAt list n)) ] ++ imap' (inc n);

     

       49
       49
       +
                 else [ (f (n + 1) (elemAt list n)) ] ++ imap' (n + 1);

     

       58
       50
        
           in imap' 0;

     

       59
       51
        
       

     

       60
       52
        
       

     
···

       104
       96
        
       

     

       105
       97
        
         # Count how many times function `pred' returns true for the elements

     

       106
       98
        
         # of `list'.

     

       107
       107
       -
         count = pred: fold (x: c: if pred x then inc c else c) 0;

     

       99
       99
       +
         count = pred: fold (x: c: if pred x then c + 1 else c) 0;

     

       108
       100
        
       

     

       109
       101
        
       

     

       110
       102
        
         # Return a singleton list or an empty list, depending on a boolean

     
···

       125
       117
        
       

     

       126
       118
        
         # Return a list of integers from `first' up to and including `last'.

     

       127
       119
        
         range = first: last:

     

       128
       128
       -
           if lessThan last first

     

       120
       120
       +
           if last < first

     

       129
       121
        
           then []

     

       130
       130
       -
           else [first] ++ range (add first 1) last;

     

       122
       122
       +
           else [first] ++ range (first + 1) last;

     

       131
       123
        
       

     

       132
       124
        
       

     

       133
       125
        
         # Partition the elements of a list in two lists, `right' and

     
···

       144
       136
        
           let

     

       145
       137
        
             len1 = length fst;

     

       146
       138
        
             len2 = length snd;

     

       147
       147
       -
             len = if lessThan len1 len2 then len1 else len2;

     

       139
       139
       +
             len = if len1 < len2 then len1 else len2;

     

       148
       140
        
             zipListsWith' = n:

     

       149
       141
        
               if n != len then

     

       150
       142
        
                 [ (f (elemAt fst n) (elemAt snd n)) ]

     

       151
       151
       -
                 ++ zipListsWith' (inc n)

     

       143
       143
       +
                 ++ zipListsWith' (n + 1)

     

       152
       144
        
               else [];

     

       153
       145
        
           in zipListsWith' 0;

     

       154
       146
        
       

     
···

       167
       159
        
           let

     

       168
       160
        
             len = length list;

     

       169
       161
        
             first = head list;

     

       170
       170
       -
             pivot' = n: acc@{ left, right }: let el = elemAt list n; next = pivot' (inc n); in

     

       162
       162
       +
             pivot' = n: acc@{ left, right }: let el = elemAt list n; next = pivot' (n + 1); in

     

       171
       163
        
               if n == len

     

       172
       164
        
                 then acc

     

       173
       165
        
               else if strictLess first el

     
···

       176
       168
        
                 next { left = [ el ] ++ left; inherit right; };

     

       177
       169
        
             pivot = pivot' 1 { left = []; right = []; };

     

       178
       170
        
           in

     

       179
       179
       -
             if lessThan len 2 then list

     

       171
       171
       +
             if len < 2 then list

     

       180
       172
        
             else (sort strictLess pivot.left) ++  [ first ] ++  (sort strictLess pivot.right);

     

       181
       173
        
       

     

       182
       174
        
       

     
···

       188
       180
        
               if n == len || n == count

     

       189
       181
        
                 then []

     

       190
       182
        
               else

     

       191
       191
       -
                 [ (elemAt list n) ] ++ take' (inc n);

     

       183
       183
       +
                 [ (elemAt list n) ] ++ take' (n + 1);

     

       192
       184
        
           in take' 0;

     

       193
       185
        
       

     

       194
       186
        
       

     
···

       197
       189
        
           let

     

       198
       190
        
             len = length list;

     

       199
       191
        
             drop' = n:

     

       200
       200
       -
               if n == minus1 || lessThan n count

     

       192
       192
       +
               if n == -1 || n < count

     

       201
       193
        
                 then []

     

       202
       194
        
               else

     

       203
       203
       -
                 drop' (dec n) ++ [ (elemAt list n) ];

     

       204
       204
       -
           in drop' (dec len);

     

       195
       195
       +
                 drop' (n - 1) ++ [ (elemAt list n) ];

     

       196
       196
       +
           in drop' (len - 1);

     

       205
       197
        
       

     

       206
       198
        
       

     

       207
       199
        
         # Return the last element of a list.

     

       208
       200
        
         last = list:

     

       209
       209
       -
           assert list != []; elemAt list (dec (length list));

     

       201
       201
       +
           assert list != []; elemAt list (length list - 1);

     

       210
       202
        
       

     

       211
       203
        
       

     

       212
       204
        
         # Return all elements but the last

     
···

       218
       210
        
           let

     

       219
       211
        
             len1 = length xs;

     

       220
       212
        
             len2 = length ys;

     

       221
       221
       -
             len = if lessThan len1 len2 then len1 else len2;

     

       213
       213
       +
             len = if len1 < len2 then len1 else len2;

     

       222
       214
        
             zipTwoLists' = n:

     

       223
       215
        
               if n != len then

     

       224
       216
        
                 [ { first = elemAt xs n; second = elemAt ys n; } ]

     

       225
       225
       -
                 ++ zipTwoLists' (inc n)

     

       217
       217
       +
                 ++ zipTwoLists' (n + 1)

     

       226
       218
        
               else [];

     

       227
       219
        
           in zipTwoLists' 0;

     

       228
       220

+1 -1

lib/modules.nix

···

       278
       278
        
           let

     

       279
       279
        
             defaultPrio = 100;

     

       280
       280
        
             getPrio = def: if def.value._type or "" == "override" then def.value.priority else defaultPrio;

     

       281
       281
       -
             min = x: y: if builtins.lessThan x y then x else y;

     

       281
       281
       +
             min = x: y: if x < y then x else y;

     

       282
       282
        
             highestPrio = fold (def: prio: min (getPrio def) prio) 9999 defs;

     

       283
       283
        
             strip = def: if def.value._type or "" == "override" then def // { value = def.value.content; } else def;

     

       284
       284
        
           in concatMap (def: if getPrio def == highestPrio then [(strip def)] else []) defs;

+8 -8

lib/strings.nix

···

       2
       2
        
       

     

       3
       3
        
       let lib = import ./default.nix;

     

       4
       4
        
       

     

       5
       5
       -
       inherit (builtins) add sub lessThan length;

     

       5
       5
       +
       inherit (builtins) length;

     

       6
       6
        
       

     

       7
       7
        
       in

     

       8
       8
        
       

     
···

       79
       79
        
         stringToCharacters = s: let l = stringLength s; in

     

       80
       80
        
           if l == 0

     

       81
       81
        
           then []

     

       82
       82
       -
           else map (p: substring p 1 s) (lib.range 0 (sub l 1));

     

       82
       82
       +
           else map (p: substring p 1 s) (lib.range 0 (l - 1));

     

       83
       83
        
       

     

       84
       84
        
       

     

       85
       85
        
         # Manipulate a string charcater by character and replace them by strings

     
···

       123
       123
        
         toUpper = replaceChars lowerChars upperChars;

     

       124
       124
        
       

     

       125
       125
        
         # Appends string context from another string

     

       126
       126
       -
         addContextFrom = a: b: (substring 0 0 a)+b;

     

       126
       126
       +
         addContextFrom = a: b: substring 0 0 a + b;

     

       127
       127
        
       

     

       128
       128
        
         # Compares strings not requiring context equality

     

       129
       129
        
         # Obviously, a workaround but works on all Nix versions

     
···

       139
       139
        
             s = addContextFrom _sep _s;

     

       140
       140
        
             sepLen = stringLength sep;

     

       141
       141
        
             sLen = stringLength s;

     

       142
       142
       -
             lastSearch = sub sLen sepLen;

     

       142
       142
       +
             lastSearch = sLen - sepLen;

     

       143
       143
        
             startWithSep = startAt:

     

       144
       144
        
               substring startAt sepLen s == sep;

     

       145
       145
        
       

     

       146
       146
        
             recurse = index: startAt:

     

       147
       147
       -
               let cutUntil = i: [(substring startAt (sub i startAt) s)]; in

     

       148
       148
       -
               if lessThan index lastSearch then

     

       147
       147
       +
               let cutUntil = i: [(substring startAt (i - startAt) s)]; in

     

       148
       148
       +
               if index < lastSearch then

     

       149
       149
        
                 if startWithSep index then

     

       150
       150
       -
                   let restartAt = add index sepLen; in

     

       150
       150
       +
                   let restartAt = index + sepLen; in

     

       151
       151
        
                   cutUntil index ++ recurse restartAt restartAt

     

       152
       152
        
                 else

     

       153
       153
       -
                   recurse (add index 1) startAt

     

       153
       153
       +
                   recurse (index + 1) startAt

     

       154
       154
        
               else

     

       155
       155
        
                 cutUntil sLen;

     

       156
       156
        
           in

+1 -1

lib/systems.nix

···

       24
       24
        
       

     

       25
       25
        
         isCpuType = x: isType "cpu-type" x

     

       26
       26
        
           && elem x.bits [8 16 32 64 128]

     

       27
       27
       -
           && (builtins.lessThan 8 x.bits -> isSignificantByte x.significantByte);

     

       27
       27
       +
           && (8 < x.bits -> isSignificantByte x.significantByte);

     

       28
       28
        
       

     

       29
       29
        
         cpuTypes = with significantBytes;

     

       30
       30
        
           setTypes "cpu-type" {