चेतावनी क्यों करें scala.language.implicitConversions अंतिम आयात नहीं है?

Question

मेरी स्काला कोड में, मैं कुछ निहित रूपांतरण है, और मुझे आवश्यक आयात वर्तमान है:

import scala.language.implicitConversions 

लेकिन, कभी कभी जब वहाँ एक और आयात इस एक के बाद किया है, मैं चेतावनी के रूप में करता है, तो आयात है मिल नहीं वहाँ सब पर:

चेतावनी: (112, 18) अंतर्निहित रूपांतरण विधि pair2Dimension अंतर्निहित मूल्य scala.language.implicitConversions दृश्यमान बनाकर सक्षम होना चाहिए।

build.sbt:

name := "ImplicitSBT" 

version := "1.0" 

scalaVersion := "2.11.5" 

scalacOptions ++= Seq("-deprecation","-feature") 

libraryDependencies += "org.scala-lang.modules" %% "scala-swing" % "1.0.1" 

Main.scala:

import scala.language.implicitConversions 
import scala.swing.{Action, _} 

object Main extends App { 

    implicit def pair2Dimension(pair: (Int, Int)): Dimension = new Dimension(pair._1, pair._2) 

    val dim : Dimension = (0,0) 

    println(dim) 


} 

इस क्यों होता है? import scala.swing.{Action, _}implicitConversions आयात छुपा कैसे है?

Answer 1

आयात scala.swing कैसे आयात करें। {Action, _} अंतर्निहित रूपांतरण आयात छुपाएं?

आपका:

import scala.language.implicitConversions 

... scala.swing पैकेज वस्तु में implicitConversionsdefined द्वारा आच्छादित हो जाता है:

package scala 

... 

package object swing { 

... 

implicit lazy val implicitConversions = scala.language.implicitConversions 

... 

} 

---

आप यहाँ वाइल्डकार्ड आयात का उपयोग कर रहे के बाद से:

import scala.swing.{Action, _} 

... scala.swing.implicitConversionsscala.swing से आयातित हो जाता है और अंत में छाया scala.language.implicitConversions से आयात हो जाता है।

दिलचस्प सवाल यह है कि क्यों scalac यह पता लगाने में विफल रहता है कि इस सुविधा में दो "फीचर फ्लैग" (implicitConversions) हैं, तो एक भाषा स्तर सक्षम है, एक दूसरे को एक ही स्तर पर छायांकन कर रहा है।

यह एक बग और साथ ही SIP 18 लागू करने के बारे में बता सकता है।

वैसे भी, यह मैं आपको सुझाव दे सकते हैं हल करने के लिए निम्न में से एक कार्य करें:

1. आयात नहीं करते scala.language.implicitConversions (के रूप में यह पहले से ही आयात किया जाता है जब वाइल्डकार्ड का आयात scala.swing)

2. नहीं करते scala.swing से वाइल्डकार्ड आयात (अपने दायरे को प्रदूषित न करें और इसके बदले आपको आयात करें)

3. का एक और आयात करें (जो किसी अन्य द्वारा छाया नहीं है)अपने Main वस्तु स्तर

Answer 2

इस पर निहित देखने में एक बग है।

यहां सामान्य संरचना में एक ही संरचना है, जहां आवश्यक निहित निष्पादन संदर्भ है।

(इसका कोई प्रभाव नहीं है कि क्या वाइल्डकार्ड आयात एक पैकेज वस्तु से है, या अन्य पैकेज एक ही संकलन इकाई में है या नहीं।)

के बाद से कोड एक स्पष्ट global साथ संकलित, इसके साथ संकलन चाहिए एक निहित तर्क।

यदि यह accessed without a prefix हो सकता है तो एक निहित उपलब्ध है।

binding precedence स्रोत कोड ऑर्डर से प्रभावित नहीं है। छाया सामान्य तरीके से काम करता है; एक बाध्यकारी कभी भी उच्च प्राथमिकता के बाध्यकारी छाया नहीं करता है।

/* 
package object bound2 { 
    implicit lazy val global = scala.concurrent.ExecutionContext.Implicits.global 
} 
*/ 
package bound2 { 
    object B { 
    implicit lazy val global: concurrent.ExecutionContextExecutor = scala.concurrent.ExecutionContext.global 
    } 
} 

package bound { 
    // the order of these imports in the same scope should not matter 
    import scala.concurrent.ExecutionContext.Implicits.global 
    import bound2.B._ 

    object Test extends App { 
    val f = concurrent.Future(42) //(global) // explicit arg works 
    Console println concurrent.Await.result(f, concurrent.duration.Duration.Inf) 
    } 
} 

कल्पना उदाहरण 2.0.1 में, जोड़ने लाइन में चिह्नित "ठीक है" संकलित, और आप उस क्रम आवश्यक नहीं है सत्यापित कर सकते हैं, लेकिन यह आंतरिक दायरे में अस्पष्ट हो जाता है क्योंकि "वाइल्डकार्ड वाई" वहाँ बाहरी दायरे से "स्पष्ट y" छाया नहीं करता है:

import X.y   // `y' bound by explicit import 
    println("L16: "+y) // `y' refers to `Q.X.y' here 
    import P.X._ 
    println("OK: "+y) // `y' refers to `Q.X.y' here 

    locally { val x = "abc"  // `x' bound by local definition 
     import P.X._  // `x' and `y' bound by wildcard import 
//  println("L19: "+y) // reference to `y' is ambiguous here 

Answer 3

रूप

http://docs.scala-lang.org/tutorials/FAQ/finding-implicits.html

एक वाइल्डकार्ड आयात में विस्तार से बताया है (जैसा कि आप ने लिखा) किसी भी Swin के लिए देता है जी अंतर्निहित परिभाषा काफी उच्च प्राथमिकता है और यह स्पष्ट रूप से आपकी छुपा रही है।

आप एसबीटी के साथ संकलित कर रहे हैं के बाद से, नहीं यह बहुत आसान

scalacOptions ++= Seq(
    "-feature", 
    "-language:implicitConversions" 
) 

की स्थापना निम्नलिखित गुजरती हैं और क्या scala.language.implicitConversions आयात करने के लिए सही जगह के बारे में चिंता करना बंद करने के लिए हो सकता है?