जावा टाइप अनुमान कब एक अनंत प्रकार का उत्पादन करता है?

Question

JLS प्रकार निष्कर्ष एल्गोरिथ्म (§15.12.2) में उल्लेख है:

यह है कि इस प्रक्रिया से ऊपर एक अनंत प्रकार पैदावार संभव है। यह अनुमत है, और जावा कंपाइलर्स को ऐसी परिस्थितियों को पहचानना चाहिए और चक्रीय डेटा संरचनाओं का उपयोग करके उचित रूप से उनका प्रतिनिधित्व करना चाहिए।

हालांकि, मैं एक वास्तविक उदाहरण है जहाँ javac एक अनंत प्रकार का उत्पादन खोजने में असमर्थ हूँ। मुझे लगता है कि निम्नलिखित मामले में एक निर्माण करने के लिए चाहिए:

<T> T pick(T a, T b) { ... } 

pick("string", 3); 

दोनों स्ट्रिंग और पूर्णांक, तुलनीय < themselve> हैं, इसलिए उनके आम महाप्रकार Comparable<? extends Comparable<? extends Comparable<? ...>>> (अनंत) होना चाहिए।

मैं कर सकते हैं:

Comparable<? extends Comparable<?>> x = pick("string", 3); 

लेकिन फिर मैं करने की कोशिश की:

Comparable<? extends Comparable<? extends Comparable<?>>> x = pick("string", 3); 

और इस संकलन नहीं है। ऐसा लगता है कि रिकर्सन 2 चरणों के बाद निरस्त कर दिया गया है।

क्या आप जावा को असीमित प्रकार का उत्पादन करने के लिए किसी भी मामले के बारे में जानते हैं?

-

संपादित करें: ऐसा लगता है कि इसके बाद के संस्करण एक संकलक बग है। विनिर्देश पढ़ना, देखते हैं कैसे lub(String, Integer) की गणना बाहर काम करता है:

ST(String) = { String, Comparable<String>, Serializable, CharSequence, Object } 
ST(Integer) = { Integer, Comparable<Integer>, Serializable, Number, Object } 
EC = { Comparable, Serializable, Object } 
MEC = { Comparable, Serializable } 
Inv(Comparable) = { Comparable<String>, Comparable<Integer> } 
lcta(String, Integer) = ? extends lub(String, Integer) 
lci(Inv(Comparable)) = Comparable<? extends lub(String, Integer)> 
lub(String, Integer) = Serializable & Comparable<? extends lub(String, Integer)> 

तो lub(String, Integer) एक अनंत प्रकार होना चाहिए। जैवैक यहां गलत लगता है। शायद यह अनंत प्रकारों को लागू नहीं करता है?

Answer 1

निम्न कोड एक अनंत लूप को javac भेजता क्या देख रहे हैं। मुमकिन है, यह एक अनंत प्रकार का निर्माण करने की कोशिश करता है, लेकिन इसे एक सीमित चक्रीय डेटा संरचना के रूप में प्रस्तुत करने का प्रबंधन नहीं करता है।

interface I<T> {} 
interface A<T> extends I<A<A<T>>>{} 
abstract class X { 
    abstract <T> T foo(T x, T y); 

    void bar(A<Integer> x, A<String> y){ 
     foo(x, y); 
    } 
} 

Answer 2

अनंत प्रकार के संभावना हो सकता है (उदाहरण के लिए, आदि एक नक्शे के अंदर एक नक्शा, अंदर मानचित्र की एक वस्तु .....

Map<? extends Serializable, Map<? extends Serializable, Map<? extends Serializable, Map<? extends Serializable, Map<? extends Serializable, Map>>>>> objectMap; 

(यह पठनीयता के लिए गहराई से 5 से किया जाता है .. लेकिन आप एक नक्शे के असीम गहरी अंदर नक्शे जोड़ सकते हैं।

मैं नहीं जानता कि यदि आप के लिए ....