函数数组<可选< T>> - >可选<阵列< T>> [英] Function Array<Optional<T>> -> Optional<Array<T>>

问题描述

 扩展数组<可选的< T>> {
 func unwrap（） - >可选<阵列< T>> {
 let a = self.flatMap（）{a in 
 switch a {
 case Optional.ome（let x）：return [x] 
 case Optional.None：return [] 
} 
} 
如果a.count == self.count {
 return Optional。某些（a）
} else {
 return可选.None 
} 
} 
} 
  

但是，它没有没有编译错误使用未声明的类型T 。
下面是我想要使用它的方法：

  let a = [可选。一些（2），可选。一些（3），Optional.Some（4）] 
让b = [Optional.Some（1），Optional.None] 
 a.unwrap（）//可选[2,3,4] 
 b.unwrap（）//无
  

如何解决这个问题？或者在swift中没有这种可能性？

解决方案

试试这个：

  protocol OptionalType {
 typealias W 
 var可选：W？ {get} 
} 
 
扩展可选：OptionalType {
 typealias W = Wrapped 
 var可选：W？ {return self} 
} 
 
扩展数组元素：OptionalType {
 func unwrap（） - > [Element.W]？ {
 return reduce（可选< [Element.W]>（[]））{acc，e in 
 acc.flatMap {a in e.optional.map {a + [$ 0]}} 
} 
} 
} 
  

然后，

  let a：[Int？] = [1，2，3] 
 let b：[Int？] = [1 ，nil，3] 
 
 a.unwrap（）// ==> [1，2，3] 
 b.unwrap（）// ==>无
  

Here is what I'm trying to do:

extension Array<Optional<T>> {   
  func unwrap() -> Optional<Array<T>> {
    let a = self.flatMap() { a in
      switch a {
      case Optional.Some(let x): return [x]
      case Optional.None: return []
      }
    }
    if a.count == self.count {
      return Optional.Some(a)
    } else {
      return Optional.None
    }   
  } 
}

But, it doesn't compiles with error Use of undeclared type T. Here is how I want to use it:

let a = [Optional.Some(2), Optional.Some(3), Optional.Some(4)]
let b = [Optional.Some(1), Optional.None]
a.unwrap() // Optional[2, 3, 4]
b.unwrap() // nil

How can I get around with this? Or there is no such possibility in swift?

解决方案

Try this:

protocol OptionalType {
    typealias W
    var optional: W? { get }
}

extension Optional: OptionalType {
    typealias W = Wrapped
    var optional: W? { return self }
}

extension Array where Element: OptionalType {
    func unwrap() -> [Element.W]? {
        return reduce(Optional<[Element.W]>([])) { acc, e in
            acc.flatMap { a in e.optional.map { a + [$0] } }
        }
    } 
}

And then,

let a: [Int?] = [1,   2, 3]
let b: [Int?] = [1, nil, 3]

a.unwrap() // ==> [1, 2, 3]
b.unwrap() // ==> nil

这篇关于函数数组<可选< T>> - >可选<阵列< T>>的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！