     ///
     /// - Parameter value: The new value to set this object to.
     /// - Returns: The value previously held by this object.
-    @_specialize(where T == Int)
-    @_specialize(where T == Bool)
-    @_specialize(where T == UInt64)
-    // in Swift 4.0 (fixed in 4.0.2), there was a crash that only allowed three specialisations otherwise the compiler would crash
-    // FIXME: Bring back when we require Swift >= 4.0.2
-    // @_specialize(where T == UInt)
-    // @_specialize(where T == Int64)
+    @inlinable
     public func exchange(with value: T) -> T {
         return self.embedded.exchange(with: value)
     }

/// sense to talk about managing an atomic value when each time it's modified
/// the thread that modified it gets a local copy!
public final class Atomic<T: AtomicPrimitive> {
    private let embedded: UnsafeEmbeddedAtomic<T>

    /// Create an atomic object with `value`.
    @_specialize(where T == Int)
    @_specialize(where T == Bool)
    @_specialize(where T == UInt64)
    // in Swift 4.0 (fixed in 4.0.2), there was a crash that only allowed three specialisations otherwise the compiler would crash
    // FIXME: Bring back when we require Swift >= 4.0.2
    // @_specialize(where T == UInt)
    // @_specialize(where T == Int64)
    public init(value: T) {
        self.embedded = UnsafeEmbeddedAtomic(value: value)
    }

    ///     succeeds.
    /// - Returns: `True` if the exchange occurred, or `False` if `expected` did not
    ///     match the current value and so no exchange occurred.
    @inlinable
    public func compareAndExchange(expected: T, desired: T) -> Bool {
        return self.embedded.compareAndExchange(expected: expected, desired: desired)
    }
