5

के अनुरूप नहीं प्रकार के साथ परेशानी हो रही है "प्रकार":प्रकार प्रकार लैम्ब्डा

trait Sys[ S <: Sys[S]] 
trait Expr[S <: Sys[S], A] 
trait Attr[S <: Sys[S], A[_]] 
def test[ S <: Sys[S]]: Attr[S, ({type l[x<:Sys[x]]=Expr[x,Int]})#l] = ??? 

यह

error: kinds of the type arguments (S,[x <: Sys[x]]Expr[x,Int]) do not conform 
to the expected kinds of the type parameters (type S,type A) in trait Attr. 
[x <: Sys[x]]Expr[x,Int]'s type parameters do not match type A's expected parameters: 
type x's bounds <: Sys[x] are stricter than type _'s declared bounds >: Nothing <: Any 
      def test[S <: Sys[S]]: Attr[S, ({type l[x<:Sys[x]]=Expr[x,Int]})#l] = ??? 
           ^

घोषित सीमा के साथ समस्या क्या है के साथ विफल हो? क्या मुझे trait Attr के प्रकार कन्स्ट्रक्टर में उस cr * ppy आंशिक रूप से लागू प्रकार को ले जाने की आवश्यकता है? और क्यों? क्या मैं Attr की परिभाषा को छूए बिना इसे ठीक कर सकता हूं?

मैं क्रम में समारोह test में सीमा की जरूरत कार्यान्वयन काम करने के लिए करते हैं, लेकिन मैं कर सार्वजनिक इंटरफ़ेस Attr करने के लिए उन सीमा पैदा करना नहीं चाहते हैं।


नोट: अगर मैं एक प्रकार का उपयोग सदस्य (मैं नहीं है क्या चाहते हैं), यह काम करता है:

trait Attr[S <: Sys[S]] { type A[_]} 
def test[ S <: Sys[S]]: Attr[S] { type A[S <: Sys[S]] = Expr[S, Int]} = ??? 

उत्तर

4

आप मनाया के रूप में, आप हमेशा सीमा जब बेमेल नहीं कर सकते हैं एक उच्च प्रकार के प्रकार तर्क प्रदान करते हैं।

class A 
class B extends A 
trait NeedsNeedsA[T[S <: A]] 
trait NeedsNeedsB[T[S <: B]] 
trait NeedsA[S <: A] 
trait NeedsB[S <: B] 

def x: NeedsNeedsA[NeedsB] // fails 
def y: NeedsNeedsB[NeedsA] // works 

जो समझ में आता है अगर आप अपने तर्क के लिए बाध्य में प्रकार पर एक समारोह, contravariant के रूप में एक उच्च kinded प्रकार के बारे में सोच: दिलचस्प है, यह वास्तव में एक विचरण मुद्दा है।

दिलचस्प है, एक संरचनात्मक प्रकार है, जो subtyping की तरह एक बहुत सतह पर है में, स्काला वही त्रुटि नहीं देता:

def t: MemberNeedsA { type T[S <: B] } 
def u: MemberNeedsB { type T[S <: A] } 

कारण यह है कि एक संरचनात्मक प्रकार एक चौराहे की तरह तरह की है:

def s: MemberNeedsA with MemberNeedsB 

और यह हो सकता है कि चौराहे वास्तव में प्रकृति में मौजूद न हो, लेकिन स्कैला इसे जांच नहीं पाती है।

ठीक है, लेकिन यह आपके प्रश्न के लिए इतना प्रासंगिक नहीं है। अपने प्रश्न पर वापस जाएं: मुझे लगता है कि आपके पास एक भिन्नता समस्या है। आप test फोन करने वाले वापस एक Attr देना चाहते हैं, और एक Attr एक प्रकार समारोह (A[_]) posseses, और आप कहना चाहते हैं, इसAttr एक प्रकार समारोह है कि एक अधिक विशिष्ट तर्क की आवश्यकता है। मुझे लगता है कि आप देख सकते हैं कि आपको ऐसा करने की अनुमति क्यों नहीं दी जानी चाहिए - यही कारण है कि आप एक ऐसे फ़ंक्शन को प्रतिस्थापित नहीं कर सकते हैं जिसके लिए एक अधिक सामान्य तर्क की आवश्यकता होती है जिसके लिए अधिक सामान्य तर्क की आवश्यकता होती है।

इस बिंदु पर मुझे डर है कि समाधान को पूरा करने में सक्षम होने के लिए Attr पर निर्भर होना होगा। आपको यह समझने की आवश्यकता है कि आपको कुछ मामलों में दूसरों के मुकाबले टाइप तर्क को प्रतिबंधित करने की आवश्यकता क्यों है। यह अपने कार्यक्रम में वैचारिक भावना है कि "कुछ Attr रों दूसरों की तुलना में अधिक प्रतिबंधात्मक हैं" बनाता है, तो आप निर्धारित कर सकते हैं:

trait Attr[S <: Sys[S], B[Y <: B[Y]], A[X <: B[X]]] 
def test[S <: Sys[S]]: Attr[S, Sys, L] = ... 

लेकिन समाधान क्या A[_] तर्क पर प्रतिबंध मतलब करने का इरादा है पर निर्भर करेगा।

+0

आपके विश्लेषण के लिए धन्यवाद। यह समझ में आता है, हालांकि "ए [_]' "होने पर यह आपको" टाइप कन्स्ट्रक्टर "'ए [एनी]' कहने की अनुमति देता है, आप एक मूल्य कन्स्ट्रक्टर को कॉल नहीं कर सकते हैं, इसलिए रनटाइम के मामले में यह ठीक होगा IMO। दूसरी तरफ, मुझे लगता है कि यह टाइप बाधाओं का उपयोग कर संकलन-समय मेटा प्रोग्रामिंग के साथ समस्याएं पैदा कर सकता है? अंत में, समाधान (कम से कम जहां तक ​​मैं इसका उपयोग कर रहा हूं) सरल है। उपयोग साइट 'ए [_]' के साथ बहुत कुछ नहीं कर सकती है और इस प्रकार की जानकारी 'test' के कॉलर के लिए अधिक है, इसलिए मैंने' ए 1 = ए [_] '' Attr' और 'test' में प्रतिस्थापित किया, फिर' Attr [एस, Expr [एस, Int]] '। –

संबंधित मुद्दे