मैं a, b और c के चौराहों को खोजना चाहता हूं। चूंकि मैं भविष्य में lst-ऑब्जेक्ट में और सेट जोड़ना चाहता हूं, इसलिए मैंने इसे एक MutableList के रूप में परिभाषित किया।

var a = mutableSetOf(1, 2, 3)
var b = mutableSetOf(2, 3, 4)
var c = mutableSetOf(3, 4, 5)
var lst = mutableListOf(a, b, c)

var intersection = lst.reduce {
    acc, currSet -> acc.intersect(currSet)
}

हालांकि, अंतिम अभिव्यक्ति विफल प्रकार के अनुमान के कारण "अमान्य" उठाती है। (यह खेल का मैदान देखें)

दस्तावेज़ों से मेरे पास निम्नलिखित हस्ताक्षर हैं reduce ऑपरेशन:

inline fun <S, T : S> Iterable<T>.reduce(
    operation: (acc: S, T) -> S
): S

तो S और T एक ही प्रकार के क्यों नहीं हो सकते?

0
soupwaylee 17 पद 2019, 12:39

1 उत्तर

सबसे बढ़िया उत्तर

आपको यहां "म्यूटेबल" प्रकारों का उपयोग करने की आवश्यकता क्यों है? यह गैर-परिवर्तनीय सेट के साथ काम करेगा:

val a = setOf(1, 2, 3)
val b = setOf(2, 3, 4)
val c = setOf(3, 4, 5)
val lst = listOf(a, b, c)

val intersection = lst.reduce { acc, currSet -> 
    acc.intersect(currSet)
}

समस्या यह है कि intersect एक MutableSet के बजाय एक Set देता है, जो टाइप चेक को नाखुश बनाता है। reduce लैम्ब्डा में acc.intersect(currSet).toMutableSet() का उपयोग करके या acc: Set<Int> में बदलकर ठीक किया जा सकता है। मैं हमेशा अपरिवर्तनीय प्रकारों के साथ जाऊंगा, और ऊपर पोस्ट किए गए कोड को पसंद करूंगा।

Nit: var के बजाय val को प्राथमिकता दें।

2
s1m0nw1 17 पद 2019, 09:48