假设它是可选类型，我如何编写一个可以迅速打开通用属性的函数？

Question

到目前为止，我只能使用全局函数来实现此目的。我不确定是否有可能，但我希望编写一个通用类的扩展，希望能够实现相同的目的。

以下是它正在使用ReactiveCocoa的SignalProducer类的工作全局函数，但原理对于任何通用类都应相同。

func ignoreNilValues <Value,Error> (producer: SignalProducer<Value?,Error>) -> SignalProducer<Value, Error> {
   return producer.filter { return $0 != nil }.map { $0! }
}

更新：

我已经取得了进步，但仍然没有一个完整的解决方案

给定具有某些通用属性的任何类

class GenericClass<SomeType> {
    var someProperty: [SomeType] = []
}

我如何编写一个扩展名，该扩展名将过滤所有可选值并使用 Wrapped 类型返回该值？

以下内容将过滤所有nil值，但仍将其作为 Optional 类型返回。

protocol AnOptional {
    var isNil: Bool {get}
}

extension Optional : AnOptional {
    var isNil: Bool {
        get {
            guard let hasValue = self.map({ (value: Wrapped) -> Bool in
                return true
            }) else {
                return true
            }

            return !hasValue
        }
    }
}

extension GenericClass where SomeType : AnOptional {
    func filterNilValuesOfSomeProperty() -> [SomeType] {
        return someProperty.filter({ (anOptional: AnOptional) -> Bool in
            return !anOptional.isNil
        })
    }
}

可以看出

let aClass = GenericClass<Int?>()

aClass.someProperty = [3,5,6,nil,4,3,6, nil]

let x = aClass.someProperty 
//x = [Some(3),Some(5),Some(6),nil,Some(4),Some(3),Some(6), nil]

let y = aClass.filterNilValuesOfSomeProperty()
//y = [Some(3),Some(5),Some(6),Some(4),Some(3),Some(6)]

是否可以编写一个将返回包装类型的类扩展？在上面的示例中，它将[Int]代替[Int?]。

我为该示例重写了全局函数解决方案。

func ignoreNilValues <Value> (aClass: GenericClass<Value?>) -> GenericClass<Value> {
    let aNewClass = GenericClass<Value>()

    aNewClass.someProperty = aClass.someProperty.filter({ (v: Value?) -> Bool in
        v != nil
    }).map { (oldValue: Value?) -> Value in
        return oldValue!
    }

    return aNewClass
}

let z = ignoreNilValues(aClass).someProperty
//z = [3, 5, 6, 4, 3, 6]

Answer 1

“技巧”是定义所有可选选项都遵循的协议这是从[创建扩展以
略微简化来从Swift中的Array筛选出nil的想法；这个想法可以追溯到此Apple Forum
Thread
）：

protocol OptionalType {  
    typealias Wrapped 
    func intoOptional() -> Wrapped?  
}

extension Optional : OptionalType {  
    func intoOptional() -> Wrapped? {  
        return self 
    }  
}

您可以将其用于以下情况：

class GenericClass<SomeType> {
    var someProperty: [SomeType] = []
}

extension GenericClass where SomeType : OptionalType {
    func filterNilValuesOfSomeProperty() -> [SomeType.Wrapped] {
        return someProperty.flatMap { $0.intoOptional() }
    }
}

使用以下flatMap()方法SequenceType：

extension SequenceType {
    /// Return an `Array` containing the non-nil results of mapping
    /// `transform` over `self`.
    ///
    /// - Complexity: O(*M* + *N*), where *M* is the length of `self`
    ///   and *N* is the length of the result.
    @warn_unused_result
    public func flatMap<T>(@noescape transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]
}

例：

let aClass = GenericClass<Int?>()
aClass.someProperty = [3,5,6,nil,4,3,6, nil]

let x = aClass.someProperty 
print(x) // [Optional(3), Optional(5), Optional(6), nil, Optional(4), Optional(3), Optional(6), nil]

let y = aClass.filterNilValuesOfSomeProperty()
print(y) // [3, 5, 6, 4, 3, 6]

在 Swift 3 及更高版本中，协议必须定义为

protocol OptionalType {
    associatedtype Wrapped
    func intoOptional() -> Wrapped?
}