 
   /// Raises this rational value to the power of `exp`.
   func toPower(of exp: Integer) -> Self
-}
-
-// TODO: make this a static member of `Rational` once this is supported
-private let rationalSeparator: Character = "/"
+  
+  /// Adds `rhs` to `self` and reports the result together with a boolean indicating an overflow.
+  func addingReportingOverflow(_ rhs: Self) -> (partialValue: Self, overflow: Bool)
+  
+  /// Subtracts `rhs` from `self` and reports the result together with a boolean indicating
+  /// an overflow.
+  func subtractingReportingOverflow(_ rhs: Self) -> (partialValue: Self, overflow: Bool)
+  
+  /// Multiplies `rhs` with `self` and reports the result together with a boolean indicating
+  /// an overflow.
+  func multipliedReportingOverflow(by rhs: Self) -> (partialValue: Self, overflow: Bool)
+  
+  /// Divides `self` by `rhs` and reports the result together with a boolean indicating
+  /// an overflow.
+  func dividedReportingOverflow(by rhs: Self) -> (partialValue: Self, overflow: Bool)
+  
+  /// Returns the greatest common denominator for `self` and `y` and a boolean which indicates
+  /// whether there was an overflow.
+  func gcdReportingOverflow(with y: Self) -> (partialValue: Self, overflow: Bool)
+  
+  /// Returns the least common multiplier for `self` and `y` and a boolean which indicates
+  /// whether there was an overflow.
+  func lcmReportingOverflow(with y: Self) -> (partialValue: Self, overflow: Bool)
+}
 
 
 /// Struct `Rational<T>` implements the `RationalNumber` interface on top of the

    }
    return (y, overflow)
  }

  /// Compute the least common multiplier of `x` and `y`.
  public static func lcmWithOverflow(_ x: T, _ y: T) -> (T, Bool) {
    let (abs, overflow1) = x.multipliedReportingOverflow(by: y)
    let (gcd, overflow2) = Rational.gcdWithOverflow(x, y)
    return ((abs < 0 ? -abs : abs) / gcd, overflow1 || overflow2)
  }

  /// Returns the greatest common denominator for the two given rational numbers and a boolean
  /// which indicates whether there was an overflow.
  public static func gcdWithOverflow(_ x: Rational<T>, _ y: Rational<T>) -> (Rational<T>, Bool) {
    let (numer, overflow1) = Rational.gcdWithOverflow(x.numerator, y.numerator)
    let (denom, overflow2) = Rational.lcmWithOverflow(x.denominator, y.denominator)
    return (Rational(numer, denom), overflow1 || overflow2)
  }

  /// Returns the least common multiplier for the two given rational numbers and a boolean
  /// which indicates whether there was an overflow.
  public static func lcmWithOverflow(_ x: Rational<T>, _ y: Rational<T>) -> (Rational<T>, Bool) {
    let (xn, yn, denom, overflow1) = Rational.commonDenomWithOverflow(x, y)
    let (numer, overflow2) = Rational.lcmWithOverflow(xn, yn)
    return (Rational(numer, denom), overflow1 || overflow2)
  }

  return lhs.compare(to: rhs) != 0
}

// TODO: make this a static member of `Rational` once this is supported
private let rationalSeparator: Character = "/"
