स्विफ्ट

Question

में निजी enum के लिए एक समान विधि कैसे लिखना है मैं स्विफ्ट के लिए नया हूं और एक निजी enum लिखने की कोशिश कर रहा था जो समेकित अनुरूप है।

class Baz { 

    /* Other members in class Baz */ 

    private enum Test: Equatable { 
     case Foo 
     case Bar 
    } 

    private func == (lhs: Test, rhs: Test) -> Bool { 
     //comparison 
    } 
} 

"==" विधि, संकलक शिकायत कर रहा है की लाइन पर "ऑपरेटरों केवल वैश्विक क्षेत्र में अनुमति दी जाती है": यहाँ मेरी कोड का एक सरलीकृत प्रतिनिधित्व है। और जब मैं enum टेस्ट और "==" विधि को सार्वजनिक रूप से बदलता हूं तो कक्षा से बाहर "==" स्थानांतरित करता है, तो त्रुटियां दूर हो जाती हैं।

मेरा प्रश्न यह है कि एक निजी enum के लिए "==" विधि को लागू करने का सही तरीका क्या है?

किसी भी मदद की सराहना की है।

========

संपादित करें:

सब मुझे बाहर की मदद करने के लिए धन्यवाद। मैं निर्दिष्ट नहीं किया है कि मेरी निजी enum और समारोह के ऊपर एक वर्ग में हैं .. (कोड अद्यतन किया जाता है)

Answer 1

मैं एक खेल का मैदान में करने की कोशिश की और यह मेरे लिए काम करता है:

private enum Test: Equatable { 
    case Foo 
    case Bar 
} 

private func ==(lhs: Test, rhs: Test) -> Bool { 
    return true 
} 

class A { 
    func aFunc() { 
     let test: Test = .Foo 
     let test2: Test = .Foo 

     if (test == test2) { 
      print("Hello world") 
     } 
    } 
} 

let a = A() 

a.aFunc() // Hello world 

आप अपने प्रश्न संपादित कर सकते हैं आपके कोड के साथ? इसलिए मैं आपकी समस्या के अनुरूप अपना उत्तर संपादित कर सकता हूं।

Answer 2

आप क्या किया साथ गलत कुछ भी नहीं है:

private enum Test: Equatable { 
    case Foo 
    case Bar 
} 

private func ==(lhs: Test, rhs: Test) -> Bool { 
    // Put logic here 
} 

private let test = Test.Foo 
private let test2 = Test.Foo 

if (test == test2) { 
    print("Hello world") 
} 

देखें this article for details.

Answer 3

जबकि शायद तुरंत आपके लिए उपयोगी नहीं है, यह देखते हुए कि बीटा 5 के रूप में, स्विफ्ट 3 में आप इस एक बना सकते हैं लायक है प्रकार के भीतर static func। Xcode 8 Beta Release Notes देखें, जो कहता है

ऑपरेटरों को इसके प्रकार या एक्सटेंशन के भीतर परिभाषित किया जा सकता है। उदाहरण के लिए:

struct Foo: Equatable { 
    let value: Int 
    static func ==(lhs: Foo, rhs: Foo) -> Bool { 
     return lhs.value == rhs.value 
    } 
} 

इस तरह के ऑपरेटरों static (या, एक वर्ग के भीतर, class final) के रूप में घोषित किया जाना चाहिए, और अपने वैश्विक समकक्षों के समान हस्ताक्षर किया है।

यह enum प्रकारों के साथ भी काम करता है। इस प्रकार:

private enum Test: Equatable { 
    case foo 
    case bar 

    static func ==(lhs: Test, rhs: Test) -> Bool { 
     // your test here 
    } 
} 

और जब इस Test एक अन्य प्रकार के भीतर कार्यान्वित किया जाता है यह भी काम करता है।