René's URL Explorer Experiment

{"@context":"https://schema.org","@type":"DiscussionForumPosting","headline":"Use strong typing instead of ruby-like `1.seconds`","articleBody":"Extending `Int` and `Double` with properties `second`, `seconds`, `minute`, etc. seems like a rather bad idea. There's two problems with this:\n1. Anyone using your code in a project with other 3rd-party code that wants to do something similar will have a compile-time naming collision, making it impossible to use either one.\n2. It's weakly-typed. You're still taking `NSTimeInterval` as your actual time type, and all it takes is for someone to accidentally leave off the `.minutes` and they'll get the wrong time. This isn't a huge issue, as `NSTimeInterval` is used everywhere to mean seconds and people are used to it, but we can still do better.\n\nThe better approach is to use an actual `Duration` type that requires the user to type the unit as part of the constructor. With the ruby-like approach you can just say `NSTimer.after(1) { ... }` but with a proper strong type there's no way to do this. I'd suggest something like\n\n``` swift\n/// A type that represents a given duration.\npublic struct Duration: Comparable, Hashable, Printable, DebugPrintable {\n    /// The time interval of the `Duration`, in seconds.\n    let seconds: NSTimeInterval\n    /// The time interval of the `Duration`, in minutes.\n    var minutes: NSTimeInterval {\n        return seconds / 60\n    }\n    /// The time interval of the `Duration`, in hours.\n    var hours: NSTimeInterval {\n        return seconds / 3600\n    }\n    /// The time interval of the `Duration`, in milliseconds.\n    /// Sub-millisecond values are truncated.\n    var milliseconds: Int64 {\n        return Int64(seconds * 1_000)\n    }\n    /// The time interval of the `Duration`, in microseconds.\n    /// Sub-microsecond values are truncated.\n    var microseconds: Int64 {\n        return Int64(seconds * 1_000_000)\n    }\n    /// The time interval of the `Duration`, in nanoseconds.\n    var nanoseconds: Int64 {\n        return Int64(seconds * 1_000_000_000)\n    }\n\n    /// Construct a `Duration` for a given number of seconds.\n    public init(seconds: NSTimeInterval) {\n        self.seconds = seconds\n    }\n    /// Construct a `Duration` for a given number of minutes.\n    public init(minutes: NSTimeInterval) {\n        self.init(seconds: minutes * 60)\n    }\n    /// Construct a `Duration` for a given number of hours.\n    public init(hours: NSTimeInterval) {\n        self.init(seconds: hours * 3600)\n    }\n    /// Construct a `Duration` for a given number of milliseconds.\n    // Use Int64 because milliseconds are generally not floating-point\n    // values\n    public init(milliseconds: Int64) {\n        self.init(seconds: NSTimeInterval(milliseconds) / 1_000)\n    }\n    /// Construct a `Duration` for a given number of microseconds.\n    public init(microseconds: Int64) {\n        self.init(seconds: NSTimeInterval(microseconds) / 1_000_000)\n    }\n    /// Constructs a `Duration` for a given number of nanoseconds.\n    // How much tolerance does a timer actually support?\n    public init(nanoseconds: Int64) {\n        self.init(seconds: NSTimeInterval(nanoseconds) / 1_000_000_000)\n    }\n\n    public var description: String {\n        // TODO: Display human-readable string with multiple units\n        return toString(seconds)\n    }\n\n    public var debugDescription: String {\n        return \"Duration(\\(seconds))\"\n    }\n\n    public var hashValue: Int {\n        return seconds.hashValue\n    }\n}\n\npublic func +(lhs: Duration, rhs: Duration) -\u003e Duration {\n    return Duration(seconds: lhs.seconds + rhs.seconds)\n}\npublic func -(lhs: Duration, rhs: Duration) -\u003e Duration {\n    return Duration(seconds: lhs.seconds - rhs.seconds)\n}\n// NB: Don't implement multiplication/division, that doesn't make any sense for\n// durations. As such, we don't conform to IntegerArithmeticType either.\npublic func \u003c(lhs: Duration, rhs: Duration) -\u003e Bool {\n    return lhs.seconds \u003c rhs.seconds\n}\npublic func ==(lhs: Duration, rhs: Duration) -\u003e Bool {\n    return lhs.seconds == rhs.seconds\n}\n```\n\nThis way you can then say `NSTimer.after(Duration(seconds: 1)) { ... }`. You could also experiment with replacing all those initializers with static functions instead (e.g. `static func seconds(seconds: NSTimeInterval)`) so that way you can say `NSTimer.after(.seconds(1)) { ... }`.\n","author":{"url":"https://github.com/lilyball","@type":"Person","name":"lilyball"},"datePublished":"2015-05-11T21:47:10.000Z","interactionStatistic":{"@type":"InteractionCounter","interactionType":"https://schema.org/CommentAction","userInteractionCount":8},"url":"https://github.com/4/SwiftyTimer/issues/4"}