Time: Uses a concise, type-protected Time library

This micro-library is made for you if:

You have ever written something like this:

let interval: TimeInterval = 10 * 60Copy the code

To represent 10 minutes.

Usage

import Time

let tenMinutes = 10.minutes
let afterTenMinutes = Date(a)+ 10.minutes
let tenMinutesAndSome = 10.minutes + 15.seconds
let tenMinutesInSeconds = 10.minutes.inSeconds
if 10.minutes > 500.seconds {
    print("That's right")}Copy the code

Basics

Time is not just a bunch of Double conversion functions. The main advantage of it is that all time units are strongly-typed. So, for example:

let tenMinutes = 10.minutesCopy the code

Here tenMinutes will actually be of type Interval

(not to be confused with Foundation’s TimeInterval). There are seven time units available, from nanoseconds to days:

public extension Double {
    
    var seconds: Interval<Second> {
        return Interval<Second>(self)}var minutes: Interval<Minute> {
        return Interval<Minute>(self)}var milliseconds: Interval<Millisecond> {
        return Interval<Millisecond>(self)}var microseconds: Interval<Microsecond> {
        return Interval<Microsecond>(self)}var nanoseconds: Interval<Nanosecond> {
        return Interval<Nanosecond>(self)}var hours: Interval<Hour> {
        return Interval<Hour>(self)}var days: Interval<Day> {
        return Interval<Day>(self)}}Copy the code

You can perform all basic arithmetic operations on time intervals, even of different units:

let interval = 10.minutes + 15.seconds - 3.minutes + 2.hours // Interval<Minute>
let doubled = interval * 2

let seconds = 10.seconds + 3.minutes // Interval<Second>Copy the code

You can also use these operations on Date:

let oneHourAfter = Date(a)+ 1.hoursCopy the code

Conversions

Time intervals are easily convertible:

let twoMinutesInSeconds = 2.minutes.inSeconds // Interval<Second>Copy the code

You can also convert intervals to Foundation‘s TimeInterval, if needed:

let timeInterval = 5.minutes.timeIntervalCopy the code

You can also use converted(to:) method:

let fiveSecondsInHours = 5.seconds.converted(to: Hour.self) // Interval<Hour>
// or
let fiveSecondsInHours: Interval<Hour> = 5.seconds.converted(a)Copy the code

Although, in my opinion, you would rarely need to.

Creating your own time units

If, for some reason, you need to create your own time unit, that’s super easy to do:

public enum Week : TimeUnit {
    
    public static var toTimeIntervalRatio: Double {
        return 604800}}Copy the code

Now you can use it as any other time unit:

let fiveWeeks = Interval<Week>(5)Copy the code

For the sake of convenience, don’t forget to write those handy extensions:

public enum Week : TimeUnit {
    
    public static var toTimeIntervalRatio: Double {
        return 604800}}extension Interval {
    
    public var inWeeks: Interval<Week> {
        return converted()}}extension Double {
    
    public var weeks: Interval<Week> {
        return Interval<Week>(self)}}extension Int {
    
    public var weeks: Interval<Week> {
        return Interval<Week>(Double(self))}}Copy the code

Also available:

Get conversion rate:

let conversionRate = Hour.conversionRate(to: Second.self) // 3600.0Copy the code

GCD integration:

DispatchQueue.main.asyncAfter(after: 5.seconds) {
	// do stuff
}Copy the code

Disclaimer

Time is in very early stage. Some stuff will probably be broken at some point.

Time is available through Carthage. To install, just write into your Cartfile:

github "dreymonde/Time" ~> 0.2.0Copy the code

You can also use SwiftPM. Just add to your Package.swift:

import PackageDescription

let package = Package(
    dependencies: [.Package(url: "https://github.com/dreymonde/Time.git".majorVersion: 0.minor: 2),])Copy the code