rationals.nim: Use `func` everywhere (#16302)

1 files changed, 41 insertions, 41 deletions

diff --git a/lib/pure/rationals.nim b/lib/pure/rationals.nim
index 38a88ebc3..2a1a97d3b 100644
--- a/lib/pure/rationals.nim
+++ b/lib/pure/rationals.nim
@@ -18,28 +18,28 @@ type Rational*[T] = object
   ## a rational number, consisting of a numerator and denominator
   num*, den*: T
 
-proc initRational*[T: SomeInteger](num, den: T): Rational[T] =
+func initRational*[T: SomeInteger](num, den: T): Rational[T] =
   ## Create a new rational number.
   assert(den != 0, "a denominator of zero value is invalid")
   result.num = num
   result.den = den
 
-proc `//`*[T](num, den: T): Rational[T] = initRational[T](num, den)
+func `//`*[T](num, den: T): Rational[T] = initRational[T](num, den)
   ## A friendlier version of `initRational`. Example usage:
   ##
   ## .. code-block:: nim
   ##   var x = 1//3 + 1//5
 
-proc `$`*[T](x: Rational[T]): string =
+func `$`*[T](x: Rational[T]): string =
   ## Turn a rational number into a string.
   result = $x.num & "/" & $x.den
 
-proc toRational*[T: SomeInteger](x: T): Rational[T] =
+func toRational*[T: SomeInteger](x: T): Rational[T] =
   ## Convert some integer `x` to a rational number.
   result.num = x
   result.den = 1
 
-proc toRational*(x: float,
+func 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
@@ -74,16 +74,16 @@ proc toRational*(x: float,
     ai = int(x)
   result = m11 // m21
 
-proc toFloat*[T](x: Rational[T]): float =
+func toFloat*[T](x: Rational[T]): float =
   ## Convert a rational number `x` to a float.
   x.num / x.den
 
-proc toInt*[T](x: Rational[T]): int =
+func toInt*[T](x: Rational[T]): int =
   ## Convert a rational number `x` to an int. Conversion rounds towards 0 if
   ## `x` does not contain an integer value.
   x.num div x.den
 
-proc reduce*[T: SomeInteger](x: var Rational[T]) =
+func reduce*[T: SomeInteger](x: var Rational[T]) =
   ## Reduce rational `x`.
   let common = gcd(x.num, x.den)
   if x.den > 0:
@@ -95,97 +95,97 @@ proc reduce*[T: SomeInteger](x: var Rational[T]) =
   else:
     raise newException(DivByZeroDefect, "division by zero")
 
-proc `+` *[T](x, y: Rational[T]): Rational[T] =
+func `+` *[T](x, y: Rational[T]): Rational[T] =
   ## Add two rational numbers.
   let common = lcm(x.den, y.den)
   result.num = common div x.den * x.num + common div y.den * y.num
   result.den = common
   reduce(result)
 
-proc `+` *[T](x: Rational[T], y: T): Rational[T] =
+func `+` *[T](x: Rational[T], y: T): Rational[T] =
   ## Add rational `x` to int `y`.
   result.num = x.num + y * x.den
   result.den = x.den
 
-proc `+` *[T](x: T, y: Rational[T]): Rational[T] =
+func `+` *[T](x: T, y: Rational[T]): Rational[T] =
   ## Add int `x` to rational `y`.
   result.num = x * y.den + y.num
   result.den = y.den
 
-proc `+=` *[T](x: var Rational[T], y: Rational[T]) =
+func `+=` *[T](x: var Rational[T], y: Rational[T]) =
   ## Add rational `y` to rational `x`.
   let common = lcm(x.den, y.den)
   x.num = common div x.den * x.num + common div y.den * y.num
   x.den = common
   reduce(x)
 
-proc `+=` *[T](x: var Rational[T], y: T) =
+func `+=` *[T](x: var Rational[T], y: T) =
   ## Add int `y` to rational `x`.
   x.num += y * x.den
 
-proc `-` *[T](x: Rational[T]): Rational[T] =
+func `-` *[T](x: Rational[T]): Rational[T] =
   ## Unary minus for rational numbers.
   result.num = -x.num
   result.den = x.den
 
-proc `-` *[T](x, y: Rational[T]): Rational[T] =
+func `-` *[T](x, y: Rational[T]): Rational[T] =
   ## Subtract two rational numbers.
   let common = lcm(x.den, y.den)
   result.num = common div x.den * x.num - common div y.den * y.num
   result.den = common
   reduce(result)
 
-proc `-` *[T](x: Rational[T], y: T): Rational[T] =
+func `-` *[T](x: Rational[T], y: T): Rational[T] =
   ## Subtract int `y` from rational `x`.
   result.num = x.num - y * x.den
   result.den = x.den
 
-proc `-` *[T](x: T, y: Rational[T]): Rational[T] =
+func `-` *[T](x: T, y: Rational[T]): Rational[T] =
   ## Subtract rational `y` from int `x`.
   result.num = x * y.den - y.num
   result.den = y.den
 
-proc `-=` *[T](x: var Rational[T], y: Rational[T]) =
+func `-=` *[T](x: var Rational[T], y: Rational[T]) =
   ## Subtract rational `y` from rational `x`.
   let common = lcm(x.den, y.den)
   x.num = common div x.den * x.num - common div y.den * y.num
   x.den = common
   reduce(x)
 
-proc `-=` *[T](x: var Rational[T], y: T) =
+func `-=` *[T](x: var Rational[T], y: T) =
   ## Subtract int `y` from rational `x`.
   x.num -= y * x.den
 
-proc `*` *[T](x, y: Rational[T]): Rational[T] =
+func `*` *[T](x, y: Rational[T]): Rational[T] =
   ## Multiply two rational numbers.
   result.num = x.num * y.num
   result.den = x.den * y.den
   reduce(result)
 
-proc `*` *[T](x: Rational[T], y: T): Rational[T] =
+func `*` *[T](x: Rational[T], y: T): Rational[T] =
   ## Multiply rational `x` with int `y`.
   result.num = x.num * y
   result.den = x.den
   reduce(result)
 
-proc `*` *[T](x: T, y: Rational[T]): Rational[T] =
+func `*` *[T](x: T, y: Rational[T]): Rational[T] =
   ## Multiply int `x` with rational `y`.
   result.num = x * y.num
   result.den = y.den
   reduce(result)
 
-proc `*=` *[T](x: var Rational[T], y: Rational[T]) =
+func `*=` *[T](x: var Rational[T], y: Rational[T]) =
   ## Multiply rationals `y` to `x`.
   x.num *= y.num
   x.den *= y.den
   reduce(x)
 
-proc `*=` *[T](x: var Rational[T], y: T) =
+func `*=` *[T](x: var Rational[T], y: T) =
   ## Multiply int `y` to rational `x`.
   x.num *= y
   reduce(x)
 
-proc reciprocal*[T](x: Rational[T]): Rational[T] =
+func reciprocal*[T](x: Rational[T]): Rational[T] =
   ## Calculate the reciprocal of `x`. (1/x)
   if x.num > 0:
     result.num = x.den
@@ -196,63 +196,63 @@ proc reciprocal*[T](x: Rational[T]): Rational[T] =
   else:
     raise newException(DivByZeroDefect, "division by zero")
 
-proc `/`*[T](x, y: Rational[T]): Rational[T] =
+func `/`*[T](x, y: Rational[T]): Rational[T] =
   ## Divide rationals `x` by `y`.
   result.num = x.num * y.den
   result.den = x.den * y.num
   reduce(result)
 
-proc `/`*[T](x: Rational[T], y: T): Rational[T] =
+func `/`*[T](x: Rational[T], y: T): Rational[T] =
   ## Divide rational `x` by int `y`.
   result.num = x.num
   result.den = x.den * y
   reduce(result)
 
-proc `/`*[T](x: T, y: Rational[T]): Rational[T] =
+func `/`*[T](x: T, y: Rational[T]): Rational[T] =
   ## Divide int `x` by Rational `y`.
   result.num = x * y.den
   result.den = y.num
   reduce(result)
 
-proc `/=`*[T](x: var Rational[T], y: Rational[T]) =
+func `/=`*[T](x: var Rational[T], y: Rational[T]) =
   ## Divide rationals `x` by `y` in place.
   x.num *= y.den
   x.den *= y.num
   reduce(x)
 
-proc `/=`*[T](x: var Rational[T], y: T) =
+func `/=`*[T](x: var Rational[T], y: T) =
   ## Divide rational `x` by int `y` in place.
   x.den *= y
   reduce(x)
 
-proc cmp*(x, y: Rational): int =
+func cmp*(x, y: Rational): int =
   ## Compares two rationals.
   (x - y).num
 
-proc `<` *(x, y: Rational): bool =
+func `<` *(x, y: Rational): bool =
   (x - y).num < 0
 
-proc `<=` *(x, y: Rational): bool =
+func `<=` *(x, y: Rational): bool =
   (x - y).num <= 0
 
-proc `==` *(x, y: Rational): bool =
+func `==` *(x, y: Rational): bool =
   (x - y).num == 0
 
-proc abs*[T](x: Rational[T]): Rational[T] =
+func abs*[T](x: Rational[T]): Rational[T] =
   result.num = abs x.num
   result.den = abs x.den
 
-proc `div`*[T: SomeInteger](x, y: Rational[T]): T =
+func `div`*[T: SomeInteger](x, y: Rational[T]): T =
   ## Computes the rational truncated division.
   (x.num * y.den) div (y.num * x.den)
 
-proc `mod`*[T: SomeInteger](x, y: Rational[T]): Rational[T] =
+func `mod`*[T: SomeInteger](x, y: Rational[T]): Rational[T] =
   ## Computes the rational modulo by truncated division (remainder).
   ## This is same as ``x - (x div y) * y``.
   result = ((x.num * y.den) mod (y.num * x.den)) // (x.den * y.den)
   reduce(result)
 
-proc floorDiv*[T: SomeInteger](x, y: Rational[T]): T =
+func floorDiv*[T: SomeInteger](x, y: Rational[T]): T =
   ## Computes the rational floor division.
   ##
   ## Floor division is conceptually defined as ``floor(x / y)``.
@@ -261,15 +261,15 @@ proc floorDiv*[T: SomeInteger](x, y: Rational[T]): T =
   ## rounds down.
   floorDiv(x.num * y.den, y.num * x.den)
 
-proc floorMod*[T: SomeInteger](x, y: Rational[T]): Rational[T] =
+func floorMod*[T: SomeInteger](x, y: Rational[T]): Rational[T] =
   ## Computes the rational modulo by floor division (modulo).
   ##
   ## This is same as ``x - floorDiv(x, y) * y``.
-  ## This proc behaves the same as the ``%`` operator in python.
+  ## This func behaves the same as the ``%`` operator in python.
   result = floorMod(x.num * y.den, y.num * x.den) // (x.den * y.den)
   reduce(result)
 
-proc hash*[T](x: Rational[T]): Hash =
+func hash*[T](x: Rational[T]): Hash =
   ## Computes hash for rational `x`
   # reduce first so that hash(x) == hash(y) for x == y
   var copy = x