lazy objects.swift

// Playground - noun: a place where people can play

import Foundation

enum LazyVal<T, U> {
    case Raw(T)
    case Val(U)
    case None
}

struct Transformer<T, U> {
    let transform: T? -> U?
    let reverse:   U? -> T?
    init(_ transform: T? -> U?, _ reverse: U? -> T?) {
        self.transform = transform
        self.reverse = reverse
    }
}

struct LazilyTransformed<T, U> {
    let transformer: Transformer<T, U>
    var value: LazyVal<T, U> = .None
    
    init(_ transformer: Transformer<T, U>) {
        self.transformer = transformer
    }
    
    mutating func val() -> U? {
        switch value {
        case let .Val(val):
            return val
        case let .Raw(raw):
            println("Transforming value \(raw)!")
            switch transformer.transform(raw) {
            case let transformed as U:
                value = .Val(transformed)
                return transformed
            default:
                value = .None
                return nil
            }
        default:
            return nil
        }
    }
    
    mutating func setRaw(raw: T?) {
        switch raw {
        case let val as T:
            value = .Raw(val)
        default:
            value = .None
        }
    }
    
    mutating func set(val: U?) {
        switch val {
        case let val as U:
            value = .Val(val)
        default:
            value = .None
        }
    }
    
    func rawValue() -> T? {
        switch value {
        case let .Val(val):
            return transformer.reverse(val)
        case let .Raw(raw):
            return raw
        case .None:
            return nil
        }
    }
}

// some transformers

func jsonStringTransformer(json: String?) -> String? {
    if let json = json {
        return json
    }
    return nil
}

func reverseJSONStringTransformer(str: String?) -> String? {
    if let str = str {
        return str
    }
    return nil
}

func jsonDateTransformer(json: Int?) -> NSDate? {
    if let timestamp = json {
        return NSDate(timeIntervalSince1970: NSTimeInterval(timestamp))
    }
    return nil
}

func reverseJSONDateTransformer(date: NSDate?) -> Int? {
    if let date = date {
        return Int(date.timeIntervalSince1970)
    }
    return nil
}

// meta-function-type magic

let JSONString = Transformer(jsonStringTransformer, reverseJSONStringTransformer)
let JSONDate   = Transformer(jsonDateTransformer, reverseJSONDateTransformer)

class SomeJSONBackedObject {
    var title     = LazilyTransformed(JSONString)
    var createdAt = LazilyTransformed(JSONDate)
    var fizzedAt  = LazilyTransformed(JSONDate)
    
    init(_ json: NSDictionary) {
        title.setRaw(json["title"] as? String)
        createdAt.setRaw(json["created_at"] as? Int)
        fizzedAt.setRaw(json["fizzed_at"] as? Int)
    }
}

var obj = SomeJSONBackedObject(["created_at": 1405499362, "title": "My Second Object"])

println("Title is \(obj.createdAt.val())")
println("Fizzed at \(obj.fizzedAt.val())")