चीजों को संदर्भ में रखने के लिए: यह उत्तर मूल रूप से किसी अन्य थ्रेड में पोस्ट किया गया था। आप इसे यहां देख रहे हैं क्योंकि दो धागे विलय हो गए हैं। उक्त सूत्र में प्रश्न कथन इस प्रकार था:
इस प्रकार की परिभाषा को कैसे हल करें: शुद्ध [({प्रकार? [A] = (R, a)})?]?
ऐसे निर्माण का उपयोग करने के कारण क्या हैं?
स्नैप्ड स्केलज़ लाइब्रेरी से आता है:
trait Pure[P[_]] {
def pure[A](a: => A): P[A]
}
object Pure {
import Scalaz._
//...
implicit def Tuple2Pure[R: Zero]: Pure[({type ?[a]=(R, a)})#?] = new Pure[({type ?[a]=(R, a)})#?] {
def pure[A](a: => A) = (Ø, a)
}
//...
}
उत्तर:
trait Pure[P[_]] {
def pure[A](a: => A): P[A]
}
बक्से में एक अंडरस्कोर का Pतात्पर्य है कि यह एक प्रकार का कंस्ट्रक्टर है जो एक प्रकार लेता है और एक अन्य प्रकार देता है। इस तरह के प्रकार के निर्माणकर्ताओं के उदाहरण: List, Option।
दे दो Listएक Int, एक ठोस प्रकार, और यह आपको देता है List[Int], एक और ठोस प्रकार। दे दो Listएक Stringऔर यह आपको देता है List[String]। आदि।
तो, List, Option1. औपचारिक रूप से हम कह arity के प्रकार के स्तर के कार्यों माना जा सकता है, वे एक तरह * -> *। तारांकन एक प्रकार को दर्शाता है।
अब Tuple2[_, _]प्रकार के साथ एक प्रकार का कंस्ट्रक्टर है। (*, *) -> *आपको एक नया प्रकार प्राप्त करने के लिए इसे दो प्रकार देने की आवश्यकता है।
के बाद से अपने हस्ताक्षर से मेल नहीं खाते, तो आप स्थानापन्न नहीं कर सकता Tuple2के लिए P। आपको इसके एक तर्क पर आंशिक रूप से लागू Tuple2 करने की आवश्यकता है, जो हमें प्रकार के साथ एक प्रकार का निर्माण देगा * -> *, और हम इसके लिए प्रतिस्थापन कर सकते हैं P।
दुर्भाग्य से स्काला में टाइप कंस्ट्रक्टर्स के आंशिक अनुप्रयोग के लिए कोई विशेष वाक्यविन्यास नहीं है, और इसलिए हमें प्रकार lambdas नामक राक्षसी का सहारा लेना होगा। (आपके उदाहरण में आपके पास क्या है।) उन्हें कहा जाता है क्योंकि वे लैम्ब्डा अभिव्यक्तियों के अनुरूप हैं जो मूल्य स्तर पर मौजूद हैं।
निम्नलिखित उदाहरण से मदद मिल सकती है:
// VALUE LEVEL
// foo has signature: (String, String) => String
scala> def foo(x: String, y: String): String = x + " " + y
foo: (x: String, y: String)String
// world wants a parameter of type String => String
scala> def world(f: String => String): String = f("world")
world: (f: String => String)String
// So we use a lambda expression that partially applies foo on one parameter
// to yield a value of type String => String
scala> world(x => foo("hello", x))
res0: String = hello world
// TYPE LEVEL
// Foo has a kind (*, *) -> *
scala> type Foo[A, B] = Map[A, B]
defined type alias Foo
// World wants a parameter of kind * -> *
scala> type World[M[_]] = M[Int]
defined type alias World
// So we use a lambda lambda that partially applies Foo on one parameter
// to yield a type of kind * -> *
scala> type X[A] = World[({ type M[A] = Foo[String, A] })#M]
defined type alias X
// Test the equality of two types. (If this compiles, it means they're equal.)
scala> implicitly[X[Int] =:= Foo[String, Int]]
res2: =:=[X[Int],Foo[String,Int]] = <function1>
संपादित करें:
अधिक मूल्य स्तर और प्रकार स्तर समानताएं।
// VALUE LEVEL
// Instead of a lambda, you can define a named function beforehand...
scala> val g: String => String = x => foo("hello", x)
g: String => String = <function1>
// ...and use it.
scala> world(g)
res3: String = hello world
// TYPE LEVEL
// Same applies at type level too.
scala> type G[A] = Foo[String, A]
defined type alias G
scala> implicitly[X =:= Foo[String, Int]]
res5: =:=[X,Foo[String,Int]] = <function1>
scala> type T = World[G]
defined type alias T
scala> implicitly[T =:= Foo[String, Int]]
res6: =:=[T,Foo[String,Int]] = <function1>
आपके द्वारा प्रस्तुत किए गए मामले में, प्रकार पैरामीटर Rकार्य करने के लिए स्थानीय है Tuple2Pureऔर इसलिए आप बस परिभाषित नहीं कर सकते हैं type PartialTuple2[A] = Tuple2[R, A], क्योंकि बस कोई जगह नहीं है जहां आप उस पर्यायवाची को रख सकते हैं।
इस तरह के एक मामले से निपटने के लिए, मैं निम्नलिखित चाल का उपयोग करता हूं जो टाइप सदस्यों का उपयोग करता है। (उम्मीद है कि उदाहरण आत्म-व्याख्यात्मक है।)
scala> type Partial2[F[_, _], A] = {
| type Get[B] = F[A, B]
| }
defined type alias Partial2
scala> implicit def Tuple2Pure[R]: Pure[Partial2[Tuple2, R]#Get] = sys.error("")
Tuple2Pure: [R]=> Pure[[B](R, B)]