क्या हम स्कैला में उच्च-प्रकार के प्रकार-स्तरीय पहचान फ़ंक्शन को परिभाषित कर सकते हैं?

Question

स्काला में हम तो जैसे निचले kinded प्रकार के लिए प्रकार स्तरीय पहचान समारोह को परिभाषित कर सकते,

type Id[A] = A 

हम भी उच्च kinded प्रकार के लिए कुछ इसी तरह परिभाषित कर सकते हैं? अर्थात। हम में रिक्त स्थान को भरने कर सकते हैं,

type HKId[A[...]] = ... 

ताकि HKId [सूची] के लिए कुछ इसी तरह हमें वापस सूची प्रकार निर्माता के लिए हो जाता है?

जैसी चीजों में नि: शुल्क नामों की बाइंडिंग

,

type Foo[X] = List[X] 
val l : Foo[Int] = List(1, 2, 3) 

सकता है कि एक उच्च kinded प्रकार स्तरीय पहचान कैसा दिखेगा उम्मीद करने के लिए हमें का नेतृत्व,

type HKId[A[X]] = A[X] 

लेकिन scalac उस प्रकार एक्स शिकायत आरएचएस पर नहीं मिला है।

क्या कुछ चालाक एन्कोडिंग है जो चाल करेगा? या अभी यह अभी संभव नहीं है?

Answer 1

यह सही जवाब @retronym से दूर छीन थोड़ा अनुचित लगता है, लेकिन लगता है कि हम एक छोटे से समाधान की तरह मैं के बाद था के करीब प्राप्त कर सकते हैं यह लग रहा है,

scala> type HKId[A[_]] = { type λ[X] = A[X] } 
defined type alias HKId 

scala> def foo[C[_]] : C[Int] = null.asInstanceOf 
foo: [C[_]]=> C[Int] 

scala> foo[List] 
res0: List[Int] = null 

scala> foo[HKId[List]#λ] 
res1: List[Int] = null 

मैं मुझे यकीन नहीं है कि यह अब क्यों स्पष्ट प्रतीत होता है लेकिन एक साल पहले स्पष्ट नहीं था ...हो सकता है क्योंकि तब से हम सभी को प्रकार lambdas देखने के लिए बहुत अधिक उपयोग किया गया है।

Answer 2

एक type के रूप में यह करने के लिए एक तरह से नहीं मिल सकता है, लेकिन यह काम करता है:

class HKId[A[_]] { 
    type Value[X] = A[X] 
} 

यह संकलित:

scala> List(1): HKId[List]#Value[Int] 
res2: List[Int] = List(1) 

और यह नहीं करता है:

scala> List(1): HKId[List]#Value[Boolean] 
<console>:7: error: type mismatch; 
found : Int(1) 
required: Boolean 
     List(1): HKId[List]#Value[Boolean] 

Answer 3

Xtype HKId[A[X]] = ... में एक उच्च आदेश प्रकार पैरामीटर है। यह प्रकार पैरामीटर खंड के लिए scoped है, आमतौर पर एक प्रकार की बाधा में संदर्भित। कल्पना की §4.4 देखें:

The above scoping restrictions are generalized to the case of nested type parameter clauses, which declare higher-order type parameters. Higher-order type parameters (the type parameters of a type parameter t) are only visible in their immediately surrounding parameter clause (possibly including clauses at a deeper nesting level) and in the bounds of t . Therefore, their names must only be pairwise different from the names of other visible parameters. Since the names of higher-order type parameters are thus often irrelevant, they may be denoted with a ‘_’, which is nowhere visible.

कुछ समय पहले, हम प्रकार काम करता है, उदाहरण के लिए के लिए एक शाब्दिक वाक्य रचना को जोड़ने की संभावना पर चर्चा की [A] Either[Int, A]। यह स्कालज़ में वास्तव में उपयोगी होगा। इस बीच, हम PartialApplyXofY traits में व्यक्त एलेक्सी के जवाब से चाल का उपयोग करते हैं। निष्कर्ष भी बेहतर होगा, लेकिन इतना जटिल काम है, innocuous entry in Trac के बावजूद)

वैसे भी, कि धागे के दौरान, Adriaan mentioned:

It obviously won't be trivial to implement everything that logically follows from having anonymous type functions, as we currently don't have the necessary infrastructure to allow people to write higher-kinded type aliases, for example:

type MyTypeFun = [X, Y] Pair[Y, X] // desirable, but hard to support with the current implementation (we look at the type params of a symbol to infer its kind)

अद्यतन

बाहर कर देता है आप पहले से ही बहुत करीब प्राप्त कर सकते हैं :

def hk[_[_]] =(); 
hk[({type A[X] = X})#A] 

या थोड़ा रचनात्मक प्राप्त करना:

def hk[_[_]] =(); hk[({type \[X] = X}) # \ ] 
def hk[_[_]] =(); hk[({type λ[α]=α})#λ ]