PerformanceTest.swift

import Foundation


typealias TPerson = (name:String, age:Int, male:Bool)

struct SPerson{
    let name : String
    let age : Int
    let male : Bool
}

enum EPerson {
    case Male(name: String, age : Int)
    case Female(name : String, age : Int)
    
    func name()->String{
        switch self {
        case let Male(name, _):
            return name
        case let Female(name, _):
            return name
        }
    }
}

class CPerson{
    let name : String
    let age : Int
    let male : Bool
    
    init(name : String, age : Int, male : Bool){
        self.name = name
        self.age = age
        self.male = male
    }
}

func measureTuple(){
    var name : String = ""
    let time = NSDate()
    for _ in 1...10_000_000{
        let p = TPerson("some", 25, true)
        name = p.name
    }
    let after = NSDate()
    print("\((after.timeIntervalSince1970 - time.timeIntervalSince1970) * 1000.0) Tuple 10M")
    print(name)
}
measureTuple()

func measureStruct(){
    var name : String = ""
    let time = NSDate()
    for _ in 1...10_000_000{
        let p = SPerson(name: "some", age: 25, male: true)
        name = p.name
    }
    let after = NSDate()
    print("\((after.timeIntervalSince1970 - time.timeIntervalSince1970) * 1000.0) Struct 10M")
    print(name)
}
measureStruct()

func measureEnum(){
    var name : String = ""
    let time = NSDate()
    for _ in 1...10_000_000 {
        let p = EPerson.Male(name: "some", age: 25)
        name = p.name()
    }
    let after = NSDate()
    print("\((after.timeIntervalSince1970 - time.timeIntervalSince1970) * 1000.0) Enum 10M")
    print(name)
}
measureEnum()

func measureClas(){
    var name : String = ""
    let time = NSDate()
    for _ in 1...10_000_000 {
        let p = CPerson(name: "some", age: 25, male: true)
        name = p.name
    }
    let after = NSDate()
    print("\((after.timeIntervalSince1970 - time.timeIntervalSince1970) * 1000.0) Class 10M")
    print(name)
}
measureClas()

private protocol List{
    var tail : List {get}
}

private struct EmptyList : List{
    var tail : List {
        return EmptyList()
    }
}

infix operator => {
associativity right
precedence 150
}

public func => <T>(lhs: T, rhs: ListNode<T>?) -> ListNode<T> {
    if let node = rhs {
        return ListNode(value: lhs, tail: node)
    }
    return ListNode(value: lhs, tail: EmptyList())
}


public struct ListNode<T> : List {
    public let value : T
    private let _tail : List
    private var tail : List {
        return _tail
    }
    
    private init(value: T, tail : List){
        self.value = value
        self._tail = tail
    }
    
    public subscript(var index : UInt) -> ListNode<T>?{
        var result : List = self
        while(index>0){
            result = result.tail
            index--
        }
        return result as? ListNode<T>
    }
    
}

class Box<T>{
    let value : T
    init(_ value : T ){
        self.value = value
    }
}

enum EList<T> {
    case Cons(Box<T>, Box<EList>)
    case Nil
    
    init(_ head: T, _ tail: EList) {
        self = Cons(Box(head), Box(tail))
    }
    
    var value: T? {
        switch self {
        case let Cons(x, _):
            return x.value
        case Nil:
            return nil
        }
    }
    
    func prepand(value : T)->EList{
        return EList(value, self)
    }
}

enum EEList<Element> {
    case End
    indirect case Node(Element, next: EEList<Element>)
    var value: Element? {
        switch self {
        case let Node(x, _):
            return x
        case End:
            return nil
        }
    }
}
extension EEList {
    func cons(x: Element) -> EEList {
        return .Node(x, next: self)
    }
}

class CList<T> {
    let value: T
    let next: CList?
    init(_ value : T, next : CList? = nil){
        self.value = value
        self.next = next
    }
    
    func prepand(value : T) -> CList{
        return CList(value, next: self)
    }
}


func measureArray(){
    let time = NSDate()
    var a = [0]
    for i in 1...1_000{
        a.append(i)
    }
    let after = NSDate()
    print("\((after.timeIntervalSince1970 - time.timeIntervalSince1970) * 1000.0) Array 1K")
}

func measureList(){
    let time = NSDate()
    var a = 0 => nil
    for i in 1...1_000{
        a = i => a
    }
    let after = NSDate()
    print("\((after.timeIntervalSince1970 - time.timeIntervalSince1970) * 1000.0) List 1K")
}

func measureEList(){
    let time = NSDate()
    let a = EList<Int>.Nil
    for i in 1...1_000{
        a.prepand(i)
    }
    let after = NSDate()
    print("\((after.timeIntervalSince1970 - time.timeIntervalSince1970) * 1000.0) BoxEList 1K")
}

func measureEEList(){
    let time = NSDate()
    var a = EEList<Int>.End
    for i in 1...1_000{
        a = a.cons(i)
    }
    let after = NSDate()
    print("\((after.timeIntervalSince1970 - time.timeIntervalSince1970) * 1000.0) EEList 1K")
}


func measureClasList(){
    let time = NSDate()
    var a = CList<Int>(0)
    for i in 1...1_000{
        a = a.prepand(i)
    }
    let after = NSDate()
    print("\((after.timeIntervalSince1970 - time.timeIntervalSince1970) * 1000.0) ClassList 1K")
}

measureList()
measureEList()
measureEEList()
measureClasList()

measureArray()