Compiler Explorer

Source code

func even(n: Int, a: Int) -> Int {
    n.distance(to: a)
}

func signed1(n: Int64, a: Int64) -> Int32 {
    n.distance1(to: a)
}

func signed2(n: Int64, a: Int64) -> Int32 {
    n.distance2(to: a)
}

func unsigned1(n: UInt64, a: UInt64) -> Int32 {
    n.distance1(to: a)
}

func unsigned2(n: UInt64, a: UInt64) -> Int32 {
    n.distance2(to: a)
}

extension FixedWidthInteger {
  public func distance1(to other: Self) -> Int32 {
    if !Self.isSigned {
      if self > other {
        if let result = Int32(exactly: self - other) {
          return -result //.................................................(1) crashes on UInt.max.distance(to: UInt.max / 2)
        }
      } else {
        if let result = Int32(exactly: other - self) {
          return result
        }
      }
    } else {
      let isNegative = self < (0 as Self)
      if isNegative == (other < (0 as Self)) {
        if let result = Int32(exactly: other - self) {
          return result
        }
      } else {
        if let result = Int32(exactly: self.magnitude + other.magnitude) {
          return isNegative ? result : -result //...........................(2) crashes on Int.max.distance(to: -1)
        }
      }
    }
    preconditionFailure("Distance is not representable in Int")
  }

public func distance2(to other: Self) -> Int32 {
    if Self.isSigned {
      if self.bitWidth <= Int32.bitWidth && other.bitWidth <= Int32.bitWidth { //.....(2a) constant-foldable bit width comparison
        return Int32(truncatingIfNeeded: other) - Int32(truncatingIfNeeded: self) //..(2b) checked subtraction
      } else {
        return Int32(other - self) //.................................................(2c) checked subtraction and Int32.init(_:)
      }
    } else {
      if self > other {
        let result: Self = self - other //..............................................................(1a) result is in 0...
        if result.bitWidth < Int32.bitWidth || result <= Self(truncatingIfNeeded: Int32.min.magnitude) { // (1b) smaller unsigned bit widths always fit
          return ~Int32(truncatingIfNeeded: result) &+ 1 //...............................................(1c) result is in 0...Int32.min.magnitude
        }
      } else {
        let result: Self = other - self //..............................................................(1d) result is in 0...
        if result.bitWidth < Int32.bitWidth || result <= Self(truncatingIfNeeded: Int32.max.magnitude) { // (1e) smaller unsigned bit widths always fit
          return Int32(truncatingIfNeeded: result) //.....................................................(1f) result is in 0...Int32.max.magnitude
        }
      }
    }
    preconditionFailure("Distance is not representable in Int32")
  }
}