स्विफ्ट

Question

में जेनेरिक के साथ रिकर्सिव एन्युमरेशंस मैं स्विफ्ट के लिए नया हूं। मैं पुनरावर्ती enumerations और जेनरिक के साथ एक द्विआधारी पेड़ को लागू करने की कोशिश कर रहा था:

$ swift ADT.swift 
ADT.swift:83:20: error: cannot convert value of type 'BinaryTree<T>' to expected argument type 'BinaryTree<_>' 
    return inorder(left) + [val] + inorder(right) 
        ^~~~ 

बहरहाल, यह काम करता है::

func inorder<T>(_ root: BinaryTree<T>) -> [T] { 
    switch root { 
    case .Nothing: 
    return [] 
    case let .Node(val, left, right): 
    let l = inorder(left) 
    let r = inorder(right) 
    return l + [val] + r 
    } 
} 

वहाँ है कोई गलती

enum BinaryTree<T> { 
    indirect case Node(T, BinaryTree<T>, BinaryTree<T>) 
    case Nothing 
} 

func inorder<T>(_ root: BinaryTree<T>) -> [T] { 
    switch root { 
    case .Nothing: 
    return [] 
    case let .Node(val, left, right): 
    return inorder(left) + [val] + inorder(right) 
    } 
} 

यहाँ त्रुटि मुझे मिल गया है मेरे वाक्यविन्यास में? धन्यवाद!

मैं स्विफ्ट 3.0 का उपयोग कर रहा हूं।

Answer 1

अद्यतन
तो मैं कम से कम उदाहरण कोड में समस्या यह है कि अपने आप संकलन और asked a question और SR-4304 दायर करने में विफल रहता गाढ़ा करने के लिए कोशिश की। जवाब बदलता है कि यह वास्तव में संकलक में एक बग है।

मूल उत्तर
जहां तक ​​मेरा बता सकते हैं, अपने वाक्य रचना पूरी तरह से वैध है। ऐसा लगता है कि स्विफ्ट कंपाइलर के प्रकार के अनुमान को सही दिशा में एक झुकाव की आवश्यकता होती है जो आपका दूसरा समाधान स्पष्ट रूप से प्रदान करता है। जैसा कि मैंने अतीत में कई समान समस्याओं का अनुभव किया था, खासकर + ऑपरेटर के संबंध में, आपके प्रश्न ने मुझे सरणी में शामिल होने के कई अन्य तरीकों का प्रयास करने के लिए प्रेरित किया। भी ऑपरेटर कॉलिंग एक समारोह संकलित रूप में

return (inorder(left) as [T]) + [val] + inorder(right) 
return Array([inorder(left), [val], inorder(right)].joined()) 
return [inorder(left), [val], inorder(right)].reduce([], +) 
return [inorder(left), [val], inorder(right)].flatMap { $0 } 

func myjoin1<T>(_ arrays: [T]...) -> [T] 
{ 
    return arrays.reduce([], +) 
} 
return myjoin1(inorder(left), [val], inorder(right)) 

func myjoin2<T>(_ array1: [T], _ array2: [T], _ array3: [T]) -> [T] 
{ 
    return array1 + array2 + array3 
} 
return myjoin2(inorder(left), [val], inorder(right)) 

extension Array 
{ 
    func appending(_ array: [Element]) -> [Element] 
    { 
     return self + array 
    } 
} 
return inorder(left).appending([val]).appending(inorder(right)) 

:: ये सब काम (मैं सिर्फ वापसी बयान दिखा रहा हूँ और पिछले तीन मामलों के लिए कार्यों का समर्थन)

return (+)(inorder(left), [val]) + inorder(right) 

यह अगर बहुत अच्छा होगा स्विफ्ट कंपाइलर के अधिक घनिष्ठ ज्ञान वाले किसी को इस पर कुछ प्रकाश डाला जा सकता है।