जेनेरिक विशेषता एक वर्ग और उसके साथी ऑब्जेक्ट को एक प्रकार पैरामीटर

Question

के रूप में ले रही है, इसलिए मैं एक सामान्य पैरा क्लास के साथ एक सामान्य पैरा क्लास से प्राप्त एक साथी ऑब्जेक्ट के साथ एक क्लास टाइप पैरामीटर के रूप में एक सामान्य विशेषता लेना चाहता हूं और दोनों साथी ऑब्जेक्ट को संदर्भित करता हूं और कक्षा ही तो,

abstract class BaseModel[T] { 
    def all: Seq[T] 
} 

case class Customer(email: String, password: String) 

object Customer extends BaseModel[Customer] 

// This trait is my issue 
trait BaseCrud[T] { 
    def table[T](f: T => String): String = { 
    T.all.map(f _).mkString("") 
    } 
} 

object Controller with BaseCrud { 
    def foo = table(_.email) 
} 

मुझे लगता है कि ऐसी विशेषता है जो करीब थे करने के लिए कुछ समाधान था, लेकिन मैं इसे नीचे आसुत तो आप देख सकते हैं कि मैं क्या करने की कोशिश कर रहा हूँ।

धन्यवाद

अद्यतन

तो मैं नीचे फ्रैंक से समाधान के साथ चला गया, लेकिन मैं अपने प्रारंभिक पहेली को हल करने का प्रबंधन किया था। हालांकि, इस मामले में समाधान थोड़ा बदसूरत था, मैं इसे पूर्णता के लिए यहां शामिल करूंगा।

abstract class BaseModel[T] { 
    def all: Seq[T] = Seq() 
} 

case class Customer(email: String, password: String) 

object Customer extends BaseModel[Customer] 

trait BaseCrud[T, U <: BaseModel[T]] { 
    def table(f: T => String)(implicit obj: U): String = { 
    obj.all.map(f(_)).mkString("") 
    } 
} 

object Controller extends BaseCrud[Customer, Customer.type] { 
    implicit val model = Customer 
    def foo = table(_.email) 
} 

तो प्रकार पैरामीटर BaseCrud को बदल दिया है और निहित BaseCrud.table को जोड़ा गया और Controller.model में लागू किया गया था। मैंने अपने सभी टाइपो को भी तय किया। मुझे यह दिलचस्प ग्राहक मिला। टाइप साथी वस्तु का प्रकार प्रतीत होता है।

Answer 1

मुझे लगता है कि आप स्केल self टाइप BaseCrud विशेषता का उपयोग कर सकते हैं ताकि कक्षा को मिश्रित किया जा सके। विवरण के लिए linked question देखें।

trait BaseCrud[T] { 
    self: BaseModel[T] => 
    def table(f: T => String): String = 
    all.map(f).mkString("") 
} 

object Controller extends BaseModel[Customer] with BaseCrud[Customer]{ 
    def foo = table(_.email) 
} 

Answer 2

वहाँ अपने कोड में समस्याओं का एक गुच्छा है .. चलो यह एक के बाद एक से निपटने:

• def table[T](... ध्यान दें कि यह T अधिलेखित कर देता है विधि के दायरे के लिए मूल प्रकार पैरामीटर।
  1. यह extends नहीं with हो गया है: नहीं हैं कि क्या तुम सच में चाहते हैं, तो बस यह छोड़ देते हैं और इस def table(...
  2. object Controller with BaseCrud { दो और गलतियों में शामिल है। उत्तरार्द्ध का उपयोग केवल कुछ बेस-क्लास/विशेषता से पहले ही विस्तारित होने के बाद किया जाता है।
  3. BaseCrud एक प्रकार पैरामीटर आप यहाँ निर्दिष्ट करने के लिए है, इसलिए BaseCrud[Customer]
• और अंत में, अपने वास्तविक सवाल का जवाब देने की तरह कुछ की आवश्यकता है: वहाँ एक प्रकार पैरामीटर T और एक साथी के बीच एक बड़ा अंतर है ऑब्जेक्ट। वे स्वाभाविक रूप से अलग-अलग चीजें हैं, इसलिए आप T.something के माध्यम से साथी ऑब्जेक्ट तक नहीं पहुंच सकते हैं। इसके बजाय आपको अपने गुण में साथी वस्तु को किसी अन्य तरीके से प्रदान करने की आवश्यकता है, उदाहरण के लिए एक सार क्षेत्र के रूप में।

यहाँ मैं क्या लगता है कि आप क्या करना चाहते हैं का एक संस्करण है:

abstract class BaseModel[T] { 
    def all: Seq[T] 
} 

case class Customer(email: String, password: String) 

object Customer extends BaseModel[Customer] { 
    def all = List[Customer]() // have to define this 
} 

trait BaseCrud[T] { 
    val companion : BaseModel[T] 
    def table(f: T => String): String = { 
    companion.all.map(f).mkString("") 
    } 
} 

object Controller extends BaseCrud[Customer] { 
    val companion = Customer 
    def foo = table(_.email) 
}