filter enum cases

💈範例

💾 程式：paiza.io

⬆️ 需要：CaseReflectable ⭐️

// ------------
//     Enum
// ------------

// enum with associated values
// (conforms to `CaseReflectable`) ⭐️ 
enum Enum: CaseReflectable {
    case int(Int)
    case int2(Int)
    case person(name: String, age: Int)
    case str(String)
}

// ------------
//     main
// ------------

let a: Enum = .int(3)

Enum.int ~= a        // true
Enum.int2 ~= a       // false

let joe = Enum.person(name: "joe", age: 8)

Enum.person ~= joe   // true
Enum.int ~= joe      // false

// array of enum cases
let items: [Enum] = [
    .int(1), .str("hi"), .int(2)
]

// filter enum cases ⭐️ 
let filtered = items.filter { Enum.int ~= $0 }
print(filtered)      // [Enum.int(1), Enum.int(2)]

📗 參考

• Erica ⟩ Challenge: Filtering associated value enumeration arrays (💈範例)

👥 相關

• operator (~=)

• enum case pattern

• enum

• CaseReflectable - required protocol.

🗣 討論

• how to use if case statement as boolean in swift

• How to filter array of enums with associated values?

❓ 問題

問：到底要如何寫才能使用下列語法❓

// ⭐ custom pattern matching
.enumCase ~= anEnumInstance // with associated value

• StackOverflow 有提到某個高深的解法(列在下面)，但要再研究。內文也提及：「Normally, if case and switch statements are abstractions based on the pattern matching operator ~=, but that's not how enums with associated types are implemented.」

I needed to know the name of the enum case without any associated types (values?). It turned out that the Mirror API was what I needed.

👉 SwiftLee

💾 程式：paiza.io

// enum with associated values
enum Enum {
    case int(Int)
    case str(String)
}

// ⭐️ enum case as function
print([3].map(Enum.int))        // [ .int(3) ]
print(type(of: Enum.int))       // (Int) -> Enum ⭐️ 

// --------------------------------------------
// https://stackoverflow.com/a/67204360/5409815
// --------------------------------------------

/// ⭐️ generic pattern matching operator (~=)
/// match enum cases with associated values, while disregarding the values themselves.
/// usage: `Enum.enumCase ~= instance`
public func ~= <Enum, AssociatedValue>(
  // an enum case (which accepts associated values of type `AssociatedValue`)
  enumCase: (AssociatedValue) -> Enum,
  // an instance of Enum
  instance: Enum
) -> Bool 
{
  // if `instance` is of case `enumCase`, return true.
  Mirror.associatedValue(of: instance, ifCase: enumCase) != nil
}

// extension
public extension Mirror {
  /// get an `enumCase`'s `associatedValue`.
  static func associatedValue<AssociatedValue>(
    of subject: Any,
    _         : AssociatedValue.Type = AssociatedValue.self
  ) -> AssociatedValue? 
  {
    guard let childValue = Self(reflecting: subject).children.first?.value
    else { return nil }

    if let associatedValue = childValue as? AssociatedValue {
      return associatedValue
    }

    let labeledAssociatedValue = Self(reflecting: childValue).children.first
    return labeledAssociatedValue?.value as? AssociatedValue
  }

  /// Get an `enum` case's `associatedValue`.
  /// - Parameter case: Looks like `Enum.case`.
  static func associatedValue<Enum, AssociatedValue>(
    of instance: Enum,
    ifCase case: (AssociatedValue) throws -> Enum
  ) rethrows -> AssociatedValue? 
  {
    try associatedValue(of: instance).filter {
      .equate(try `case`($0), to: instance) {
        Self(reflecting: $0).children.first?.label
      }
    }
  }
}

public extension Optional {
  /// Transform `.some` into `.none`, if a condition fails.
  /// - Parameters:
  ///   - isSome: The condition that will result in `nil`, when evaluated to `false`.
  func filter(_ isSome: (Wrapped) throws -> Bool) rethrows -> Self {
    try flatMap { try isSome($0) ? $0 : nil }
  }
}

public extension Equatable {
  /// Equate two values using a closure.
   static func equate<Wrapped, Equatable: Swift.Equatable>(
    _ optional0: Wrapped?, to optional1: Wrapped?,
    using transform: (Wrapped) throws -> Equatable
  ) rethrows -> Bool {
    try optional0.map(transform) == optional1.map(transform)
  }
}

let a: Enum = .int(3)
print(Enum.int ~= a)        // true ⭐️ 

History

history

1. 剛開始的解法：使用 switch case, if case.

1

💾 程式：paiza.io

// ⭐️ enum with associated values
enum Enum {
    case int(Int)
    case str(String)
    case boo(Bool)
}

// array of enum cases
let items: [Enum] = [
    .int(1), .str("hi"), .int(2)
]

// -----------------
//     filtering
// -----------------

// ⭐️ `switch-case` pattern
let ints = items.filter {             // [ .int(1), .int(2) ]
    switch $0 { 
        case .int: return true
        default  : return false 
    }
} 

// ⭐️ `if-case` pattern
let strs = items.filter {                // [ .str("hi') ]
    if case .str = $0 { return true } 
    return false 
}  

// -------------------
//     ⭐️ extension
// -------------------

extension Enum {
    // ⭐️ convenience computed property
    var isInt: Bool {
        if case .int = self { return true }
        return false
    }
}

// ⭐️ filter using keypath
items.filter(\.isInt)        // [.int(1), .int(2)]