Swift Optional Extension

Optional-ext.swift

protocol Index {
    typealias IndexType
    typealias Result
    subscript (i: IndexType) -> Result { get }
}


protocol IndexMut: Index {
    typealias IndexType
    typealias Result
    subscript (i: IndexType) -> Result { set get }
}

extension Optional {
    func is_some() -> Bool {
        switch self {
        case .Some(_):
            return true
        case _:
            return false
        }
    }

    func is_none() -> Bool {
        switch self {
        case .None:
            return true
        case _:
            return false
        }
    }

    func expect(msg: StaticString) -> T {
        switch self {
        case .Some(let val):
            return val
        case _:
            fatalError(msg)
        }
    }

    @transparent func unwrap() -> T {
        return self!
    }

    func unwrap_or(def: T) -> T {
        switch self {
        case .Some(let val):
            return val
        case _:
            return def
        }
    }

    func unwrap_or_else(f: () -> T) -> T {
        switch self {
        case .Some(let val):
            return val
        case _:
            return f()
        }
    }

    func map_or<U>(def: U, f: (T) -> U) -> U {
        switch self {
        case .Some(let val):
            return f(val)
        case _:
            return def
        }
    }

    func add<U>(optb: Optional<U>) -> Optional<U> {
        if self {
            return optb
        } else {
            return nil
        }
    }

    func add_then<U>(f: (T) -> Optional<U>) -> Optional<U> {
        if self {
            return f(self!)
        } else {
            return nil
        }
    }

    func or(optb: Optional<T>) -> Optional<T> {
        if self {
            return self
        } else {
            return optb
        }
    }

    func or_else(f: () -> Optional<T>) -> Optional<T> {
        if self {
            return self
        } else {
            return f()
        }
    }

    func filtered(f: (T) -> Bool) -> Optional<T> {
        if self.map_or(false, f) {
            return self
        } else {
            return nil
        }
    }

    func while_some(f: (T) -> Optional<T>) {
        var val = self
        while val {
            val = val.map(f).unwrap_or(nil)
        }
    }



}

extension Optional: Sequence, Generator {
    public func generate() -> T? {
        return self
    }
    public func next() -> T? {
        return self
    }
}

I think you should be able to simply for methods by combining the value and function methods with @autoclosure, e.g or and or_else could become:

func or(@autoclosure f: () -> Optional<T>) -> Optional<T> {
    if self {
        return self
    } else {
        return f()
    }
}

Then you could write:

myOptional or 42

or

myOptional or {
  39 + 3
}

This is untested...