निर्भर विधि प्रकारों के समतुल्य संदेश

Question

this पोस्ट के लिए धन्यवाद मैं आश्रित विधि प्रकारों के आसपास अपना सिर प्राप्त कर रहा हूं। मैं एक संरचना के समान

trait Environment{ 
    type Population <: PopulationBase 
    protected trait PopulationBase 

    def evolveUs(population: Population): Population 
} 

object FactoredOut{ 
    def evolvePopulation(env: Environment)(prevPopulation: env.Population): env.Population = { 
     env.evolveUs(prevPopulation) 
    } 
} 

निम्नलिखित मैं अब एक क्लस्टर भर FactoredOut भाग में काम का प्रसार करने के अभिनेताओं का उपयोग शुरू करना चाहते हैं। ऐसा करने के लिए मुझे Environment ले जाने वाले अपरिवर्तनीय संदेशों को पारित करने का एक तरीका चाहिए।

जाहिर निम्नलिखित काम नहीं करता है, लेकिन यह दर्शाता है कि मैं क्या

object Messages{ 
    case class EvolvePopulation(env: Environment)(prevPopulation: env.Population) 
} 

आबादी पारित करने के लिए सही तरीका क्या है करने के लिए कोशिश कर रहा हूँ और यह आसपास के वातावरण संलग्न है?

(निर्भर-विधि-प्रकार टैग जोड़ लिया होगा, लेकिन मैं एक 'नए' टैग को जोड़ने के लिए पर्याप्त अंक नहीं हैं)

Answer 1

अपने अंतर्ज्ञान है कि आप निर्भर के दोनों मूल्य को पैक करने के लिए की जरूरत है टाइप करें (env.Population) और जिस प्रकार का मान निर्भर करता है (env) एक ऑब्जेक्ट के रूप में बिल्कुल सही है।

परिभाषाओं आप पहले से ही पोस्ट किया है को देखते हुए, शायद सबसे सरल दृष्टिकोण कुछ इस तरह हो सकता है,

// Type representing the packaging up of an environment and a population 
// from that environment 
abstract class EvolvePopulation { 
    type E <: Environment 
    val env : E 
    val prevPopulation : env.Population 
} 

object EvolvePopulation { 
    def apply(env0 : Environment)(prevPopulation0 : env0.Population) = 
    new EvolvePopulation { 
     type E = env0.type 
     val env : E = env0 // type annotation required to prevent widening from 
         // the singleton type 
     val prevPopulation = prevPopulation0 
    } 
} 

अब अगर हम एक ठोस पर्यावरण के प्रकार को परिभाषित,

class ConcreteEnvironment extends Environment { 
    class Population extends PopulationBase 
    def evolveUs(population: Population): Population = population 
} 

हम इसे उपयोग कर सकते हैं सीधे पहले,

val e1 = new ConcreteEnvironment 

val p1 = new e1.Population 
val p2 = e1.evolveUs(p1) 
val p3 = e1.evolveUs(p2) 

और हम पर्यावरण को भी पैकेज कर सकते हैं और वितरण के लिए आबादी,

def distrib(ep : EvolvePopulation) { 
    import ep._ 
    val p4 = env.evolveUs(prevPopulation) 
    val p5 = env.evolveUs(p4) 
    val p6 = env.evolveUs(p5) 
} 

val ep1 = EvolvePopulation(e1)(p3) 

distrib(ep1)