अंतर्निहित रूपांतरण

Question

मैं परोक्ष स्काला एक्सएमएल Elem वस्तु और एक XML तत्व का एक और प्रतिनिधित्व के बीच परिवर्तित करने के लिए, मेरे मामले में चाहते हैं तत्व dom4j। मैं निम्नलिखित निहित रूपांतरण लिखा है:

implicit def elemToElement(e: Elem): Element = ... do conversion here ... 
implicit def elementToElem(e: Element): Elem = ... do conversion here ... 

अब तक तो अच्छा, यह काम करता है।

अब मैं भी के संग्रह तत्वों दोनों तरीकों से कन्वर्ट करने के लिए कहा की जरूरत है। सबसे पहले, क्या मुझे अतिरिक्त रूपांतरण विधियों को लिखने की ज़रूरत है? अगर मैंने नहीं किया तो चीजें काम नहीं कर रही थीं।

implicit def elemTToElementT(t: Traversable[Elem]) = t map (elemToElement(_)) 
implicit def elementTToElemT(t: Traversable[Element]) = t map (elementToElem(_)) 

इस रूपांतरण विधि एक traversable लेता है, तो यह भी एक traversable रिटर्न क्योंकि बहुत आदर्श नहीं लगती है:

मैं निम्नलिखित लिखने का प्रयास किया। अगर मैं एक सूची पास करता हूं, तो मुझे ट्रैवर्सबल भी मिल जाता है। तो मुझे लगता है कि रूपांतरण किसी भी तरह से parametrized किया जाना चाहिए।

तो आदेश संभव के रूप में सामान्य हो इन रूपांतरणों को लिखने की मानक तरीका क्या है?

Answer 1

मुझे लगता है कि इस implicits ले जा सकता है बहुत दूर। विशेष रूप से के रूप में आप सिर्फ एक नक्शा

val listOfElements = listOfElems map elemToElement(_) 

में कनवर्टर विधि का उपयोग कर सकते हैं मुझे लगता है कि स्तर संक्षिप्तता आप के लिए जा रहे हैं कहानियो में हो रही है। मैं कनवर्टर परत बनाउंगा और केवल एक प्रस्तुति में काम करूंगा ताकि चीजों को उलझन में रखने के लिए।

Answer 2

यह इसलिए क्रम में आप क्या मुझे लगता है कि आप थोड़ा गहरा जाना होगा चाहते गैर तुच्छ है। यह आलेख बताता है कि स्कैला संग्रह कैसे काम करता है (और दिलचस्प पढ़ना भी यह है): http://www.artima.com/scalazine/articles/scala_collections_architecture.html

आप मूल रूप से List.map (...) (या ट्रैवर्सबल लाइक के रूप में कार्य करने की कोशिश कर रहे हैं)) और इसी तरह के तरीकों .... केवल इसके अलावा अंतर्निहित रूपांतरण के साथ।

अद्यतन:

मैं इस के साथ एक छोटा सा प्रयोग शुरू कर दिया और क्या TraversableLike.map (...) करता है के आधार पर एक रूपांतरण लिखा था। हालांकि मैंने पाया कि यह इसके बिना भी काम करता है। ऐसा लगता है जैसे स्कैला इसे बॉक्स से बाहर करता है (कम से कम मेरी मशीन पर :-)):

case class Element(e: Elem) 
implicit def elemToElement(e: Elem): Element = Element(e) 
implicit def elementToElem(e: Element): Elem = e.e 

val a: List[Element] = List(<a/>, <b/>, <c/>) 
val b: List[Elem] = List(Element(<a/>), Element(<b/>), Element(<c/>)) 
val c: Set[Element] = Set(<a/>, <b/>, <c/>) 

यह वही था जो आप के बाद थे?