[stdlib] Introducing the new Arithmetic protocol (#3479)

* [stdlib] Introducing the new Arithmetic protocol

* [stdlib] conforming floating point types to the new Arithmetic protocol

* [stdlib] removing AbsoluteValuable conformance from floating point types

* [stdlib] removing the integers prototype

Author: moiseev

benchmark/single-source/MonteCarloE.swift

@@ -33,6 +33,6 @@ public func run_MonteCarloE(scale: Int) {
                "Incorrect results in MonteCarloE: no empty intervals.")
   let e_estimate = Double(N)/Double(numEmptyIntervals)
   let e = 2.71828
-  CheckResults(Double.abs(e_estimate - e) < 0.1,
+  CheckResults(abs(e_estimate - e) < 0.1,
                "Incorrect results in MonteCarloE: e_estimate == \(e_estimate)")
 }

benchmark/single-source/MonteCarloPi.swift

@@ -25,6 +25,6 @@ public func run_MonteCarloPi(scale: Int) {
   }
   let pi_estimate: Double = Double(pointsInside)*4.0/Double(N)
   let pi = 3.1415
-  CheckResults(Double.abs(pi_estimate - pi) < 0.1,
+  CheckResults(abs(pi_estimate - pi) < 0.1,
                "Incorrect results in MonteCarloPi: pi_estimate == \(pi_estimate)")
 }

stdlib/public/SDK/CoreGraphics/CGFloat.swift.gyb

@@ -174,8 +174,8 @@ public struct CGFloat {
     return CGFloat(native.nextUp)
   }
 
-  public static func abs(_ x: CGFloat) -> CGFloat {
-    return CGFloat(NativeType.abs(x.native))
+  public var magnitude: CGFloat {
+    return CGFloat(abs(native))
   }
 
   public mutating func negate() {
@@ -296,6 +296,11 @@ extension CGFloat {
   public static var max: CGFloat {
     fatalError("unavailable")
   }
+
+  @available(*, unavailable, message: "Please use the `abs(_:)` free function")
+  public static func abs(_ x: CGFloat) -> CGFloat {
+    fatalError("unavailable")
+  }
 }
 
 @available(*, unavailable, renamed: "CGFloat.leastNormalMagnitude")

stdlib/public/core/CMakeLists.txt

@@ -62,6 +62,7 @@ set(SWIFTLIB_ESSENTIAL
   InputStream.swift
   IntegerArithmetic.swift.gyb
   IntegerParsing.swift.gyb
+  Integers.swift.gyb
   Join.swift
   LazyCollection.swift.gyb
   LazySequence.swift

stdlib/public/core/FloatingPoint.swift.gyb

@@ -27,15 +27,12 @@ word_bits = int(CMAKE_SIZEOF_VOID_P) * 8
 /// The BinaryFloatingPoint protocol refines these requirements, adds some
 /// additional operations that only make sense for a fixed radix, and also
 /// provides default implementations of some of the FloatingPoint APIs.
-public protocol FloatingPoint: Comparable, ExpressibleByIntegerLiteral,
-  SignedNumber, AbsoluteValuable, Strideable {
+public protocol FloatingPoint: Comparable, Arithmetic,
+  SignedNumber, Strideable {
 
   /// An integer type that can represent any written exponent.
   associatedtype Exponent: SignedInteger
 
-  /// Initialize to zero
-  init()
-
   /// Initialize from sign, exponent, and significand.
   ///
   /// The result is:
@@ -926,5 +923,11 @@ extension BinaryFloatingPoint {
   */
 }
 
+/// Returns the absolute value of `x`.
+@_transparent
+public func abs<T : FloatingPoint>(_ x: T) -> T where T.Magnitude == T {
+  return x.magnitude
+}
+
 @available(*, unavailable, renamed: "FloatingPoint")
 public typealias FloatingPointType = FloatingPoint

stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -766,12 +766,10 @@ extension ${Self} : Hashable {
   }
 }
 
-@_transparent
-extension ${Self} : AbsoluteValuable {
-  /// Returns the absolute value of `x`.
+extension ${Self} : Arithmetic {
   @_transparent
-  public static func abs(_ x: ${Self}) -> ${Self} {
-    return ${Self}(_bits: Builtin.int_fabs_FPIEEE${bits}(x._value))
+  public var magnitude: ${Self} {
+    return ${Self}(_bits: Builtin.int_fabs_FPIEEE${bits}(_value))
   }
 }
 
@@ -1008,4 +1006,13 @@ extension ${Self} {
 %     end
 %   end
 }
+
+
+extension ${Self} {
+  @available(*, unavailable, message: "Please use the `abs(_:)` free function")
+  public static func abs(_ x: ${Self}) -> ${Self} {
+    fatalError("unavailable")
+  }
+}
+
 % end # for (bits, signed) in allInts()

stdlib/public/core/GroupInfo.json

@@ -100,6 +100,7 @@
     "BuiltinMath.swift",
     {
     "Integers": [
+      "Integers.swift",
       "IntegerArithmetic.swift",
       "FixedPoint.swift",
       "IntegerParsing.swift"],

stdlib/public/core/Integers.swift.gyb

@@ -0,0 +1,130 @@
+//===--- Integers.swift.gyb -----------------------------------*- swift -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+ %{
+#
+# Utility code for later in this template
+#
+
+# Number of bits in the Builtin.Word type
+word_bits = int(CMAKE_SIZEOF_VOID_P) * 8
+
+# Number of bits in integer literals.
+builtinIntLiteralBits = 2048
+IntLiteral = 'Int%s' % builtinIntLiteralBits
+
+class struct(object):
+  def __init__(self, **kw):
+    self.__dict__ = kw
+  def __repr__(self):
+    return 'struct(%r)' % self.__dict__
+
+binaryArithmetic = {
+  'Arithmetic' : [
+    struct(operator='+', name='adding',      mutatingName='add',      firstArg='_',  llvmName='add', kind='+'),
+    struct(operator='-', name='subtracting', mutatingName='subtract', firstArg='_',  llvmName='sub', kind='-'),
+    struct(operator='*', name='multiplied',  mutatingName='multiply', firstArg='by', llvmName='mul', kind='*'),
+    struct(operator='/', name='divided',     mutatingName='divide',   firstArg='by', llvmName='div', kind='/'),
+  ],
+}
+
+}%
+
+//===--- Bits for the Stdlib ----------------------------------------------===//
+
+
+//FIXME: This should go in the stdlib separately, probably.
+extension ExpressibleByIntegerLiteral
+  where Self : _ExpressibleByBuiltinIntegerLiteral {
+  /// Create an instance initialized to `value`.
+  @_transparent
+  public init(integerLiteral value: Self) {
+    self = value
+  }
+}
+
+//===----------------------------------------------------------------------===//
+//===--- Arithmetic -------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+
+/// Declares methods backing binary arithmetic operators—such as `+`, `-` and
+/// `*`—and their mutating counterparts.
+/// 
+/// It provides a suitable basis for arithmetic on scalars such as integers and
+/// floating point numbers.
+/// 
+/// Both mutating and non-mutating operations are declared in the protocol,
+/// however only the mutating ones are required, as default implementations of
+/// the non-mutating ones are provided by a protocol extension.
+/// 
+/// The `Magnitude` associated type is able to hold the absolute value of any
+/// possible value of `Self`. Concrete types do not have to provide a typealias
+/// for it, as it can be inferred from the `magnitude` property. This property
+/// can be useful in operations that are simpler to implement in terms of
+/// unsigned values, for example, printing a value of an integer, which is just
+/// printing a '-' character in front of an absolute value.
+/// 
+/// Please note that for ordinary work, the `magnitude` property **should not**
+/// be preferred to the `abs(_)` function, whose return value is of the same
+/// type as its argument.
+public protocol Arithmetic : Equatable, ExpressibleByIntegerLiteral {
+  // FIXME: implement
+  //init?<T : Integer>(exactly source: T)
+
+  // FIXME(ABI): should be just Arithmetic
+  associatedtype Magnitude : Equatable, ExpressibleByIntegerLiteral
+
+  var magnitude: Magnitude { get }
+
+
+% for x in binaryArithmetic['Arithmetic']:
+  // defaulted using an in-place counterpart, but can be used as an
+  // optimization hook
+  func ${x.name}(${x.firstArg} rhs: Self) -> Self
+
+  // implementation hook
+  mutating func ${x.mutatingName}(${x.firstArg} rhs: Self)
+% end
+}
+
+extension Arithmetic {
+  @_transparent
+  public init() {
+    self = 0
+  }
+}
+
+% for Protocol in ['Arithmetic']:
+extension ${Protocol} {
+%   for x in binaryArithmetic[Protocol]:
+%     callLabel = x.firstArg + ': ' if not x.firstArg == '_' else ''
+  public func ${x.name}(${x.firstArg} rhs: Self) -> Self {
+    var lhs = self
+    lhs.${x.mutatingName}(${callLabel}rhs)
+    return lhs
+  }
+%   end
+}
+% end
+
+public protocol SignedArithmetic : Arithmetic {
+  func negated() -> Self
+  mutating func negate()
+}
+
+extension SignedArithmetic {
+  public func negated() -> Self {
+    return Self().subtracting(self)
+  }
+  public mutating func negate() {
+    self = negated()
+  }
+}