[backport] run nimpretty on numbers stuff

6 files changed, 189 insertions, 173 deletions

diff --git a/lib/pure/algorithm.nim b/lib/pure/algorithm.nim
index 002cb3a7a..5d157dfc8 100644
--- a/lib/pure/algorithm.nim
+++ b/lib/pure/algorithm.nim
@@ -172,8 +172,8 @@ proc binarySearch*[T, K](a: openArray[T], key: K,
   ## ``cmp`` is the comparator function to use, the expected return values are
   ## the same as that of system.cmp.
   runnableExamples:
-    assert binarySearch(["a","b","c","d"], "d", system.cmp[string]) == 3
-    assert binarySearch(["a","b","d","c"], "d", system.cmp[string]) == 2
+    assert binarySearch(["a", "b", "c", "d"], "d", system.cmp[string]) == 3
+    assert binarySearch(["a", "b", "d", "c"], "d", system.cmp[string]) == 2
   if a.len == 0:
     return -1
 
@@ -228,7 +228,8 @@ proc smartBinarySearch*[T](a: openArray[T], key: T): int {.deprecated:
 const
   onlySafeCode = true
 
-proc lowerBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {.closure.}): int =
+proc lowerBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {.
+    closure.}): int =
   ## Returns a position to the first element in the ``a`` that is greater than
   ## ``key``, or last if no such element is found.
   ## In other words if you have a sorted sequence and you call
@@ -244,12 +245,12 @@ proc lowerBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {.clo
   ## * `upperBound proc<#upperBound,openArray[T],K,proc(T,K)>`_ sorted by ``cmp`` in the specified order
   ## * `upperBound proc<#upperBound,openArray[T],T>`_
   runnableExamples:
-    var arr = @[1,2,3,5,6,7,8,9]
+    var arr = @[1, 2, 3, 5, 6, 7, 8, 9]
     assert arr.lowerBound(3, system.cmp[int]) == 2
     assert arr.lowerBound(4, system.cmp[int]) == 3
     assert arr.lowerBound(5, system.cmp[int]) == 3
     arr.insert(4, arr.lowerBound(4, system.cmp[int]))
-    assert arr == [1,2,3,4,5,6,7,8,9]
+    assert arr == [1, 2, 3, 4, 5, 6, 7, 8, 9]
   result = a.low
   var count = a.high - a.low + 1
   var step, pos: int
@@ -275,7 +276,8 @@ proc lowerBound*[T](a: openArray[T], key: T): int = lowerBound(a, key, cmp[T])
   ## * `upperBound proc<#upperBound,openArray[T],K,proc(T,K)>`_ sorted by ``cmp`` in the specified order
   ## * `upperBound proc<#upperBound,openArray[T],T>`_
 
-proc upperBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {.closure.}): int =
+proc upperBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {.
+    closure.}): int =
   ## Returns a position to the first element in the ``a`` that is not less
   ## (i.e. greater or equal to) than ``key``, or last if no such element is found.
   ## In other words if you have a sorted sequence and you call
@@ -291,12 +293,12 @@ proc upperBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {.clo
   ## * `lowerBound proc<#lowerBound,openArray[T],K,proc(T,K)>`_ sorted by ``cmp`` in the specified order
   ## * `lowerBound proc<#lowerBound,openArray[T],T>`_
   runnableExamples:
-    var arr = @[1,2,3,5,6,7,8,9]
+    var arr = @[1, 2, 3, 5, 6, 7, 8, 9]
     assert arr.upperBound(2, system.cmp[int]) == 2
     assert arr.upperBound(3, system.cmp[int]) == 3
     assert arr.upperBound(4, system.cmp[int]) == 3
     arr.insert(4, arr.upperBound(3, system.cmp[int]))
-    assert arr == [1,2,3,4,5,6,7,8,9]
+    assert arr == [1, 2, 3, 4, 5, 6, 7, 8, 9]
   result = a.low
   var count = a.high - a.low + 1
   var step, pos: int
@@ -422,7 +424,8 @@ func sort*[T](a: var openArray[T],
       dec(m, s*2)
     s = s*2
 
-proc sort*[T](a: var openArray[T], order = SortOrder.Ascending) = sort[T](a, system.cmp[T], order)
+proc sort*[T](a: var openArray[T], order = SortOrder.Ascending) = sort[T](a,
+    system.cmp[T], order)
   ## Shortcut version of ``sort`` that uses ``system.cmp[T]`` as the comparison function.
   ##
   ## **See also:**
@@ -492,11 +495,13 @@ template sortedByIt*(seq1, op: untyped): untyped =
       p2: Person = (name: "p2", age: 20)
       p3: Person = (name: "p3", age: 30)
       p4: Person = (name: "p4", age: 30)
-      people = @[p1,p2,p4,p3]
+      people = @[p1, p2, p4, p3]
 
-    assert people.sortedByIt(it.name) == @[(name: "p1", age: 60), (name: "p2", age: 20), (name: "p3", age: 30), (name: "p4", age: 30)]
+    assert people.sortedByIt(it.name) == @[(name: "p1", age: 60), (name: "p2",
+        age: 20), (name: "p3", age: 30), (name: "p4", age: 30)]
     # Nested sort
-    assert people.sortedByIt((it.age, it.name)) == @[(name: "p2", age: 20), (name: "p3", age: 30), (name: "p4", age: 30), (name: "p1", age: 60)]
+    assert people.sortedByIt((it.age, it.name)) == @[(name: "p2", age: 20),
+       (name: "p3", age: 30), (name: "p4", age: 30), (name: "p1", age: 60)]
   var result = sorted(seq1, proc(x, y: type(seq1[0])): int =
     var it {.inject.} = x
     let a = op
@@ -529,7 +534,7 @@ func isSorted*[T](a: openArray[T],
     assert isSorted(e) == false
   result = true
   for i in 0..<len(a)-1:
-    if cmp(a[i],a[i+1]) * order > 0:
+    if cmp(a[i], a[i+1]) * order > 0:
       return false
 
 proc isSorted*[T](a: openArray[T], order = SortOrder.Ascending): bool =
@@ -665,19 +670,19 @@ proc prevPermutation*[T](x: var openArray[T]): bool {.discardable.} =
 
 when isMainModule:
   # Tests for lowerBound
-  var arr = @[1,2,3,5,6,7,8,9]
+  var arr = @[1, 2, 3, 5, 6, 7, 8, 9]
   assert arr.lowerBound(0) == 0
   assert arr.lowerBound(4) == 3
   assert arr.lowerBound(5) == 3
   assert arr.lowerBound(10) == 8
-  arr = @[1,5,10]
+  arr = @[1, 5, 10]
   assert arr.lowerBound(4) == 1
   assert arr.lowerBound(5) == 1
   assert arr.lowerBound(6) == 2
   # Tests for isSorted
-  var srt1 = [1,2,3,4,4,4,4,5]
-  var srt2 = ["iello","hello"]
-  var srt3 = [1.0,1.0,1.0]
+  var srt1 = [1, 2, 3, 4, 4, 4, 4, 5]
+  var srt2 = ["iello", "hello"]
+  var srt3 = [1.0, 1.0, 1.0]
   var srt4: seq[int]
   assert srt1.isSorted(cmp) == true
   assert srt2.isSorted(cmp) == false
@@ -686,8 +691,8 @@ when isMainModule:
   var srtseq = newSeq[int]()
   assert srtseq.isSorted(cmp) == true
   # Tests for reversed
-  var arr1 = @[0,1,2,3,4]
-  assert arr1.reversed() == @[4,3,2,1,0]
+  var arr1 = @[0, 1, 2, 3, 4]
+  assert arr1.reversed() == @[4, 3, 2, 1, 0]
   for i in 0 .. high(arr1):
     assert arr1.reversed(0, i) == arr1.reversed()[high(arr1) - i .. high(arr1)]
     assert arr1.reversed(i, high(arr1)) == arr1.reversed()[0 .. high(arr1) - i]
@@ -745,7 +750,8 @@ proc rotatedInternal[T](arg: openArray[T]; first, middle, last: int): seq[T] =
   for i in last ..< arg.len:
     result[i] = arg[i]
 
-proc rotateLeft*[T](arg: var openArray[T]; slice: HSlice[int, int]; dist: int): int {.discardable.} =
+proc rotateLeft*[T](arg: var openArray[T]; slice: HSlice[int, int];
+    dist: int): int {.discardable.} =
   ## Performs a left rotation on a range of elements. If you want to rotate
   ## right, use a negative ``dist``. Specifically, ``rotateLeft`` rotates
   ## the elements at ``slice`` by ``dist`` positions.
@@ -801,7 +807,8 @@ proc rotateLeft*[T](arg: var openArray[T]; dist: int): int {.discardable.} =
   let distLeft = ((dist mod arglen) + arglen) mod arglen
   arg.rotateInternal(0, distLeft, arglen)
 
-proc rotatedLeft*[T](arg: openArray[T]; slice: HSlice[int, int], dist: int): seq[T] =
+proc rotatedLeft*[T](arg: openArray[T]; slice: HSlice[int, int],
+    dist: int): seq[T] =
   ## Same as ``rotateLeft``, just with the difference that it does
   ## not modify the argument. It creates a new ``seq`` instead.
   ##
@@ -858,7 +865,7 @@ when isMainModule:
   doAssert list == expected
   doAssert list2 == @expected
 
-  var s0,s1,s2,s3,s4,s5 = "xxxabcdefgxxx"
+  var s0, s1, s2, s3, s4, s5 = "xxxabcdefgxxx"
 
   doAssert s0.rotateLeft(3 ..< 10, 3) == 7
   doAssert s0 == "xxxdefgabcxxx"
@@ -876,20 +883,22 @@ when isMainModule:
   block product:
     doAssert product(newSeq[seq[int]]()) == newSeq[seq[int]](), "empty input"
     doAssert product(@[newSeq[int](), @[], @[]]) == newSeq[seq[int]](), "bit more empty input"
-    doAssert product(@[@[1,2]]) == @[@[1,2]], "a simple case of one element"
-    doAssert product(@[@[1,2], @[3,4]]) == @[@[2,4],@[1,4],@[2,3],@[1,3]], "two elements"
-    doAssert product(@[@[1,2], @[3,4], @[5,6]]) == @[@[2,4,6],@[1,4,6],@[2,3,6],@[1,3,6], @[2,4,5],@[1,4,5],@[2,3,5],@[1,3,5]], "three elements"
-    doAssert product(@[@[1,2], @[]]) == newSeq[seq[int]](), "two elements, but one empty"
+    doAssert product(@[@[1, 2]]) == @[@[1, 2]], "a simple case of one element"
+    doAssert product(@[@[1, 2], @[3, 4]]) == @[@[2, 4], @[1, 4], @[2, 3], @[1,
+        3]], "two elements"
+    doAssert product(@[@[1, 2], @[3, 4], @[5, 6]]) == @[@[2, 4, 6], @[1, 4, 6],
+        @[2, 3, 6], @[1, 3, 6], @[2, 4, 5], @[1, 4, 5], @[2, 3, 5], @[1, 3, 5]], "three elements"
+    doAssert product(@[@[1, 2], @[]]) == newSeq[seq[int]](), "two elements, but one empty"
 
   block lowerBound:
-    doAssert lowerBound([1,2,4], 3, system.cmp[int]) == 2
-    doAssert lowerBound([1,2,2,3], 4, system.cmp[int]) == 4
-    doAssert lowerBound([1,2,3,10], 11) == 4
+    doAssert lowerBound([1, 2, 4], 3, system.cmp[int]) == 2
+    doAssert lowerBound([1, 2, 2, 3], 4, system.cmp[int]) == 4
+    doAssert lowerBound([1, 2, 3, 10], 11) == 4
 
   block upperBound:
-    doAssert upperBound([1,2,4], 3, system.cmp[int]) == 2
-    doAssert upperBound([1,2,2,3], 3, system.cmp[int]) == 4
-    doAssert upperBound([1,2,3,5], 3) == 3
+    doAssert upperBound([1, 2, 4], 3, system.cmp[int]) == 2
+    doAssert upperBound([1, 2, 2, 3], 3, system.cmp[int]) == 4
+    doAssert upperBound([1, 2, 3, 5], 3) == 3
 
   block fillEmptySeq:
     var s = newSeq[int]()
@@ -901,16 +910,16 @@ when isMainModule:
     let oneData = @[1]
     doAssert binarySearch(oneData, 1) == 0
     doAssert binarySearch(onedata, 7) == -1
-    let someData = @[1,3,4,7]
+    let someData = @[1, 3, 4, 7]
     doAssert binarySearch(someData, 1) == 0
     doAssert binarySearch(somedata, 7) == 3
     doAssert binarySearch(someData, -1) == -1
     doAssert binarySearch(someData, 5) == -1
     doAssert binarySearch(someData, 13) == -1
-    let moreData = @[1,3,5,7,4711]
+    let moreData = @[1, 3, 5, 7, 4711]
     doAssert binarySearch(moreData, -1) == -1
-    doAssert binarySearch(moreData,  1) == 0
-    doAssert binarySearch(moreData,  5) == 2
-    doAssert binarySearch(moreData,  6) == -1
-    doAssert binarySearch(moreData,  4711) == 4
-    doAssert binarySearch(moreData,  4712) == -1
+    doAssert binarySearch(moreData, 1) == 0
+    doAssert binarySearch(moreData, 5) == 2
+    doAssert binarySearch(moreData, 6) == -1
+    doAssert binarySearch(moreData, 4711) == 4
+    doAssert binarySearch(moreData, 4712) == -1
diff --git a/lib/pure/complex.nim b/lib/pure/complex.nim
index 7c669cd6d..6a5e0465e 100644
--- a/lib/pure/complex.nim
+++ b/lib/pure/complex.nim
@@ -62,12 +62,12 @@ proc `==` *[T](x, y: Complex[T]): bool =
   ## Compare two complex numbers ``x`` and ``y`` for equality.
   result = x.re == y.re and x.im == y.im
 
-proc `+` *[T](x: T, y: Complex[T]): Complex[T] =
+proc `+` *[T](x: T; y: Complex[T]): Complex[T] =
   ## Add a real number to a complex number.
   result.re = x + y.re
   result.im = y.im
 
-proc `+` *[T](x: Complex[T], y: T): Complex[T] =
+proc `+` *[T](x: Complex[T]; y: T): Complex[T] =
   ## Add a complex number to a real number.
   result.re = x.re + y
   result.im = x.im
@@ -82,11 +82,11 @@ proc `-` *[T](z: Complex[T]): Complex[T] =
   result.re = -z.re
   result.im = -z.im
 
-proc `-` *[T](x: T, y: Complex[T]): Complex[T] =
+proc `-` *[T](x: T; y: Complex[T]): Complex[T] =
   ## Subtract a complex number from a real number.
   x + (-y)
 
-proc `-` *[T](x: Complex[T], y: T): Complex[T] =
+proc `-` *[T](x: Complex[T]; y: T): Complex[T] =
   ## Subtract a real number from a complex number.
   result.re = x.re - y
   result.im = x.im
@@ -96,12 +96,12 @@ proc `-` *[T](x, y: Complex[T]): Complex[T] =
   result.re = x.re - y.re
   result.im = x.im - y.im
 
-proc `/` *[T](x: Complex[T], y: T): Complex[T] =
+proc `/` *[T](x: Complex[T]; y: T): Complex[T] =
   ## Divide complex number ``x`` by real number ``y``.
   result.re = x.re / y
   result.im = x.im / y
 
-proc `/` *[T](x: T, y: Complex[T]): Complex[T] =
+proc `/` *[T](x: T; y: Complex[T]): Complex[T] =
   ## Divide real number ``x`` by complex number ``y``.
   result = x * inv(y)
 
@@ -119,12 +119,12 @@ proc `/` *[T](x, y: Complex[T]): Complex[T] =
     result.re = (x.re + r * x.im) / den
     result.im = (x.im - r * x.re) / den
 
-proc `*` *[T](x: T, y: Complex[T]): Complex[T] =
+proc `*` *[T](x: T; y: Complex[T]): Complex[T] =
   ## Multiply a real number and a complex number.
   result.re = x * y.re
   result.im = x * y.im
 
-proc `*` *[T](x: Complex[T], y: T): Complex[T] =
+proc `*` *[T](x: Complex[T]; y: T): Complex[T] =
   ## Multiply a complex number with a real number.
   result.re = x.re * y
   result.im = x.im * y
@@ -135,23 +135,23 @@ proc `*` *[T](x, y: Complex[T]): Complex[T] =
   result.im = x.im * y.re + x.re * y.im
 
 
-proc `+=` *[T](x: var Complex[T], y: Complex[T]) =
+proc `+=` *[T](x: var Complex[T]; y: Complex[T]) =
   ## Add ``y`` to ``x``.
   x.re += y.re
   x.im += y.im
 
-proc `-=` *[T](x: var Complex[T], y: Complex[T]) =
+proc `-=` *[T](x: var Complex[T]; y: Complex[T]) =
   ## Subtract ``y`` from ``x``.
   x.re -= y.re
   x.im -= y.im
 
-proc `*=` *[T](x: var Complex[T], y: Complex[T]) =
+proc `*=` *[T](x: var Complex[T]; y: Complex[T]) =
   ## Multiply ``y`` to ``x``.
   let im = x.im * y.re + x.re * y.im
   x.re = x.re * y.re - x.im * y.im
   x.im = im
 
-proc `/=` *[T](x: var Complex[T], y: Complex[T]) =
+proc `/=` *[T](x: var Complex[T]; y: Complex[T]) =
   ## Divide ``x`` by ``y`` in place.
   x = x / y
 
@@ -222,7 +222,7 @@ proc pow*[T](x, y: Complex[T]): Complex[T] =
     result.re = s * cos(r)
     result.im = s * sin(r)
 
-proc pow*[T](x: Complex[T], y: T): Complex[T] =
+proc pow*[T](x: Complex[T]; y: T): Complex[T] =
   ## Complex number ``x`` raised to the power ``y``.
   pow(x, complex[T](y))
 
@@ -352,18 +352,18 @@ when isMainModule:
   proc `=~`[T](x, y: Complex[T]): bool =
     result = abs(x.re-y.re) < 1e-6 and abs(x.im-y.im) < 1e-6
 
-  proc `=~`[T](x: Complex[T], y: T): bool =
+  proc `=~`[T](x: Complex[T]; y: T): bool =
     result = abs(x.re-y) < 1e-6 and abs(x.im) < 1e-6
 
   var
-    z: Complex64   = complex(0.0, 0.0)
-    oo: Complex64  = complex(1.0, 1.0)
-    a: Complex64   = complex(1.0, 2.0)
-    b: Complex64   = complex(-1.0, -2.0)
-    m1: Complex64  = complex(-1.0, 0.0)
-    i: Complex64   = complex(0.0, 1.0)
+    z: Complex64 = complex(0.0, 0.0)
+    oo: Complex64 = complex(1.0, 1.0)
+    a: Complex64 = complex(1.0, 2.0)
+    b: Complex64 = complex(-1.0, -2.0)
+    m1: Complex64 = complex(-1.0, 0.0)
+    i: Complex64 = complex(0.0, 1.0)
     one: Complex64 = complex(1.0, 0.0)
-    tt: Complex64  = complex(10.0, 20.0)
+    tt: Complex64 = complex(10.0, 20.0)
     ipi: Complex64 = complex(0.0, -PI)
 
   doAssert(a/2.0 =~ complex(0.5, 1.0))
diff --git a/lib/pure/fenv.nim b/lib/pure/fenv.nim
index 6a6d05f2b..6da6aedad 100644
--- a/lib/pure/fenv.nim
+++ b/lib/pure/fenv.nim
@@ -10,7 +10,7 @@
 ## Floating-point environment. Handling of floating-point rounding and
 ## exceptions (overflow, division by zero, etc.).
 
-{.deadCodeElim: on.}  # dce option deprecated
+{.deadCodeElim: on.} # dce option deprecated
 
 when defined(Posix) and not defined(genode):
   {.passl: "-lm".}
@@ -103,26 +103,26 @@ proc feupdateenv*(envp: ptr Tfenv): cint {.importc, header: "<fenv.h>".}
   ## according to saved exceptions.
 
 const
-  FLT_RADIX = 2 ## the radix of the exponent representation
-
-  FLT_MANT_DIG = 24 ## the number of base FLT_RADIX digits in the mantissa part of a float
-  FLT_DIG = 6 ## the number of digits of precision of a float
-  FLT_MIN_EXP = -125 # the minimum value of base FLT_RADIX in the exponent part of a float
-  FLT_MAX_EXP = 128 # the maximum value of base FLT_RADIX in the exponent part of a float
-  FLT_MIN_10_EXP = -37 ## the minimum value in base 10 of the exponent part of a float
-  FLT_MAX_10_EXP = 38 ## the maximum value in base 10 of the exponent part of a float
-  FLT_MIN = 1.17549435e-38'f32  ## the minimum value of a float
-  FLT_MAX = 3.40282347e+38'f32 ## the maximum value of a float
-  FLT_EPSILON = 1.19209290e-07'f32  ## the difference between 1 and the least value greater than 1 of a float
-
-  DBL_MANT_DIG = 53 ## the number of base FLT_RADIX digits in the mantissa part of a double
-  DBL_DIG = 15 ## the number of digits of precision of a double
-  DBL_MIN_EXP = -1021 ## the minimum value of base FLT_RADIX in the exponent part of a double
-  DBL_MAX_EXP = 1024 ## the maximum value of base FLT_RADIX in the exponent part of a double
-  DBL_MIN_10_EXP = -307 ## the minimum value in base 10 of the exponent part of a double
-  DBL_MAX_10_EXP = 308 ## the maximum value in base 10 of the exponent part of a double
-  DBL_MIN = 2.2250738585072014E-308 ## the minimal value of a double
-  DBL_MAX = 1.7976931348623157E+308 ## the minimal value of a double
+  FLT_RADIX = 2                     ## the radix of the exponent representation
+
+  FLT_MANT_DIG = 24                ## the number of base FLT_RADIX digits in the mantissa part of a float
+  FLT_DIG = 6                      ## the number of digits of precision of a float
+  FLT_MIN_EXP = -125               ## the minimum value of base FLT_RADIX in the exponent part of a float
+  FLT_MAX_EXP = 128                ## the maximum value of base FLT_RADIX in the exponent part of a float
+  FLT_MIN_10_EXP = -37             ## the minimum value in base 10 of the exponent part of a float
+  FLT_MAX_10_EXP = 38              ## the maximum value in base 10 of the exponent part of a float
+  FLT_MIN = 1.17549435e-38'f32     ## the minimum value of a float
+  FLT_MAX = 3.40282347e+38'f32     ## the maximum value of a float
+  FLT_EPSILON = 1.19209290e-07'f32 ## the difference between 1 and the least value greater than 1 of a float
+
+  DBL_MANT_DIG = 53                    ## the number of base FLT_RADIX digits in the mantissa part of a double
+  DBL_DIG = 15                         ## the number of digits of precision of a double
+  DBL_MIN_EXP = -1021                  ## the minimum value of base FLT_RADIX in the exponent part of a double
+  DBL_MAX_EXP = 1024                   ## the maximum value of base FLT_RADIX in the exponent part of a double
+  DBL_MIN_10_EXP = -307                ## the minimum value in base 10 of the exponent part of a double
+  DBL_MAX_10_EXP = 308                 ## the maximum value in base 10 of the exponent part of a double
+  DBL_MIN = 2.2250738585072014E-308    ## the minimal value of a double
+  DBL_MAX = 1.7976931348623157E+308    ## the minimal value of a double
   DBL_EPSILON = 2.2204460492503131E-16 ## the difference between 1 and the least value greater than 1 of a double
 
 template fpRadix*: int = FLT_RADIX
diff --git a/lib/pure/math.nim b/lib/pure/math.nim
index 8457b8e0b..79a8675a6 100644
--- a/lib/pure/math.nim
+++ b/lib/pure/math.nim
@@ -51,7 +51,7 @@
 
 
 include "system/inclrtl"
-{.push debugger:off .} # the user does not want to trace a part
+{.push debugger: off.} # the user does not want to trace a part
                        # of the standard library!
 
 import bitops
@@ -93,39 +93,39 @@ proc fac*(n: int): int =
   assert(n < factTable.len, $n & " is too large to look up in the table")
   factTable[n]
 
-{.push checks:off, line_dir:off, stack_trace:off.}
+{.push checks: off, line_dir: off, stack_trace: off.}
 
 when defined(Posix) and not defined(genode):
   {.passl: "-lm".}
 
 const
-  PI* = 3.1415926535897932384626433 ## The circle constant PI (Ludolph's number)
-  TAU* = 2.0 * PI ## The circle constant TAU (= 2 * PI)
-  E* = 2.71828182845904523536028747 ## Euler's number
-
-  MaxFloat64Precision* = 16 ## Maximum number of meaningful digits
-                            ## after the decimal point for Nim's
-                            ## ``float64`` type.
-  MaxFloat32Precision* = 8  ## Maximum number of meaningful digits
-                            ## after the decimal point for Nim's
-                            ## ``float32`` type.
+  PI* = 3.1415926535897932384626433        ## The circle constant PI (Ludolph's number)
+  TAU* = 2.0 * PI                          ## The circle constant TAU (= 2 * PI)
+  E* = 2.71828182845904523536028747        ## Euler's number
+
+  MaxFloat64Precision* = 16                ## Maximum number of meaningful digits
+                                           ## after the decimal point for Nim's
+                                           ## ``float64`` type.
+  MaxFloat32Precision* = 8                 ## Maximum number of meaningful digits
+                                           ## after the decimal point for Nim's
+                                           ## ``float32`` type.
   MaxFloatPrecision* = MaxFloat64Precision ## Maximum number of
                                            ## meaningful digits
                                            ## after the decimal point
                                            ## for Nim's ``float`` type.
-  RadPerDeg = PI / 180.0 ## Number of radians per degree
+  RadPerDeg = PI / 180.0                   ## Number of radians per degree
 
 type
   FloatClass* = enum ## Describes the class a floating point value belongs to.
                      ## This is the type that is returned by
                      ## `classify proc <#classify,float>`_.
-    fcNormal,    ## value is an ordinary nonzero floating point value
-    fcSubnormal, ## value is a subnormal (a very small) floating point value
-    fcZero,      ## value is zero
-    fcNegZero,   ## value is the negative zero
-    fcNan,       ## value is Not-A-Number (NAN)
-    fcInf,       ## value is positive infinity
-    fcNegInf     ## value is negative infinity
+    fcNormal,        ## value is an ordinary nonzero floating point value
+    fcSubnormal,     ## value is a subnormal (a very small) floating point value
+    fcZero,          ## value is zero
+    fcNegZero,       ## value is the negative zero
+    fcNan,           ## value is Not-A-Number (NAN)
+    fcInf,           ## value is positive infinity
+    fcNegInf         ## value is negative infinity
 
 proc classify*(x: float): FloatClass =
   ## Classifies a floating point value.
@@ -186,7 +186,7 @@ proc nextPowerOfTwo*(x: int): int {.noSideEffect.} =
   result = result or (result shr 4)
   result = result or (result shr 2)
   result = result or (result shr 1)
-  result += 1 + ord(x<=0)
+  result += 1 + ord(x <= 0)
 
 proc countBits32*(n: int32): int {.noSideEffect, deprecated:
   "Deprecated since v0.20.0; use 'bitops.countSetBits' instead".} =
@@ -472,7 +472,8 @@ when not defined(JS): # C
     ## .. code-block:: nim
     ##  echo arctan(1.0) ## 0.7853981633974483
     ##  echo radToDeg(arctan(1.0)) ## 45.0
-  proc arctan2*(y, x: float32): float32 {.importc: "atan2f", header: "<math.h>".}
+  proc arctan2*(y, x: float32): float32 {.importc: "atan2f",
+      header: "<math.h>".}
   proc arctan2*(y, x: float64): float64 {.importc: "atan2", header: "<math.h>".}
     ## Calculate the arc tangent of ``y`` / ``x``.
     ##
@@ -603,9 +604,11 @@ when not defined(JS): # C
       ##  echo gamma(11.0) # 3628800.0
       ##  echo gamma(-1.0) # nan
     proc tgamma*(x: float32): float32
-      {.deprecated: "Deprecated since v0.19.0; use 'gamma' instead", importc: "tgammaf", header: "<math.h>".}
+      {.deprecated: "Deprecated since v0.19.0; use 'gamma' instead",
+          importc: "tgammaf", header: "<math.h>".}
     proc tgamma*(x: float64): float64
-      {.deprecated: "Deprecated since v0.19.0; use 'gamma' instead", importc: "tgamma", header: "<math.h>".}
+      {.deprecated: "Deprecated since v0.19.0; use 'gamma' instead",
+          importc: "tgamma", header: "<math.h>".}
       ## The gamma function
     proc lgamma*(x: float32): float32 {.importc: "lgammaf", header: "<math.h>".}
     proc lgamma*(x: float64): float64 {.importc: "lgamma", header: "<math.h>".}
@@ -739,8 +742,10 @@ when not defined(JS): # C
       ##  echo trunc(PI) # 3.0
       ##  echo trunc(-1.85) # -1.0
 
-  proc fmod*(x, y: float32): float32 {.deprecated: "Deprecated since v0.19.0; use 'mod' instead", importc: "fmodf", header: "<math.h>".}
-  proc fmod*(x, y: float64): float64 {.deprecated: "Deprecated since v0.19.0; use 'mod' instead", importc: "fmod", header: "<math.h>".}
+  proc fmod*(x, y: float32): float32 {.deprecated: "Deprecated since v0.19.0; use 'mod' instead",
+      importc: "fmodf", header: "<math.h>".}
+  proc fmod*(x, y: float64): float64 {.deprecated: "Deprecated since v0.19.0; use 'mod' instead",
+      importc: "fmod", header: "<math.h>".}
     ## Computes the remainder of ``x`` divided by ``y``.
 
   proc `mod`*(x, y: float32): float32 {.importc: "fmodf", header: "<math.h>".}
@@ -779,7 +784,8 @@ else: # JS
     ##  ( 6.5 mod -2.5) ==  1.5
     ##  (-6.5 mod -2.5) == -1.5
 
-proc round*[T: float32|float64](x: T, places: int): T {.deprecated: "use strformat module instead".} =
+proc round*[T: float32|float64](x: T, places: int): T {.
+    deprecated: "use strformat module instead".} =
   ## Decimal rounding on a binary floating point number.
   ##
   ## This function is NOT reliable. Floating point numbers cannot hold
diff --git a/lib/pure/random.nim b/lib/pure/random.nim
index 9abbe947e..c3ccd121b 100644
--- a/lib/pure/random.nim
+++ b/lib/pure/random.nim
@@ -78,10 +78,10 @@
 ##   <lib.html#pure-libraries-cryptography-and-hashing>`_
 ##   in the standard library
 
-import algorithm                    #For upperBound
+import algorithm #For upperBound
 
 include "system/inclrtl"
-{.push debugger:off.}
+{.push debugger: off.}
 
 when defined(JS):
   type ui = uint32
@@ -94,18 +94,18 @@ else:
 
 type
   Rand* = object ## State of a random number generator.
-    ##
-    ## Create a new Rand state using the `initRand proc<#initRand,int64>`_.
-    ##
-    ## The module contains a default Rand state for convenience.
-    ## It corresponds to the default random number generator's state.
-    ## The default Rand state always starts with the same values, but the
-    ## `randomize proc<#randomize>`_ can be used to seed the default generator
-    ## with a value based on the current time.
-    ##
-    ## Many procs have two variations: one that takes in a Rand parameter and
-    ## another that uses the default generator. The procs that use the default
-    ## generator are **not** thread-safe!
+                 ##
+                 ## Create a new Rand state using the `initRand proc<#initRand,int64>`_.
+                 ##
+                 ## The module contains a default Rand state for convenience.
+                 ## It corresponds to the default random number generator's state.
+                 ## The default Rand state always starts with the same values, but the
+                 ## `randomize proc<#randomize>`_ can be used to seed the default generator
+                 ## with a value based on the current time.
+                 ##
+                 ## Many procs have two variations: one that takes in a Rand parameter and
+                 ## another that uses the default generator. The procs that use the default
+                 ## generator are **not** thread-safe!
     a0, a1: ui
 
 when defined(JS):
@@ -481,7 +481,7 @@ proc sample*[T](a: openArray[T]): T =
     doAssert sample(marbles) == "red"
   result = a[rand(a.low..a.high)]
 
-proc sample*[T, U](r: var Rand; a: openArray[T], cdf: openArray[U]): T =
+proc sample*[T, U](r: var Rand; a: openArray[T]; cdf: openArray[U]): T =
   ## Returns an element from ``a`` using a cumulative distribution function
   ## (CDF) and the given state.
   ##
@@ -509,14 +509,14 @@ proc sample*[T, U](r: var Rand; a: openArray[T], cdf: openArray[U]): T =
     doAssert r.sample(marbles, cdf) == "red"
     doAssert r.sample(marbles, cdf) == "green"
     doAssert r.sample(marbles, cdf) == "blue"
-  assert(cdf.len == a.len)              # Two basic sanity checks.
+  assert(cdf.len == a.len) # Two basic sanity checks.
   assert(float(cdf[^1]) > 0.0)
   #While we could check cdf[i-1] <= cdf[i] for i in 1..cdf.len, that could get
   #awfully expensive even in debugging modes.
   let u = r.rand(float(cdf[^1]))
   a[cdf.upperBound(U(u))]
 
-proc sample*[T, U](a: openArray[T], cdf: openArray[U]): T =
+proc sample*[T, U](a: openArray[T]; cdf: openArray[U]): T =
   ## Returns an element from ``a`` using a cumulative distribution function
   ## (CDF).
   ##
diff --git a/lib/pure/rationals.nim b/lib/pure/rationals.nim
index 76891a830..b668a9f71 100644
--- a/lib/pure/rationals.nim
+++ b/lib/pure/rationals.nim
@@ -39,7 +39,8 @@ proc toRational*[T: SomeInteger](x: T): Rational[T] =
   result.num = x
   result.den = 1
 
-proc toRational*(x: float, n: int = high(int) shr (sizeof(int) div 2 * 8)): Rational[int] =
+proc toRational*(x: float,
+                 n: int = high(int) shr (sizeof(int) div 2 * 8)): Rational[int] =
   ## Calculates the best rational numerator and denominator
   ## that approximates to `x`, where the denominator is
   ## smaller than `n` (default is the largest possible
@@ -67,9 +68,9 @@ proc toRational*(x: float, n: int = high(int) shr (sizeof(int) div 2 * 8)): Rati
     swap m22, m21
     m11 = m12 * ai + m11
     m21 = m22 * ai + m21
-    if x == float(ai): break  # division by zero
+    if x == float(ai): break # division by zero
     x = 1/(x - float(ai))
-    if x > float(high(int32)): break  # representation failure
+    if x > float(high(int32)): break # representation failure
     ai = int(x)
   result = m11 // m21
 
@@ -282,69 +283,69 @@ proc hash*[T](x: Rational[T]): Hash =
 when isMainModule:
   var
     z = Rational[int](num: 0, den: 1)
-    o = initRational(num=1, den=1)
+    o = initRational(num = 1, den = 1)
     a = initRational(1, 2)
     b = -1 // -2
     m1 = -1 // 1
     tt = 10 // 2
 
-  assert( a == a )
-  assert( (a-a) == z )
-  assert( (a+b) == o )
-  assert( (a/b) == o )
-  assert( (a*b) == 1 // 4 )
-  assert( (3/a) == 6 // 1 )
-  assert( (a/3) == 1 // 6 )
-  assert( a*b == 1 // 4 )
-  assert( tt*z == z )
-  assert( 10*a == tt )
-  assert( a*10 == tt )
-  assert( tt/10 == a  )
-  assert( a-m1 == 3 // 2 )
-  assert( a+m1 == -1 // 2 )
-  assert( m1+tt == 16 // 4 )
-  assert( m1-tt == 6 // -1 )
-
-  assert( z < o )
-  assert( z <= o )
-  assert( z == z )
-  assert( cmp(z, o) < 0 )
-  assert( cmp(o, z) > 0 )
-
-  assert( o == o )
-  assert( o >= o )
-  assert( not(o > o) )
-  assert( cmp(o, o) == 0 )
-  assert( cmp(z, z) == 0 )
-  assert( hash(o) == hash(o) )
-
-  assert( a == b )
-  assert( a >= b )
-  assert( not(b > a) )
-  assert( cmp(a, b) == 0 )
-  assert( hash(a) == hash(b) )
+  assert(a == a)
+  assert( (a-a) == z)
+  assert( (a+b) == o)
+  assert( (a/b) == o)
+  assert( (a*b) == 1 // 4)
+  assert( (3/a) == 6 // 1)
+  assert( (a/3) == 1 // 6)
+  assert(a*b == 1 // 4)
+  assert(tt*z == z)
+  assert(10*a == tt)
+  assert(a*10 == tt)
+  assert(tt/10 == a)
+  assert(a-m1 == 3 // 2)
+  assert(a+m1 == -1 // 2)
+  assert(m1+tt == 16 // 4)
+  assert(m1-tt == 6 // -1)
+
+  assert(z < o)
+  assert(z <= o)
+  assert(z == z)
+  assert(cmp(z, o) < 0)
+  assert(cmp(o, z) > 0)
+
+  assert(o == o)
+  assert(o >= o)
+  assert(not(o > o))
+  assert(cmp(o, o) == 0)
+  assert(cmp(z, z) == 0)
+  assert(hash(o) == hash(o))
+
+  assert(a == b)
+  assert(a >= b)
+  assert(not(b > a))
+  assert(cmp(a, b) == 0)
+  assert(hash(a) == hash(b))
 
   var x = 1//3
 
   x *= 5//1
-  assert( x == 5//3 )
+  assert(x == 5//3)
   x += 2 // 9
-  assert( x == 17//9 )
+  assert(x == 17//9)
   x -= 9//18
-  assert( x == 25//18 )
+  assert(x == 25//18)
   x /= 1//2
-  assert( x == 50//18 )
+  assert(x == 50//18)
 
   var y = 1//3
 
   y *= 4
-  assert( y == 4//3 )
+  assert(y == 4//3)
   y += 5
-  assert( y == 19//3 )
+  assert(y == 19//3)
   y -= 2
-  assert( y == 13//3 )
+  assert(y == 13//3)
   y /= 9
-  assert( y == 13//27 )
+  assert(y == 13//27)
 
   assert toRational(5) == 5//1
   assert abs(toFloat(y) - 0.4814814814814815) < 1.0e-7