8
कहें कि मेरे पास एक विशेषता है जिसमें दो सूचियां हैं। कभी-कभी मुझे उसमें दिलचस्पी है, कभी-कभी टीथ में।कॉल स्टैक के नीचे राज्य-चयन संदर्भ को पार करने से बचने के लिए "कार्यात्मक तरीका" क्या है?
trait ListHolder {
val listOne = List("foo", "bar")
val listTwo = List("bat", "baz")
}
मैं जिनमें से मैं संदर्भ मैं सूचियों के बीच चयन करने की आवश्यकता है शीर्ष पर फ़ंक्शन कॉल की एक श्रृंखला है, है, लेकिन निचले भाग में, जिनमें से मैं विशेषता का उपयोग करें।
अनिवार्य प्रतिमान में, मैं कार्यों के माध्यम से संदर्भ नीचे से गुजरती हैं:
class Imperative extends Object with ListHolder {
def activeList(choice : Int) : List[String] = {
choice match {
case 1 => listOne
case 2 => listTwo
}
}
}
def iTop(is : List[Imperative], choice : Int) = {
is.map{iMiddle(_, choice)}
}
def iMiddle(i : Imperative, choice : Int) = {
iBottom(i, choice)
}
def iBottom(i : Imperative, choice : Int) = {
i.activeList(choice)
}
val ps = List(new Imperative, new Imperative)
println(iTop(ps, 1)) //Prints "foo, bar" "foo,bar"
println(iTop(ps, 2)) //Prints "bat, baz" "bat, baz"
वस्तु उन्मुख प्रतिमान में, मैं संदर्भ नीचे गुजर से बचने के लिए आंतरिक स्थिति का उपयोग कर सकते हैं:
class ObjectOriented extends Imperative {
var variable = listOne
}
def oTop(ps : List[ObjectOriented], choice : Int) = {
ps.map{ p => p.variable = p.activeList(choice) }
oMiddle(ps)
}
def oMiddle(ps : List[ObjectOriented]) = oBottom(ps)
def oBottom(ps : List[ObjectOriented]) = {
ps.map(_.variable) //No explicitly-passed-down choice, but hidden state
}
val oops = List(new ObjectOriented, new ObjectOriented)
println(oTop(oops, 1))
println(oTop(oops, 2))
एक कार्यात्मक भाषा में एक समान परिणाम प्राप्त करने के लिए बेवकूफ तरीका क्या है?
यही है, मैं उपरोक्त से आउटपुट के समान होने के लिए निम्न के आउटपुट को पसंद करूंगा।
class Functional extends Object with ListHolder{
//IDIOMATIC FUNCTIONAL CODE
}
def fTop(fs : List[Functional], choice : Int) = {
//CODE NEEDED HERE TO CHOOSE LIST
fMiddle(fs)
}
def fMiddle(fs : List[Functional]) = {
//NO CHANGES ALLOWED
fBottom(fs)
}
def fBottom(fs : List[Functional]) = {
fs.map(_.activeList) //or similarly simple
}
def fs = List(new Functional, new Functional)
println(fTop(fs, 1))
println(fTop(fs, 2))
अद्यतन: इस ठीक से कार्यात्मक माना जाएगा?
class Functional extends Imperative with ListHolder{}
class FunctionalWithList(val activeList : List[String]) extends Functional{}
def fTop(fs : List[Functional], band : Int) = {
fMiddle(fs.map(f => new FunctionalWithList(f.activeList(band))))
}
def fMiddle(fs : List[FunctionalWithList]) = {
//NO CHANGES ALLOWED
fBottom(fs)
}
def fBottom(fs : List[FunctionalWithList]) = {
fs.map(_.activeList)
}
def fs = List(new Functional, new Functional)
println(fTop(fs, 1))
println(fTop(fs, 2))
छोटा नोट: आपको 'लिस्टहोल्डर के साथ ऑब्जेक्ट बढ़ाता है' लिखना नहीं है। बस 'लिस्टहोल्डर' बढ़ाएं (कक्षाएं गुणों का विस्तार कर सकती हैं)। – Jesper