Попытка расширить IntegerType (и FloatingPointType); Почему нельзя преобразовать все типы Int в NSTimeInterval

Я мог бы избыточно расширить Uint, а затем UInt16, а затем Int16 и т. д....

Правильный. Вот как это делается сегодня в Swift. Вы не можете объявить, что протокол соответствует другому протоколу в расширении. («Почему?» «Потому что компилятор этого не позволяет».)

Но это не значит, что вам нужно переписать всю реализацию. В настоящее время вам нужно реализовать его три раза (четыре раза, если вы хотите Float80, но здесь это не кажется полезным). Во-первых, вы объявляете свой протокол.

import Foundation

// Declare the protocol
protocol TimeIntervalConvertible {
    func toTimeInterval() -> NSTimeInterval
}

// Add all the helpers you wanted
extension TimeIntervalConvertible {
    var seconds:NSTimeInterval {
        return NSTimeInterval(self.toTimeInterval())
    }

    var minutes:NSTimeInterval {
        return NSTimeInterval(self.toTimeInterval() * 60)
    }

    var hours:NSTimeInterval {
        return NSTimeInterval(self.toTimeInterval() * 3600)
    }

    var days:NSTimeInterval {
        return NSTimeInterval(self.toTimeInterval() * 3600 * 24)
    }
}

// Provide the implementations. FloatingPointType doesn't have an equivalent to
// toIntMax(). There's no toDouble() or toFloatMax(). Converting a Float to
// a Double injects data noise in a way that converting Int8 to IntMax does not.
extension Double {
    func toTimeInterval() -> NSTimeInterval { return NSTimeInterval(self) }
}

extension Float {
    func toTimeInterval() -> NSTimeInterval { return NSTimeInterval(self) }
}

extension IntegerType {
    func toTimeInterval() -> NSTimeInterval { return NSTimeInterval(self.toIntMax()) }
}

// And then we tell it that all the int types can get his implementation
extension Int: TimeIntervalConvertible {}
extension Int8: TimeIntervalConvertible {}
extension Int16: TimeIntervalConvertible {}
extension Int32: TimeIntervalConvertible {}
extension Int64: TimeIntervalConvertible {}
extension UInt: TimeIntervalConvertible {}
extension UInt8: TimeIntervalConvertible {}
extension UInt16: TimeIntervalConvertible {}
extension UInt32: TimeIntervalConvertible {}
extension UInt64: TimeIntervalConvertible {}

Вот как числовые типы в настоящее время выполняются в Swift. Посмотрите через stdlib. Вы увидите много таких вещей, как:

extension Double {
    public init(_ v: UInt8)
    public init(_ v: Int8)
    public init(_ v: UInt16)
    public init(_ v: Int16)
    public init(_ v: UInt32)
    public init(_ v: Int32)
    public init(_ v: UInt64)
    public init(_ v: Int64)
    public init(_ v: UInt)
    public init(_ v: Int)
}

Было бы неплохо в некоторых случаях говорить о «числоподобных вещах»? Конечно. Вы не можете в Swift сегодня.

"Почему?"

Потому что компилятор этого не реализует. Когда-нибудь может. А пока создайте расширение для каждого типа, для которого вы хотите его использовать. Год назад для этого потребовалось бы еще больше кода.

Обратите внимание, что, хотя некоторые из этого являются "Swift еще не имеет этой функции", некоторые также преднамеренно. Swift намеренно требует явного преобразования между числовыми типами. Преобразование между числовыми типами часто может приводить к потере информации или введению шума и исторически было источником коварных ошибок. Вы должны думать об этом каждый раз, когда конвертируете число. Например, есть очевидный случай, когда переход от Int64 к Int8 или от UInt8 к Int8 может привести к потере информации. Но переход от Int64 к Double также может привести к потере информации. Не все 64-битные целые числа могут быть выражены как Double. Это тонкий факт, который довольно часто обжигает людей при работе с очень большими числами, и Swift призывает вас с этим смириться. Даже преобразование Float в Double вводит шум в ваши данные. 1/10, выраженная как Float, отличается от 1/10, выраженной как Double. Когда вы конвертируете Float в Double, вы хотели расширить повторяющиеся цифры или нет? Вы будете вводить различные виды ошибок в зависимости от того, что вы выберете, поэтому вам нужно выбрать.

Также обратите внимание, что ваш .days может содержать небольшие ошибки в зависимости от конкретной проблемной области. В сутках не всегда 24 часа. Это может быть 23 часа или 25 часов в зависимости от изменения летнего времени. Иногда это имеет значение. Иногда это не так. Но это причина быть очень осторожным при обращении с «днями», как если бы это было определенное количество секунд. Обычно, если вы хотите работать в днях, вы должны использовать NSDate, а не NSTimeInterval. Я бы очень подозрительно отнесся к этому конкретному.

Кстати, вас может заинтересовать моя старая реализация этой идеи. Вместо использования синтаксиса:

1.seconds

1 * Second

let Second: NSTimeInterval = 1
let Seconds = Second
let Minute = 60 * Seconds
let Minutes = Minute
let Hour = 60 * Minutes
let Hours = Hour

let x = 100*Seconds

NSTimeInterval — это просто псевдоним для Double. Вы можете легко добиться того, чего хотите, определив свою собственную структуру, например:

struct MyTimeInterval {
    var totalSecs: NSTimeInterval

    var totalHours: NSTimeInterval {
        get {
            return self.totalSecs / 3600.0
        }
        set {
            self.totalSecs = newValue * 3600.0
        }
    }

    init(_ secs: NSTimeInterval) {
        self.totalSecs = secs
    }

    func totalHourString() -> String {
        return String(format: "%.2f hours", arguments: [self.totalHours])
    }
}

var t = MyTimeInterval(5400)
print(t.totalHourString())